import Foundation

public struct ProviderDiagnosticBatchExport: Codable, Sendable {
    public let schemaVersion: String
    public let timestamp: Date
    public let diagnostics: [ProviderDiagnosticExport]

    public init(
        schemaVersion: String = "1.0",
        timestamp: Date,
        diagnostics: [ProviderDiagnosticExport])
    {
        self.schemaVersion = schemaVersion
        self.timestamp = timestamp
        self.diagnostics = diagnostics
    }
}

public struct ProviderDiagnosticExport: Codable, Sendable {
    public let schemaVersion: String
    public let timestamp: Date
    public let platform: String
    public let appVersion: String?
    public let provider: String
    public let displayName: String
    public let source: String
    public let sourceMode: String
    public let auth: ProviderDiagnosticAuthSummary
    public let usage: ProviderDiagnosticUsageSummary?
    public let fetchAttempts: [ProviderDiagnosticFetchAttempt]
    public let error: ProviderDiagnosticError?
    public let settings: ProviderDiagnosticSettingsSummary
    public let details: ProviderDiagnosticDetails?

    private enum CodingKeys: String, CodingKey {
        case schemaVersion
        case timestamp
        case platform
        case appVersion
        case provider
        case displayName
        case source
        case sourceMode
        case auth
        case usage
        case fetchAttempts
        case error
        case settings
        case details
    }

    public init(
        schemaVersion: String = "1.0",
        timestamp: Date,
        platform: String = ProviderDiagnosticPlatform.current,
        appVersion: String? = nil,
        provider: String,
        displayName: String,
        source: String,
        sourceMode: String,
        auth: ProviderDiagnosticAuthSummary,
        usage: ProviderDiagnosticUsageSummary?,
        fetchAttempts: [ProviderDiagnosticFetchAttempt],
        error: ProviderDiagnosticError?,
        settings: ProviderDiagnosticSettingsSummary,
        details: ProviderDiagnosticDetails?)
    {
        self.schemaVersion = schemaVersion
        self.timestamp = timestamp
        self.platform = platform
        self.appVersion = appVersion
        self.provider = provider
        self.displayName = displayName
        self.source = source
        self.sourceMode = sourceMode
        self.auth = auth
        self.usage = usage
        self.fetchAttempts = fetchAttempts
        self.error = error
        self.settings = settings
        self.details = details
    }

    public init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        try self.init(
            schemaVersion: container.decode(String.self, forKey: .schemaVersion),
            timestamp: container.decode(Date.self, forKey: .timestamp),
            platform: container.decodeIfPresent(String.self, forKey: .platform)
                ?? ProviderDiagnosticPlatform.current,
            appVersion: container.decodeIfPresent(String.self, forKey: .appVersion),
            provider: container.decode(String.self, forKey: .provider),
            displayName: container.decode(String.self, forKey: .displayName),
            source: container.decode(String.self, forKey: .source),
            sourceMode: container.decode(String.self, forKey: .sourceMode),
            auth: container.decode(ProviderDiagnosticAuthSummary.self, forKey: .auth),
            usage: container.decodeIfPresent(ProviderDiagnosticUsageSummary.self, forKey: .usage),
            fetchAttempts: container.decode([ProviderDiagnosticFetchAttempt].self, forKey: .fetchAttempts),
            error: container.decodeIfPresent(ProviderDiagnosticError.self, forKey: .error),
            settings: container.decode(ProviderDiagnosticSettingsSummary.self, forKey: .settings),
            details: container.decodeIfPresent(ProviderDiagnosticDetails.self, forKey: .details))
    }
}

public enum ProviderDiagnosticPlatform {
    public static var current: String {
        #if os(macOS)
        "macOS"
        #elseif os(Linux)
        "Linux"
        #else
        "unknown"
        #endif
    }
}

public struct ProviderDiagnosticAuthSummary: Codable, Sendable {
    public let configured: Bool
    public let modes: [String]

    public init(configured: Bool, modes: [String]) {
        self.configured = configured
        self.modes = modes
    }

    public func resolved(with outcome: ProviderFetchOutcome) -> ProviderDiagnosticAuthSummary {
        var resolvedModes = self.modes
        if outcome.isSuccess {
            for attempt in outcome.attempts where attempt.wasAvailable {
                let mode = ProviderDiagnosticFetchAttempt.kindLabel(attempt.kind)
                if !resolvedModes.contains(mode) {
                    resolvedModes.append(mode)
                }
            }
        }
        let configured = self.configured || outcome.isSuccess
        return ProviderDiagnosticAuthSummary(configured: configured, modes: resolvedModes)
    }
}

public struct ProviderDiagnosticUsageSummary: Codable, Sendable {
    public let updatedAt: Date
    public let dataConfidence: String
    public let windows: [ProviderDiagnosticRateWindow]
    public let extraWindowCount: Int
    public let providerCostPresent: Bool
    public let providerSpecificData: [String]

    private enum CodingKeys: String, CodingKey {
        case updatedAt
        case dataConfidence
        case windows
        case extraWindowCount
        case providerCostPresent
        case providerSpecificData
    }

    public init(from snapshot: UsageSnapshot) {
        var windows: [ProviderDiagnosticRateWindow] = []
        if let primary = snapshot.primary {
            windows.append(ProviderDiagnosticRateWindow(label: "primary", window: primary))
        }
        if let secondary = snapshot.secondary {
            windows.append(ProviderDiagnosticRateWindow(label: "secondary", window: secondary))
        }
        if let tertiary = snapshot.tertiary {
            windows.append(ProviderDiagnosticRateWindow(label: "tertiary", window: tertiary))
        }
        for extra in snapshot.extraRateWindows ?? [] {
            windows.append(ProviderDiagnosticRateWindow(
                label: extra.title,
                window: extra.window,
                usageKnown: extra.usageKnown))
        }

        var providerSpecificData: [String] = []
        if snapshot.kiroUsage != nil { providerSpecificData.append("kiroUsage") }
        if snapshot.ampUsage != nil { providerSpecificData.append("ampUsage") }
        if snapshot.zaiUsage != nil { providerSpecificData.append("zaiUsage") }
        if snapshot.minimaxUsage != nil { providerSpecificData.append("minimaxUsage") }
        if snapshot.deepseekUsage != nil { providerSpecificData.append("deepseekUsage") }
        if snapshot.openRouterUsage != nil { providerSpecificData.append("openRouterUsage") }
        if snapshot.sakanaPayAsYouGo != nil { providerSpecificData.append("sakanaPayAsYouGo") }
        if snapshot.openAIAPIUsage != nil { providerSpecificData.append("openAIAPIUsage") }
        if snapshot.claudeAdminAPIUsage != nil { providerSpecificData.append("claudeAdminAPIUsage") }
        if snapshot.mistralUsage != nil { providerSpecificData.append("mistralUsage") }
        if snapshot.deepgramUsage != nil { providerSpecificData.append("deepgramUsage") }
        if snapshot.cursorRequests != nil { providerSpecificData.append("cursorRequests") }
        if snapshot.crossModelUsage != nil { providerSpecificData.append("crossModelUsage") }

        self.updatedAt = snapshot.updatedAt
        self.dataConfidence = snapshot.dataConfidence.rawValue
        self.windows = windows
        self.extraWindowCount = snapshot.extraRateWindows?.count ?? 0
        self.providerCostPresent = snapshot.providerCost != nil
        self.providerSpecificData = providerSpecificData.sorted()
    }

    public init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.updatedAt = try container.decode(Date.self, forKey: .updatedAt)
        self.dataConfidence = try container.decodeIfPresent(String.self, forKey: .dataConfidence)
            ?? UsageDataConfidence.unknown.rawValue
        self.windows = try container.decode([ProviderDiagnosticRateWindow].self, forKey: .windows)
        self.extraWindowCount = try container.decode(Int.self, forKey: .extraWindowCount)
        self.providerCostPresent = try container.decode(Bool.self, forKey: .providerCostPresent)
        self.providerSpecificData = try container.decode([String].self, forKey: .providerSpecificData)
    }
}

public struct ProviderDiagnosticRateWindow: Codable, Sendable {
    public let label: String
    public let usedPercent: Double
    public let windowMinutes: Int?
    public let resetsAt: Date?
    public let hasResetDescription: Bool
    public let nextRegenPercent: Double?
    public let usageKnown: Bool

    private enum CodingKeys: String, CodingKey {
        case label
        case usedPercent
        case windowMinutes
        case resetsAt
        case hasResetDescription
        case nextRegenPercent
        case usageKnown
    }

    public init(label: String, window: RateWindow, usageKnown: Bool = true) {
        self.label = label
        self.usedPercent = window.usedPercent
        self.windowMinutes = window.windowMinutes
        self.resetsAt = window.resetsAt
        self.hasResetDescription = window.resetDescription?.isEmpty == false
        self.nextRegenPercent = window.nextRegenPercent
        self.usageKnown = usageKnown
    }

    public init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.label = try container.decode(String.self, forKey: .label)
        self.usedPercent = try container.decode(Double.self, forKey: .usedPercent)
        self.windowMinutes = try container.decodeIfPresent(Int.self, forKey: .windowMinutes)
        self.resetsAt = try container.decodeIfPresent(Date.self, forKey: .resetsAt)
        self.hasResetDescription = try container.decode(Bool.self, forKey: .hasResetDescription)
        self.nextRegenPercent = try container.decodeIfPresent(Double.self, forKey: .nextRegenPercent)
        self.usageKnown = try container.decodeIfPresent(Bool.self, forKey: .usageKnown) ?? true
    }

    public func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        try container.encode(self.label, forKey: .label)
        try container.encode(self.usedPercent, forKey: .usedPercent)
        try container.encodeIfPresent(self.windowMinutes, forKey: .windowMinutes)
        try container.encodeIfPresent(self.resetsAt, forKey: .resetsAt)
        try container.encode(self.hasResetDescription, forKey: .hasResetDescription)
        try container.encodeIfPresent(self.nextRegenPercent, forKey: .nextRegenPercent)
        if !self.usageKnown {
            try container.encode(false, forKey: .usageKnown)
        }
    }
}

public struct ProviderDiagnosticFetchAttempt: Codable, Sendable {
    public let kind: String
    public let wasAvailable: Bool
    public let errorCategory: String?

    public init(
        kind: String,
        wasAvailable: Bool,
        errorCategory: String?)
    {
        self.kind = kind
        self.wasAvailable = wasAvailable
        self.errorCategory = errorCategory
    }

    public init(from attempt: ProviderFetchAttempt) {
        self.kind = Self.kindLabel(attempt.kind)
        self.wasAvailable = attempt.wasAvailable
        self.errorCategory = attempt.errorDescription.map(Self.errorCategoryLabel)
    }

    public static func kindLabel(_ kind: ProviderFetchKind) -> String {
        switch kind {
        case .cli: "cli"
        case .web: "web"
        case .oauth: "oauth"
        case .apiToken: "api"
        case .localProbe: "local"
        case .webDashboard: "web"
        }
    }

    public static func errorCategoryLabel(_ description: String?) -> String {
        guard let desc = description?.lowercased() else { return "unknown" }
        if desc.contains("endpoint override") {
            return "configuration"
        }
        if desc.contains("network") || desc.contains("timeout") || desc.contains("connection") {
            return "network"
        }
        if desc.contains("auth") || desc.contains("credential") || desc.contains("token") || desc.contains("cookie") ||
            desc.contains("api key") || desc.contains("key not configured") || desc.contains("missing key")
        {
            return "auth"
        }
        if desc.contains("source") || desc.contains("not supported") || desc.contains("unavailable") {
            return "configuration"
        }
        if desc.contains("api") || desc.contains("http") || desc.contains("404") || desc.contains("403") {
            return "api"
        }
        if desc.contains("parse") || desc.contains("format") || desc.contains("decode") {
            return "parse"
        }
        return "unknown"
    }
}

public struct ProviderDiagnosticError: Codable, Sendable {
    public let category: String
    public let safeDescription: String

    public init(category: String, safeDescription: String) {
        self.category = category
        self.safeDescription = safeDescription
    }

    public init(from error: Error, authConfigured: Bool) {
        self.category = Self.errorCategory(error, authConfigured: authConfigured)
        self.safeDescription = Self.safeDescription(category: self.category)
    }

    private static func errorCategory(_ error: Error, authConfigured: Bool) -> String {
        if case ProviderFetchError.noAvailableStrategy = error {
            return authConfigured ? "configuration" : "auth"
        }
        if error is ProviderEndpointOverrideError {
            return "configuration"
        }
        if let minimaxError = error as? MiniMaxUsageError {
            switch minimaxError {
            case .networkError: return "network"
            case .invalidCredentials: return "auth"
            case .apiError: return "api"
            case .parseFailed: return "parse"
            }
        }
        if let alibabaError = error as? AlibabaCodingPlanUsageError {
            switch alibabaError {
            case .networkError: return "network"
            case .loginRequired, .invalidCredentials: return "auth"
            case .apiError, .apiKeyUnavailableInRegion: return "api"
            case .parseFailed: return "parse"
            }
        }
        if error is MiniMaxSettingsError || error is MiniMaxAPISettingsError { return "auth" }
        return ProviderDiagnosticFetchAttempt.errorCategoryLabel(error.localizedDescription)
    }

    private static func safeDescription(category: String) -> String {
        switch category {
        case "network":
            "Network error - check your connection"
        case "auth":
            "Authentication or setup issue - check provider credentials"
        case "api":
            "API error - service returned an unexpected response"
        case "parse":
            "Parse error - unexpected response format"
        case "configuration":
            "Configuration issue - check provider source and settings"
        default:
            "An unexpected error occurred"
        }
    }
}

public struct ProviderDiagnosticSettingsSummary: Codable, Sendable {
    public let sourceMode: String
    public let apiRegion: String?

    public init(sourceMode: ProviderSourceMode, apiRegion: String? = nil) {
        self.sourceMode = sourceMode.rawValue
        self.apiRegion = apiRegion
    }
}

public enum ProviderDiagnosticDetails: Codable, Sendable {
    case minimax(MiniMaxDiagnosticDetails)

    private enum CodingKeys: String, CodingKey {
        case type
        case minimax
    }

    public init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        let type = try container.decode(String.self, forKey: .type)
        switch type {
        case "minimax":
            self = try .minimax(container.decode(MiniMaxDiagnosticDetails.self, forKey: .minimax))
        default:
            throw DecodingError.dataCorruptedError(
                forKey: .type,
                in: container,
                debugDescription: "Unknown provider diagnostic detail type")
        }
    }

    public func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        switch self {
        case let .minimax(details):
            try container.encode("minimax", forKey: .type)
            try container.encode(details, forKey: .minimax)
        }
    }
}

public struct MiniMaxDiagnosticDetails: Codable, Sendable {
    public let planName: String?
    public let availablePrompts: Int?
    public let currentPrompts: Int?
    public let remainingPrompts: Int?
    public let windowMinutes: Int?
    public let usedPercent: Double?
    public let resetsAt: Date?
    public let services: [MiniMaxDiagnosticServiceUsage]?
    public let billingSummaryPresent: Bool

    public init(from snapshot: MiniMaxUsageSnapshot) {
        self.planName = snapshot.planName
        self.availablePrompts = snapshot.availablePrompts
        self.currentPrompts = snapshot.currentPrompts
        self.remainingPrompts = snapshot.remainingPrompts
        self.windowMinutes = snapshot.windowMinutes
        self.usedPercent = snapshot.usedPercent
        self.resetsAt = snapshot.resetsAt
        self.services = snapshot.services?.map { MiniMaxDiagnosticServiceUsage(from: $0) }
        self.billingSummaryPresent = snapshot.billingSummary != nil
    }
}

public struct MiniMaxDiagnosticServiceUsage: Codable, Sendable {
    public let displayName: String
    public let percent: Double
    public let usage: Int
    public let limit: Int
    public let remaining: Int?
    public let isUnlimited: Bool
    public let windowType: String
    public let resetsAt: Date?
    public let hasResetDescription: Bool

    private enum CodingKeys: String, CodingKey {
        case displayName
        case percent
        case usage
        case limit
        case remaining
        case isUnlimited
        case windowType
        case resetsAt
        case hasResetDescription
    }

    public init(from service: MiniMaxServiceUsage) {
        self.displayName = service.displayName
        self.percent = service.percent
        self.usage = service.usage
        self.limit = service.limit
        self.remaining = service.isUnlimited ? nil : max(0, service.limit - service.usage)
        self.isUnlimited = service.isUnlimited
        self.windowType = service.windowType
        self.resetsAt = service.resetsAt
        self.hasResetDescription = !service.resetDescription.isEmpty
    }

    public init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.displayName = try container.decode(String.self, forKey: .displayName)
        self.percent = try container.decode(Double.self, forKey: .percent)
        self.usage = try container.decodeIfPresent(Int.self, forKey: .usage) ?? 0
        self.limit = try container.decodeIfPresent(Int.self, forKey: .limit) ?? 0
        self.remaining = try container.decodeIfPresent(Int.self, forKey: .remaining)
        self.isUnlimited = try container.decodeIfPresent(Bool.self, forKey: .isUnlimited) ?? false
        self.windowType = try container.decode(String.self, forKey: .windowType)
        self.resetsAt = try container.decodeIfPresent(Date.self, forKey: .resetsAt)
        self.hasResetDescription = try container.decode(Bool.self, forKey: .hasResetDescription)
    }
}

public enum ProviderDiagnosticExportBuilder {
    public struct Input: Sendable {
        public let provider: UsageProvider
        public let descriptor: ProviderDescriptor
        public let outcome: ProviderFetchOutcome
        public let sourceMode: ProviderSourceMode
        public let settings: ProviderSettingsSnapshot?
        public let auth: ProviderDiagnosticAuthSummary
        public let appVersion: String?

        public init(
            provider: UsageProvider,
            descriptor: ProviderDescriptor,
            outcome: ProviderFetchOutcome,
            sourceMode: ProviderSourceMode,
            settings: ProviderSettingsSnapshot?,
            auth: ProviderDiagnosticAuthSummary,
            appVersion: String? = nil)
        {
            self.provider = provider
            self.descriptor = descriptor
            self.outcome = outcome
            self.sourceMode = sourceMode
            self.settings = settings
            self.auth = auth
            self.appVersion = appVersion
        }
    }

    public static func build(_ input: Input) -> ProviderDiagnosticExport {
        let resolvedAuth = input.auth.resolved(with: input.outcome)
        let usage = input.outcome.usageSnapshot.map { ProviderDiagnosticUsageSummary(from: $0) }
        let error = input.outcome.failureError
            .map { ProviderDiagnosticError(from: $0, authConfigured: resolvedAuth.configured) }
        let settingsSummary = ProviderDiagnosticSettingsSummary(
            sourceMode: input.sourceMode,
            apiRegion: Self.safeAPIRegion(provider: input.provider, settings: input.settings))

        return ProviderDiagnosticExport(
            timestamp: Date(),
            appVersion: input.appVersion,
            provider: input.provider.rawValue,
            displayName: input.descriptor.metadata.displayName,
            source: input.outcome.sourceLabel,
            sourceMode: input.sourceMode.rawValue,
            auth: resolvedAuth,
            usage: usage,
            fetchAttempts: input.outcome.attempts.map { ProviderDiagnosticFetchAttempt(from: $0) },
            error: error,
            settings: settingsSummary,
            details: Self.details(provider: input.provider, outcome: input.outcome))
    }

    private static func safeAPIRegion(provider: UsageProvider, settings: ProviderSettingsSnapshot?) -> String? {
        guard provider == .minimax else { return nil }
        return settings?.minimax?.apiRegion.rawValue ?? "global"
    }

    private static func details(provider: UsageProvider, outcome: ProviderFetchOutcome) -> ProviderDiagnosticDetails? {
        guard provider == .minimax,
              let usage = outcome.usageSnapshot?.minimaxUsage
        else {
            return nil
        }
        return .minimax(MiniMaxDiagnosticDetails(from: usage))
    }
}

extension ProviderFetchOutcome {
    fileprivate var isSuccess: Bool {
        guard case .success = self.result else { return false }
        return true
    }

    fileprivate var sourceLabel: String {
        guard case let .success(result) = result else { return "failed" }
        return result.sourceLabel
    }

    fileprivate var usageSnapshot: UsageSnapshot? {
        guard case let .success(result) = result else { return nil }
        return result.usage
    }

    fileprivate var failureError: Error? {
        guard case let .failure(error) = result else { return nil }
        return error
    }
}