//
//  ServerListConverterTests.swift
//  PrivadoTests
//
//  Created by Lizaveta Malinouskaya on 22.02.22.
//  Copyright © 2022 Privado LLC. All rights reserved.
//

import XCTest
@testable import PrivadoVPN

final class ServerListConverterTests: XCTestCase {

    enum Constant {
        static let allRecords = "ServerRecords"
        static let overquota = "Overquota"
        static let freemium = "Freemium"
        static let premium = "Premium"
        static let capacityGreater = "ServerRecordsCapacityGreater"
        static let freemiumWithEmpty = "FreemiumEmptyFields"
        static let freemiumNoEmpty = "FreemiumNoEmptyFields"
        static let freemiumMaintenance = "FreemiumMaintenance"
        static let capacityServers = "CapacityServers"
        static let capacityServersResult = "CapacityServersResult"
        static let lastServer = "LastServerSample"
        static let lastServerResult = "LastServerResult"
        static let currentServer = "CurrentServer"
        static let randomServers = "RandomServers"
    }
    
    let sampleGeolocation = GeoLocation(country: "AU",
                                        city: "Sydney",
                                        ip: "93.115.35.61",
                                        lat: "-33.946100000000001", long: "151.17699999999999")
    
    func sampleRecords(for resourseName: String) -> [ServerRecord] {
        let url = Bundle(for: CustomerRepoTests.self).url(forResource: resourseName, withExtension: "data")
        let data = try! Data(contentsOf: url!)
        let decoder = JSONDecoder()
        return try! decoder.decode(Array<ServerRecord>.self, from: data)
    }
    
    class ServerListInteractorMockup: ServerListInteractorInput {
        var preferredServer: PreferredServerType = .best
        
        var isFreemium: Bool = false
        
        var isOverquota: Bool = true
        
        var lastServerIsNil: Bool = false
        
        func fetchServers(completion: @escaping (Result<ServerListInteractorResult, Error>) -> Void) {
        }
        
        func cancelRequest() {
        }
        
        func storeServer(_ server: Server) {
        }
        
        func restoreServer() -> Server? {
            lastServerIsNil ? nil : sampleRecords(for: Constant.lastServer).first?.server
        }
        
        func sampleRecords(for resourseName: String) -> [ServerRecord] {
            let url = Bundle(for: CustomerRepoTests.self).url(forResource: resourseName, withExtension: "data")
            let data = try! Data(contentsOf: url!)
            let decoder = JSONDecoder()
            return try! decoder.decode(Array<ServerRecord>.self, from: data)
        }
        
        func setUser(userType: Customer.Plan) {
            switch userType {
            case .overquota:
                self.isFreemium = false
                self.isOverquota = true
            case .premium(value: ""):
                self.isFreemium = false
                self.isOverquota = false
            case .freemium:
                self.isFreemium = true
                self.isOverquota = false
            default:
                break
            }
        }
        
        func setPreffered(to type: PreferredServerType) {
            self.preferredServer = type
        }
    }
    
    let interactor = ServerListInteractorMockup()
    
    // MARK: - FilterRecordsForCurrentUser func tests
    
    func testFilterRecordsCapacityGreater() throws {
        let records = self.sampleRecords(for: Constant.capacityGreater)
        
        let result = ServerListConverter.filterRecords(records: records)
        XCTAssertEqual(result, [])
    }
    
    func testFilterRecordsCapacityLess() throws {
        let records = self.sampleRecords(for: Constant.allRecords)
        
        let result = ServerListConverter.filterRecords(records: records)
        XCTAssertEqual(result, records)
    }
    
    func testFilterRecordsEmptyStrings() throws {
        // In sample data there is single record for each case, and normal records:
        // server.name == ""
        // server.ip == ""
        // server.city == ""
        // server.country == ""
        
        let sampleEmptyRecords = self.sampleRecords(for: Constant.freemiumWithEmpty)
        let sampleResult = self.sampleRecords(for: Constant.freemiumNoEmpty)
        
        self.interactor.setUser(userType: .freemium)
        
        let result = ServerListConverter.filterRecords(records: sampleEmptyRecords)
        
        XCTAssertEqual(result, sampleResult)
    }
    
    func testFilterRecordsIsMaintenance() throws {
        
        let sampleMaintenanceRecords = self.sampleRecords(for: Constant.freemiumMaintenance)
        
        self.interactor.setUser(userType: .freemium)
        
        let result = ServerListConverter.filterRecords(records: sampleMaintenanceRecords)
        
        XCTAssertEqual(result, [])
    }
    
    // MARK: - selectLowCapacityCityRecords func tests
    
    func testSelectLowCapacityCityRecords() throws {
        
        let sampleCapacity = self.sampleRecords(for: Constant.capacityServers)
        var sampleResult = self.sampleRecords(for: Constant.capacityServersResult)
        
        var result = ServerListConverter.selectLowCapacityCityRecords(records: sampleCapacity)
        result = result.sorted(by: {$0.city > $1.city})
        sampleResult = sampleResult.sorted(by:  {$0.city > $1.city})
        XCTAssertEqual(sampleResult, result)
    }
    
    // MARK: - prepareContext func test
    // Testing logic of selecting server
    
    func testSelectOverquotaServer() throws {
        let sampleServers = self.sampleRecords(for: Constant.allRecords)
        self.interactor.setUser(userType: .overquota)
        
        let resultContext = ServerListConverter.prepareContext(using: nil,
                                                               isInitialLoading: false,
                                                               serverRecords: sampleServers,
                                                               preferred: self.interactor.preferredServer,
                                                               current: nil,
                                                               interactor: self.interactor)
        
        XCTAssertEqual(resultContext.selectedRecord, resultContext.bestRecord)
    }
    
    func testSelectPrefferedLastIsInitialLoadingServer() throws {
        let sampleServers = self.sampleRecords(for: Constant.allRecords)
        let lastRecord = self.sampleRecords(for: Constant.lastServer)
        self.interactor.setUser(userType: .freemium)
        self.interactor.setPreffered(to: .last)
        self.interactor.lastServerIsNil = false
        
        let resultContext = ServerListConverter.prepareContext(using: nil,
                                                               isInitialLoading: true,
                                                               serverRecords: sampleServers,
                                                               preferred: self.interactor.preferredServer,
                                                               current: nil,
                                                               interactor: self.interactor)
        
        XCTAssertEqual(resultContext.selectedRecord, lastRecord.first)
    }
    
    func testSelectPrefferedRandomIsInitialLoadingServer() throws {
        let sampleServers = self.sampleRecords(for: Constant.randomServers)
        self.interactor.setUser(userType: .freemium)
        self.interactor.setPreffered(to: .random)
        self.interactor.lastServerIsNil = false
        
        let resultContext = ServerListConverter.prepareContext(using: nil,
                                                               isInitialLoading: true,
                                                               serverRecords: sampleServers,
                                                               preferred: self.interactor.preferredServer,
                                                               current: nil,
                                                               interactor: self.interactor)
        
        XCTAssertEqual(sampleServers.first, resultContext.selectedRecord)
    }
    
    func testSelectCurrentServerNilLastServerNil() throws {
        let sampleServers = self.sampleRecords(for: Constant.allRecords)
        self.interactor.setUser(userType: .freemium)
        self.interactor.setPreffered(to: .none)
        self.interactor.lastServerIsNil = true
        
        let resultContext = ServerListConverter.prepareContext(using: self.sampleGeolocation,
                                                               isInitialLoading: false,
                                                               serverRecords: sampleServers,
                                                               preferred: self.interactor.preferredServer,
                                                               current: nil,
                                                               interactor: self.interactor)
        
        XCTAssertEqual(resultContext.selectedRecord, resultContext.bestRecord)
        
    }
    
    func testSelectCurrentServerNilLastServerNotNil() throws {
        let sampleServers = self.sampleRecords(for: Constant.allRecords)
        self.interactor.setUser(userType: .freemium)
        self.interactor.setPreffered(to: .none)
        self.interactor.lastServerIsNil = false
        
        let resultLastServer = self.sampleRecords(for: Constant.lastServer)
        
        let resultContext = ServerListConverter.prepareContext(using: nil,
                                                               isInitialLoading: false,
                                                               serverRecords: sampleServers,
                                                               preferred: self.interactor.preferredServer,
                                                               current: nil,
                                                               interactor: self.interactor)
        
        XCTAssertEqual(resultLastServer.first, resultContext.selectedRecord)
    }
    
    func testSelectCurrentServerNilLastServerIsBest() throws {
        let sampleServers = self.sampleRecords(for: Constant.lastServer)
        self.interactor.setUser(userType: .freemium)
        self.interactor.setPreffered(to: .none)
        self.interactor.lastServerIsNil = false
        
        let resultLastServer = self.sampleRecords(for: Constant.lastServer)
        
        let resultContext = ServerListConverter.prepareContext(using: self.sampleGeolocation,
                                                               isInitialLoading: false,
                                                               serverRecords: sampleServers,
                                                               preferred: self.interactor.preferredServer,
                                                               current: nil,
                                                               interactor: self.interactor)
        
        XCTAssertEqual(resultLastServer.first, resultContext.selectedRecord)
    }
    
    func testSelectCurrentServerExistsCityExists() throws {
        let sampleServers = self.sampleRecords(for: Constant.allRecords)
        let current = self.sampleRecords(for: Constant.currentServer)
        self.interactor.setUser(userType: .freemium)
        self.interactor.setPreffered(to: .none)
        self.interactor.lastServerIsNil = false
        
        let resultLastServer = self.sampleRecords(for: Constant.lastServer)
        
        let resultContext = ServerListConverter.prepareContext(using: nil,
                                                               isInitialLoading: false,
                                                               serverRecords: sampleServers,
                                                               preferred: self.interactor.preferredServer,
                                                               current: current.first,
                                                               interactor: self.interactor)
        
        XCTAssertEqual(resultLastServer.first, resultContext.selectedRecord)
    }
    
    func testSelectCurrentServerExistsCityNil() throws {
        let sampleServers = self.sampleRecords(for: Constant.randomServers)
        let current = self.sampleRecords(for: Constant.currentServer)
        self.interactor.setUser(userType: .freemium)
        self.interactor.setPreffered(to: .none)
        self.interactor.lastServerIsNil = false
        
        let resultBestServer = self.sampleRecords(for: Constant.randomServers)
        
        let resultContext = ServerListConverter.prepareContext(using: self.sampleGeolocation,
                                                               isInitialLoading: false,
                                                               serverRecords: sampleServers,
                                                               preferred: self.interactor.preferredServer,
                                                               current: current.first,
                                                               interactor: self.interactor)
        
        XCTAssertEqual(resultBestServer.first, resultContext.selectedRecord)
    }
    
}