import Foundation#if canImport(FoundationNetworking)import FoundationNetworking#endif // MARK: - Wire DTOs (CrossModel returns integer micro units; 1 major currency unit = 1_000_000 micro) /// `GET /v1/credits` response.struct CrossModelCreditsResponse: Decodable {    let currency: String    let balanceMicro: Int64    let uncollectedMicro: Int64     private enum CodingKeys: String, CodingKey {        case currency        case balanceMicro = "balance_micro"        case uncollectedMicro = "uncollected_micro"    }} /// One usage window from `GET /v1/usage`.struct CrossModelUsageWindowDTO: Decodable {    let costMicro: Int64    let promptTokens: Int64    let completionTokens: Int64    let totalTokens: Int64    let requestCount: Int64    let successCount: Int64     private enum CodingKeys: String, CodingKey {        case costMicro = "cost_micro"        case promptTokens = "prompt_tokens"        case completionTokens = "completion_tokens"        case totalTokens = "total_tokens"        case requestCount = "request_count"        case successCount = "success_count"    }} /// `GET /v1/usage` response.struct CrossModelUsageResponse: Decodable {    let currency: String    let daily: CrossModelUsageWindowDTO    let weekly: CrossModelUsageWindowDTO    let monthly: CrossModelUsageWindowDTO} // MARK: - Snapshot (currency-normalized, persisted in UsageSnapshot) /// One usage window with cost converted to the response currency's major unit.public struct CrossModelUsageWindow: Codable, Sendable, Equatable {    public let cost: Double    public let promptTokens: Int    public let completionTokens: Int    public let totalTokens: Int    public let requestCount: Int    public let successCount: Int     public init(        cost: Double,        promptTokens: Int,        completionTokens: Int,        totalTokens: Int,        requestCount: Int,        successCount: Int)    {        self.cost = cost        self.promptTokens = promptTokens        self.completionTokens = completionTokens        self.totalTokens = totalTokens        self.requestCount = requestCount        self.successCount = successCount    }     init(dto: CrossModelUsageWindowDTO) {        self.cost = CrossModelUsageSnapshot.majorUnits(dto.costMicro)        self.promptTokens = Int(dto.promptTokens)        self.completionTokens = Int(dto.completionTokens)        self.totalTokens = Int(dto.totalTokens)        self.requestCount = Int(dto.requestCount)        self.successCount = Int(dto.successCount)    }} /// Complete CrossModel usage snapshot: wallet balance plus UTC day/week/month spend.public struct CrossModelUsageSnapshot: Codable, Sendable, Equatable {    public let currency: String    public let balance: Double    public let uncollected: Double    public let daily: CrossModelUsageWindow?    public let weekly: CrossModelUsageWindow?    public let monthly: CrossModelUsageWindow?    public let updatedAt: Date     public init(        currency: String,        balance: Double,        uncollected: Double,        daily: CrossModelUsageWindow?,        weekly: CrossModelUsageWindow?,        monthly: CrossModelUsageWindow?,        updatedAt: Date)    {        self.currency = Self.normalizedCurrency(currency)        self.balance = balance        self.uncollected = uncollected        self.daily = daily        self.weekly = weekly        self.monthly = monthly        self.updatedAt = updatedAt    }     static func majorUnits(_ micro: Int64) -> Double {        Double(micro) / 1_000_000.0    }     static func normalizedCurrency(_ raw: String) -> String {        raw.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()    }     /// Formatted balance for provider-owned menu/status display.    public var balanceDisplay: String {        self.currencyString(self.balance)    }     public func currencyString(_ value: Double) -> String {        UsageFormatter.currencyString(value, currencyCode: self.currency)    }} extension CrossModelUsageSnapshot {    public func toUsageSnapshot() -> UsageSnapshot {        let identity = ProviderIdentitySnapshot(            providerID: .crossmodel,            accountEmail: nil,            accountOrganization: nil,            loginMethod: "API key")         return UsageSnapshot(            primary: nil,            secondary: nil,            tertiary: nil,            crossModelUsage: self,            updatedAt: self.updatedAt,            identity: identity,            dataConfidence: .exact)    }} // MARK: - Fetcher /// Fetches balance + usage stats from the CrossModel API.public struct CrossModelUsageFetcher: Sendable {    private static let log = CodexBarLog.logger(LogCategories.crossModelUsage)    private static let creditsRequestTimeoutSeconds: TimeInterval = 15    private static let usageRequestTimeoutSeconds: TimeInterval = 3    private static let maxErrorBodyLength = 240     /// Fetches balance (required) and usage windows (best-effort) using the provided API key.    public static func fetchUsage(        apiKey: String,        environment: [String: String] = ProcessInfo.processInfo.environment,        includeOptionalUsage: Bool = true,        transport: any ProviderHTTPTransport = ProviderHTTPClient.shared,        usageJoinGrace: Duration = .seconds(3)) async throws -> CrossModelUsageSnapshot    {        guard !apiKey.isEmpty else {            throw CrossModelUsageError.invalidCredentials        }        try CrossModelSettingsReader.validateEndpointOverrides(environment: environment)         let baseURL = CrossModelSettingsReader.apiURL(environment: environment)        let credits = try await self.fetchCredits(apiKey: apiKey, baseURL: baseURL, transport: transport)        let currency = try self.normalizedResponseCurrency(credits.currency, endpoint: "credits")         guard includeOptionalUsage else {            return CrossModelUsageSnapshot(                currency: currency,                balance: CrossModelUsageSnapshot.majorUnits(credits.balanceMicro),                uncollected: CrossModelUsageSnapshot.majorUnits(credits.uncollectedMicro),                daily: nil,                weekly: nil,                monthly: nil,                updatedAt: Date())        }         // Usage windows are best-effort: a slow or failing /usage call should not        // block the balance the user came to see.        let usage = try await self.fetchUsageWindows(            apiKey: apiKey,            baseURL: baseURL,            transport: transport,            joinGrace: usageJoinGrace)        let validatedUsage: CrossModelUsageResponse?        if let usage {            let usageCurrency: String            do {                usageCurrency = try self.normalizedResponseCurrency(usage.currency, endpoint: "usage")            } catch {                Self.log.error("CrossModel /usage omitted: invalid currency")                validatedUsage = nil                return CrossModelUsageSnapshot(                    currency: currency,                    balance: CrossModelUsageSnapshot.majorUnits(credits.balanceMicro),                    uncollected: CrossModelUsageSnapshot.majorUnits(credits.uncollectedMicro),                    daily: nil,                    weekly: nil,                    monthly: nil,                    updatedAt: Date())            }            guard usageCurrency == currency else {                Self.log.error("CrossModel currency mismatch: credits=\(currency) usage=\(usageCurrency)")                return CrossModelUsageSnapshot(                    currency: currency,                    balance: CrossModelUsageSnapshot.majorUnits(credits.balanceMicro),                    uncollected: CrossModelUsageSnapshot.majorUnits(credits.uncollectedMicro),                    daily: nil,                    weekly: nil,                    monthly: nil,                    updatedAt: Date())            }            validatedUsage = usage        } else {            validatedUsage = nil        }         return CrossModelUsageSnapshot(            currency: currency,            balance: CrossModelUsageSnapshot.majorUnits(credits.balanceMicro),            uncollected: CrossModelUsageSnapshot.majorUnits(credits.uncollectedMicro),            daily: validatedUsage.map { CrossModelUsageWindow(dto: $0.daily) },            weekly: validatedUsage.map { CrossModelUsageWindow(dto: $0.weekly) },            monthly: validatedUsage.map { CrossModelUsageWindow(dto: $0.monthly) },            updatedAt: Date())    }     private static func fetchCredits(        apiKey: String,        baseURL: URL,        transport: any ProviderHTTPTransport) async throws -> CrossModelCreditsResponse    {        let url = baseURL.appendingPathComponent("credits")        var request = URLRequest(url: url)        request.httpMethod = "GET"        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")        request.setValue("application/json", forHTTPHeaderField: "Accept")        request.timeoutInterval = Self.creditsRequestTimeoutSeconds         let response = try await transport.response(for: request)        guard response.statusCode == 200 else {            let summary = LogRedactor.redact(Self.sanitizedResponseBodySummary(response.data))            Self.log.error("CrossModel /credits returned \(response.statusCode): \(summary)")            if response.statusCode == 401 || response.statusCode == 403 {                throw CrossModelUsageError.invalidCredentials            }            throw CrossModelUsageError.apiError("HTTP \(response.statusCode)")        }        try self.validateSameOrigin(response: response, request: request, endpoint: "credits")         do {            return try JSONDecoder().decode(CrossModelCreditsResponse.self, from: response.data)        } catch let error as DecodingError {            Self.log.error("CrossModel /credits decode error: \(error.localizedDescription)")            throw CrossModelUsageError.parseFailed(error.localizedDescription)        }    }     private static func fetchUsageWindows(        apiKey: String,        baseURL: URL,        transport: any ProviderHTTPTransport,        joinGrace: Duration) async throws -> CrossModelUsageResponse?    {        let url = baseURL.appendingPathComponent("usage")        var request = URLRequest(url: url)        request.httpMethod = "GET"        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")        request.setValue("application/json", forHTTPHeaderField: "Accept")        request.timeoutInterval = Self.usageRequestTimeoutSeconds         let sourceTask = Task<CrossModelUsageResponse?, Error> {            let response = try await transport.response(for: request)            guard response.statusCode == 200 else {                Self.log.debug("CrossModel /usage enrichment returned \(response.statusCode)")                return nil            }            try self.validateSameOrigin(response: response, request: request, endpoint: "usage")            return try JSONDecoder().decode(CrossModelUsageResponse.self, from: response.data)        }        let join = BoundedTaskJoin(sourceTask: sourceTask)        let outcome = await join.value(joinGrace: joinGrace)        do {            switch outcome {            case let .value(response):                return response            case .timedOut:                Self.log.debug("Timed out fetching CrossModel /usage enrichment")                return nil            case let .failure(error):                throw error            }        } catch is CancellationError {            throw CancellationError()        } catch let error as URLError where error.code == .cancelled {            throw CancellationError()        } catch {            if Task.isCancelled {                throw CancellationError()            }            Self.log.debug("Failed to fetch CrossModel /usage enrichment: \(error.localizedDescription)")            return nil        }    }     private static func normalizedResponseCurrency(_ raw: String, endpoint: String) throws -> String {        let currency = CrossModelUsageSnapshot.normalizedCurrency(raw)        guard !currency.isEmpty else {            throw CrossModelUsageError.parseFailed("Missing CrossModel /\(endpoint) currency")        }        return currency    }     private static func validateSameOrigin(        response: ProviderHTTPResponse,        request: URLRequest,        endpoint: String) throws    {        guard let requestURL = request.url,              let responseURL = response.response.url,              let requestHost = requestURL.host?.lowercased(),              let responseHost = responseURL.host?.lowercased(),              requestURL.scheme?.lowercased() == responseURL.scheme?.lowercased(),              requestHost == responseHost,              self.effectivePort(for: requestURL) == self.effectivePort(for: responseURL)        else {            throw CrossModelUsageError.apiError("CrossModel /\(endpoint) redirected to a different origin")        }    }     private static func effectivePort(for url: URL) -> Int? {        if let port = url.port {            return port        }        switch url.scheme?.lowercased() {        case "https":            return 443        case "http":            return 80        default:            return nil        }    }     private static func sanitizedResponseBodySummary(_ data: Data) -> String {        guard !data.isEmpty else { return "empty body" }        guard let rawBody = String(bytes: data, encoding: .utf8) else {            return "non-text body (\(data.count) bytes)"        }         let body = Self.redactSensitiveBodyContent(rawBody)            .replacingOccurrences(of: #"\s+"#, with: " ", options: .regularExpression)            .trimmingCharacters(in: .whitespacesAndNewlines)         guard !body.isEmpty else { return "non-text body (\(data.count) bytes)" }        guard body.count > Self.maxErrorBodyLength else { return body }         let index = body.index(body.startIndex, offsetBy: Self.maxErrorBodyLength)        return "\(body[..<index])… [truncated]"    }     private static func redactSensitiveBodyContent(_ text: String) -> String {        let replacements: [(String, String)] = [            (#"(?i)(bearer\s+)[A-Za-z0-9._\-]+"#, "$1[REDACTED]"),            (#"(?i)(cm-)[A-Za-z0-9._\-]+"#, "$1[REDACTED]"),            (                #"(?i)(\"(?:api_?key|authorization|token|access_token|refresh_token)\"\s*:\s*\")([^\"]+)(\")"#,                "$1[REDACTED]$3"),            (                #"(?i)((?:api_?key|authorization|token|access_token|refresh_token)\s*[=:]\s*)([^,\s]+)"#,                "$1[REDACTED]"),        ]         return replacements.reduce(text) { partial, replacement in            partial.replacingOccurrences(                of: replacement.0,                with: replacement.1,                options: .regularExpression)        }    }     #if DEBUG    static func _sanitizedResponseBodySummaryForTesting(_ body: String) -> String {        self.sanitizedResponseBodySummary(Data(body.utf8))    }    #endif} /// Errors that can occur during CrossModel usage fetching.public enum CrossModelUsageError: LocalizedError, Sendable, Equatable {    case invalidCredentials    case networkError(String)    case apiError(String)    case parseFailed(String)     public var errorDescription: String? {        switch self {        case .invalidCredentials:            "Invalid CrossModel API credentials"        case let .networkError(message):            "CrossModel network error: \(message)"        case let .apiError(message):            "CrossModel API error: \(message)"        case let .parseFailed(message):            "Failed to parse CrossModel response: \(message)"        }    }}