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

public enum DeepgramUsageError: LocalizedError, Sendable {
    case missingAPIKey
    case invalidEndpointOverride(String)
    case invalidCredentials
    case invalidProjectID
    case forbidden(String)
    case networkError(String)
    case apiError(String)
    case parseFailed(String)

    public var errorDescription: String? {
        switch self {
        case .missingAPIKey:
            "Missing Deepgram API key. Set apiKey in ~/.codexbar/config.json or DEEPGRAM_API_KEY."
        case let .invalidEndpointOverride(key):
            "Deepgram endpoint override \(key) must use HTTPS or a bare host."
        case .invalidCredentials:
            "Deepgram API key is invalid or expired."
        case .invalidProjectID:
            "Deepgram project ID is invalid or no projects were returned for this API key."
        case let .forbidden(message):
            "Deepgram rejected access: \(message)"
        case let .networkError(message):
            "Deepgram network error: \(message)"
        case let .apiError(message):
            "Deepgram API error: \(message)"
        case let .parseFailed(message):
            "Deepgram parse error: \(message)"
        }
    }
}

// MARK: - API Responses

public struct DeepgramProjectsResponse: Decodable, Sendable {
    public let projects: [DeepgramProject]
}

public struct DeepgramProject: Decodable, Sendable, Equatable {
    public let projectID: String
    public let name: String?

    private enum CodingKeys: String, CodingKey {
        case projectID = "project_id"
        case name
    }

    public init(projectID: String, name: String? = nil) {
        self.projectID = projectID
        self.name = name
    }
}

public struct DeepgramUsageResponse: Decodable, Sendable {
    public let start: String?
    public let end: String?
    public let resolution: DeepgramUsageResolution?
    public let results: [DeepgramUsageResult]
}

public struct DeepgramUsageResolution: Decodable, Sendable {
    public let units: String?
    public let amount: Int?
}

public struct DeepgramUsageResult: Codable, Sendable {
    public let start: String?
    public let end: String?
    public let hours: Double?
    public let totalHours: Double?
    public let agentHours: Double?
    public let tokensIn: Int?
    public let tokensOut: Int?
    public let ttsCharacters: Int?
    public let requests: Int?

    private enum CodingKeys: String, CodingKey {
        case start
        case end
        case hours
        case totalHours = "total_hours"
        case agentHours = "agent_hours"
        case tokensIn = "tokens_in"
        case tokensOut = "tokens_out"
        case ttsCharacters = "tts_characters"
        case requests
    }
}

// MARK: - Query

public struct DeepgramUsageQuery: Sendable {
    public var start: String?
    public var end: String?

    public init(
        start: String? = nil,
        end: String? = nil)
    {
        self.start = start
        self.end = end
    }

    public func queryItems() -> [URLQueryItem] {
        var items: [URLQueryItem] = []

        func add(_ name: String, _ value: String?) {
            guard let value = value?.trimmingCharacters(in: .whitespacesAndNewlines),
                  !value.isEmpty
            else {
                return
            }
            items.append(URLQueryItem(name: name, value: value))
        }

        add("start", self.start)
        add("end", self.end)

        return items
    }
}

// MARK: - Snapshot

public struct DeepgramUsageSnapshot: Codable, Sendable {
    public let projectID: String
    public let projectName: String?
    public let projectCount: Int
    public let start: String?
    public let end: String?
    public let hours: Double
    public let totalHours: Double
    public let agentHours: Double
    public let tokensIn: Int
    public let tokensOut: Int
    public let ttsCharacters: Int
    public let requests: Int
    public let updatedAt: Date

    public init(
        projectID: String,
        projectName: String? = nil,
        projectCount: Int = 1,
        start: String?,
        end: String?,
        hours: Double,
        totalHours: Double,
        agentHours: Double = 0,
        tokensIn: Int = 0,
        tokensOut: Int = 0,
        ttsCharacters: Int = 0,
        requests: Int,
        updatedAt: Date)
    {
        self.projectID = projectID
        self.projectName = projectName
        self.projectCount = projectCount
        self.start = start
        self.end = end
        self.hours = hours
        self.totalHours = totalHours
        self.agentHours = agentHours
        self.tokensIn = tokensIn
        self.tokensOut = tokensOut
        self.ttsCharacters = ttsCharacters
        self.requests = requests
        self.updatedAt = updatedAt
    }
}

extension DeepgramUsageSnapshot {
    public func toUsageSnapshot() -> UsageSnapshot {
        let identity = ProviderIdentitySnapshot(
            providerID: .deepgram,
            accountEmail: nil,
            accountOrganization: nil,
            loginMethod: self.identityLabel)

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

    public var displayLines: [String] {
        var lines: [String] = []
        lines.append("Requests: \(Self.formatInteger(self.requests))")

        var usageParts: [String] = []
        if self.hours > 0 {
            usageParts.append("\(Self.formatDecimal(self.hours)) audio hours")
        }
        if self.totalHours > 0 {
            usageParts.append("\(Self.formatDecimal(self.totalHours)) billable hours")
        }
        if !usageParts.isEmpty {
            lines.append(usageParts.joined(separator: " · "))
        }

        var modelParts: [String] = []
        if self.agentHours > 0 {
            modelParts.append("\(Self.formatDecimal(self.agentHours)) agent hours")
        }
        if self.tokensIn > 0 || self.tokensOut > 0 {
            modelParts.append("\(Self.formatInteger(self.tokensIn + self.tokensOut)) tokens")
        }
        if self.ttsCharacters > 0 {
            modelParts.append("\(Self.formatInteger(self.ttsCharacters)) TTS chars")
        }
        if !modelParts.isEmpty {
            lines.append(modelParts.joined(separator: " · "))
        }

        if let start, let end {
            lines.append("Period: \(start) to \(end)")
        }

        return lines
    }

    private var identityLabel: String? {
        if self.projectCount > 1 {
            return "\(self.projectCount) projects"
        }
        if let projectName = self.projectName?.trimmingCharacters(in: .whitespacesAndNewlines),
           !projectName.isEmpty
        {
            return "Project: \(projectName)"
        }
        return "Project: \(self.projectID)"
    }

    fileprivate static func aggregate(
        _ snapshots: [DeepgramUsageSnapshot],
        updatedAt: Date) throws -> DeepgramUsageSnapshot
    {
        guard let first = snapshots.first else {
            throw DeepgramUsageError.invalidProjectID
        }
        if snapshots.count == 1 { return first }
        return DeepgramUsageSnapshot(
            projectID: "all",
            projectName: nil,
            projectCount: snapshots.count,
            start: snapshots.compactMap(\.start).min(),
            end: snapshots.compactMap(\.end).max(),
            hours: snapshots.reduce(0) { $0 + $1.hours },
            totalHours: snapshots.reduce(0) { $0 + $1.totalHours },
            agentHours: snapshots.reduce(0) { $0 + $1.agentHours },
            tokensIn: snapshots.reduce(0) { $0 + $1.tokensIn },
            tokensOut: snapshots.reduce(0) { $0 + $1.tokensOut },
            ttsCharacters: snapshots.reduce(0) { $0 + $1.ttsCharacters },
            requests: snapshots.reduce(0) { $0 + $1.requests },
            updatedAt: updatedAt)
    }

    private static func formatInteger(_ value: Int) -> String {
        let formatter = NumberFormatter()
        formatter.locale = Locale(identifier: "en_US_POSIX")
        formatter.numberStyle = .decimal
        formatter.usesGroupingSeparator = true
        formatter.groupingSeparator = ","
        formatter.maximumFractionDigits = 0
        return formatter.string(from: NSNumber(value: value)) ?? "\(value)"
    }

    private static func formatDecimal(_ value: Double) -> String {
        let formatter = NumberFormatter()
        formatter.locale = Locale(identifier: "en_US_POSIX")
        formatter.numberStyle = .decimal
        formatter.usesGroupingSeparator = true
        formatter.groupingSeparator = ","
        formatter.minimumFractionDigits = value == floor(value) ? 0 : 1
        formatter.maximumFractionDigits = 1
        return formatter.string(from: NSNumber(value: value)) ?? String(format: "%.1f", value)
    }
}

// MARK: - Fetcher

public struct DeepgramUsageFetcher: Sendable {
    public static let apiURLKey = "DEEPGRAM_API_URL"

    private static let log = CodexBarLog.logger(LogCategories.deepgramUsage)
    private static let defaultBaseURL = URL(string: "https://api.deepgram.com/v1")!

    private struct FetchContext {
        let apiKey: String
        let query: DeepgramUsageQuery
        let timeout: TimeInterval
        let environment: [String: String]
        let transport: ProviderHTTPTransport
        let updatedAt: Date
    }

    public static func fetchUsage(
        apiKey: String,
        projectID: String? = nil,
        query: DeepgramUsageQuery = DeepgramUsageQuery(),
        timeout: TimeInterval = 15,
        environment: [String: String] = ProcessInfo.processInfo.environment,
        transport: ProviderHTTPTransport = ProviderHTTPClient.shared) async throws -> DeepgramUsageSnapshot
    {
        let cleanedAPIKey = apiKey.trimmingCharacters(in: .whitespacesAndNewlines)
        guard !cleanedAPIKey.isEmpty else {
            throw DeepgramUsageError.missingAPIKey
        }
        try self.validateEndpointOverrides(environment: environment)

        let updatedAt = Date()
        let context = FetchContext(
            apiKey: cleanedAPIKey,
            query: query,
            timeout: timeout,
            environment: environment,
            transport: transport,
            updatedAt: updatedAt)

        if let cleanedProjectID = self.cleaned(projectID) {
            return try await self.fetchUsage(
                project: DeepgramProject(projectID: cleanedProjectID),
                context: context)
        }

        let projects = try await self.listProjects(
            apiKey: cleanedAPIKey,
            timeout: timeout,
            environment: environment,
            transport: transport)
        guard !projects.isEmpty else {
            throw DeepgramUsageError.invalidProjectID
        }

        var snapshots: [DeepgramUsageSnapshot] = []
        snapshots.reserveCapacity(projects.count)
        for project in projects {
            let snapshot = try await self.fetchUsage(
                project: project,
                context: context)
            snapshots.append(snapshot)
        }
        return try DeepgramUsageSnapshot.aggregate(snapshots, updatedAt: updatedAt)
    }

    static func _parseSnapshotForTesting(
        _ data: Data,
        projectID: String = "project-test",
        projectName: String? = nil,
        updatedAt: Date = Date()) throws -> DeepgramUsageSnapshot
    {
        try self.parseUsage(
            data: data,
            project: DeepgramProject(projectID: projectID, name: projectName),
            updatedAt: updatedAt)
    }

    private static func listProjects(
        apiKey: String,
        timeout: TimeInterval,
        environment: [String: String],
        transport: ProviderHTTPTransport) async throws -> [DeepgramProject]
    {
        let url = self.apiURL(environment: environment).appendingPathComponent("projects")
        var request = URLRequest(url: url)
        request.httpMethod = "GET"
        request.timeoutInterval = timeout
        request.setValue("Token \(apiKey)", forHTTPHeaderField: "Authorization")
        request.setValue("application/json", forHTTPHeaderField: "Accept")

        let response = try await self.perform(request: request, transport: transport)
        do {
            return try JSONDecoder().decode(DeepgramProjectsResponse.self, from: response.data).projects
        } catch {
            Self.log.error("Deepgram projects decode failed: \(error.localizedDescription)")
            throw DeepgramUsageError.parseFailed(error.localizedDescription)
        }
    }

    private static func fetchUsage(
        project: DeepgramProject,
        context: FetchContext) async throws -> DeepgramUsageSnapshot
    {
        let url = try self.usageURL(
            projectID: project.projectID,
            query: context.query,
            environment: context.environment)

        var request = URLRequest(url: url)
        request.httpMethod = "GET"
        request.timeoutInterval = context.timeout
        request.setValue("Token \(context.apiKey)", forHTTPHeaderField: "Authorization")
        request.setValue("application/json", forHTTPHeaderField: "Accept")

        let response = try await self.perform(request: request, transport: context.transport)
        return try self.parseUsage(data: response.data, project: project, updatedAt: context.updatedAt)
    }

    private static func perform(
        request: URLRequest,
        transport: ProviderHTTPTransport) async throws -> ProviderHTTPResponse
    {
        let response: ProviderHTTPResponse
        do {
            response = try await transport.response(for: request)
        } catch {
            throw DeepgramUsageError.networkError(error.localizedDescription)
        }

        guard response.statusCode == 200 else {
            let summary = self.responseSummary(response.data)
            Self.log.error("Deepgram returned HTTP \(response.statusCode): \(summary)")

            switch response.statusCode {
            case 401:
                throw DeepgramUsageError.invalidCredentials
            case 403:
                throw DeepgramUsageError.forbidden(
                    "The API key may not have access to the project or the Management API. HTTP 403: \(summary)")
            case 400:
                throw DeepgramUsageError.apiError("Bad request. HTTP 400: \(summary)")
            default:
                throw DeepgramUsageError.apiError("HTTP \(response.statusCode): \(summary)")
            }
        }

        return response
    }

    private static func usageURL(
        projectID: String,
        query: DeepgramUsageQuery,
        environment: [String: String]) throws -> URL
    {
        let usageURL = self.apiURL(environment: environment)
            .appendingPathComponent("projects")
            .appendingPathComponent(projectID)
            .appendingPathComponent("usage")
            .appendingPathComponent("breakdown")

        guard var components = URLComponents(url: usageURL, resolvingAgainstBaseURL: false) else {
            throw DeepgramUsageError.networkError("Invalid usage URL")
        }

        let queryItems = query.queryItems()
        if !queryItems.isEmpty {
            components.queryItems = queryItems
        }

        guard let finalURL = components.url else {
            throw DeepgramUsageError.networkError("Invalid usage query")
        }

        return finalURL
    }

    private static func apiURL(environment: [String: String]) -> URL {
        if let raw = self.cleaned(environment[self.apiURLKey]),
           let url = ProviderEndpointOverrideValidator.normalizedHTTPSURL(from: raw)
        {
            return url
        }

        return self.defaultBaseURL
    }

    public static func validateEndpointOverrides(environment: [String: String] = ProcessInfo.processInfo
        .environment) throws
    {
        guard let raw = self.cleaned(environment[self.apiURLKey]) else { return }
        guard ProviderEndpointOverrideValidator.normalizedHTTPSURL(from: raw) == nil else { return }
        throw DeepgramUsageError.invalidEndpointOverride(self.apiURLKey)
    }

    private static func parseUsage(
        data: Data,
        project: DeepgramProject,
        updatedAt: Date) throws -> DeepgramUsageSnapshot
    {
        do {
            let response = try JSONDecoder().decode(DeepgramUsageResponse.self, from: data)
            return DeepgramUsageSnapshot(
                projectID: project.projectID,
                projectName: project.name,
                start: response.start,
                end: response.end,
                hours: response.results.reduce(0) { $0 + ($1.hours ?? 0) },
                totalHours: response.results.reduce(0) { $0 + ($1.totalHours ?? 0) },
                agentHours: response.results.reduce(0) { $0 + ($1.agentHours ?? 0) },
                tokensIn: response.results.reduce(0) { $0 + ($1.tokensIn ?? 0) },
                tokensOut: response.results.reduce(0) { $0 + ($1.tokensOut ?? 0) },
                ttsCharacters: response.results.reduce(0) { $0 + ($1.ttsCharacters ?? 0) },
                requests: response.results.reduce(0) { $0 + ($1.requests ?? 0) },
                updatedAt: updatedAt)
        } catch let error as DecodingError {
            Self.log.error("Deepgram decoding error: \(error.localizedDescription)")
            Self.log.error("Deepgram raw response: \(self.responseSummary(data))")
            throw DeepgramUsageError.parseFailed(error.localizedDescription)
        } catch {
            Self.log.error("Deepgram parse error: \(error.localizedDescription)")
            Self.log.error("Deepgram raw response: \(self.responseSummary(data))")
            throw DeepgramUsageError.parseFailed(error.localizedDescription)
        }
    }

    private static func cleaned(_ raw: String?) -> String? {
        guard let value = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
            return nil
        }
        return value
    }

    private static func responseSummary(_ data: Data) -> String {
        guard !data.isEmpty else { return "empty body" }

        guard let text = String(data: data, encoding: .utf8) else {
            return "non-text body (\(data.count) bytes)"
        }

        let cleaned = text
            .replacingOccurrences(of: #"\s+"#, with: " ", options: .regularExpression)
            .trimmingCharacters(in: .whitespacesAndNewlines)

        guard !cleaned.isEmpty else {
            return "empty body"
        }

        let maxLength = 240
        guard cleaned.count > maxLength else {
            return self.redact(cleaned)
        }

        let index = cleaned.index(cleaned.startIndex, offsetBy: maxLength)
        return self.redact("\(cleaned[..<index])... [truncated]")
    }

    private static func redact(_ text: String) -> String {
        let replacements: [(String, String)] = [
            (#"(?i)(token\s+)[A-Za-z0-9._\-]+"#, "$1[REDACTED]"),
            (#"(?i)(dg_[A-Za-z0-9._\-]+)"#, "[REDACTED]"),
            (
                #"(?i)(\"(?:api_?key|authorization|token|access_token|refresh_token)\"\s*:\s*\")([^\"]+)(\")"#,
                "$1[REDACTED]$3"),
        ]

        return replacements.reduce(text) { partial, replacement in
            partial.replacingOccurrences(
                of: replacement.0,
                with: replacement.1,
                options: .regularExpression)
        }
    }
}