//
//  MainControllerRoot.swift
//  List
//
//  Created by Saveliy Stavitsky on 7/14/20.
//  Copyright © 2020 Igor Danich. All rights reserved.
//

import UIKit
import Branch
import Alamofire
import WebKit
import WalletKit
import WalletFoundation
import Combine
import RealmSwift

extension UserDefaults {
    @objc dynamic var chatsReadCount: [String: Int] {
        return (dictionary(forKey: "chatsReadCount") as? [String: Int]) ?? [:]
    }
}

extension UIViewController {
    // swiftlint:disable force_cast
    var mainController: MainController { UIApplication.shared.windows.first?.rootViewController as! MainController }
}

final class MainController: UIViewController {

    @IBOutlet var headerView: UIView!
    @IBOutlet var accountButton: UIButton!
    @IBOutlet var accountBarButton: UIBarButtonItem!
    @IBOutlet var backButton: UIButton!
    @IBOutlet var barNav: UINavigationBar!
    @IBOutlet weak var resourcesSwitch: CommonSwitch!
    @IBOutlet private weak var resourcesBtn: UIBarButtonItem!
    @IBOutlet weak var settingsGearButton: UIBarButtonItem!
    @IBOutlet private weak var offset: NSLayoutConstraint!
    @IBOutlet var inviteView: MainViewInvite!
    private lazy var interfaceCover: UIView = {
        let view = UIView()
        view.backgroundColor = Asset.snow.color
        view.frame = self.view.bounds
        return view
    }()

    private let service = Main.Service()

    private var notificationTokens = [NotificationToken]()
    
    private var cancellables = Set<AnyCancellable>()
    
    private var hasTitle: Bool {
        guard let barNavItems = self.barNav.items else { return false }
        let titlesOfItems = barNavItems.compactMap { $0.title }
        return !titlesOfItems.isEmpty
    }

    var content: MainControllerContent { self.child()! }

    let timerFreeTx = Timer.scheduledTimer(withTimeInterval: 5.0, repeats: true) { timer in
        timer.tolerance = 0.5
        Accounts().fetchQuota()
    }
    
    let timerBalances = Timer.scheduledTimer(withTimeInterval: 2.0, repeats: true) { timer in
        timer.tolerance = 0.2
        if Wallet.Service.Tokens.shared.balances.collection.count == 0 {
            Wallet.Service.Tokens.shared.balances.fetch()
        } else {
            timer.invalidate()
        }
    }

    override func viewDidLoad() {
        
        super.viewDidLoad()
        
        self.accountBarButton.customView = self.accountButton
        self.headerView.layer.shadowColor = Asset.lightGray.color.cgColor
        self.configureAccountButton()
        self.configureQRButton()
        self.inviteView.changeVisibility(Accounts().hasActiveAccounts)
        self.updateMsgCount()

//        if !UserDefaults.standard.bool(forKey: "isFreeTransactionsOn") {
//            changeFreeSwitchState()
//        }
        
//        Network.shared.onReabilityChange = {  }
        
        self.view.addSubview(self.interfaceCover)
        Loader.show()
        
        Accounts().messageShelf.activeBook?.fetch()
        
        Account.Service.Authorize.shared.updateAuthPublisher
            .sink { [weak self] in
                
                guard let self else { return }
                
                self.setupSubscriptions()
                guard let link = self.deepLink else { return }
                self.process(deepLink: link)
                self.deepLink = nil
            }
            .store(in: &self.cancellables)
        
        NotificationCenter.default.publisher(for: .didUpdateAccountQuota)
            .sink { [weak self] _ in
                guard let self else { return }
                
                self.configureResourcesSwitch()
            }
            .store(in: &self.cancellables)
        
        NotificationCenter.default.publisher(for: .didUpdateReachability)
            .sink { _ in
                guard !Network.Service().isReachable else { return }
                Alert.error(text: L10n.Main.NoInternet.text)
            }
            .store(in: &self.cancellables)

        self.inviteView.didLockedFunds = { [weak self] in
            self?.content.push(P2PLockedFundsController(), animated: true)
        }

//        Notification.subscribe(name: .didChangeAccount) { [weak self] _ in
//            P2PMainLockedFundsService.shared.fetch {
// //               if P2P.Service.balances.collection.
//                if P2PMyDealsService.shared.deals.count > 0 || P2PMyOrdersService.shared.orders.count > 0 {
//                    self?.inviteView.lockedFundsView.isHidden = false
//                    let msg = P2PMyOrdersService.shared.orders
//                        .reduce("", { $0 + "Order: \($1.id):\($1.volume_balance)" })
//                        + P2PMyDealsService.shared.deals
//                        .reduce("", { $0 + "Deal: \($1.id):\($1.volume)" })
//                    self?.inviteView.lockedFundsLabel.attributedText = msg.attributed
//                        .applying(attribute: .font, value: FontFamily.GolosUI.medium.font(size: 20))
//                        .applying(attribute: .foregroundColor, value: Asset.textSnow.color)
//                    self?.inviteView.lockedFundsLabel.speed = .rate(20.0)
//                } else {
//                    self?.inviteView.lockedFundsView.isHidden = true
//                }
//            }
//        }

        self.resourcesBtn.customView = self.resourcesSwitch
        self.resourcesSwitch.isSelected = Accounts().quota.isEnabled
        
        Accounts().activePublisher
            .sink { [weak self] _ in
                
                guard let self else { return }
                
                self.notificationTokens.removeAll()

                self.notificationTokens.append(contentsOf: [
                    self.service.p2pBalancesService.balances.observe(on: .main) { [weak self] _ in
                        
                        Wallet.Service.Tokens.shared.balances.fetch()

                        if (self?.service.p2pBalancesService.balances.filter("amount > 0 || blockedAmount > 0").count ?? 0) > 0 {
                            self?.inviteView.lockedFundsView.isHidden = false
                            let msg = L10n.P2p.Main.LockedFunds.headerTitle +
                            (self?.service.p2pBalancesService.balances.filter("amount > 0 || blockedAmount > 0")
                                    .reduce("", { $0 + " \(($1.amount.decimalValue + $1.blockedAmount.decimalValue).toString(max: 5)) \($1.symbol)    " }) ?? "")
                            + "     "
                            self?.inviteView.lockedFundsLabel.attributedText = msg.attributed
                                .applying(attribute: .font, value: FontFamily.GolosUI.medium.font(size: 20))
                                .applying(attribute: .foregroundColor, value: Asset.textSnow.color)
                            self?.inviteView.lockedFundsLabel.speed = .rate(20.0)
                        } else {
                            self?.inviteView.lockedFundsView.isHidden = true
                        }
                    }
                ].compactMap { $0 })
            }
            .store(in: &self.cancellables)
        
        Accounts().activePublisher
            .sink { [weak self] _ in
                Accounts().fetchQuota()
                self?.onAccountChange()
            }
            .store(in: &self.cancellables)
        
        Accounts().lockedPublisher
            .sink { [weak self] _ in
                self?.onAccountChange()
            }
            .store(in: &self.cancellables)
        
        Account.Service.Update.shared.updatePublisher
            .receive(on: DispatchQueue.main)
            .sink { [weak self] _ in
                self?.onAccountChange()
            }
            .store(in: &self.cancellables)

        // TODO: - Here we need handle update notifications
        // Notification.subscribe(name: .socketDidUpdateValue) { [weak self] in
            // print($0)
            // print("\(Date()) - socket update")
        // }
        
        NotificationCenter.default.publisher(for: .didUpdateHistory)
            .sink { [weak self] in
                guard let username = Accounts().current?.name,
                      username == $0.userInfo?["username"] as? String else { return }
                Wallet.Service.Tokens.shared.balances.fetch()
                self?.updateMsgCount()
            }
            .store(in: &self.cancellables)

        UserDefaults.standard
            .publisher(for: \.chatsReadCount, options: [.initial, .new])
            .sink { [weak self] _ in
                guard let self else { return }
                guard let username = Accounts().current?.name else {
                    self.setChatsBadge(count: 0)
                    return
                }
                self.setChatsBadge(count: self.chatsMsgsCount(username: username) - self.chatsRead(by: username))
            }
            .store(in: &self.cancellables)
        
        self.inviteView.didClose = { [weak self] in self?.inviteView.isHidden = true }
    }
    
    func chatsRead(by username: String) -> Int {
        var chatsRead = 0
        AccountViewAuthorize.showGetPrivateKey(in: self) {
            guard
                let msgsHistoryService = try? CryptoChat.Service.MsgsHistory(
                    username: username,
                    encryptionKey: $0
                )
            else { return }
            msgsHistoryService.fetchFromLocalHistory()
            chatsRead = msgsHistoryService.readCount
        }
        return chatsRead
    }

    private func chatsMsgsCount(username: String) -> Int {
        
        guard let current = Accounts().messageShelf.activeBook else { return 0 }
        
        let contract = ApplicationEnvironment.shared().current.contract(.chat)
        let action = Network.Model.Blockchain.Action.chatSendDm.rawValue
        
        return current.actions
            .where {
                $0.username == username
                && $0.account == contract
                && $0.name == action
                && $0.receiver == username
            }
            .count
    }

    func setChatsBadge(count: Int) {
        DispatchQueue.main.async { [weak self] in
            self?.content.viewControllers?
                .compactMap { $0 as? UINavigationController }
                .compactMap { $0.viewControllers.first }
                .first(where: { $0 is CryptoChatControllerChats })?
                .navigationController?.tabBarItem.badgeValue = count > 0 ? "\(count)" : nil
        }
    }
    
    override func viewDidAppear(_ animated: Bool) {
        super.viewDidAppear(animated)

        StoreReviewHelper.checkAndAskForReview()
        
        Accounts().messageShelf.activeBook?.fetch()
        
        let bank = Accounts().bank
        if !bank.active.isExist {
            
            if !bank.wallets.isEmpty {
                let ctrl = AccountsListController()
                self.mainController.content.push(ctrl, animated: true)
            } else if Account.Service.isAccountMigrated,
                      !(Account.Service.Authorize.shared.password ?? "").isEmpty {
                self.showWalletBoarding()
            }
            
        }
//        else if !UserDefaults.standard.bool(forKey: "onboardingOverviewPassed") {
//            present(StoryboardScene.AccountOnboarding.accountOnboardingControllerInterfaceType.instantiate(), animated: true)
//        }
        else if Accounts().isAuthorized {
            
            self.interfaceCover.isHidden = true
            Loader.hide()
            
            // Show news
            /*Task {
                if let urlString = await service.loadNews().first?.url,
                   let url = URL(string: urlString),
                    !(AccountOnboarding.Service.Common().newsShowed ?? []).contains(urlString) {

                    let webview = WKWebView()
                    webview.load(URLRequest(url: url))
                    webview.addHeightConstraint(height: UIScreen.main.bounds.height * 0.8 - 100)

                    Popup.show(
                        views: [webview],
                        submit: L10n.Common.Button.close,
                        in: self
                    )

                    AccountOnboarding.Service.Common().newsShowed = (AccountOnboarding.Service.Common().newsShowed ?? []) + [urlString]
                }
            }*/
        }
    }
    
    func showWalletBoarding() {
        guard self.view.window != nil else { return }
        let ctrl = WalletBoardingViewController {
            if !Accounts().hasActiveAccounts {
                let vc = AccountsListController()
                self.content.push(vc, animated: false)
            }
        }
        ctrl.modalPresentationStyle = .fullScreen
        self.present(ctrl, animated: true)
    }

    func updateMsgCount() {
        
        guard let username = Accounts().current?.name else {
            self.setChatsBadge(count: 0)
            return 
        }
        
        if UserDefaults.standard.object(forKey: "chatsReadCount") == nil {
            UserDefaults.standard.setValue([username: self.chatsMsgsCount(username: username)], forKey: "chatsReadCount")
        } else if !(UserDefaults.standard.dictionary(forKey: "chatsReadCount")?.keys.contains(username) ?? false) {
            var readDict = (UserDefaults.standard.dictionary(forKey: "chatsReadCount") as? [String: Int]) ?? [:]
            readDict[username] = self.chatsMsgsCount(username: username)
            UserDefaults.standard.setValue(readDict, forKey: "chatsReadCount")
        }
        
        self.setChatsBadge(count: self.chatsMsgsCount(username: username) - self.chatsRead(by: username))
    }

    @objc func onAccountChange() {
        
        self.configureAccountButton()
        self.configureQRButton()
        self.configureResourcesSwitch()
        self.setupSubscriptions()
        self.inviteView.changeVisibility(Accounts().hasActiveAccounts)

        self.updateMsgCount()
        
        if Accounts().collection.isEmpty { 
            self.showWalletBoarding() 
        }
        
        DispatchQueue.main.async { [weak self] in
            guard let self,
                  self.view.window.isExist else { return }
            self.interfaceCover.isHidden = true
            Loader.hide()
        }
    }
    
    func setupSubscriptions() {
        
        guard let username = Accounts().current?.name,
              !Network.webSockets.contains(id: "\(username)-sockets2.0") else {
            return
        }
        
        Network.webSockets.remove(idSuffix: "-sockets2.0")
        
        let timeText = Date().toISODateString
        let signature = Network.Service.Blockchain.signWithK1(privateKey: AccountViewAuthorize.getPrivateKey(),
                                                              data: timeText.data(using: .utf8) ?? Data())
        
        let signaturesString = #"""
        { \\\"username\\\": \\\"$username\\\", \\\"text\\\": \\\"$timeText\\\", \\\"signature\\\": \\\"$signature\\\" }
        """#
            .replacingOccurrences(of: "$username", with: username)
            .replacingOccurrences(of: "$timeText", with: timeText)
            .replacingOccurrences(of: "$signature", with: signature)

        let subscription =
        #"""
        {"id":"2","type":"start","payload":{"query":"subscription { notifications(lang: $lang, signature: \"$signature\"){ notificationType state payload previousUid currentUid }}","variables":null}}
        """#
            .replacingOccurrences(of: "$signature", with: signaturesString)
            .replacingOccurrences(of: "$lang", with: Common.Model.Language.current.rawValue)
        Network.webSockets.open(subscription: subscription, id: "\(username)-sockets2.0")

        self.service.reloadP2PData(username: Accounts().current?.name ?? "")
    }

    private func configureAccountButton() {
        
        let wallet = Accounts().current
        
        let accountButtonTitle = wallet?.isOnActiveState == true ? (wallet?.name ?? L10n.Account.Button.empty)
                                                              : L10n.Account.Button.addAccounts
        self.accountButton.setAttributedTitle(accountButtonTitle.attributed(style: .bold,
                                                                            size: 16,
                                                                            color: Asset.textSnow.color),
            for: .normal
        )
        
        self.accountButton.isEnabled = wallet?.isOnActiveState == true
        self.accountButton.backgroundColor = wallet?.isOnActiveState == true ? Asset.deepWater.color : Asset.disabled.color
        self.accountButton.isUserInteractionEnabled = wallet?.isOnActiveState == true && !Accounts().isLocked
        self.accountButton.setImage(Accounts().isLocked ? Asset.accountLock.image : Asset.commonEos.image, for: .normal)
    }
    
    private func configureQRButton() {
        let wallet = Accounts().current
        self.settingsGearButton.isEnabled = wallet?.isOnActiveState == true
        self.settingsGearButton.image = wallet?.isOnActiveState == true ? Asset.commonButtonQr.image : Asset.commonButtonQrDisabled.image
    }
    
    private func configureResourcesSwitch() {
        let wallet = Accounts().current
        let quota = Accounts().quota
        self.resourcesSwitch.isActive = wallet?.isOnActiveState == true
        self.resourcesSwitch.lzTextFrontSelected = wallet?.isOnActiveState == true ? "\(quota.count)" : ""
        self.resourcesSwitch.set(isSelected: quota.isEnabled, animated: true)
    }

    @IBAction func accountPressed(_ sender: Any) {
//        let ctrl = AccountsSelectionViewController()
        let ctrl = AccountsListController()
        self.mainController.content.push(ctrl, animated: true)
    }

    @IBAction func onResources(_: AnyObject?) {
        let ctrl = StoryboardScene.Resources.setup.instantiate()
        ctrl.shouldHideBackButton = self.hasTitle
        self.content.push(ctrl, animated: true)
    }
    
    @IBAction func qrPressed(_ sender: Any) {
        guard UIImagePickerController.isSourceTypeAvailable(.photoLibrary) else {
            let ctrl = ScannerViewController()
            ctrl.navigationItem.leftBarButtonItem = .close { [weak self] in self?.dismiss(animated: true) }
            ctrl.didCapture = { [weak self] string in
                guard let self else { return }
                self.dismiss(animated: true)
                self.readQrData(string: string)
            }
            let navCtrl = UINavigationController(rootViewController: ctrl)
            navCtrl.modalPresentationStyle = .fullScreen
            present(navCtrl, animated: true)
            return
        }
        Alert.system(
            actions: [
                .init(title: L10n.Wallet.Send.qrCamera, style: .default) { [weak self] _ in
                    let ctrl = ScannerViewController()
                    ctrl.navigationItem.leftBarButtonItem = .close { [weak ctrl] in ctrl?.dismiss(animated: true) }
                    ctrl.didCapture = { string in
                        self?.dismiss(animated: true)
                        self?.readQrData(string: string)
                    }
                    let navCtrl = UINavigationController(rootViewController: ctrl)
                    navCtrl.modalPresentationStyle = .fullScreen
                    UIViewController.topController().present(navCtrl, animated: true)
                },
                .init(title: L10n.Wallet.Send.qrLibrary, style: .default) { [weak self] _ in
                    guard let self else { return }
                    let ctrl =  UIImagePickerController()
                    ctrl.delegate = self
                    ctrl.sourceType = .photoLibrary
                    UIViewController.topController().present(ctrl, animated: true)
                },
                .init(title: L10n.Main.Qr.showMy, style: .default) { [weak self] _ in
                    guard let self else { return }
                    let ctrl = StoryboardScene.Wallet.receive.instantiate()
                    ctrl.isQuickLook = true
                    self.mainController.content.push(ctrl, animated: true)
                },
                .init(title: L10n.Common.Button.cancel, style: .cancel)
            ],
            style: .actionSheet,
            in: self
        )
    }
    
    private func openTransfer(with dictionary: [String: Any]) {
        let viewController = StoryboardScene.Wallet.transfer.instantiate()
        viewController.dictionary = dictionary
        
        let navigationController = self.content.selectedViewController as? UINavigationController
        navigationController?.popToRootViewController(animated: true)
        navigationController?.pushViewController(viewController, animated: true)
    }

    private func readQrData(string: String) {
        if let link = URL(string: string) {
            Branch.getInstance().handleDeepLink(link)
        } else {
            self.openTransfer(with: convertStringToDictionary(text: string) ?? [:])
        }
    }
    
    private var deepLink: DeepLink?
    
    // swiftlint:disable cyclomatic_complexity function_body_length
    func process(deepLink: DeepLink) {
        
        guard Accounts().isAuthorized else {
            self.deepLink = deepLink
            return
        }
        
        let navigationController = self.content.selectedViewController as? UINavigationController

        switch deepLink.action {
        case .walletAuth:
            let dictionary = deepLink.dictionary()
            if let callbackUrl = dictionary["callback_url"] as? String,
               let verificationCode = dictionary["verification_code"] as? String,
               let account = Accounts().current?.name {
                let siteUrl = dictionary["site_url"] as? String ?? ""
                let siteName = ((dictionary["site_name"] as? String) ?? "").isEmpty
                    ? " " : "\((dictionary["site_name"] as? String) ?? " ")"
                Popup.show(
                    title: ((dictionary["site_name"] as? String) ?? "").isEmpty
                    ? L10n.Main.ListLogin.title : L10n.Main.ListLogin.titleOn(siteName),
                    views: [
                        .label(
                            text: L10n.Main.ListLogin.description(siteName)
                                .attributed(style: .regular, size: 16, color: Asset.textCoal.color),
                            numberOfLines: 0
                        )
                    ],
                    submit: L10n.Common.Button.confirm,
                    in: navigationController ?? self
                ) { ctrl in
                    Loader.show(in: ctrl)
                    AccountViewAuthorize.showGetPrivateKey(in: navigationController ?? self) {
                        let data = "{\"account\":\"\(account)\",\"verification_code\":\"\(verificationCode)\"}"
                        let signature = Network.Service.Blockchain.signWithK1(privateKey: $0, data: data.data(using: .utf8) ?? Data())
                        AF.request(
                            callbackUrl,
                            method: .post,
                            parameters: ["signature": signature, "data": data],
                            encoding: JSONEncoding.default
                        ).responseString {
                            self.interfaceCover.isHidden = true
                            Loader.hide(in: ctrl)
                            Popup.hide()
                            
                            guard let statusCode = $0.response?.statusCode else { return }
                            
                            let errorTitle: String?
                            if statusCode == 200 {
                                // Open URL if it exists
                                deepLink.url >>- { UIApplication.shared.open($0) }
                                return
                            } else if !siteUrl.isEmpty,
                                      let url = URL(string: siteUrl) {
                                url >>- { UIApplication.shared.open($0) }
                                return
                            } else if let error = ($0.error as NSError?) {
                                Alert.notify(error.localizedDescription, dismiss: ctrl)
                                return
                            } else if statusCode >= 400, statusCode < 500 {
                                errorTitle = L10n.tr("Localizable", "main.listLogin.expired")
                            } else {
                                errorTitle = L10n.tr("Localizable", "main.listLogin.unexpected")
                            }
                            
                            errorTitle >>- { Alert.notify($0, dismiss: ctrl) }
                            
                        }
                    }
                }
            }
        case .transfer, .competitivePrice:
            let viewController = StoryboardScene.Wallet.transfer.instantiate()
            viewController.dictionary = deepLink.dictionary()
            navigationController?.popToRootViewController(animated: true)
            navigationController?.pushViewController(viewController, animated: true)
        case .connect:
            if let model = deepLink.get(AccountModelConnect.self),
               let account = Accounts().collection.filter({ $0.name == model.from }).first {
                Accounts().current = account
                let ctrl = StoryboardScene.Account.connect.instantiate()
                ctrl.service.model = model
                (self.content.selectedViewController as? UINavigationController)?.popToRootViewController(animated: true)
                (self.content.selectedViewController as? UINavigationController)?.pushViewController(ctrl, animated: true)
            }
        case .chat:
            // guard UIApplication.shared.applicationState == .inactive else { return }
            if let model = deepLink.get(CryptoChat.Model.DeepLink.self) {
                AccountViewAuthorize.showGetPrivateKey(in: self) {
                    guard
                       let user = Accounts().current,
                       let msgsHistoryService = try? CryptoChat.Service.MsgsHistory(
                           username: user.name,
                           encryptionKey: $0
                       )
                    else { return }
                    let ctrl = CryptoChatControllerChat(username: model.account, unreadCount: 0, service: msgsHistoryService)
                    (self.content.selectedViewController as? UINavigationController)?.popToRootViewController(animated: true)
                    self.content.selectChatViewController()
                    guard let selectedNavigation = (self.content.selectedViewController as? UINavigationController),
                          !(selectedNavigation.viewControllers.last is CryptoChatControllerChat) else { return }
                    selectedNavigation.pushViewController(ctrl, animated: true)
                    selectedNavigation.setNavigationBarHidden(false, animated: true)
               }
            }
        case .chatMessage:
            // guard UIApplication.shared.applicationState == .inactive else { return }
            guard let info = deepLink.info,
                let receiver = info["receiver"] as? String,
                let sender = info["sender"] as? String,
                let account = Accounts().collection.filter({ $0.name == receiver }).first
            else { return }
            Accounts().current = account
            AccountViewAuthorize.showGetPrivateKey(in: self) {
                guard
                   let user = Accounts().current,
                   let msgsHistoryService = try? CryptoChat.Service.MsgsHistory(
                       username: user.name,
                       encryptionKey: $0
                   )
                else { return }
                let controller = CryptoChatControllerChat(username: sender, unreadCount: 0, service: msgsHistoryService)
                (self.content.selectedViewController as? UINavigationController)?.popToRootViewController(animated: true)
                self.content.selectChatViewController()
                guard let selectedNavigation = (self.content.selectedViewController as? UINavigationController),
                      !(selectedNavigation.viewControllers.last is CryptoChatControllerChat) else {
                    return
                }
                selectedNavigation.pushViewController(controller, animated: true)
                selectedNavigation.setNavigationBarHidden(false, animated: true)
           }
        case .tokenization:
            if let model = deepLink.get(Apartments.Model.Tokenization.self),
               let account = Accounts().collection.filter({
                    $0.name == model.permission
               }).first {
                Accounts().current = account
                let ctrl = StoryboardScene.Apartments.request.instantiate()
                ctrl.title = L10n.Apartments.Tokenization.title
                ctrl.popupDescription = L10n.Apartments.Tokenization.popup
                let service = Apartments.Service.Tokenization()
                service.image = Asset.apartmentsTokenization.image
                service.warning = L10n.Apartments.Tokenization.warning
                service.submit = L10n.Apartments.Tokenization.submit
                service.title = L10n.Apartments.Tokenization.description
                service.actionTitle = L10n.Apartments.Tokenization.Emission.title
                service.contract = model.contract
                service.action = model.action
                service.symbol = model.symbol
                service.fetchApartment(id: model.apt_id, contract: model.contract, symbol: model.symbol) { (success) in
                    guard success else { return }
                    service.receiver = nil
                    ctrl.service = service
                    (self.content.selectedViewController as? UINavigationController)?.popToRootViewController(animated: true)
                    (self.content.selectedViewController as? UINavigationController)?.pushViewController(ctrl, animated: true)
                }
            }
        case .approveBuy:
            if let model = deepLink.get(Apartments.Model.ApproveBuy.self),
               let account = Accounts().collection.filter({
                    $0.name == model.permission
               }).first {
                Accounts().current = account
                let ctrl = StoryboardScene.Apartments.request.instantiate()
                ctrl.title = L10n.Apartments.Approve.title
                ctrl.popupDescription = L10n.Apartments.Approve.popup
                let service = Apartments.Service.Approve()
                service.warning = L10n.Apartments.Approve.warning
                service.submit = L10n.Apartments.Approve.submit
                service.title = L10n.Apartments.Approve.description
                service.actionTitle = L10n.Apartments.Approve.Emission.title
                service.contract = model.contract
                service.action = model.action
                service.symbol = model.token
                service.fetchApartment(id: model.apt_id, contract: model.contract, symbol: model.token) { (success) in
                    guard success else { return }
                    service.receiver = nil
                    ctrl.service = service
                    (self.content.selectedViewController as? UINavigationController)?.popToRootViewController(animated: true)
                    (self.content.selectedViewController as? UINavigationController)?.pushViewController(ctrl, animated: true)
                }
            }
        case .emission:
            if let model = deepLink.get(Apartments.Model.Emission.self),
               let account = Accounts().collection.filter({
                    $0.name == model.permission
               }).first {
                Accounts().current = account
                let ctrl = StoryboardScene.Apartments.request.instantiate()
                ctrl.title = L10n.Apartments.Emission.title
                ctrl.popupDescription = L10n.Apartments.Emission.popup
                let service = Apartments.Service.Emission()
                service.image = Asset.apartmentsEmission.image
                service.warning = L10n.Apartments.Emission.warning
                service.title = L10n.Apartments.Emission.description
                service.actionTitle = L10n.Apartments.Tokenization.Emission.title
                service.submit = L10n.Apartments.Emission.submit
                service.contract = model.contract
                service.action = model.action
                service.to = model.to
                service.amount = model.amount
                service.symbol = model.symbol
                service.memo = model.memo
                service.fetchApartment(id: model.apt_id, contract: model.contract, symbol: model.symbol) { (success) in
                    guard success else { return }
                    ctrl.service = service
                    (self.content.selectedViewController as? UINavigationController)?.popToRootViewController(animated: true)
                    (self.content.selectedViewController as? UINavigationController)?.pushViewController(ctrl, animated: true)
                }
            }
        case .transactionTransfer, .transactionEmission, .transactionInheritance/*, .cashDealComplete*/:
            if let info = deepLink.info,
               let username = info["receiver"] as? String,
               let symbol = info["currency"] as? String,
               let account = Accounts().collection.filter({ $0.name == username }).first {
                Accounts().current = account
                if let index = self.content.viewControllers?.lastIndex(where: { ($0 as? UINavigationController)?.viewControllers.first is WalletController }) {
                    self.content.selectedIndex = index
                    let walletController = ((self.content.viewControllers?[index] as? UINavigationController)?.viewControllers.first as? WalletController)
                    walletController?.selectedSymbol = symbol
                    ((self.content.viewControllers?[index] as? UINavigationController)?.viewControllers.first as? WalletController)?.selectedSymbol = symbol
                    (self.content.viewControllers?[index] as? UINavigationController)?.popToRootViewController(animated: true)
                }

                Wallet.Service.Tokens.shared.balances.fetch()
            }
        case .p2pDealNew, .p2pDealComplete, .p2pDealCancel, .p2pDealDispute:
            guard UIApplication.shared.applicationState == .inactive else { return }
            if let info = deepLink.info,
               let username = info["receiver"] as? String,
               (info["currency"] as? String).isExist,
               let account = Accounts().collection.filter({ $0.name == username }).first {

                Accounts().current = account
                if let index = self.content.viewControllers?.lastIndex(where: { ($0 as? UINavigationController)?.viewControllers.first is P2PControllerDashboard }) {
                    self.content.selectedIndex = index
                    (self.content.viewControllers?[index] as? UINavigationController)?.popToRootViewController(animated: true)
//                    P2P.Service.Dashboard.shared.symbol = symbol
                    Wallet.Service.Tokens.shared.balances.fetch()
                }
            }
        /*case .cashDealNew, .cashDealConfirm, .cashDealCancel:
            if let info = deepLink.info,
               let username = info["receiver"] as? String,
               let account = Accounts().collection.filter({ $0.username == username }).first {
                Accounts().current = account
                if let index = content.viewControllers?.lastIndex(where: { ($0 as? UINavigationController)?.viewControllers.first is CCCPMainViewController }) {
                    content.selectedIndex = index
                    (content.viewControllers?[index] as? UINavigationController)?.popToRootViewController(animated: true)
                    if deepLink.action == .cashDealNew || deepLink.action == .cashDealCancel {
                        let ctrl = CCCPControllerExchangeRequests()
                        ctrl.type = .incomingRequests
                        (content.viewControllers?[index] as? UINavigationController)?.pushViewController(ctrl, animated: true)
                    }
                }
            }*/
        case .news:
            if let info = deepLink.info,
               let aps = info["aps"] as? [String: Any],
               let alert = aps["alert"] as? [String: String] {
                Popup.show(title: alert["title"], description: alert["body"] ?? "", submit: L10n.Common.Button.ok)
            }
        }
    }
}

extension MainController: UINavigationControllerDelegate, UIImagePickerControllerDelegate {
    func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey: Any]) {
        picker.dismiss(animated: true)
        guard
            let selectedImage = info[.originalImage] as? UIImage,
            let detector = CIDetector(ofType: CIDetectorTypeQRCode, context: nil, options: [CIDetectorAccuracy: CIDetectorAccuracyHigh]),
            let ciImage = CIImage(image: selectedImage)
        else { return }
        var qrCodeLink = ""
        for feature in (detector.features(in: ciImage) as? [CIQRCodeFeature]) ?? [] {
            qrCodeLink += feature.messageString ?? ""
        }
        print(qrCodeLink) // Your result from QR Code
        if !qrCodeLink.isEmpty {
            readQrData(string: qrCodeLink)
        } else {
            Alert.error(L10n.Main.Qr.notValidError)
        }
    }
}