PadelClub/PadelClub/Data/Federal/FederalPlayer.swift

//
//  FederalPlayer.swift
//  PadelClub
//
//  Created by Razmig Sarkissian on 01/03/2024.
//

import Foundation

protocol PlayerHolder {

    func getFirstName() -> String
    func getLastName() -> String
    func formattedRank() -> String
    func formattedLicense() -> String
    func getPoints() -> Double?
    func getRank() -> Int?
    func isUnranked() -> Bool
    var male: Bool { get }
    var tournamentPlayed: Int? { get }
    var clubName: String? { get }
    var ligueName: String? { get }
    var assimilation: String? { get }
    var computedAge: Int? { get }
    func getAssimilatedAsMaleRank() -> Int?
}

extension PlayerHolder {
    var isAssimilated: Bool {
        assimilation == "Oui"
    }
}

fileprivate extension Int {
    var femaleInMaleAssimilation: Int {
        self + femaleInMaleAssimilationAddition
    }
    
    var femaleInMaleAssimilationAddition: Int {
        switch self {
        case 1...10: return 400
        case 11...30: return 1000
        case 31...60: return 2000
        case 61...100: return 3000
        case 101...200: return 8000
        case 201...500: return 12000
        default:
            return 15000
        }
    }
}

extension ImportedPlayer: PlayerHolder {
    func getAssimilatedAsMaleRank() -> Int? {
        guard male == false else { return nil }
        return getRank()?.femaleInMaleAssimilation
    }
    
    var computedAge: Int? { nil }
    
    var tournamentPlayed: Int? {
        Int(tournamentCount)
    }
    
    func getPoints() -> Double? {
        self.points
    }
    
    func getFirstName() -> String {
        self.firstName ?? "prénom inconnu"
    }
    
    func getLastName() -> String {
        self.lastName ?? "nom inconnu"
    }
    
    func formattedLicense() -> String {
        if let license { return license.computedLicense }
        return "aucune licence"
    }
    
    func getRank() -> Int? {
        Int(rank)
    }
    
    func isUnranked() -> Bool {
        false
    }
    
    func formattedRank() -> String {
        rank.formatted()
    }

    func isMalePlayer() -> Bool {
        male
    }
    
    func hitForSearch(_ searchText: String) -> Int {
        var trimmedSearchText = searchText.lowercased().trimmingCharacters(in: .whitespaces).folding(options: .diacriticInsensitive, locale: .current)
        trimmedSearchText = trimmedSearchText.replaceCharactersFromSet(characterSet: .punctuationCharacters, replacementString: " ")
        trimmedSearchText = trimmedSearchText.replaceCharactersFromSet(characterSet: .symbols, replacementString: " ")
        
        if trimmedSearchText.isEmpty { return 0 }
        let tokens = trimmedSearchText.components(separatedBy: .whitespacesAndNewlines).filter { $0.isEmpty == false }
        if let license, trimmedSearchText.contains(license) {
            return 100
        }
        
        let label = canonicalFullName!
        if tokens.count > 1 {
            var wordFound = 0
            if trimmedSearchText.lowercased().components(separatedBy: .whitespacesAndNewlines).count > 1 {
                let searchFields: Set = Set([firstName!.canonicalVersion.components(separatedBy: .whitespacesAndNewlines), lastName!.canonicalVersion.components(separatedBy: .whitespacesAndNewlines)].flatMap { $0 })
                let tokens: Set = Set(trimmedSearchText.components(separatedBy: .whitespacesAndNewlines))
                wordFound = searchFields.intersection(tokens).count
            }

            if wordFound == 2 {
                if let first = tokens.pairs().first(where: { a,b in
                    label.contains(a) && label.contains(b)
                }) {
                    return 2 + first.0.count + first.1.count
                }
            } else {
                return wordFound * 10
            }
        } else if let first = tokens.first {
            if label.contains(first) {
                return 1
            }
        }
        return 0
    }
}

struct FederalPlayer {
    var rank: Int
    var lastName: String
    var firstName: String
    var country: String
    var license: String
    var points: Double?
    var assimilation: String
    var tournamentCount: Int?
    var ligue: String
    var clubCode: String
    var club: String
    var isMale: Bool
    
    var fullNameCanonical: String
    
    /*
     ;RANG;NOM;PRENOM;Nationalité;N° Licence;POINTS;Assimilation;NB. DE TOURNOIS JOUES;LIGUE;CODE CLUB;CLUB;
     */
    
    var isManPlayer: Bool {
        isMale
    }

    var isAssimilated: Bool {
        assimilation == "Oui"
    }
    
    var currentRank: Int {
        rank
    }
    
    init?(_ data: String, isMale: Bool = false) {
        self.isMale = isMale

        var result = data.components(separatedBy: .newlines).map { $0.trimmed }
        result = result.reversed().drop(while: {
            $0.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
        }).reversed() as [String]
        
        result = Array(result.drop(while: {
            $0.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
        }))

        print(result)
        if result.count < 11 {
            return nil
        }
        if let _rank = Int(result[0]) {
            rank = _rank
        } else {
            return nil
        }
        lastName = result[1]
        firstName = result[2]
        
        fullNameCanonical = result[1].canonicalVersion + " " + result[2].canonicalVersion
        country = result[3]
        license = result[4]
        
//        let matches = result[5].matches(of: try! Regex("[0-9]{1,5}\\.00"))
//
//        if matches.count == 1 {
//            let pts = result[5][matches.first!.range]
//            points = Double(pts.replacingOccurrences(of: ",", with: "."))
//            if pts.count < result[5].count {
//
//            }
//        }
//
        points = Double(result[5].replacingOccurrences(of: ",", with: "."))
        assimilation = result[6]
        tournamentCount = Int(result[7])
        ligue = result[8]
        clubCode = result[9]
        club = result[10]
    }

    static func lastRank(mostRecentDateAvailable: Date?, man: Bool) async -> Int? {
        let context = PersistenceController.shared.localContainer.newBackgroundContext()
        let lastPlayerFetch = ImportedPlayer.fetchRequest()
        lastPlayerFetch.sortDescriptors = [NSSortDescriptor(keyPath: \ImportedPlayer.rank, ascending: false)]
        var predicate = NSPredicate(format: "male == \(man)")
        if let mostRecentDateAvailable {
            predicate = NSCompoundPredicate(andPredicateWithSubpredicates: [predicate, NSPredicate(format: "importDate == %@", mostRecentDateAvailable as CVarArg)])
        }
        lastPlayerFetch.predicate = predicate

        do {
            if let lr = try context.fetch(lastPlayerFetch).first?.rank {
                let fetch = ImportedPlayer.fetchRequest()
                var rankPredicate = NSPredicate(format: "rank == %i", lr)
                if let mostRecentDateAvailable {
                    rankPredicate = NSCompoundPredicate(andPredicateWithSubpredicates: [rankPredicate, NSPredicate(format: "importDate == %@", mostRecentDateAvailable as CVarArg)])
                }
                fetch.predicate = rankPredicate

                let lastPlayersCount = try context.count(for: fetch)
                return Int(lr) + Int(lastPlayersCount) - 1
            }
        } catch {
            print("ImportedPlayer.fetchRequest", error)
        }
        
        return nil
    }

}