import Foundation

public struct ProviderTokenCostConfig: Sendable {
    public let supportsTokenCost: Bool
    public let noDataMessage: @Sendable () -> String

    public init(supportsTokenCost: Bool, noDataMessage: @escaping @Sendable () -> String) {
        self.supportsTokenCost = supportsTokenCost
        self.noDataMessage = noDataMessage
    }
}

public enum ProviderPaceWindowRule: Sendable {
    case unsupported
    case resetDatePresent
    case windowDurationPresent
    case windowDuration(minutes: Int)
    case custom(@Sendable (_ window: RateWindow, _ now: Date) -> Bool)

    public func matches(window: RateWindow, now: Date) -> Bool {
        switch self {
        case .unsupported:
            false
        case .resetDatePresent:
            window.resetsAt != nil
        case .windowDurationPresent:
            window.windowMinutes != nil
        case let .windowDuration(minutes):
            window.windowMinutes == minutes
        case let .custom(predicate):
            predicate(window, now)
        }
    }
}

public enum ProviderPaceDurationRule: Sendable {
    case unsupported
    case windowDurationMissing
    case windowDuration(minutes: Int)

    public func matches(window: RateWindow) -> Bool {
        switch self {
        case .unsupported:
            false
        case .windowDurationMissing:
            window.windowMinutes == nil
        case let .windowDuration(minutes):
            window.windowMinutes == minutes
        }
    }
}

public struct ProviderPaceCapability: Sendable {
    public static let monthlyWindowSentinelMinutes = 30 * 24 * 60
    public static let unsupported = ProviderPaceCapability()
    public static let calendarMonthResetWindow = ProviderPaceCapability(
        resetWindowPace: .windowDuration(minutes: ProviderPaceCapability.monthlyWindowSentinelMinutes),
        inferredMonthlyDuration: .windowDuration(minutes: ProviderPaceCapability.monthlyWindowSentinelMinutes))

    public let resetWindowPace: ProviderPaceWindowRule
    public let inferredMonthlyDuration: ProviderPaceDurationRule

    public init(
        resetWindowPace: ProviderPaceWindowRule = .unsupported,
        inferredMonthlyDuration: ProviderPaceDurationRule = .unsupported)
    {
        self.resetWindowPace = resetWindowPace
        self.inferredMonthlyDuration = inferredMonthlyDuration
    }

    public func supportsResetWindowPace(window: RateWindow, now: Date) -> Bool {
        self.resetWindowPace.matches(window: window, now: now)
    }

    public func usesInferredMonthlyDuration(window: RateWindow) -> Bool {
        self.inferredMonthlyDuration.matches(window: window)
    }
}

public struct ProviderDescriptor: Sendable {
    public let id: UsageProvider
    public let metadata: ProviderMetadata
    public let branding: ProviderBranding
    public let tokenCost: ProviderTokenCostConfig
    public let pace: ProviderPaceCapability
    public let fetchPlan: ProviderFetchPlan
    public let cli: ProviderCLIConfig

    public init(
        id: UsageProvider,
        metadata: ProviderMetadata,
        branding: ProviderBranding,
        tokenCost: ProviderTokenCostConfig,
        pace: ProviderPaceCapability = .unsupported,
        fetchPlan: ProviderFetchPlan,
        cli: ProviderCLIConfig)
    {
        self.id = id
        self.metadata = metadata
        self.branding = branding
        self.tokenCost = tokenCost
        self.pace = pace
        self.fetchPlan = fetchPlan
        self.cli = cli
    }

    public func fetchOutcome(context: ProviderFetchContext) async -> ProviderFetchOutcome {
        await self.fetchPlan.fetchOutcome(context: context, provider: self.id)
    }

    public func fetch(context: ProviderFetchContext) async throws -> ProviderFetchResult {
        let outcome = await self.fetchOutcome(context: context)
        return try outcome.result.get()
    }
}

public enum ProviderDescriptorRegistry {
    private final class Store: @unchecked Sendable {
        var ordered: [ProviderDescriptor] = []
        var byID: [UsageProvider: ProviderDescriptor] = [:]
    }

    private static let lock = NSLock()
    private static let store = Store()
    private static let descriptorsByID: [UsageProvider: ProviderDescriptor] = [
        .codex: CodexProviderDescriptor.descriptor,
        .openai: OpenAIAPIProviderDescriptor.descriptor,
        .azureopenai: AzureOpenAIProviderDescriptor.descriptor,
        .claude: ClaudeProviderDescriptor.descriptor,
        .clinepass: ClinePassProviderDescriptor.descriptor,
        .cursor: CursorProviderDescriptor.descriptor,
        .opencode: OpenCodeProviderDescriptor.descriptor,
        .opencodego: OpenCodeGoProviderDescriptor.descriptor,
        .alibaba: AlibabaCodingPlanProviderDescriptor.descriptor,
        .alibabatokenplan: AlibabaTokenPlanProviderDescriptor.descriptor,
        .factory: FactoryProviderDescriptor.descriptor,
        .gemini: GeminiProviderDescriptor.descriptor,
        .antigravity: AntigravityProviderDescriptor.descriptor,
        .copilot: CopilotProviderDescriptor.descriptor,
        .devin: DevinProviderDescriptor.descriptor,
        .zai: ZaiProviderDescriptor.descriptor,
        .minimax: MiniMaxProviderDescriptor.descriptor,
        .manus: ManusProviderDescriptor.descriptor,
        .kimi: KimiProviderDescriptor.descriptor,
        .kilo: KiloProviderDescriptor.descriptor,
        .kiro: KiroProviderDescriptor.descriptor,
        .vertexai: VertexAIProviderDescriptor.descriptor,
        .augment: AugmentProviderDescriptor.descriptor,
        .jetbrains: JetBrainsProviderDescriptor.descriptor,
        .moonshot: MoonshotProviderDescriptor.descriptor,
        .amp: AmpProviderDescriptor.descriptor,
        .t3chat: T3ChatProviderDescriptor.descriptor,
        .ollama: OllamaProviderDescriptor.descriptor,
        .synthetic: SyntheticProviderDescriptor.descriptor,
        .openrouter: OpenRouterProviderDescriptor.descriptor,
        .elevenlabs: ElevenLabsProviderDescriptor.descriptor,
        .warp: WarpProviderDescriptor.descriptor,
        .windsurf: WindsurfProviderDescriptor.descriptor,
        .zed: ZedProviderDescriptor.descriptor,
        .perplexity: PerplexityProviderDescriptor.descriptor,
        .mimo: MiMoProviderDescriptor.descriptor,
        .doubao: DoubaoProviderDescriptor.descriptor,
        .sakana: SakanaProviderDescriptor.descriptor,
        .abacus: AbacusProviderDescriptor.descriptor,
        .mistral: MistralProviderDescriptor.descriptor,
        .deepseek: DeepSeekProviderDescriptor.descriptor,
        .deepinfra: DeepInfraProviderDescriptor.descriptor,
        .codebuff: CodebuffProviderDescriptor.descriptor,
        .crof: CrofProviderDescriptor.descriptor,
        .venice: VeniceProviderDescriptor.descriptor,
        .commandcode: CommandCodeProviderDescriptor.descriptor,
        .qoder: QoderProviderDescriptor.descriptor,
        .stepfun: StepFunProviderDescriptor.descriptor,
        .bedrock: BedrockProviderDescriptor.descriptor,
        .grok: GrokProviderDescriptor.descriptor,
        .groq: GroqProviderDescriptor.descriptor,
        .llmproxy: LLMProxyProviderDescriptor.descriptor,
        .litellm: LiteLLMProviderDescriptor.descriptor,
        .deepgram: DeepgramProviderDescriptor.descriptor,
        .poe: PoeProviderDescriptor.descriptor,
        .chutes: ChutesProviderDescriptor.descriptor,
        .neuralwatt: NeuralWattProviderDescriptor.descriptor,
        .clawrouter: ClawRouterProviderDescriptor.descriptor,
        .longcat: LongCatProviderDescriptor.descriptor,
        .sub2api: Sub2APIProviderDescriptor.descriptor,
        .wayfinder: WayfinderProviderDescriptor.descriptor,
        .zenmux: ZenMuxProviderDescriptor.descriptor,
        .aiand: AiAndProviderDescriptor.descriptor,
    ]
    private static let bootstrap: Void = {
        for provider in UsageProvider.allCases {
            guard let descriptor = descriptorsByID[provider] else {
                preconditionFailure("Missing ProviderDescriptor for \(provider.rawValue)")
            }
            _ = ProviderDescriptorRegistry.register(descriptor)
        }
    }()

    private static func ensureBootstrapped() {
        _ = self.bootstrap
    }

    @discardableResult
    public static func register(_ descriptor: ProviderDescriptor) -> ProviderDescriptor {
        self.lock.lock()
        defer { self.lock.unlock() }
        if self.store.byID[descriptor.id] == nil {
            self.store.ordered.append(descriptor)
        }
        self.store.byID[descriptor.id] = descriptor
        return descriptor
    }

    public static var all: [ProviderDescriptor] {
        self.ensureBootstrapped()
        self.lock.lock()
        defer { self.lock.unlock() }
        return self.store.ordered
    }

    public static var metadata: [UsageProvider: ProviderMetadata] {
        Dictionary(uniqueKeysWithValues: self.all.map { ($0.id, $0.metadata) })
    }

    public static func descriptor(for id: UsageProvider) -> ProviderDescriptor {
        self.ensureBootstrapped()
        if let found = self.store.byID[id] { return found }
        if let found = self.all.first(where: { $0.id == id }) { return found }
        fatalError("Missing ProviderDescriptor for \(id.rawValue)")
    }

    public static var cliNameMap: [String: UsageProvider] {
        self.ensureBootstrapped()
        var map: [String: UsageProvider] = [:]
        for descriptor in self.all {
            map[descriptor.cli.name] = descriptor.id
            for alias in descriptor.cli.aliases {
                map[alias] = descriptor.id
            }
        }
        return map
    }
}