import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif

public enum QoderWebSite: CaseIterable, Sendable {
    case international
    case china

    var usageURL: URL {
        switch self {
        case .international:
            URL(string: "https://qoder.com/api/v2/me/usages/big_model_credits")!
        case .china:
            URL(string: "https://qoder.com.cn/api/v2/me/usages/big_model_credits")!
        }
    }

    public var dashboardURL: URL {
        switch self {
        case .international:
            URL(string: "https://qoder.com/account/usage")!
        case .china:
            URL(string: "https://qoder.com.cn/account/usage")!
        }
    }

    var webOrigin: String {
        switch self {
        case .international:
            "https://qoder.com"
        case .china:
            "https://qoder.com.cn"
        }
    }

    var cookieDomains: [String] {
        switch self {
        case .international:
            ["qoder.com", "www.qoder.com"]
        case .china:
            ["qoder.com.cn", "www.qoder.com.cn"]
        }
    }
}

public enum QoderUsageFetcher {
    private static let log = CodexBarLog.logger(LogCategories.qoderUsage)
    private static let userAgent =
        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " +
        "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36"

    public static func fetchUsage(
        cookieHeader: String,
        site: QoderWebSite = .international,
        transport: any ProviderHTTPTransport = ProviderHTTPClient.shared,
        now: Date = Date(),
        timeout: TimeInterval = 15) async throws -> QoderUsageSnapshot
    {
        let data = try await self.send(
            cookieHeader: cookieHeader,
            site: site,
            transport: transport,
            timeout: timeout)
        return try self.parseUsage(data: data, now: now)
    }

    private static func send(
        cookieHeader: String,
        site: QoderWebSite,
        transport: any ProviderHTTPTransport,
        timeout: TimeInterval) async throws -> Data
    {
        var request = URLRequest(url: site.usageURL)
        request.httpMethod = "GET"
        request.timeoutInterval = timeout
        request.setValue(cookieHeader, forHTTPHeaderField: "Cookie")
        request.setValue("application/json, text/plain, */*", forHTTPHeaderField: "Accept")
        request.setValue("en-US,en;q=0.9", forHTTPHeaderField: "Accept-Language")
        request.setValue(self.userAgent, forHTTPHeaderField: "User-Agent")
        request.setValue(site.webOrigin, forHTTPHeaderField: "Origin")
        request.setValue("\(site.webOrigin)/account/usage", forHTTPHeaderField: "Referer")
        request.setValue("XMLHttpRequest", forHTTPHeaderField: "X-Requested-With")
        request.setValue("2.5.35", forHTTPHeaderField: "Bx-V")

        let response: ProviderHTTPResponse
        do {
            response = try await transport.response(for: request)
        } catch is CancellationError {
            throw CancellationError()
        } catch let error as URLError where error.code == .cancelled {
            throw CancellationError()
        } catch {
            throw QoderUsageError.networkError(error.localizedDescription)
        }
        if response.statusCode == 401 || response.statusCode == 403 {
            throw QoderUsageError.invalidCredentials
        }
        guard (200..<300).contains(response.statusCode) else {
            Self.log.error("Qoder usage API returned \(response.statusCode)")
            throw QoderUsageError.apiError(response.statusCode)
        }
        return response.data
    }

    static func parseUsage(data: Data, now: Date = Date()) throws -> QoderUsageSnapshot {
        let response: QoderUsageResponse
        do {
            response = try JSONDecoder().decode(QoderUsageResponse.self, from: data)
        } catch {
            throw QoderUsageError.parseFailed("invalid JSON: \(error.localizedDescription)")
        }

        guard let summary = response.totalQuota?.quotaSummary else {
            throw QoderUsageError.parseFailed("missing totalQuota.quotaSummary")
        }

        let merged = try Self.mergedQuota(
            base: summary,
            shared: response.sharedQuota?.quotaSummary)

        return QoderUsageSnapshot(
            usedCredits: merged.usedCredits,
            totalCredits: merged.totalCredits,
            remainingCredits: merged.remainingCredits,
            usagePercentage: merged.usagePercentage,
            unit: merged.unit,
            resetsAt: response.nextResetAt,
            updatedAt: now)
    }

    private struct MergedQuota {
        let usedCredits: Double
        let totalCredits: Double
        let remainingCredits: Double
        let usagePercentage: Double
        let unit: String?
    }

    private static func mergedQuota(
        base: QoderQuotaSummary,
        shared: QoderQuotaSummary?) throws -> MergedQuota
    {
        let baseUsed = base.usedValue
        let baseTotal = base.limitValue
        let baseRemaining = try Self.remainingCredits(for: base)

        guard let shared else {
            let percentage = try Self.usagePercentage(
                used: baseUsed,
                total: baseTotal,
                remaining: baseRemaining,
                provided: base.usagePercentage)
            return MergedQuota(
                usedCredits: baseUsed,
                totalCredits: baseTotal,
                remainingCredits: baseRemaining,
                usagePercentage: percentage,
                unit: base.unit)
        }

        let sharedUsed = shared.usedValue
        let sharedTotal = shared.limitValue
        let sharedRemaining = try Self.remainingCredits(for: shared)
        let used = baseUsed + sharedUsed
        let total = baseTotal + sharedTotal
        let remaining = baseRemaining + sharedRemaining
        let percentage = try Self.usagePercentage(
            used: used,
            total: total,
            remaining: remaining,
            provided: nil)
        return MergedQuota(
            usedCredits: used,
            totalCredits: total,
            remainingCredits: remaining,
            usagePercentage: percentage,
            unit: base.unit ?? shared.unit)
    }

    private static func remainingCredits(for summary: QoderQuotaSummary) throws -> Double {
        guard summary.usedValue >= 0,
              summary.limitValue >= 0,
              summary.remainingValue.map({ $0 >= 0 }) ?? true
        else {
            throw QoderUsageError.parseFailed("quota values must be nonnegative")
        }
        return summary.remainingValue ?? max(0, summary.limitValue - summary.usedValue)
    }

    private static func usagePercentage(
        used: Double,
        total: Double,
        remaining: Double,
        provided: Double?) throws -> Double
    {
        guard used >= 0, total >= 0, remaining >= 0 else {
            throw QoderUsageError.parseFailed("quota values must be nonnegative")
        }
        guard total > 0 else {
            guard used == 0, remaining == 0 else {
                throw QoderUsageError.parseFailed("zero total quota must have zero usage and remaining")
            }
            return provided ?? 100
        }
        return provided ?? (used / total) * 100
    }
}

private struct QoderUsageResponse: Decodable {
    let totalQuota: QoderQuotaContainer?
    let sharedQuota: QoderQuotaContainer?
    let nextResetAt: Date?

    private enum CodingKeys: String, CodingKey {
        case totalQuota
        case totalQuotaSnake = "total_quota"
        case sharedQuota
        case sharedQuotaSnake = "shared_quota"
        case nextResetAt
        case nextResetAtSnake = "next_reset_at"
    }

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.totalQuota =
            try container.decodeIfPresent(QoderQuotaContainer.self, forKey: .totalQuota) ??
            container.decodeIfPresent(QoderQuotaContainer.self, forKey: .totalQuotaSnake)
        self.sharedQuota =
            try container.decodeIfPresent(QoderQuotaContainer.self, forKey: .sharedQuota) ??
            container.decodeIfPresent(QoderQuotaContainer.self, forKey: .sharedQuotaSnake)
        self.nextResetAt =
            Self.decodeDate(from: container, forKey: .nextResetAt) ??
            Self.decodeDate(from: container, forKey: .nextResetAtSnake)
    }

    private static func decodeDate(
        from container: KeyedDecodingContainer<CodingKeys>,
        forKey key: CodingKeys) -> Date?
    {
        if let value = try? container.decode(String.self, forKey: key) {
            return self.parseISO8601Date(value)
        }
        if let value = try? container.decode(Double.self, forKey: key) {
            let seconds = value > 10_000_000_000 ? value / 1000 : value
            return Date(timeIntervalSince1970: seconds)
        }
        return nil
    }

    private static func parseISO8601Date(_ value: String) -> Date? {
        let fractional = ISO8601DateFormatter()
        fractional.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
        if let date = fractional.date(from: value) {
            return date
        }

        let plain = ISO8601DateFormatter()
        plain.formatOptions = [.withInternetDateTime]
        return plain.date(from: value)
    }
}

private struct QoderQuotaContainer: Decodable {
    let quotaSummary: QoderQuotaSummary?

    private enum CodingKeys: String, CodingKey {
        case quotaSummary
        case quotaSummarySnake = "quota_summary"
    }

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.quotaSummary =
            try container.decodeIfPresent(QoderQuotaSummary.self, forKey: .quotaSummary) ??
            container.decodeIfPresent(QoderQuotaSummary.self, forKey: .quotaSummarySnake)
    }
}

private struct QoderQuotaSummary: Decodable {
    let usedValue: Double
    let limitValue: Double
    let remainingValue: Double?
    let usagePercentage: Double?
    let unit: String?

    private enum CodingKeys: String, CodingKey {
        case usedValue
        case usedValueSnake = "used_value"
        case limitValue
        case limitValueSnake = "limit_value"
        case remainingValue
        case remainingValueSnake = "remaining_value"
        case usagePercentage
        case usagePercentageSnake = "usage_percentage"
        case unit
    }

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.usedValue =
            try container.decodeIfPresent(Double.self, forKey: .usedValue) ??
            container.decode(Double.self, forKey: .usedValueSnake)
        self.limitValue =
            try container.decodeIfPresent(Double.self, forKey: .limitValue) ??
            container.decode(Double.self, forKey: .limitValueSnake)
        self.remainingValue =
            try container.decodeIfPresent(Double.self, forKey: .remainingValue) ??
            container.decodeIfPresent(Double.self, forKey: .remainingValueSnake)
        self.usagePercentage =
            try container.decodeIfPresent(Double.self, forKey: .usagePercentage) ??
            container.decodeIfPresent(Double.self, forKey: .usagePercentageSnake)
        self.unit = try container.decodeIfPresent(String.self, forKey: .unit)
    }
}