//
//  PreferencePresenterIPAD.swift
//  OpenVPN
//
//  Created by Lizaveta Malinouskaya on 26.07.21.
//  Copyright © 2021 Privado LLC. All rights reserved.
//

import UIKit

protocol PreferenceViewInputIPAD {
    @discardableResult
    func showContent(for builder: ViewModuleBuilderClosure?, output: PreferenceControllerViewOutput, route: Route.iOSPreference?) -> Bool
    @discardableResult
    func showExistContent(view: UIView, route: Route.iOSPreference?) -> Bool
}

class PreferencePresenterIPAD: OptionsModuleOutputIPAD,
                               SettingsModuleOutput,
                               PreferenceControllerViewOutput,
                               PreferenceControllerOutputIPAD,
                               SettingsProtocolViewModuleOutput,
                               PreferenceMenuNBViewModuleOutput,
                               AccountPreferenceModuleOutput,
                               PreferenceModuleInputIPAD {
    public var viewInput: PreferenceViewInputIPAD?
    private var output: PreferenceModuleOutputIPAD
    private var customerPlan: Customer.Plan?
    private var isPremiumSuspendedCustomer: Bool = false
    private let session: Session

    private var viewStack: [(UIView, Route.iOSPreference?)] = []
    
    private var settingsState: SaveSettingsModel?
    init(customerRepo: CustomerRepo, session: Session, output: PreferenceModuleOutputIPAD) {
        self.output = output
        self.session = session
        self.customerPlan = customerRepo.currentCustomer?.plan
        
        customerRepo.customerEmitter.addReaction { [weak self] customer in
            guard let customer = customer else { return false }
            self?.customerPlan = customer.plan
            self?.isPremiumSuspendedCustomer = customer.isPremium && !(customer.isVPNActive ?? true) ? true : false
            return self.isExist
        }
        
        if let currentCustomer = customerRepo.currentCustomer {
            self.isPremiumSuspendedCustomer = currentCustomer.isPremium && !(currentCustomer.isVPNActive ?? true) ? true : false
            self.customerPlan = currentCustomer.plan
        }
    }

// very first controller
    func openPreference() {
        let preferenceViewBuilder = PreferenceViewModuleBuilder.build(
            data: Self.getPreferenceRoutes(for: self.customerPlan, isPremiumSuspended: self.isPremiumSuspendedCustomer),
            output: self
        )
        self.viewInput?.showContent(for: preferenceViewBuilder, output: self, route: nil)
    }
    
    // MARK: - SubmodulesOutput
        
    func openCrashReports() {
        let crashViewBuilder = CrashReportsBuilder.build()
        self.viewInput?.showContent(for: crashViewBuilder, output: self, route: .crashReports)
    }
    
    func openAccount() {
        let accountViewBuilder = AccountPreferenceBuilderIPAD.build(output: self)
        self.viewInput?.showContent(for: accountViewBuilder, output: self, route: .account)
    }

    func openPrivacyPolicy() {
        let privacyViewBuilder = PreferenceTextModuleBuilder.build(with: .privacyPolicy)
        self.viewInput?.showContent(for: privacyViewBuilder, output: self, route: .privacyPolicy)
    }
    
    func openTermsOfService() {
        let termsViewBuilder = PreferenceTextModuleBuilder.build(with: .termsOfService)
        self.viewInput?.showContent(for: termsViewBuilder, output: self, route: .termsOfService)
    }
    
    func openSettings() {
        let settingsViewBuilder = SettingsModuleBuilder.build(output: self)
        self.viewInput?.showContent(for: settingsViewBuilder, output: self, route: .settings)
    }
    
   func openContactUs() {
       guard let url = URL(string: PrivadoConstants.Link.contactUs) else {
           return
       }
       self.output.navigate(to: .navigate(url: url))
   }
    
    func openUpgrade() {
        let purchaseViewBuilder = PurchaseViewModuleBuilder.build(session: self.session, output: self)
        self.viewInput?.showContent(for: purchaseViewBuilder, output: self, route: .upgrade)
    }
    
    func openAutoConnect() {
        let autoConnectViewBuilder = AutoConnectViewModuleBuilder.build(output: self)
        self.viewInput?.showContent(for: autoConnectViewBuilder, output: self, route: .autoconnect)
    }
        
    func openOpenVPN() {
        let openVPNViewBuilder = OpenVPNPreferenceBuilder.build(output: self)
        self.viewInput?.showContent(for: openVPNViewBuilder, output: self, route: .openVPN)
    }
        
    func openDiagnostic() {
        let diagnosticViewBuilder = LogsModuleBuilder.build()
        self.viewInput?.showContent(for: diagnosticViewBuilder, output: self, route: .diagnostics)
    }
        
    func openOpenVPNPort() {
        let portView = OVPNPortPreferenceBuilder.build(output: self)
        self.viewInput?.showContent(for: portView, output: self, route: .openVPNPort)
    }
        
    func openOpenVPNProtocol() {
        let protocolViewBuilder = OVPNProtocolPreferenceBuilder.build(output: self)
        self.viewInput?.showContent(for: protocolViewBuilder, output: self, route: .openVPNProtocol)
    }
    
    func openMainScreen() {
        openApplicationRoute(.servers)
    }
        
    func doSignOut() {
        self.signOut()
    }
    
    func signOut() {
        openApplicationRoute(.login(type: .signout(isPassreset: false)))
    }

    func appendToStack(view: UIView, title route: Route.iOSPreference?) {
        self.viewStack.append((view, route))
    }
    
    func getSettings() -> SaveSettingsModel {
        let killswitch = UserSettings.shared.killSwitchEnabled
        var autoconnect: Bool {
            if UserSettings.shared.preferredServer == .none {
                return false
            }
            return true
        }
        let autoconnectvalue = UserSettings.shared.preferredServer.description
        let crashreporting = UserSettings.shared.isCrashReportsEnabled
        var proto: ProtocolsDescription {
            switch UserSettings.shared.vpnType {
            case .ikev2:
                return ProtocolsDescription.ikev
            case .openVPN:
                return ProtocolsDescription.openvpn
            case .wireGuard:
                return ProtocolsDescription.wireguard
            case .none:
                return ProtocolsDescription.automatic
            }
        }

        return SaveSettingsModel(killswitch: killswitch, autoconnect: autoconnect, autoconnectvalue: autoconnectvalue, crashreporting: crashreporting, proto: proto.description)
    }
    
    func didEnterSettings() {
        self.settingsState = self.getSettings()
    }
    
    func didExitSettings() {
        
        let settingsStateObject = self.getSettings()
        guard let settingsState = self.settingsState else { return }
        
        let extradata = settingsStateObject.jsonString
        var attributes = [PrivadoConstants.Event.Attributes.extradata: extradata]
        
        if settingsState == settingsStateObject {
            attributes[PrivadoConstants.Event.Attributes.value] = PrivadoConstants.Event.Attributes.canceled
        } else {
            attributes[PrivadoConstants.Event.Attributes.value] = PrivadoConstants.Event.Attributes.success
        }
        
        CometLogger.shared.event(name: PrivadoConstants.Event.Statistic.Application.settings, attributes: attributes, secured: nil)
    }
    
    func openPreviousScreen() {
        if self.viewStack.count > 1 {
            
            self.viewStack.remove(at: self.viewStack.count-1)
            guard let (view, route) = self.viewStack.last else {
                return
            }
            self.viewInput?.showExistContent(view: view, route: route)
        } 
    }
    
    func popAllContent() {
        while self.viewStack.count > 1 {
            openPreviousScreen()
        }
    }
    
    func handleRightNavItemClick() {
        guard let (currentView, _) = self.viewStack.last else {
            return
        }
        
        guard let handlableView = currentView as? PreferenceNavigationBar else {
            return
        }
        
        handlableView.rightItemClick()
    }
    
    func handleTrashNavItemClick() {
        guard let (currentView, _) = self.viewStack.last else {
            return
        }
        
        guard let handlableView = currentView as? PreferenceNavigationBar else {
            return
        }
        
        handlableView.trashItemClick()
    }
    
    // MARK: - Private
    
    private static func getPreferenceRoutes(for plan: Customer.Plan?, isPremiumSuspended: Bool) -> [Route.iOSPreference] {
        
        var preferenceRoutes: [Route.iOSPreference] = [.account, .settings, .contactus]
        
        guard let plan = plan else {
            return preferenceRoutes
        }
        if case .premium = plan,
           !isPremiumSuspended {
            return preferenceRoutes
        }
        preferenceRoutes.append(.upgrade)
        return preferenceRoutes
    }
    // MARK: - OptionsModuleOutput & AccountPreferenceModuleOutput
    func navigate(to route: Route.iOSPreference) {
        switch route {
        
        case .base:
            self.popAllContent()
            output.navigate(to: .preference(tab: nil))
        case .account:
            self.popAllContent()
            self.openAccount()
        case .contactus:
            self.popAllContent()
            self.openContactUs()
        case .settings:
            self.popAllContent()
            self.openSettings()
        case .upgrade:
            self.popAllContent()
            let extradata = CTAClick(screenType: CTAScreenType.menu).jsonString
            CometLogger.shared.event(name: PrivadoConstants.Event.Statistic.Application.CTAClick, attributes: [PrivadoConstants.Event.Attributes.extradata: extradata], secured: nil)
            self.openUpgrade()
        case .termsOfService:
            self.openTermsOfService()
        case .privacyPolicy:
            self.openPrivacyPolicy()
        default:
            break
        }
    }
    
    // MARK: - SettingsModuleOutput
    
    func didTapSettingsCell(of type: SettingsCellType) {
        switch type {
        case .openVPN:
            self.openOpenVPN()
        case .crashReports:
            self.openCrashReports()
        case .diagnostics:
            self.openDiagnostic()
        default:
            break
        }
    }
}