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

public enum Sub2APIUsageError: LocalizedError, Equatable, Sendable {
    case missingCredentials
    case missingBaseURL
    case invalidCredentials
    case apiError(Int)
    case parseFailed(String)

    public var errorDescription: String? {
        switch self {
        case .missingCredentials:
            "Missing sub2api API key. Add a group API key in Settings or set SUB2API_API_KEY."
        case .missingBaseURL:
            "Missing or invalid sub2api base URL. Add one in Settings or set SUB2API_BASE_URL."
        case .invalidCredentials:
            "sub2api rejected the API key. Check that the key is active and assigned to a group."
        case let .apiError(statusCode):
            "sub2api API returned HTTP \(statusCode)."
        case let .parseFailed(message):
            "Could not parse sub2api usage: \(message)"
        }
    }
}

public struct Sub2APIUsageDetails: Codable, Sendable, Equatable {
    public enum Kind: String, Codable, Sendable {
        case keyQuota
        case subscription
        case wallet
        case unknown
    }

    public struct Totals: Codable, Sendable, Equatable {
        public let requests: Int
        public let totalTokens: Int
        public let actualCostUSD: Double

        public init(requests: Int, totalTokens: Int, actualCostUSD: Double) {
            self.requests = requests
            self.totalTokens = totalTokens
            self.actualCostUSD = actualCostUSD
        }
    }

    public let kind: Kind
    public let balance: Double?
    public let unit: String
    public let today: Totals?
    public let total: Totals?

    public init(kind: Kind, balance: Double?, unit: String, today: Totals?, total: Totals?) {
        self.kind = kind
        self.balance = balance
        self.unit = unit
        self.today = today
        self.total = total
    }
}

public struct Sub2APIUsageSnapshot: Sendable, Equatable {
    public struct Quota: Sendable, Equatable {
        public let limit: Double
        public let used: Double
        public let remaining: Double
        public let unit: String
    }

    public struct RateLimit: Sendable, Equatable {
        public let window: String
        public let limit: Double
        public let used: Double
        public let remaining: Double
        public let resetAt: Date?
    }

    public struct Subscription: Sendable, Equatable {
        public let dailyUsageUSD: Double
        public let weeklyUsageUSD: Double
        public let monthlyUsageUSD: Double
        public let dailyLimitUSD: Double?
        public let weeklyLimitUSD: Double?
        public let monthlyLimitUSD: Double?
        public let expiresAt: Date?
    }

    public struct UsageTotals: Sendable, Equatable {
        public let requests: Int
        public let totalTokens: Int
        public let actualCostUSD: Double
    }

    public let mode: String
    public let isValid: Bool
    public let status: String?
    public let planName: String?
    public let remaining: Double?
    public let unit: String
    public let balance: Double?
    public let quota: Quota?
    public let rateLimits: [RateLimit]
    public let subscription: Subscription?
    public let todayUsage: UsageTotals?
    public let totalUsage: UsageTotals?
    public let expiresAt: Date?
    public let updatedAt: Date

    public func toUsageSnapshot() -> UsageSnapshot {
        let subscription = self.subscription
        let kind: Sub2APIUsageDetails.Kind = if subscription != nil {
            .subscription
        } else if self.quota != nil || !self.rateLimits.isEmpty {
            .keyQuota
        } else if self.balance != nil {
            .wallet
        } else {
            .unknown
        }
        let subscriptionWindows = subscription.map { subscription in
            [
                Self.rateWindow(
                    usage: subscription.dailyUsageUSD,
                    limit: subscription.dailyLimitUSD,
                    windowMinutes: 24 * 60),
                Self.rateWindow(
                    usage: subscription.weeklyUsageUSD,
                    limit: subscription.weeklyLimitUSD,
                    windowMinutes: 7 * 24 * 60),
                Self.rateWindow(
                    usage: subscription.monthlyUsageUSD,
                    limit: subscription.monthlyLimitUSD,
                    windowMinutes: 30 * 24 * 60),
            ]
        }
        let primary = subscriptionWindows?[0] ?? self.quota.map(Self.quotaWindow)
        let secondary = subscriptionWindows?[1]
        let tertiary = subscriptionWindows?[2]
        let namedWindows = self.rateLimits.map { rateLimit in
            NamedRateWindow(
                id: rateLimit.window,
                title: Self.rateLimitTitle(rateLimit.window),
                window: RateWindow(
                    usedPercent: Self.usedPercent(usage: rateLimit.used, limit: rateLimit.limit),
                    windowMinutes: Self.windowMinutes(rateLimit.window),
                    resetsAt: rateLimit.resetAt,
                    resetDescription: Self.amountDescription(used: rateLimit.used, limit: rateLimit.limit)))
        }
        let usageDetails = Sub2APIUsageDetails(
            kind: kind,
            balance: self.balance,
            unit: self.unit,
            today: self.todayUsage.map {
                Sub2APIUsageDetails.Totals(
                    requests: $0.requests,
                    totalTokens: $0.totalTokens,
                    actualCostUSD: $0.actualCostUSD)
            },
            total: self.totalUsage.map {
                Sub2APIUsageDetails.Totals(
                    requests: $0.requests,
                    totalTokens: $0.totalTokens,
                    actualCostUSD: $0.actualCostUSD)
            })

        return UsageSnapshot(
            primary: primary,
            secondary: secondary,
            tertiary: tertiary,
            extraRateWindows: namedWindows.isEmpty ? nil : namedWindows,
            sub2APIUsage: usageDetails,
            subscriptionExpiresAt: subscription?.expiresAt ?? self.expiresAt,
            updatedAt: self.updatedAt,
            identity: ProviderIdentitySnapshot(
                providerID: .sub2api,
                accountEmail: nil,
                accountOrganization: self.planName,
                loginMethod: self.planName),
            dataConfidence: .exact)
    }

    private static func quotaWindow(_ quota: Quota) -> RateWindow {
        RateWindow(
            usedPercent: self.usedPercent(usage: quota.used, limit: quota.limit),
            windowMinutes: nil,
            resetsAt: nil,
            resetDescription: self.amountDescription(used: quota.used, limit: quota.limit, unit: quota.unit))
    }

    private static func rateWindow(usage: Double, limit: Double?, windowMinutes: Int) -> RateWindow? {
        guard let limit, limit > 0 else { return nil }
        return RateWindow(
            usedPercent: self.usedPercent(usage: usage, limit: limit),
            windowMinutes: windowMinutes,
            resetsAt: nil,
            resetDescription: self.amountDescription(used: usage, limit: limit))
    }

    private static func usedPercent(usage: Double, limit: Double) -> Double {
        guard limit > 0 else { return 0 }
        return min(100, max(0, usage / limit * 100))
    }

    private static func amountDescription(used: Double, limit: Double, unit: String = "USD") -> String {
        "\(self.currencyString(used, unit: unit)) / \(self.currencyString(limit, unit: unit))"
    }

    private static func currencyString(_ value: Double, unit: String) -> String {
        unit.uppercased() == "USD" ? UsageFormatter.usdString(value) : String(format: "%.2f %@", value, unit)
    }

    private static func windowMinutes(_ window: String) -> Int? {
        switch window.lowercased() {
        case "5h": 5 * 60
        case "1d": 24 * 60
        case "7d": 7 * 24 * 60
        default: nil
        }
    }

    private static func rateLimitTitle(_ window: String) -> String {
        switch window.lowercased() {
        case "5h": "5 hour limit"
        case "1d": "Daily limit"
        case "7d": "7 day limit"
        default: "\(window) limit"
        }
    }
}

private struct Sub2APIUsageResponse: Decodable {
    struct Quota: Decodable {
        let limit: Double
        let used: Double
        let remaining: Double
        let unit: String?
    }

    struct RateLimit: Decodable {
        let window: String
        let limit: Double
        let used: Double
        let remaining: Double
        let resetAt: String?

        private enum CodingKeys: String, CodingKey {
            case window
            case limit
            case used
            case remaining
            case resetAt = "reset_at"
        }
    }

    struct Subscription: Decodable {
        let dailyUsageUSD: Double?
        let weeklyUsageUSD: Double?
        let monthlyUsageUSD: Double?
        let dailyLimitUSD: Double?
        let weeklyLimitUSD: Double?
        let monthlyLimitUSD: Double?
        let expiresAt: String?

        private enum CodingKeys: String, CodingKey {
            case dailyUsageUSD = "daily_usage_usd"
            case weeklyUsageUSD = "weekly_usage_usd"
            case monthlyUsageUSD = "monthly_usage_usd"
            case dailyLimitUSD = "daily_limit_usd"
            case weeklyLimitUSD = "weekly_limit_usd"
            case monthlyLimitUSD = "monthly_limit_usd"
            case expiresAt = "expires_at"
        }
    }

    struct Usage: Decodable {
        struct Totals: Decodable {
            let requests: Int?
            let totalTokens: Int?
            let actualCost: Double?

            private enum CodingKeys: String, CodingKey {
                case requests
                case totalTokens = "total_tokens"
                case actualCost = "actual_cost"
            }
        }

        let today: Totals?
        let total: Totals?
    }

    let mode: String?
    let isValid: Bool?
    let status: String?
    let planName: String?
    let remaining: Double?
    let unit: String?
    let balance: Double?
    let quota: Quota?
    let rateLimits: [RateLimit]?
    let subscription: Subscription?
    let usage: Usage?
    let expiresAt: String?

    private enum CodingKeys: String, CodingKey {
        case mode
        case isValid
        case status
        case planName
        case remaining
        case unit
        case balance
        case quota
        case rateLimits = "rate_limits"
        case subscription
        case usage
        case expiresAt = "expires_at"
    }
}

public struct Sub2APIUsageFetcher: Sendable {
    public init() {}

    public static func fetchUsage(
        apiKey: String,
        baseURL: URL,
        transport: any ProviderHTTPTransport = ProviderHTTPClient.shared,
        timeout: Duration = .seconds(15),
        updatedAt: Date = Date()) async throws -> Sub2APIUsageSnapshot
    {
        let cleanedAPIKey = apiKey.trimmingCharacters(in: .whitespacesAndNewlines)
        guard !cleanedAPIKey.isEmpty else { throw Sub2APIUsageError.missingCredentials }

        var request = URLRequest(url: self.usageRequestURL(baseURL: baseURL))
        request.httpMethod = "GET"
        request.setValue("Bearer \(cleanedAPIKey)", forHTTPHeaderField: "Authorization")
        request.setValue("application/json", forHTTPHeaderField: "Accept")
        request.timeoutInterval = 15

        let responseTask = Task {
            try await transport.response(for: request)
        }
        let response: ProviderHTTPResponse = switch await BoundedTaskJoin(sourceTask: responseTask)
            .value(joinGrace: timeout)
        {
        case let .value(response): response
        case let .failure(error): throw error
        case .timedOut: throw URLError(.timedOut)
        }
        switch response.statusCode {
        case 200..<300:
            let snapshot = try self.parseSnapshot(data: response.data, updatedAt: updatedAt)
            guard snapshot.isValid else { throw Sub2APIUsageError.invalidCredentials }
            return snapshot
        case 401, 403:
            throw Sub2APIUsageError.invalidCredentials
        default:
            throw Sub2APIUsageError.apiError(response.statusCode)
        }
    }

    public static func _parseSnapshotForTesting(_ data: Data, updatedAt: Date) throws -> Sub2APIUsageSnapshot {
        try self.parseSnapshot(data: data, updatedAt: updatedAt)
    }

    public static func _usageURLForTesting(baseURL: URL) -> URL {
        self.usageURL(baseURL: baseURL)
    }

    private static func usageURL(baseURL: URL) -> URL {
        let components = baseURL.path.split(separator: "/")
        if components.suffix(2) == ["v1", "usage"] {
            return baseURL
        }
        if components.last == "v1" {
            return baseURL.appendingPathComponent("usage")
        }
        return baseURL.appendingPathComponent("v1/usage")
    }

    private static func usageRequestURL(baseURL: URL) -> URL {
        let url = self.usageURL(baseURL: baseURL)
        guard var components = URLComponents(url: url, resolvingAgainstBaseURL: false) else { return url }
        components.queryItems = [
            URLQueryItem(name: "days", value: "30"),
            URLQueryItem(name: "timezone", value: TimeZone.current.identifier),
        ]
        return components.url ?? url
    }

    private static func parseSnapshot(data: Data, updatedAt: Date) throws -> Sub2APIUsageSnapshot {
        do {
            let response = try JSONDecoder().decode(Sub2APIUsageResponse.self, from: data)
            let unit = response.unit ?? response.quota?.unit ?? "USD"
            return Sub2APIUsageSnapshot(
                mode: response.mode ?? "unknown",
                isValid: response.isValid ?? true,
                status: response.status,
                planName: response.planName,
                remaining: response.remaining,
                unit: unit,
                balance: response.balance,
                quota: response.quota.map {
                    Sub2APIUsageSnapshot.Quota(
                        limit: $0.limit,
                        used: $0.used,
                        remaining: $0.remaining,
                        unit: $0.unit ?? unit)
                },
                rateLimits: (response.rateLimits ?? []).map {
                    Sub2APIUsageSnapshot.RateLimit(
                        window: $0.window,
                        limit: $0.limit,
                        used: $0.used,
                        remaining: $0.remaining,
                        resetAt: self.parseDate($0.resetAt))
                },
                subscription: response.subscription.map {
                    Sub2APIUsageSnapshot.Subscription(
                        dailyUsageUSD: $0.dailyUsageUSD ?? 0,
                        weeklyUsageUSD: $0.weeklyUsageUSD ?? 0,
                        monthlyUsageUSD: $0.monthlyUsageUSD ?? 0,
                        dailyLimitUSD: $0.dailyLimitUSD,
                        weeklyLimitUSD: $0.weeklyLimitUSD,
                        monthlyLimitUSD: $0.monthlyLimitUSD,
                        expiresAt: self.parseDate($0.expiresAt))
                },
                todayUsage: self.usageTotals(response.usage?.today),
                totalUsage: self.usageTotals(response.usage?.total),
                expiresAt: self.parseDate(response.expiresAt),
                updatedAt: updatedAt)
        } catch let error as Sub2APIUsageError {
            throw error
        } catch {
            throw Sub2APIUsageError.parseFailed(error.localizedDescription)
        }
    }

    private static func usageTotals(_ totals: Sub2APIUsageResponse.Usage.Totals?)
        -> Sub2APIUsageSnapshot.UsageTotals?
    {
        guard let totals else { return nil }
        return Sub2APIUsageSnapshot.UsageTotals(
            requests: totals.requests ?? 0,
            totalTokens: totals.totalTokens ?? 0,
            actualCostUSD: totals.actualCost ?? 0)
    }

    private static func parseDate(_ raw: String?) -> Date? {
        guard let raw else { return nil }
        let fractional = ISO8601DateFormatter()
        fractional.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
        return fractional.date(from: raw) ?? ISO8601DateFormatter().date(from: raw)
    }
}