//
//  ComposeAutocompleteView.swift
//  Tusker
//
//  Created by Shadowfacts on 10/10/20.
//  Copyright © 2020 Shadowfacts. All rights reserved.
//

import SwiftUI
import CoreData
import Pachyderm

struct ComposeAutocompleteView: View {
    let autocompleteState: ComposeUIState.AutocompleteState
    
    @Environment(\.colorScheme) var colorScheme: ColorScheme
    
    private var backgroundColor: Color {
        Color(white: colorScheme == .light ? 0.98 : 0.15)
    }
    
    private var borderColor: Color {
        Color(white: colorScheme == .light ? 0.85 : 0.25)
    }
    
    var body: some View {
        suggestionsView
            // animate changes of the scroll view items
            .animation(.default)
            .background(backgroundColor)
            .overlay(borderColor.frame(height: 0.5), alignment: .top)
    }
    
    @ViewBuilder
    private var suggestionsView: some View {
        switch autocompleteState {
        case .mention(_):
            ComposeAutocompleteMentionsView()
        case .emoji(_):
            ComposeAutocompleteEmojisView()
        case .hashtag(_):
            ComposeAutocompleteHashtagsView()
        }
    }
}

struct ComposeAutocompleteMentionsView: View {
    @EnvironmentObject private var mastodonController: MastodonController
    @EnvironmentObject private var uiState: ComposeUIState
    @ObservedObject private var preferences = Preferences.shared
    
    // can't use AccountProtocol because of associated type requirements
    @State private var accounts: [EitherAccount] = []
    
    @State private var searchRequest: URLSessionTask?
    
    var body: some View {
        ScrollView(.horizontal) {
            // can't use LazyHStack because changing the contents of the ForEach causes the ScrollView to hang
            HStack(spacing: 8) {
                ForEach(accounts, id: \.id) { (account) in
                    Button {
                        uiState.autocompleteHandler?.autocomplete(with: "@\(account.acct)")
                    } label: {
                        HStack(spacing: 4) {
                            ComposeAvatarImageView(url: account.avatar)
                                .frame(width: 30, height: 30)
                                .cornerRadius(preferences.avatarStyle.cornerRadiusFraction * 30)
                            
                            VStack(alignment: .leading) {
                                switch account {
                                case let .pachyderm(underlying):
                                    AccountDisplayNameLabel(account: underlying, fontSize: 14)
                                        .foregroundColor(Color(UIColor.label))
                                case let .coreData(underlying):
                                    AccountDisplayNameLabel(account: underlying, fontSize: 14)
                                        .foregroundColor(Color(UIColor.label))
                                }
                                
                                Text(verbatim: "@\(account.acct)")
                                    .font(.system(size: 12))
                                    .foregroundColor(Color(UIColor.label))
                            }
                        }
                    }
                    .frame(height: 30)
                    .padding(.vertical, 8)
                    .animation(.linear(duration: 0.1))
                }
                
                Spacer()
            }
            .padding(.horizontal, 8)
        }
        .onReceive(uiState.$autocompleteState.debounce(for: .milliseconds(250), scheduler: DispatchQueue.main), perform: queryChanged)
        .onDisappear {
            searchRequest?.cancel()
        }
    }
    
    private func queryChanged(_ state: ComposeUIState.AutocompleteState?) {
        guard case let .mention(query) = state,
              !query.isEmpty else {
            accounts = []
            return
        }
        
        let localSearchWorkItem = DispatchWorkItem {
            // todo: there's got to be something more efficient than this :/
            let wildcardedQuery = query.map { "*\($0)" }.joined() + "*"
            let request: NSFetchRequest<AccountMO> = AccountMO.fetchRequest()
            request.predicate = NSPredicate(format: "displayName LIKE %@ OR acct LIKE %@", wildcardedQuery, wildcardedQuery)
            
            if let results = try? mastodonController.persistentContainer.viewContext.fetch(request) {
                loadAccounts(results.map { .coreData($0) }, query: query)
            }
        }
        
        // we only want to search locally if the search API call takes more than .25sec or it fails
        DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(250), execute: localSearchWorkItem)
        
        if let oldRequest = searchRequest {
            oldRequest.cancel()
        }
        
        let apiRequest = Client.searchForAccount(query: query)
        searchRequest = mastodonController.run(apiRequest) { (response) in
            guard case let .success(accounts, _) = response else { return }
            
            localSearchWorkItem.cancel()
            
            // dispatch back to the main thread because loadAccounts uses CoreData
            DispatchQueue.main.async {
                // if the query has changed, don't bother loading the now-outdated results
                if case .mention(query) = uiState.autocompleteState {
                    self.loadAccounts(accounts.map { .pachyderm($0) }, query: query)
                }
            }
        }
    }
    
    private func loadAccounts(_ accounts: [EitherAccount], query: String) {
        // when sorting account suggestions, ignore the domain component of the acct unless the user is typing it themself
        let ignoreDomain = !query.contains("@")
        
        self.accounts =
            accounts.map { (account: EitherAccount) -> (EitherAccount, (matched: Bool, score: Int)) in
                let fuzzyStr = ignoreDomain ? String(account.acct.split(separator: "@").first!) : account.acct
                let res = (account, FuzzyMatcher.match(pattern: query, str: fuzzyStr))
                return res
            }
            .filter(\.1.matched)
            .map { (account, res) -> (EitherAccount, Int) in
                // give higher weight to accounts that the user follows or is followed by
                var score = res.score
                if let relationship = mastodonController.persistentContainer.relationship(forAccount: account.id) {
                    if relationship.following {
                        score += 3
                    }
                    if relationship.followedBy {
                        score += 2
                    }
                }
                return (account, score)
            }
            .sorted { $0.1 > $1.1 }
            .map(\.0)
    }
    
    private enum EitherAccount {
        case pachyderm(Account)
        case coreData(AccountMO)
        
        var id: String {
            switch self {
            case let .pachyderm(account):
                return account.id
            case let .coreData(account):
                return account.id
            }
        }
        
        var acct: String {
            switch self {
            case let .pachyderm(account):
                return account.acct
            case let .coreData(account):
                return account.acct
            }
        }
        
        var avatar: URL {
            switch self {
            case let .pachyderm(account):
                return account.avatar
            case let .coreData(account):
                return account.avatar
            }
        }
    }
}

struct ComposeAutocompleteEmojisView: View {
    @EnvironmentObject private var mastodonController: MastodonController
    @EnvironmentObject private var uiState: ComposeUIState
    
    @State var expanded = false
    @State private var emojis: [Emoji] = []
    
    var body: some View {
        // When exapnded, the toggle button should be at the top. When collapsed, it should be centered.
        HStack(alignment: expanded ? .top : .center, spacing: 0) {
            if case let .emoji(query) = uiState.autocompleteState {
                emojiList(query: query)
                    .animation(.default)
                    .transition(.move(edge: .bottom))
            } else {
                // when the autocomplete view is animating out, the autocomplete state is nil
                // add a spacer so the expand button remains on the right
                Spacer()
            }
            
            toggleExpandedButton
                .padding(.trailing, 8)
                .padding(.top, expanded ? 8 : 0)
        }
    }
    
    @ViewBuilder
    private func emojiList(query: String) -> some View {
        if expanded {
            EmojiPickerWrapper(searchQuery: query)
                .frame(height: 150)
        } else {
            horizontalScrollView
                .onReceive(uiState.$autocompleteState, perform: queryChanged)
        }
    }
    
    private var horizontalScrollView: some View {
        ScrollView(.horizontal) {
            HStack(spacing: 8) {
                ForEach(emojis, id: \.shortcode) { (emoji) in
                    Button {
                        uiState.autocompleteHandler?.autocomplete(with: ":\(emoji.shortcode):")
                    } label: {
                        HStack(spacing: 4) {
                            CustomEmojiImageView(emoji: emoji)
                                .frame(height: 30)
                            Text(verbatim: ":\(emoji.shortcode):")
                                .foregroundColor(Color(UIColor.label))
                        }
                    }
                    .frame(height: 30)
                    .padding(.vertical, 8)
                    .animation(.linear(duration: 0.2))
                }
                
                Spacer(minLength: 30)
            }
            .padding(.horizontal, 8)
            .frame(height: 46)
        }
    }
    
    private var toggleExpandedButton: some View {
        Button {
            expanded.toggle()
        } label: {
            Image(systemName: expanded ? "chevron.down" : "chevron.up")
                .resizable()
                .aspectRatio(contentMode: .fit)
        }
        .frame(width: 20, height: 20)
    }
    
    private func queryChanged(_ autocompleteState: ComposeUIState.AutocompleteState?) {
        guard case let .emoji(query) = autocompleteState,
              !query.isEmpty else {
            emojis = []
            return
        }
        
        mastodonController.getCustomEmojis { (emojis) in
            self.emojis =
                emojis.map { (emoji) -> (Emoji, (matched: Bool, score: Int)) in
                    (emoji, FuzzyMatcher.match(pattern: query, str: emoji.shortcode))
                }
                .filter(\.1.matched)
                .sorted { $0.1.score > $1.1.score }
                .map(\.0)
        }
    }
}

struct ComposeAutocompleteHashtagsView: View {
    @EnvironmentObject private var mastodonController: MastodonController
    @EnvironmentObject private var uiState: ComposeUIState
    
    @State private var hashtags: [Hashtag] = []
    @State private var trendingRequest: URLSessionTask?
    @State private var searchRequest: URLSessionTask?
    
    var body: some View {
        ScrollView(.horizontal) {
            HStack(spacing: 8) {
                ForEach(hashtags, id: \.name) { (hashtag) in
                    Button {
                        uiState.autocompleteHandler?.autocomplete(with: "#\(hashtag.name)")
                    } label: {
                        Text(verbatim: "#\(hashtag.name)")
                            .foregroundColor(Color(UIColor.label))
                    }
                    .frame(height: 30)
                    .padding(.vertical, 8)
                    .animation(.linear(duration: 0.1))
                }
                
                Spacer()
            }
            .padding(.horizontal, 8)
        }
        .onReceive(uiState.$autocompleteState.debounce(for: .milliseconds(250), scheduler: DispatchQueue.main), perform: queryChanged)
        .onDisappear {
            trendingRequest?.cancel()
        }
    }
    
    private func queryChanged(_ autocompleteState: ComposeUIState.AutocompleteState?) {
        guard case let .hashtag(query) = autocompleteState,
              !query.isEmpty else {
            hashtags = []
            return
        }
        
        let onlySavedTagsWorkItem = DispatchWorkItem {
            self.updateHashtags(searchResults: [], trendingTags: [], query: query)
        }
        
        // we only want to do the local-only search if the trends API call takes more than .25sec or it fails
        DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(250), execute: onlySavedTagsWorkItem)
        
        var trendingTags: [Hashtag] = []
        var searchedTags: [Hashtag] = []
        
        let group = DispatchGroup()
        
        group.enter()
        trendingRequest = mastodonController.run(Client.getTrends()) { (response) in
            defer { group.leave() }
            guard case let .success(trends, _) = response else { return }
            trendingTags = trends
        }
        
        group.enter()
        searchRequest = mastodonController.run(Client.search(query: "#\(query)", types: [.hashtags])) { (response) in
            defer { group.leave() }
            guard case let .success(results, _) = response else { return }
            searchedTags = results.hashtags
        }
        
        group.notify(queue: .main) {
            onlySavedTagsWorkItem.cancel()
            
            // if the query has changed, don't bother loading the now-outdated results
            if case .hashtag(query) = self.uiState.autocompleteState {
                self.updateHashtags(searchResults: searchedTags, trendingTags: trendingTags, query: query)
            }
        }
    }
    
    private func updateHashtags(searchResults: [Hashtag], trendingTags: [Hashtag], query: String) {
        let savedTags = SavedDataManager.shared.sortedHashtags(for: mastodonController.accountInfo!)
        
        hashtags = (searchResults + savedTags + trendingTags)
            .map { (tag) -> (Hashtag, (matched: Bool, score: Int)) in
                return (tag, FuzzyMatcher.match(pattern: query, str: tag.name))
            }
            .filter(\.1.matched)
            .sorted { $0.1.score > $1.1.score }
            .map(\.0)
    }
}

struct ComposeAutocompleteView_Previews: PreviewProvider {
    static var previews: some View {
        ComposeAutocompleteView(autocompleteState: .mention("shadowfacts"))
    }
}