//
//  CustomerRepo.swift
//  PrivadoVPN
//
//  Created by Zhandos Bolatbekov on 12.02.2021.
//  Copyright © 2021 Privado LLC. All rights reserved.
//

import Foundation

typealias EmitterCustomerChangeType = (Customer?)

final class CustomerRepo {
    
    enum Constant {
        static let timeout: TimeInterval = 3
    }
    
    typealias GetCustomerDataCompletion = (_ result: Result<Customer?, Error>) -> Void
    
    let customerEmitter = Emitter<EmitterCustomerChangeType>()
    
    var currentCustomer: Customer? {
        didSet {
            DispatchQueue.main.async { [weak self] in
                guard let self = self else { return }
                guard self.currentCustomer.isExist else { return }
                self.customerEmitter.invoke(self.currentCustomer)
            }
        }
    }
    
    private(set) var shouldLoadCustomerData = true
    
    private let router: NetworkRouter
    private var sessionRecord: SessionRecord? {
        didSet {
            if let sessionRecord = self.sessionRecord
               , sessionRecord.token.value != oldValue?.token.value {
                shouldLoadCustomerData = true
            }
        }
    }
    
    // MARK: - Static
    
    static var instance = CustomerRepo()
    
    // MARK: - Init
    
    init(with router: NetworkRouter? = nil) {
        self.router = router ?? Environment.router
    }
    
    // MARK: - Interface
    
    func getCustomerData(withoutTraffic: Bool = false, then completion: @escaping GetCustomerDataCompletion) {
        let service = CustomerService.customerData(
            token: self.sessionRecord?.token.value ?? "",
            username: self.sessionRecord?.username ?? "",
            apiKey: PrivadoConstants.sessionKey,
            withoutTraffic: withoutTraffic
        )
        
        let fetchErrorTask = DispatchWorkItem { [weak self] in
            guard let self = self else { return }
            self.shouldLoadCustomerData = false
            self.currentCustomer = self.createDummyPremiumCustomer()
        }
        
        self.router.requestDecodable(Either<Customer.Response, ErrorResponse>.self, service: service) { result in
            result
                .flatMap {
                    switch $0.0 {
                    case let .firstType(response):
                        self.currentCustomer = response.data ?? self.createDummyPremiumCustomer()
                        self.shouldLoadCustomerData = false
                        fetchErrorTask.cancel()
                        return Result.success(response.data)
                    case let .secondType(error):
                        return Result.failure(error)
                    }
                }
                >>> completion
        }
        
        DispatchQueue.main.asyncAfter(deadline: .now() + Constant.timeout, execute: fetchErrorTask)
    }
    
    func set(sessionRecord: SessionRecord?) {
        self.sessionRecord = sessionRecord
    }
    
    func createDummyPremiumCustomer() -> Customer {
        return Customer(plan: .premium(value: ""),
                        email: "",
                        endDate: "",
                        username: "",
                        isPremium: true,
                        startDate: "",
                        premiumDate: nil,
                        serverGroup: "Premium",
                        trafficLeft: 0,
                        trafficTotal: 0,
                        speedLimit: 0,
                        connectionsLimit: nil,
                        loginUrl: nil,
                        isVPNActive: true,
                        localIp: nil,
                        protocols: nil)
    }
    
    func clear() {
        self.currentCustomer = nil
        self.customerEmitter.reactions = []
    }
}