import Foundation

public enum TokenAccountInjection: Sendable {
    case cookieHeader
    case environment(key: String)
}

public struct TokenAccountSupport: Sendable {
    public let title: String
    public let subtitle: String
    public let placeholder: String
    public let injection: TokenAccountInjection
    public let requiresManualCookieSource: Bool
    public let cookieName: String?
    public let environmentKeysToScrub: [String]

    public init(
        title: String,
        subtitle: String,
        placeholder: String,
        injection: TokenAccountInjection,
        requiresManualCookieSource: Bool,
        cookieName: String?,
        environmentKeysToScrub: [String] = [])
    {
        self.title = title
        self.subtitle = subtitle
        self.placeholder = placeholder
        self.injection = injection
        self.requiresManualCookieSource = requiresManualCookieSource
        self.cookieName = cookieName
        self.environmentKeysToScrub = environmentKeysToScrub
    }
}

public enum TokenAccountSupportCatalog {
    public static func support(for provider: UsageProvider) -> TokenAccountSupport? {
        supportByProvider[provider]
    }

    public static func envOverride(for provider: UsageProvider, token: String) -> [String: String]? {
        guard let support = self.support(for: provider) else { return nil }
        switch support.injection {
        case let .environment(key):
            return [key: token]
        case .cookieHeader:
            if provider == .claude,
               case let route = ClaudeCredentialRouting.resolve(tokenAccountToken: token, manualCookieHeader: nil)
            {
                switch route {
                case let .oauth(accessToken):
                    return [ClaudeOAuthCredentialsStore.environmentTokenKey: accessToken]
                case let .adminAPIKey(apiKey):
                    return [ClaudeAdminAPISettingsReader.adminAPIKeyEnvironmentKey: apiKey]
                case .none, .webCookie:
                    break
                }
            }
            return nil
        }
    }

    public static func scrubEnvironmentForSelectedAccount(
        _ environment: inout [String: String],
        provider: UsageProvider,
        token _: String)
    {
        guard let support = self.support(for: provider) else { return }
        switch support.injection {
        case let .environment(key):
            environment.removeValue(forKey: key)
            for key in support.environmentKeysToScrub {
                environment.removeValue(forKey: key)
            }
        case .cookieHeader:
            guard provider == .claude else { return }
            environment.removeValue(forKey: ClaudeOAuthCredentialsStore.environmentTokenKey)
            for key in ClaudeAdminAPISettingsReader.apiKeyEnvironmentKeys {
                environment.removeValue(forKey: key)
            }
        }
    }

    public static func normalizedCookieHeader(for provider: UsageProvider, token: String) -> String {
        guard let support = self.support(for: provider) else {
            return token.trimmingCharacters(in: .whitespacesAndNewlines)
        }
        return self.normalizedCookieHeader(token, support: support)
    }

    public static func isClaudeOAuthToken(_ token: String) -> Bool {
        ClaudeCredentialRouting.resolve(tokenAccountToken: token, manualCookieHeader: nil).isOAuth
    }

    public static func normalizedCookieHeader(_ token: String, support: TokenAccountSupport) -> String {
        let trimmed = token.trimmingCharacters(in: .whitespacesAndNewlines)
        guard let cookieName = support.cookieName else { return trimmed }
        let lower = trimmed.lowercased()
        if lower.contains("cookie:") || trimmed.contains("=") {
            return trimmed
        }
        return "\(cookieName)=\(trimmed)"
    }
}