Sportstime/SportsTime/Core/Services/CloudKitService.swift

//
//  CloudKitService.swift
//  SportsTime
//

import Foundation
import CloudKit

// MARK: - CloudKit Errors

enum CloudKitError: Error, LocalizedError {
    case notSignedIn
    case networkUnavailable
    case serverError(String)
    case quotaExceeded
    case permissionDenied
    case recordNotFound
    case unknown(Error)

    var errorDescription: String? {
        switch self {
        case .notSignedIn:
            return "Please sign in to iCloud in Settings to sync data."
        case .networkUnavailable:
            return "Unable to connect to the server. Check your internet connection."
        case .serverError(let message):
            return "Server error: \(message)"
        case .quotaExceeded:
            return "iCloud storage quota exceeded."
        case .permissionDenied:
            return "Permission denied. Check your iCloud settings."
        case .recordNotFound:
            return "Data not found."
        case .unknown(let error):
            return "An unexpected error occurred: \(error.localizedDescription)"
        }
    }

    static func from(_ error: Error) -> CloudKitError {
        if let ckError = error as? CKError {
            switch ckError.code {
            case .notAuthenticated:
                return .notSignedIn
            case .networkUnavailable, .networkFailure:
                return .networkUnavailable
            case .serverResponseLost:
                return .serverError("Connection lost")
            case .quotaExceeded:
                return .quotaExceeded
            case .permissionFailure:
                return .permissionDenied
            case .unknownItem:
                return .recordNotFound
            default:
                return .serverError(ckError.localizedDescription)
            }
        }
        return .unknown(error)
    }
}

actor CloudKitService {
    static let shared = CloudKitService()

    private let container: CKContainer
    private let publicDatabase: CKDatabase

    private init() {
        self.container = CKContainer(identifier: "iCloud.com.sportstime.app")
        self.publicDatabase = container.publicCloudDatabase
    }

    // MARK: - Availability Check

    func isAvailable() async -> Bool {
        let status = await checkAccountStatus()
        return status == .available
    }

    func checkAvailabilityWithError() async throws {
        let status = await checkAccountStatus()
        switch status {
        case .available:
            return
        case .noAccount:
            throw CloudKitError.notSignedIn
        case .restricted:
            throw CloudKitError.permissionDenied
        case .couldNotDetermine:
            throw CloudKitError.networkUnavailable
        case .temporarilyUnavailable:
            throw CloudKitError.networkUnavailable
        @unknown default:
            throw CloudKitError.networkUnavailable
        }
    }

    // MARK: - Fetch Operations

    func fetchTeams(for sport: Sport) async throws -> [Team] {
        let predicate = NSPredicate(format: "sport == %@", sport.rawValue)
        let query = CKQuery(recordType: CKRecordType.team, predicate: predicate)

        let (results, _) = try await publicDatabase.records(matching: query)

        return results.compactMap { result in
            guard case .success(let record) = result.1 else { return nil }
            return CKTeam(record: record).team
        }
    }

    func fetchStadiums() async throws -> [Stadium] {
        let predicate = NSPredicate(value: true)
        let query = CKQuery(recordType: CKRecordType.stadium, predicate: predicate)

        let (results, _) = try await publicDatabase.records(matching: query)

        return results.compactMap { result in
            guard case .success(let record) = result.1 else { return nil }
            return CKStadium(record: record).stadium
        }
    }

    func fetchGames(
        sports: Set<Sport>,
        startDate: Date,
        endDate: Date
    ) async throws -> [Game] {
        var allGames: [Game] = []

        for sport in sports {
            let predicate = NSPredicate(
                format: "sport == %@ AND dateTime >= %@ AND dateTime <= %@",
                sport.rawValue,
                startDate as NSDate,
                endDate as NSDate
            )
            let query = CKQuery(recordType: CKRecordType.game, predicate: predicate)

            let (results, _) = try await publicDatabase.records(matching: query)

            let games = results.compactMap { result -> Game? in
                guard case .success(let record) = result.1 else { return nil }
                let ckGame = CKGame(record: record)

                guard let homeRef = record[CKGame.homeTeamRefKey] as? CKRecord.Reference,
                      let awayRef = record[CKGame.awayTeamRefKey] as? CKRecord.Reference,
                      let homeId = UUID(uuidString: homeRef.recordID.recordName),
                      let awayId = UUID(uuidString: awayRef.recordID.recordName)
                else { return nil }

                // Stadium ref is optional - use placeholder if not present
                let stadiumId: UUID
                if let stadiumRef = record[CKGame.stadiumRefKey] as? CKRecord.Reference,
                   let refId = UUID(uuidString: stadiumRef.recordID.recordName) {
                    stadiumId = refId
                } else {
                    stadiumId = UUID() // Placeholder - will be resolved via team lookup
                }

                return ckGame.game(homeTeamId: homeId, awayTeamId: awayId, stadiumId: stadiumId)
            }

            allGames.append(contentsOf: games)
        }

        return allGames.sorted { $0.dateTime < $1.dateTime }
    }

    func fetchGame(by id: UUID) async throws -> Game? {
        let predicate = NSPredicate(format: "gameId == %@", id.uuidString)
        let query = CKQuery(recordType: CKRecordType.game, predicate: predicate)

        let (results, _) = try await publicDatabase.records(matching: query)

        guard let result = results.first,
              case .success(let record) = result.1 else { return nil }

        let ckGame = CKGame(record: record)

        guard let homeRef = record[CKGame.homeTeamRefKey] as? CKRecord.Reference,
              let awayRef = record[CKGame.awayTeamRefKey] as? CKRecord.Reference,
              let stadiumRef = record[CKGame.stadiumRefKey] as? CKRecord.Reference,
              let homeId = UUID(uuidString: homeRef.recordID.recordName),
              let awayId = UUID(uuidString: awayRef.recordID.recordName),
              let stadiumId = UUID(uuidString: stadiumRef.recordID.recordName)
        else { return nil }

        return ckGame.game(homeTeamId: homeId, awayTeamId: awayId, stadiumId: stadiumId)
    }

    // MARK: - League Structure & Team Aliases

    func fetchLeagueStructure(for sport: Sport? = nil) async throws -> [LeagueStructureModel] {
        let predicate: NSPredicate
        if let sport = sport {
            predicate = NSPredicate(format: "sport == %@", sport.rawValue)
        } else {
            predicate = NSPredicate(value: true)
        }

        let query = CKQuery(recordType: CKRecordType.leagueStructure, predicate: predicate)
        query.sortDescriptors = [NSSortDescriptor(key: CKLeagueStructure.displayOrderKey, ascending: true)]

        let (results, _) = try await publicDatabase.records(matching: query)

        return results.compactMap { result in
            guard case .success(let record) = result.1 else { return nil }
            return CKLeagueStructure(record: record).toModel()
        }
    }

    func fetchTeamAliases(for teamCanonicalId: String? = nil) async throws -> [TeamAlias] {
        let predicate: NSPredicate
        if let teamId = teamCanonicalId {
            predicate = NSPredicate(format: "teamCanonicalId == %@", teamId)
        } else {
            predicate = NSPredicate(value: true)
        }

        let query = CKQuery(recordType: CKRecordType.teamAlias, predicate: predicate)

        let (results, _) = try await publicDatabase.records(matching: query)

        return results.compactMap { result in
            guard case .success(let record) = result.1 else { return nil }
            return CKTeamAlias(record: record).toModel()
        }
    }

    // MARK: - Delta Sync (Date-Based for Public Database)

    /// Fetch league structure records modified after the given date
    func fetchLeagueStructureChanges(since lastSync: Date?) async throws -> [LeagueStructureModel] {
        let predicate: NSPredicate
        if let lastSync = lastSync {
            predicate = NSPredicate(format: "lastModified > %@", lastSync as NSDate)
        } else {
            predicate = NSPredicate(value: true)
        }

        let query = CKQuery(recordType: CKRecordType.leagueStructure, predicate: predicate)
        query.sortDescriptors = [NSSortDescriptor(key: CKLeagueStructure.lastModifiedKey, ascending: true)]

        let (results, _) = try await publicDatabase.records(matching: query)

        return results.compactMap { result in
            guard case .success(let record) = result.1 else { return nil }
            return CKLeagueStructure(record: record).toModel()
        }
    }

    /// Fetch team alias records modified after the given date
    func fetchTeamAliasChanges(since lastSync: Date?) async throws -> [TeamAlias] {
        let predicate: NSPredicate
        if let lastSync = lastSync {
            predicate = NSPredicate(format: "lastModified > %@", lastSync as NSDate)
        } else {
            predicate = NSPredicate(value: true)
        }

        let query = CKQuery(recordType: CKRecordType.teamAlias, predicate: predicate)
        query.sortDescriptors = [NSSortDescriptor(key: CKTeamAlias.lastModifiedKey, ascending: true)]

        let (results, _) = try await publicDatabase.records(matching: query)

        return results.compactMap { result in
            guard case .success(let record) = result.1 else { return nil }
            return CKTeamAlias(record: record).toModel()
        }
    }

    // MARK: - Sync Status

    func checkAccountStatus() async -> CKAccountStatus {
        do {
            return try await container.accountStatus()
        } catch {
            return .couldNotDetermine
        }
    }

    // MARK: - Subscriptions

    func subscribeToScheduleUpdates() async throws {
        let subscription = CKQuerySubscription(
            recordType: CKRecordType.game,
            predicate: NSPredicate(value: true),
            subscriptionID: "game-updates",
            options: [.firesOnRecordCreation, .firesOnRecordUpdate]
        )

        let notification = CKSubscription.NotificationInfo()
        notification.shouldSendContentAvailable = true
        subscription.notificationInfo = notification

        try await publicDatabase.save(subscription)
    }

    func subscribeToLeagueStructureUpdates() async throws {
        let subscription = CKQuerySubscription(
            recordType: CKRecordType.leagueStructure,
            predicate: NSPredicate(value: true),
            subscriptionID: "league-structure-updates",
            options: [.firesOnRecordCreation, .firesOnRecordUpdate]
        )

        let notification = CKSubscription.NotificationInfo()
        notification.shouldSendContentAvailable = true
        subscription.notificationInfo = notification

        try await publicDatabase.save(subscription)
    }

    func subscribeToTeamAliasUpdates() async throws {
        let subscription = CKQuerySubscription(
            recordType: CKRecordType.teamAlias,
            predicate: NSPredicate(value: true),
            subscriptionID: "team-alias-updates",
            options: [.firesOnRecordCreation, .firesOnRecordUpdate]
        )

        let notification = CKSubscription.NotificationInfo()
        notification.shouldSendContentAvailable = true
        subscription.notificationInfo = notification

        try await publicDatabase.save(subscription)
    }

    /// Subscribe to all canonical data updates
    func subscribeToAllUpdates() async throws {
        try await subscribeToScheduleUpdates()
        try await subscribeToLeagueStructureUpdates()
        try await subscribeToTeamAliasUpdates()
    }
}