import Foundation

public struct ClaudeSourcePlanningInput: Equatable, Sendable {
    public let runtime: ProviderRuntime
    public let selectedDataSource: ClaudeUsageDataSource
    public let webExtrasEnabled: Bool
    public let hasWebSession: Bool
    public let hasCLI: Bool
    public let hasOAuthCredentials: Bool

    public init(
        runtime: ProviderRuntime,
        selectedDataSource: ClaudeUsageDataSource,
        webExtrasEnabled: Bool,
        hasWebSession: Bool,
        hasCLI: Bool,
        hasOAuthCredentials: Bool)
    {
        self.runtime = runtime
        self.selectedDataSource = selectedDataSource
        self.webExtrasEnabled = webExtrasEnabled
        self.hasWebSession = hasWebSession
        self.hasCLI = hasCLI
        self.hasOAuthCredentials = hasOAuthCredentials
    }
}

public enum ClaudeSourcePlanReason: String, Equatable, Sendable {
    case explicitSourceSelection = "explicit-source-selection"
    case appAutoPreferredOAuth = "app-auto-preferred-oauth"
    case appAutoFallbackCLI = "app-auto-fallback-cli"
    case appAutoFallbackWeb = "app-auto-fallback-web"
    case cliAutoPreferredWeb = "cli-auto-preferred-web"
    case cliAutoFallbackCLI = "cli-auto-fallback-cli"
}

public struct ClaudeFetchPlanStep: Equatable, Sendable {
    public let dataSource: ClaudeUsageDataSource
    public let inclusionReason: ClaudeSourcePlanReason
    public let isPlausiblyAvailable: Bool

    public init(
        dataSource: ClaudeUsageDataSource,
        inclusionReason: ClaudeSourcePlanReason,
        isPlausiblyAvailable: Bool)
    {
        self.dataSource = dataSource
        self.inclusionReason = inclusionReason
        self.isPlausiblyAvailable = isPlausiblyAvailable
    }
}

public struct ClaudeFetchPlan: Equatable, Sendable {
    public let input: ClaudeSourcePlanningInput
    public let orderedSteps: [ClaudeFetchPlanStep]

    public init(input: ClaudeSourcePlanningInput, orderedSteps: [ClaudeFetchPlanStep]) {
        self.input = input
        self.orderedSteps = orderedSteps
    }

    public var availableSteps: [ClaudeFetchPlanStep] {
        self.orderedSteps.filter(\.isPlausiblyAvailable)
    }

    public var isNoSourceAvailable: Bool {
        self.availableSteps.isEmpty
    }

    public var preferredStep: ClaudeFetchPlanStep? {
        switch self.input.selectedDataSource {
        case .auto:
            self.availableSteps.first
        case .api, .oauth, .web, .cli:
            self.orderedSteps.first
        }
    }

    public var executionSteps: [ClaudeFetchPlanStep] {
        switch self.input.selectedDataSource {
        case .auto:
            self.availableSteps
        case .api, .oauth, .web, .cli:
            self.orderedSteps
        }
    }

    public var compatibilityStrategy: ClaudeUsageStrategy? {
        guard let preferredStep else { return nil }
        let useWebExtras = self.input.runtime == .app
            && preferredStep.dataSource == .cli
            && self.input.webExtrasEnabled
        return ClaudeUsageStrategy(
            dataSource: preferredStep.dataSource,
            useWebExtras: useWebExtras)
    }

    public var orderLabel: String {
        self.orderedSteps.map(\.dataSource.sourceLabel).joined(separator: "→")
    }

    public func debugLines() -> [String] {
        var lines = ["planner_order=\(self.orderLabel)"]
        lines.append("planner_selected=\(self.preferredStep?.dataSource.rawValue ?? "none")")
        lines.append("planner_no_source=\(self.isNoSourceAvailable)")
        for step in self.orderedSteps {
            let availability = step.isPlausiblyAvailable ? "available" : "unavailable"
            lines.append(
                "planner_step.\(step.dataSource.rawValue)=\(availability) reason=\(step.inclusionReason.rawValue)")
        }
        return lines
    }
}

public enum ClaudeCLIResolver {
    #if DEBUG
    @TaskLocal static var resolvedBinaryPathOverrideForTesting: String?

    public static var currentResolvedBinaryPathOverrideForTesting: String? {
        self.resolvedBinaryPathOverrideForTesting
    }

    public static func withResolvedBinaryPathOverrideForTesting<T>(
        _ path: String?,
        operation: () async throws -> T) async rethrows -> T
    {
        try await self.$resolvedBinaryPathOverrideForTesting.withValue(path) {
            try await operation()
        }
    }
    #endif

    public static func resolvedBinaryPath(
        environment: [String: String] = ProcessInfo.processInfo.environment,
        loginPATH: [String]? = LoginShellPathCache.shared.current)
        -> String?
    {
        #if DEBUG
        if let override = self.resolvedBinaryPathOverrideForTesting {
            return FileManager.default.isExecutableFile(atPath: override) ? override : nil
        }
        #endif

        var normalizedEnvironment = environment
        if let override = environment["CLAUDE_CLI_PATH"]?.trimmingCharacters(in: .whitespacesAndNewlines) {
            if override.isEmpty {
                normalizedEnvironment.removeValue(forKey: "CLAUDE_CLI_PATH")
            } else {
                normalizedEnvironment["CLAUDE_CLI_PATH"] = override
                if FileManager.default.isExecutableFile(atPath: override) {
                    return override
                }
            }
        }

        return BinaryLocator.resolveClaudeBinary(
            env: normalizedEnvironment,
            loginPATH: loginPATH)
    }

    public static func isAvailable(environment: [String: String] = ProcessInfo.processInfo.environment) -> Bool {
        self.resolvedBinaryPath(environment: environment) != nil
    }
}

public enum ClaudeSourcePlanner {
    public static func resolve(input: ClaudeSourcePlanningInput) -> ClaudeFetchPlan {
        ClaudeFetchPlan(input: input, orderedSteps: self.makeSteps(input: input))
    }

    private static func makeSteps(input: ClaudeSourcePlanningInput) -> [ClaudeFetchPlanStep] {
        switch input.selectedDataSource {
        case .auto:
            switch input.runtime {
            case .app:
                [
                    self.step(.oauth, reason: .appAutoPreferredOAuth, input: input),
                    self.step(.cli, reason: .appAutoFallbackCLI, input: input),
                    self.step(.web, reason: .appAutoFallbackWeb, input: input),
                ]
            case .cli:
                [
                    self.step(.web, reason: .cliAutoPreferredWeb, input: input),
                    self.step(.cli, reason: .cliAutoFallbackCLI, input: input),
                ]
            }
        case .api:
            [self.step(.api, reason: .explicitSourceSelection, input: input)]
        case .oauth:
            [self.step(.oauth, reason: .explicitSourceSelection, input: input)]
        case .web:
            [self.step(.web, reason: .explicitSourceSelection, input: input)]
        case .cli:
            [self.step(.cli, reason: .explicitSourceSelection, input: input)]
        }
    }

    private static func step(
        _ dataSource: ClaudeUsageDataSource,
        reason: ClaudeSourcePlanReason,
        input: ClaudeSourcePlanningInput) -> ClaudeFetchPlanStep
    {
        ClaudeFetchPlanStep(
            dataSource: dataSource,
            inclusionReason: reason,
            isPlausiblyAvailable: self.isPlausiblyAvailable(dataSource, input: input))
    }

    private static func isPlausiblyAvailable(
        _ dataSource: ClaudeUsageDataSource,
        input: ClaudeSourcePlanningInput) -> Bool
    {
        switch dataSource {
        case .auto, .api:
            false
        case .oauth:
            input.hasOAuthCredentials
        case .web:
            input.hasWebSession
        case .cli:
            input.hasCLI
        }
    }
}