//
//  P2PListsService.swift
//  Wallet
//
//  Created by Saveliy Stavitsky on 10/7/21.
//  Copyright © 2021 AM. All rights reserved.
//

import Foundation
import Alamofire
import RealmSwift
import struct Resolver.Injected

class P2PListsService {

    @Injected(name: .realmP2PLists) private var realm: Realm

    @Injected var countries: Results<P2PCountry>
    @Injected var cities: Results<P2PCity>
    @Injected var banks: Results<P2PBank>
    @Injected var blockchains: Results<P2PBlockchain>
    @Injected var paymentSystems: Results<P2PPaymentSystem>
    @Injected var currencies: Results<P2PCurrency>

    func fetch(reload: Bool = false, completion: @escaping (String?) -> Void) {
        let lang = Locale.preferredLanguages[0].lowercased().starts(with: "en") ? "EN" : "RU"
        let lastUpdateSaved = Date(timeIntervalSince1970: UserDefaults.standard.double(forKey: "lastUpdate"))
        let lastLang = UserDefaults.standard.string(forKey: "lastLang") ?? ""

        if !reload && (lastLang != lang || countries.isEmpty
                        || blockchains.isEmpty || cities.isEmpty
                        || paymentSystems.isEmpty || banks.isEmpty || currencies.isEmpty) {
            fetch(reload: true, completion: completion)
            return
        }

        let variables = P2PListsGraphQLRequest.Variables(
            lang: lang
        )
        
        let environment = ApplicationEnvironment.shared().current
        AF.request(
            environment.backend.urlPath,
            method: .post,
            parameters: P2PListsGraphQLRequest(variables: variables,
                                               query: reload
                                                ? P2PListsGraphQLRequest.queryFull
                                                : P2PListsGraphQLRequest.queryShort),
            encoder: JSONParameterEncoder.default,
            headers: HTTPHeaders(environment.headers)
        )
//        .responseString(completionHandler: {
//            print($0)
//            print($0)
//        })
        .responseDecodable(of: GraphQLResponse<P2PListsGraphQLRequest.ResponseData>.self) { [weak self] response in
            switch response.result {
                case let .success(value):
//                    if let error = value.data?.p2pAllNotUserOrders?.errors ?? value.errorsDescription {
                    if let error = value.errorsDescription {
                        completion(error)
                    } else {
                        let lastUpdate = value.data?.lastUpdate.lastUpdate.asISODate() ?? Date()
                        if reload {
                            let countries = value.data?.countries?.countries ?? []
                            let cities = value.data?.cities?.cities ?? []
                            let banks = value.data?.banks?.banks ?? []
//                            let blockchains = value.data?.blockchains?.blockchains ?? []
                            let paymentSystems = value.data?.paymentSystems?.paymentSystems ?? []
                            let currencies = value.data?.currencies?.currencies ?? []

                            try? self?.realm.write {
                                self?.realm.deleteAll()
                                self?.realm.add(countries, update: .modified)
                                self?.realm.add(cities, update: .modified)
                                self?.realm.add(banks, update: .modified)
//                                self?.realm.add(blockchains, update: .modified)
                                self?.realm.add(paymentSystems, update: .modified)
                                self?.realm.add(currencies, update: .modified)
                            }

                            UserDefaults.standard.setValue(lastUpdate.timeIntervalSince1970, forKey: "lastUpdate")
                            UserDefaults.standard.setValue(lang, forKey: "lastLang")
                            completion(nil)
                        } else {
                            if lastUpdateSaved.timeIntervalSince1970 != lastUpdate.timeIntervalSince1970 {
                                self?.fetch(reload: true, completion: completion)
                            }
                        }
                    }
                case let .failure(error):
                    completion(error.localizedDescription)
            }
        }
    }
}