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

/// OpenRouter credits API response
public struct OpenRouterCreditsResponse: Decodable, Sendable {
    public let data: OpenRouterCreditsData
}

/// OpenRouter credits data
public struct OpenRouterCreditsData: Decodable, Sendable {
    /// Total credits ever added to the account (in USD)
    public let totalCredits: Double
    /// Total credits used (in USD)
    public let totalUsage: Double

    private enum CodingKeys: String, CodingKey {
        case totalCredits = "total_credits"
        case totalUsage = "total_usage"
    }

    /// Remaining credits (total - usage)
    public var balance: Double {
        max(0, self.totalCredits - self.totalUsage)
    }

    /// Usage percentage (0-100)
    public var usedPercent: Double {
        guard self.totalCredits > 0 else { return 0 }
        return min(100, (self.totalUsage / self.totalCredits) * 100)
    }
}

/// OpenRouter key info API response
public struct OpenRouterKeyResponse: Decodable, Sendable {
    public let data: OpenRouterKeyData
}

/// OpenRouter key data with quota and rate limit info
public struct OpenRouterKeyData: Decodable, Sendable {
    /// Rate limit per interval
    public let rateLimit: OpenRouterRateLimit?
    /// Usage limits
    public let limit: Double?
    /// Current usage
    public let usage: Double?
    /// API key usage for the current UTC day.
    public let usageDaily: Double?
    /// API key usage for the current UTC week.
    public let usageWeekly: Double?
    /// API key usage for the current UTC month.
    public let usageMonthly: Double?

    private enum CodingKeys: String, CodingKey {
        case rateLimit = "rate_limit"
        case limit
        case usage
        case usageDaily = "usage_daily"
        case usageWeekly = "usage_weekly"
        case usageMonthly = "usage_monthly"
    }
}

/// OpenRouter rate limit info
public struct OpenRouterRateLimit: Codable, Sendable {
    /// Number of requests allowed
    public let requests: Int
    /// Interval for the rate limit (e.g., "10s", "1m")
    public let interval: String

    public init(requests: Int, interval: String) {
        self.requests = requests
        self.interval = interval
    }
}

public enum OpenRouterKeyQuotaStatus: String, Codable, Sendable {
    case available
    case noLimitConfigured
    case unavailable
}

/// Complete OpenRouter usage snapshot
public struct OpenRouterUsageSnapshot: Codable, Sendable {
    public let totalCredits: Double
    public let totalUsage: Double
    public let balance: Double
    public let usedPercent: Double
    public let keyDataFetched: Bool
    public let keyLimit: Double?
    public let keyUsage: Double?
    public let keyUsageDaily: Double?
    public let keyUsageWeekly: Double?
    public let keyUsageMonthly: Double?
    public let rateLimit: OpenRouterRateLimit?
    public let updatedAt: Date

    public init(
        totalCredits: Double,
        totalUsage: Double,
        balance: Double,
        usedPercent: Double,
        keyDataFetched: Bool = false,
        keyLimit: Double? = nil,
        keyUsage: Double? = nil,
        keyUsageDaily: Double? = nil,
        keyUsageWeekly: Double? = nil,
        keyUsageMonthly: Double? = nil,
        rateLimit: OpenRouterRateLimit?,
        updatedAt: Date)
    {
        self.totalCredits = totalCredits
        self.totalUsage = totalUsage
        self.balance = balance
        self.usedPercent = usedPercent
        self.keyDataFetched = keyDataFetched || keyLimit != nil || keyUsage != nil ||
            keyUsageDaily != nil || keyUsageWeekly != nil || keyUsageMonthly != nil
        self.keyLimit = keyLimit
        self.keyUsage = keyUsage
        self.keyUsageDaily = keyUsageDaily
        self.keyUsageWeekly = keyUsageWeekly
        self.keyUsageMonthly = keyUsageMonthly
        self.rateLimit = rateLimit
        self.updatedAt = updatedAt
    }

    /// Returns true if this snapshot contains valid data
    public var isValid: Bool {
        self.totalCredits >= 0
    }

    public var hasValidKeyQuota: Bool {
        guard self.keyDataFetched,
              let keyLimit,
              let keyUsage
        else {
            return false
        }
        return keyLimit > 0 && keyUsage >= 0
    }

    public var keyQuotaStatus: OpenRouterKeyQuotaStatus {
        if self.hasValidKeyQuota {
            return .available
        }
        guard self.keyDataFetched else {
            return .unavailable
        }
        if let keyLimit, keyLimit > 0 {
            return .unavailable
        }
        return .noLimitConfigured
    }

    public var keyRemaining: Double? {
        guard self.hasValidKeyQuota,
              let keyLimit,
              let keyUsage
        else {
            return nil
        }
        return max(0, keyLimit - keyUsage)
    }

    public var keyUsedPercent: Double? {
        guard self.hasValidKeyQuota,
              let keyLimit,
              let keyUsage
        else {
            return nil
        }
        return min(100, max(0, (keyUsage / keyLimit) * 100))
    }
}

extension OpenRouterUsageSnapshot {
    public func toUsageSnapshot() -> UsageSnapshot {
        let primary: RateWindow? = if let keyUsedPercent {
            RateWindow(
                usedPercent: keyUsedPercent,
                windowMinutes: nil,
                resetsAt: nil,
                resetDescription: nil)
        } else {
            nil
        }

        // Format balance for identity display
        let balanceStr = String(format: "$%.2f", balance)
        let identity = ProviderIdentitySnapshot(
            providerID: .openrouter,
            accountEmail: nil,
            accountOrganization: nil,
            loginMethod: "Balance: \(balanceStr)")

        return UsageSnapshot(
            primary: primary,
            secondary: nil,
            tertiary: nil,
            providerCost: nil,
            openRouterUsage: self,
            updatedAt: self.updatedAt,
            identity: identity)
    }
}

/// Fetches usage stats from the OpenRouter API
public struct OpenRouterUsageFetcher: Sendable {
    private static let log = CodexBarLog.logger(LogCategories.openRouterUsage)
    private static let rateLimitTimeoutSeconds: TimeInterval = 1.0
    private static let creditsRequestTimeoutSeconds: TimeInterval = 15
    private static let maxErrorBodyLength = 240
    private static let maxDebugErrorBodyLength = 2000
    private static let debugFullErrorBodiesEnvKey = "CODEXBAR_DEBUG_OPENROUTER_ERROR_BODIES"
    private static let httpRefererEnvKey = "OPENROUTER_HTTP_REFERER"
    private static let clientTitleEnvKey = "OPENROUTER_X_TITLE"
    private static let defaultClientTitle = "CodexBar"

    /// Fetches credits usage from OpenRouter using the provided API key
    public static func fetchUsage(
        apiKey: String,
        environment: [String: String] = ProcessInfo.processInfo.environment) async throws -> OpenRouterUsageSnapshot
    {
        guard !apiKey.isEmpty else {
            throw OpenRouterUsageError.invalidCredentials
        }
        try OpenRouterSettingsReader.validateEndpointOverrides(environment: environment)

        let baseURL = OpenRouterSettingsReader.apiURL(environment: environment)
        let creditsURL = baseURL.appendingPathComponent("credits")

        var request = URLRequest(url: creditsURL)
        request.httpMethod = "GET"
        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
        request.setValue("application/json", forHTTPHeaderField: "Accept")
        request.timeoutInterval = Self.creditsRequestTimeoutSeconds
        if let referer = Self.sanitizedHeaderValue(environment[self.httpRefererEnvKey]) {
            request.setValue(referer, forHTTPHeaderField: "HTTP-Referer")
        }
        let title = Self.sanitizedHeaderValue(environment[self.clientTitleEnvKey]) ?? Self.defaultClientTitle
        request.setValue(title, forHTTPHeaderField: "X-Title")

        let response = try await ProviderHTTPClient.shared.response(for: request)
        let data = response.data
        guard response.statusCode == 200 else {
            let errorSummary = LogRedactor.redact(Self.sanitizedResponseBodySummary(data))
            if Self.debugFullErrorBodiesEnabled(environment: environment),
               let debugBody = Self.redactedDebugResponseBody(data)
            {
                Self.log.debug("OpenRouter non-200 body (redacted): \(LogRedactor.redact(debugBody))")
            }
            Self.log.error("OpenRouter API returned \(response.statusCode): \(errorSummary)")
            throw OpenRouterUsageError.apiError("HTTP \(response.statusCode)")
        }

        do {
            let decoder = JSONDecoder()
            let creditsResponse = try decoder.decode(OpenRouterCreditsResponse.self, from: data)

            // Optionally fetch key quota/rate-limit info from /key endpoint, but keep this bounded so
            // credits updates are not blocked by a slow or unavailable secondary endpoint.
            let keyFetch = try await fetchKeyData(
                apiKey: apiKey,
                baseURL: baseURL,
                timeoutSeconds: Self.rateLimitTimeoutSeconds)

            return OpenRouterUsageSnapshot(
                totalCredits: creditsResponse.data.totalCredits,
                totalUsage: creditsResponse.data.totalUsage,
                balance: creditsResponse.data.balance,
                usedPercent: creditsResponse.data.usedPercent,
                keyDataFetched: keyFetch.fetched,
                keyLimit: keyFetch.data?.limit,
                keyUsage: keyFetch.data?.usage,
                keyUsageDaily: keyFetch.data?.usageDaily,
                keyUsageWeekly: keyFetch.data?.usageWeekly,
                keyUsageMonthly: keyFetch.data?.usageMonthly,
                rateLimit: keyFetch.data?.rateLimit,
                updatedAt: Date())
        } catch is CancellationError {
            throw CancellationError()
        } catch let error as DecodingError {
            Self.log.error("OpenRouter JSON decoding error: \(error.localizedDescription)")
            throw OpenRouterUsageError.parseFailed(error.localizedDescription)
        } catch let error as OpenRouterUsageError {
            throw error
        } catch {
            Self.log.error("OpenRouter parsing error: \(error.localizedDescription)")
            throw OpenRouterUsageError.parseFailed(error.localizedDescription)
        }
    }

    /// Fetches key quota/rate-limit info from /key endpoint
    private struct OpenRouterKeyFetchResult {
        let data: OpenRouterKeyData?
        let fetched: Bool
    }

    private static func fetchKeyData(
        apiKey: String,
        baseURL: URL,
        timeoutSeconds: TimeInterval) async throws -> OpenRouterKeyFetchResult
    {
        let timeout = max(0.1, timeoutSeconds)
        return try await self.boundedKeyFetch(timeout: .seconds(timeout)) {
            await Self.fetchKeyDataRequest(
                apiKey: apiKey,
                baseURL: baseURL,
                timeoutSeconds: timeout)
        }
    }

    static func _boundedKeyFetchForTesting(
        timeout: Duration,
        operation: @escaping @Sendable () async -> Void) async throws -> Bool
    {
        let result = try await self.boundedKeyFetch(timeout: timeout) {
            await operation()
            return OpenRouterKeyFetchResult(data: nil, fetched: true)
        }
        return result.fetched
    }

    private static func boundedKeyFetch(
        timeout: Duration,
        operation: @escaping @Sendable () async -> OpenRouterKeyFetchResult) async throws -> OpenRouterKeyFetchResult
    {
        let sourceTask = Task<OpenRouterKeyFetchResult, Error> {
            await operation()
        }
        let race = BoundedTaskJoin(sourceTask: sourceTask)
        switch await race.value(joinGrace: timeout) {
        case let .value(result):
            try Task.checkCancellation()
            return result
        case .timedOut:
            try Task.checkCancellation()
            Self.log.debug("OpenRouter /key enrichment timed out")
            return OpenRouterKeyFetchResult(data: nil, fetched: false)
        case .failure:
            sourceTask.cancel()
            try Task.checkCancellation()
            return OpenRouterKeyFetchResult(data: nil, fetched: false)
        }
    }

    private static func fetchKeyDataRequest(
        apiKey: String,
        baseURL: URL,
        timeoutSeconds: TimeInterval) async -> OpenRouterKeyFetchResult
    {
        let keyURL = baseURL.appendingPathComponent("key")

        var request = URLRequest(url: keyURL)
        request.httpMethod = "GET"
        request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
        request.setValue("application/json", forHTTPHeaderField: "Accept")
        request.timeoutInterval = timeoutSeconds

        do {
            let response = try await ProviderHTTPClient.shared.response(for: request)
            guard response.statusCode == 200 else {
                return OpenRouterKeyFetchResult(data: nil, fetched: false)
            }

            let decoder = JSONDecoder()
            let keyResponse = try decoder.decode(OpenRouterKeyResponse.self, from: response.data)
            return OpenRouterKeyFetchResult(data: keyResponse.data, fetched: true)
        } catch {
            Self.log.debug("Failed to fetch OpenRouter /key enrichment: \(error.localizedDescription)")
            return OpenRouterKeyFetchResult(data: nil, fetched: false)
        }
    }

    private static func debugFullErrorBodiesEnabled(environment: [String: String]) -> Bool {
        environment[self.debugFullErrorBodiesEnvKey] == "1"
    }

    private static func sanitizedHeaderValue(_ raw: String?) -> String? {
        OpenRouterSettingsReader.cleaned(raw)
    }

    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 redactedDebugResponseBody(_ data: Data) -> String? {
        guard let rawBody = String(bytes: data, encoding: .utf8) else { return nil }

        let body = Self.redactSensitiveBodyContent(rawBody)
            .replacingOccurrences(of: #"\s+"#, with: " ", options: .regularExpression)
            .trimmingCharacters(in: .whitespacesAndNewlines)
        guard !body.isEmpty else { return nil }
        guard body.count > Self.maxDebugErrorBodyLength else { return body }

        let index = body.index(body.startIndex, offsetBy: Self.maxDebugErrorBodyLength)
        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)(sk-or-v1-)[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))
    }

    static func _redactedDebugResponseBodyForTesting(_ body: String) -> String? {
        self.redactedDebugResponseBody(Data(body.utf8))
    }
    #endif
}

/// Errors that can occur during OpenRouter usage fetching
public enum OpenRouterUsageError: LocalizedError, Sendable {
    case invalidCredentials
    case networkError(String)
    case apiError(String)
    case parseFailed(String)

    public var errorDescription: String? {
        switch self {
        case .invalidCredentials:
            "Invalid OpenRouter API credentials"
        case let .networkError(message):
            "OpenRouter network error: \(message)"
        case let .apiError(message):
            "OpenRouter API error: \(message)"
        case let .parseFailed(message):
            "Failed to parse OpenRouter response: \(message)"
        }
    }
}