//
//  DefaultProfileManager.swift
//  Passepartout
//
//  Created by Davide De Rosa on 2/25/22.
//  Copyright (c) 2022 Davide De Rosa. All rights reserved.
//
//  https://github.com/passepartoutvpn
//
//  This file is part of Passepartout.
//
//  Passepartout is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  Passepartout is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with Passepartout.  If not, see <http://www.gnu.org/licenses/>.
//

import Foundation
import Combine
import TunnelKitManager
import PassepartoutCore
import PassepartoutCore
import PassepartoutUtils

public class DefaultProfileManager: ProfileManagerWithCurrentProfile, ObservableObject {
    
    // MARK: Initialization
    
    private let store: KeyValueStore
    
    private let providerManager: ProviderManager
    
    let appGroup: String
    
    let keychainLabel: (String, VPNProtocolType) -> String
    
    let keychain: Keychain
    
    private let strategy: ProfileManagerStrategy
    
    // MARK: Observables

    @Published private var internalActiveProfileId: UUID? {
        willSet {
            pp_log.debug("Setting active profile: \(newValue?.uuidString ?? "nil")")
        }
    }

    @Published private var internalCurrentProfileId: UUID? {
        willSet {
            pp_log.debug("Setting current profile: \(newValue?.uuidString ?? "nil")")
        }
    }

    public var currentProfileId: UUID? {
        get {
            internalCurrentProfileId
        }
        set {
            guard let id = newValue else {
                internalCurrentProfileId = nil
                return
            }
            guard let profile = liveProfile(withId: id) else {
                return
            }
            internalCurrentProfileId = id
            setCurrentProfile(profile)
        }
    }

    public let currentProfile: ObservableProfile
    
    public let didUpdateProfiles = PassthroughSubject<Void, Never>()

    public let didUpdateActiveProfile = PassthroughSubject<UUID?, Never>()

    public let didCreateProfile = PassthroughSubject<Profile, Never>()
    
    private var cancellables: Set<AnyCancellable> = []

    public init(
        store: KeyValueStore,
        providerManager: ProviderManager,
        appGroup: String,
        keychainLabel: @escaping (String, VPNProtocolType) -> String,
        strategy: ProfileManagerStrategy
    ) {
        guard let _ = UserDefaults(suiteName: appGroup) else {
            fatalError("No entitlements for group '\(appGroup)'")
        }
        self.store = store
        self.providerManager = providerManager
        self.appGroup = appGroup
        self.keychainLabel = keychainLabel
        keychain = Keychain(group: appGroup)
        self.strategy = strategy

        currentProfile = ObservableProfile()
    }
}

// MARK: Index

extension DefaultProfileManager {
    private var allHeaders: [UUID: Profile.Header] {
        strategy.allHeaders
    }
    
    public var headers: [Profile.Header] {
        Array(allHeaders.values)
    }
    
    public var profiles: [Profile] {
        strategy.profiles()
    }
    
    public func isExistingProfile(withId id: UUID) -> Bool {
        allHeaders[id] != nil
    }
    
    public func isExistingProfile(withName name: String) -> Bool {
        allHeaders.contains {
            $0.value.name == name
        }
    }
}

// MARK: Profiles

extension DefaultProfileManager {
    public func liveProfileEx(withId id: UUID) throws -> ProfileEx {
        guard let profile = liveProfile(withId: id) else {
            pp_log.error("Profile not found: \(id)")
            throw PassepartoutError.missingProfile
        }
        pp_log.info("Found profile: \(profile.logDescription)")
        return (profile, isProfileReady(profile))
    }

    private func liveProfile(withId id: UUID) -> Profile? {
        pp_log.debug("Searching profile \(id)")

        // IMPORTANT: fetch live copy first (see intents)
        if isCurrentProfile(id) {
            pp_log.debug("Profile \(currentProfile.value.logDescription) found in memory (current profile)")
            return currentProfile.value
        }

        guard let profile = strategy.profile(withId: id) else {
            assertionFailure("Profile in headers yet not found in persistent store")
            return nil
        }
        guard !profile.vpnProtocols.isEmpty else {
            assertionFailure("Ditching profile, no OpenVPN/WireGuard settings found")
            return nil
        }

        pp_log.debug("Profile \(profile.logDescription) found")
        keychain.debugAllPasswords(matching: id, context: appGroup)

        return profile
    }

    public func saveProfile(_ profile: Profile, isActive: Bool?, updateIfCurrent: Bool = true) {
        guard !profile.isPlaceholder else {
            assertionFailure("Placeholder")
            return
        }

        pp_log.info("Writing profile \(profile.logDescription) to persistent store")
        strategy.saveProfile(profile)

        if let isActive = isActive {
            if isActive {
                pp_log.info("\tActivating profile...")
                activeProfileId = profile.id
            } else if activeProfileId == profile.id {
                pp_log.info("\tDeactivating profile...")
                activeProfileId = nil
            }
        } else if allHeaders.isEmpty {
            pp_log.info("\tActivating first profile...")
            activeProfileId = profile.id
        }

        // IMPORTANT: refresh live copy if just saved (e.g. via intents)
        if updateIfCurrent && isCurrentProfile(profile.id) {
            pp_log.info("Saved profile is also current profile, updating...")
            currentProfile.value = profile
        }
    }
    
    public func removeProfiles(withIds ids: [UUID]) {
        pp_log.info("Deleting profiles with ids \(ids)")

        pp_log.info("\tDeleting passwords from keychain...")
        for id in ids {
            keychain.removeAllPasswords(matching: id, context: appGroup)
        }

        pp_log.info("\tDeleting from persistent store...")
        strategy.removeProfiles(withIds: ids)
    }
    
    @available(*, deprecated, message: "only use for testing")
    public func removeAllProfiles() {
        let ids = Array(allHeaders.keys)
        removeProfiles(withIds: ids)
    }
    
    public func duplicateProfile(withId id: UUID, setAsCurrent: Bool) {
        guard let source = liveProfile(withId: id) else {
            return
        }
        let copy = source
            .withNewId()
            .renamedUniquely(withLastUpdate: false)

        if setAsCurrent {

            // iOS 14 goes crazy when changing binding of a presented NavigationLink
            if #available(iOS 15, *) {
                internalCurrentProfileId = copy.id
            }
            
            // autosaves copy if non-existing in persistent store
            setCurrentProfile(copy)
        } else {
            strategy.saveProfile(copy)
        }
    }

    public func persist() {
        pp_log.info("Persisting pending profiles")
        if !currentProfile.value.isPlaceholder {
            saveProfile(currentProfile.value, isActive: nil, updateIfCurrent: false)
        }
    }
}

// MARK: Observation

extension DefaultProfileManager {
    private func setCurrentProfile(_ profile: Profile) {
        guard !currentProfile.isLoading else {
            pp_log.warning("Already loading another profile")
            return
        }
        guard profile.id != currentProfile.value.id else {
            pp_log.debug("Profile \(profile.logDescription) is already current profile")
            return
        }

        pp_log.info("Set current profile: \(profile.logDescription)")

        //
        // IMPORTANT: this method is called on app launch if there is an active profile, which
        // means that carelessly calling .saveProfiles() may trigger an unnecessary
        // willUpdateProfiles() and a potential animation in subscribers (e.g. OrganizerView)
        //
        // current profile, when set on launch, is always existing, so we take care
        // checking that to avoid an undesired save
        //
        var profilesToSave: [Profile] = []
        if isExistingProfile(withId: currentProfile.value.id) {
            pp_log.info("Defer saving of former current profile \(currentProfile.value.logDescription)")
            profilesToSave.append(currentProfile.value)
        }
        if !isExistingProfile(withId: profile.id) {
            pp_log.info("Defer saving of transient current profile \(profile.logDescription)")
            profilesToSave.append(profile)
        }
        defer {
            if !profilesToSave.isEmpty {
                strategy.saveProfiles(profilesToSave)
            }
        }

        if isProfileReady(profile) {
            currentProfile.value = profile
        } else {
            currentProfile.isLoading = true
            Task {
                try await makeProfileReady(profile)
                await MainActor.run {
                    currentProfile.value = profile
                    currentProfile.isLoading = false
                }
            }
        }
    }
}

extension DefaultProfileManager {
    public func observeUpdates() {
        $internalActiveProfileId
            .sink {
                self.didUpdateActiveProfile.send($0)
            }.store(in: &cancellables)

        strategy.willUpdateProfiles()
            .dropFirst()
            .sink {
                self.willUpdateProfiles($0)
            }.store(in: &cancellables)
    }
    
    private func willUpdateProfiles(_ newHeaders: [UUID: Profile.Header]) {
        pp_log.debug("Profiles updated: \(newHeaders)")
        defer {
            objectWillChange.send()
        }
        
        // IMPORTANT: invalidate current profile if deleted
        if !currentProfile.value.isPlaceholder && !newHeaders.keys.contains(currentProfile.value.id) {
            pp_log.info("\tCurrent profile deleted, invalidating...")
            currentProfile.value = .placeholder
        }

        let newProfile = strategy.profile(withId: currentProfile.value.id)
        if let newProfile = newProfile, newProfile != currentProfile.value {
            pp_log.info("Current profile remotely updated")
            currentProfile.value = newProfile
        }

        if let activeProfileId = activeProfileId, !newHeaders.keys.contains(activeProfileId) {
            pp_log.info("\tActive profile was deleted")
            self.activeProfileId = nil
        }
        
        didUpdateProfiles.send()

        // IMPORTANT: defer task to avoid recursive saves (is non-main thread an issue?)
        // FIXME: Core Data, not sure about this workaround
        Task {
            fixDuplicateNames(in: newHeaders)
        }
    }
    
    private func fixDuplicateNames(in newHeaders: [UUID: Profile.Header]) {
        var allNames = newHeaders.values.map(\.name)
        let distinctNames = Set(allNames)
        distinctNames.forEach {
            guard let i = allNames.firstIndex(of: $0) else {
                return
            }
            allNames.remove(at: i)
        }
        let duplicates = Set(allNames)
        guard !duplicates.isEmpty else {
            pp_log.debug("No duplicated profiles")
            return
        }
        pp_log.debug("Duplicated profile names: \(duplicates)")

        var renamedProfiles: [Profile] = []
        duplicates.forEach { name in
            let headers = newHeaders.values.filter {
                $0.name == name
            }
            guard headers.count > 1 else {
                assertionFailure("Name '\(name)' marked as duplicate but headers.count not > 1")
                return
            }

//            headers.removeFirst()
            headers.forEach { dupHeader in
                let uniqueHeader = dupHeader.renamedUniquely(withLastUpdate: true)
                pp_log.debug("Renaming duplicate profile \(dupHeader.logDescription) to \(uniqueHeader.logDescription)")
                guard var uniqueProfile = liveProfile(withId: uniqueHeader.id) else {
                    pp_log.warning("Skipping profile \(dupHeader.logDescription) renaming, not found")
                    return
                }
                uniqueProfile.header = uniqueHeader
                renamedProfiles.append(uniqueProfile)
            }
        }
        if !renamedProfiles.isEmpty {
            strategy.saveProfiles(renamedProfiles)
            pp_log.debug("Duplicates successfully renamed!")
        }
    }
}

// MARK: Readiness

extension DefaultProfileManager {
    private func isProfileReady(_ profile: Profile) -> Bool {
        isProfileProviderAvailable(profile)
    }

    public func makeProfileReady(_ profile: Profile) async throws {
        try await fetchProfileProviderIfMissing(profile)
    }
    
    private func isProfileProviderAvailable(_ profile: Profile) -> Bool {
        guard let providerName = profile.header.providerName else {
            return true // host
        }
        return providerManager.isAvailable(providerName, vpnProtocol: profile.currentVPNProtocol)
    }

    private func fetchProfileProviderIfMissing(_ profile: Profile) async throws {
        guard let providerName = profile.header.providerName else {
            return // host
        }
        if providerManager.isAvailable(providerName, vpnProtocol: profile.currentVPNProtocol) {
            return
        }
        do {
            pp_log.info("Importing missing provider \(providerName)...")
            try await providerManager.fetchProviderPublisher(
                withName: providerName,
                vpnProtocol: profile.currentVPNProtocol,
                priority: .remoteThenBundle
            ).async()
            pp_log.info("Finished!")
        } catch {
            pp_log.error("Unable to import missing provider: \(error)")
            throw PassepartoutError.missingProfile
        }
    }
}

// MARK: KeyValueStore

extension DefaultProfileManager {
    public private(set) var activeProfileId: UUID? {
        get {
            guard let idString: String = store.value(forLocation: StoreKey.activeProfileId) else {
                return nil
            }
            guard let id = UUID(uuidString: idString) else {
                pp_log.warning("Active profile id is malformed, ignoring")
                return nil
            }
            guard isExistingProfile(withId: id) else {
                pp_log.warning("Active profile \(id) does not exist, ignoring")
                return nil
            }
            return id
        }
        set {

            // trigger publisher
            internalActiveProfileId = newValue

            store.setValue(newValue?.uuidString, forLocation: StoreKey.activeProfileId)
        }
    }
}

private extension DefaultProfileManager {
    private enum StoreKey: String, KeyStoreDomainLocation {
        case activeProfileId
        
        var domain: String {
            "Passepartout.ProfileManager"
        }
    }
}