import Foundation#if canImport(FoundationNetworking)import FoundationNetworking#endif /// Fetches live credit balance and subscription details from the Codebuff API./// Uses Bearer token auth against the public www.codebuff.com endpoints used by/// the dashboard + the `codebuff` CLI.public enum CodebuffUsageFetcher {    private static let requestTimeoutSeconds: TimeInterval = 15    /// Extra grace period to wait for the optional subscription endpoint after the    /// primary usage call returns. Keeps the menu responsive when `/api/user/subscription`    /// is slow or hangs while `/api/v1/usage` succeeds quickly.    private static let subscriptionGraceSeconds: TimeInterval = 2     public static func fetchUsage(        apiKey: String,        environment: [String: String] = ProcessInfo.processInfo.environment,        includeSubscription: Bool = true,        session transport: any ProviderHTTPTransport = ProviderHTTPClient.shared) async throws -> CodebuffUsageSnapshot    {        try await self.fetchUsage(            apiKey: apiKey,            environment: environment,            includeSubscription: includeSubscription,            transport: transport,            subscriptionGrace: .seconds(self.subscriptionGraceSeconds))    }     static func _fetchUsageForTesting(        apiKey: String,        environment: [String: String] = ProcessInfo.processInfo.environment,        includeSubscription: Bool = true,        transport: any ProviderHTTPTransport,        subscriptionGrace: Duration) async throws -> CodebuffUsageSnapshot    {        try await self.fetchUsage(            apiKey: apiKey,            environment: environment,            includeSubscription: includeSubscription,            transport: transport,            subscriptionGrace: subscriptionGrace)    }     private static func fetchUsage(        apiKey: String,        environment: [String: String],        includeSubscription: Bool,        transport: any ProviderHTTPTransport,        subscriptionGrace: Duration) async throws -> CodebuffUsageSnapshot    {        let trimmed = apiKey.trimmingCharacters(in: .whitespacesAndNewlines)        guard !trimmed.isEmpty else {            throw CodebuffUsageError.missingCredentials        }        try CodebuffSettingsReader.validateEndpointOverrides(environment: environment)         let baseURL = CodebuffSettingsReader.apiURL(environment: environment)         let (usageValues, subscriptionValues) = try await self.fetchPayloads(            apiKey: trimmed,            baseURL: baseURL,            includeSubscription: includeSubscription,            transport: transport,            subscriptionGrace: subscriptionGrace)         return CodebuffUsageSnapshot(            creditsUsed: usageValues.used,            creditsTotal: usageValues.total,            creditsRemaining: usageValues.remaining,            weeklyUsed: subscriptionValues?.weeklyUsed,            weeklyLimit: subscriptionValues?.weeklyLimit,            weeklyResetsAt: subscriptionValues?.weeklyResetsAt,            billingPeriodEnd: subscriptionValues?.billingPeriodEnd,            nextQuotaReset: usageValues.nextQuotaReset,            tier: subscriptionValues?.tier,            subscriptionStatus: subscriptionValues?.status,            autoTopUpEnabled: usageValues.autoTopupEnabled,            accountEmail: subscriptionValues?.email,            updatedAt: Date())    }     private static func fetchPayloads(        apiKey: String,        baseURL: URL,        includeSubscription: Bool,        transport: any ProviderHTTPTransport,        subscriptionGrace: Duration) async throws -> (UsagePayload, SubscriptionPayload?)    {        guard includeSubscription else {            return try await (                self.fetchUsagePayload(apiKey: apiKey, baseURL: baseURL, transport: transport),                nil)        }         let subscriptionTask = Task<SubscriptionPayload?, Error> {            try await self.fetchSubscriptionPayload(                apiKey: apiKey,                baseURL: baseURL,                transport: transport)        }        let usageValues: UsagePayload        do {            usageValues = try await withTaskCancellationHandler {                try await self.fetchUsagePayload(                    apiKey: apiKey,                    baseURL: baseURL,                    transport: transport)            } onCancel: {                subscriptionTask.cancel()            }        } catch {            subscriptionTask.cancel()            throw error        }         do {            try Task.checkCancellation()        } catch {            subscriptionTask.cancel()            throw error        }        let race = BoundedTaskJoin(sourceTask: subscriptionTask)        switch await race.value(joinGrace: subscriptionGrace) {        case let .value(subscriptionValues):            try Task.checkCancellation()            return (usageValues, subscriptionValues)        case .timedOut:            try Task.checkCancellation()            return (usageValues, nil)        case .failure:            subscriptionTask.cancel()            try Task.checkCancellation()            return (usageValues, nil)        }    }     // MARK: - Endpoint helpers     struct UsagePayload {        let used: Double?        let total: Double?        let remaining: Double?        let nextQuotaReset: Date?        let autoTopupEnabled: Bool?    }     struct SubscriptionPayload {        let status: String?        let tier: String?        let billingPeriodEnd: Date?        let weeklyUsed: Double?        let weeklyLimit: Double?        let weeklyResetsAt: Date?        let email: String?    }     static func usageURL(baseURL: URL) -> URL {        baseURL.appendingPathComponent("/api/v1/usage")    }     static func subscriptionURL(baseURL: URL) -> URL {        baseURL.appendingPathComponent("/api/user/subscription")    }     static func statusError(for statusCode: Int) -> CodebuffUsageError? {        switch statusCode {        case 401, 403: .unauthorized        case 404: .endpointNotFound        case 500...599: .serviceUnavailable(statusCode)        default: nil        }    }     static func parseUsagePayload(_ data: Data) throws -> UsagePayload {        guard let root = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {            throw CodebuffUsageError.parseFailed("Invalid JSON")        }         let used = self.double(from: root["usage"]) ?? self.double(from: root["used"])        let total = self.double(from: root["quota"]) ?? self.double(from: root["limit"])        let remaining = self.double(from: root["remainingBalance"]) ?? self.double(from: root["remaining"])        let reset = self.date(from: root["next_quota_reset"])        let autoTopUp = root["autoTopupEnabled"] as? Bool ?? root["auto_topup_enabled"] as? Bool         return UsagePayload(            used: used,            total: total,            remaining: remaining,            nextQuotaReset: reset,            autoTopupEnabled: autoTopUp)    }     static func parseSubscriptionPayload(_ data: Data) throws -> SubscriptionPayload {        guard let root = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {            throw CodebuffUsageError.parseFailed("Invalid JSON")        }         let subscription = root["subscription"] as? [String: Any]        let rateLimit = root["rateLimit"] as? [String: Any]         let tier = self.string(from: subscription?["displayName"])            ?? self.string(from: root["displayName"])            ?? self.string(from: subscription?["tier"])            ?? self.string(from: root["tier"])            ?? self.string(from: subscription?["scheduledTier"])        let status = subscription?["status"] as? String        let email = root["email"] as? String ?? (root["user"] as? [String: Any])?["email"] as? String        let billingPeriodEnd = self.date(from: subscription?["billingPeriodEnd"])            ?? self.date(from: subscription?["currentPeriodEnd"])        let weeklyUsed = self.double(from: rateLimit?["weeklyUsed"])            ?? self.double(from: rateLimit?["used"])        let weeklyLimit = self.double(from: rateLimit?["weeklyLimit"])            ?? self.double(from: rateLimit?["limit"])        let weeklyResetsAt = self.date(from: rateLimit?["weeklyResetsAt"])         return SubscriptionPayload(            status: status,            tier: tier,            billingPeriodEnd: billingPeriodEnd,            weeklyUsed: weeklyUsed,            weeklyLimit: weeklyLimit,            weeklyResetsAt: weeklyResetsAt,            email: email)    }     // MARK: - Test hooks     static func _parseUsagePayloadForTesting(_ data: Data) throws -> UsagePayload {        try self.parseUsagePayload(data)    }     static func _parseSubscriptionPayloadForTesting(_ data: Data) throws -> SubscriptionPayload {        try self.parseSubscriptionPayload(data)    }     static func _statusErrorForTesting(_ statusCode: Int) -> CodebuffUsageError? {        self.statusError(for: statusCode)    }     // MARK: - Networking     private static func fetchUsagePayload(        apiKey: String,        baseURL: URL,        transport: any ProviderHTTPTransport) async throws -> UsagePayload    {        var request = URLRequest(url: self.usageURL(baseURL: baseURL))        request.httpMethod = "POST"        request.timeoutInterval = self.requestTimeoutSeconds        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")        request.setValue("application/json", forHTTPHeaderField: "Content-Type")        request.setValue("application/json", forHTTPHeaderField: "Accept")        request.httpBody = try? JSONSerialization.data(withJSONObject: ["fingerprintId": "codexbar-usage"])         let response = try await self.send(request: request, transport: transport)        if let err = self.statusError(for: response.statusCode) {            throw err        }        guard response.statusCode == 200 else {            throw CodebuffUsageError.apiError(response.statusCode)        }        return try self.parseUsagePayload(response.data)    }     private static func fetchSubscriptionPayload(        apiKey: String,        baseURL: URL,        transport: any ProviderHTTPTransport) async throws -> SubscriptionPayload    {        var request = URLRequest(url: self.subscriptionURL(baseURL: baseURL))        request.httpMethod = "GET"        request.timeoutInterval = self.requestTimeoutSeconds        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")        request.setValue("application/json", forHTTPHeaderField: "Accept")         let response = try await self.send(request: request, transport: transport)        if let err = self.statusError(for: response.statusCode) {            throw err        }        guard response.statusCode == 200 else {            throw CodebuffUsageError.apiError(response.statusCode)        }        return try self.parseSubscriptionPayload(response.data)    }     private static func send(        request: URLRequest,        transport: any ProviderHTTPTransport) async throws -> ProviderHTTPResponse    {        do {            return try await transport.response(for: request)        } catch let error as CodebuffUsageError {            throw error        } catch let error as URLError where error.code == .badServerResponse {            throw CodebuffUsageError.networkError("Invalid response")        } catch {            throw CodebuffUsageError.networkError(error.localizedDescription)        }    }     // MARK: - Value parsing     private static func double(from value: Any?) -> Double? {        switch value {        case let number as NSNumber:            let raw = number.doubleValue            return raw.isFinite ? raw : nil        case let string as String:            let trimmed = string.trimmingCharacters(in: .whitespacesAndNewlines)            guard !trimmed.isEmpty, let raw = Double(trimmed), raw.isFinite else { return nil }            return raw        default:            return nil        }    }     private static func string(from value: Any?) -> String? {        switch value {        case let string as String:            let trimmed = string.trimmingCharacters(in: .whitespacesAndNewlines)            return trimmed.isEmpty ? nil : trimmed        case let number as NSNumber:            let raw = number.doubleValue            guard raw.isFinite else { return nil }            return number.stringValue        default:            return nil        }    }     private static func date(from value: Any?) -> Date? {        switch value {        case let string as String:            let trimmed = string.trimmingCharacters(in: .whitespacesAndNewlines)            guard !trimmed.isEmpty else { return nil }            let fractional = ISO8601DateFormatter()            fractional.formatOptions = [.withInternetDateTime, .withFractionalSeconds]            if let date = fractional.date(from: trimmed) {                return date            }            let plain = ISO8601DateFormatter()            plain.formatOptions = [.withInternetDateTime]            if let date = plain.date(from: trimmed) {                return date            }            if let interval = Double(trimmed), interval.isFinite {                return Self.dateFromNumeric(interval)            }            return nil        case let number as NSNumber:            let raw = number.doubleValue            return raw.isFinite ? Self.dateFromNumeric(raw) : nil        default:            return nil        }    }     private static func dateFromNumeric(_ value: Double) -> Date? {        if value > 10_000_000_000 {            return Date(timeIntervalSince1970: value / 1000)        }        return Date(timeIntervalSince1970: value)    }}