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

#if os(macOS)
import SweetCookieKit
#endif

#if os(macOS)
private let t3ChatCookieImportOrder: BrowserCookieImportOrder =
    ProviderDefaults.metadata[.t3chat]?.browserCookieOrder ?? Browser.defaultImportOrder

public enum T3ChatCookieImporter {
    private static let cookieClient = BrowserCookieClient()
    private static let cookieDomains = ["t3.chat", "www.t3.chat"]

    public struct SessionInfo: Sendable {
        public let cookieHeader: String
        public let sourceLabel: String

        public init(cookieHeader: String, sourceLabel: String) {
            self.cookieHeader = cookieHeader
            self.sourceLabel = sourceLabel
        }
    }

    public static func importSession(
        browserDetection: BrowserDetection,
        logger: ((String) -> Void)? = nil) throws -> SessionInfo
    {
        let log: (String) -> Void = { msg in logger?("[t3chat-cookie] \(msg)") }
        let installed = t3ChatCookieImportOrder.cookieImportCandidates(using: browserDetection)

        for browserSource in installed {
            do {
                let query = BrowserCookieQuery(domains: self.cookieDomains)
                let sources = try self.cookieClient.codexBarRecords(
                    matching: query,
                    in: browserSource,
                    logger: log)
                for source in sources where !source.records.isEmpty {
                    let cookies = BrowserCookieClient.makeHTTPCookies(source.records, origin: query.origin)
                    guard !cookies.isEmpty else { continue }
                    let names = cookies.map(\.name).joined(separator: ", ")
                    log("\(source.label) cookies: \(names)")
                    let header = cookies.map { "\($0.name)=\($0.value)" }.joined(separator: "; ")
                    return SessionInfo(cookieHeader: header, sourceLabel: source.label)
                }
            } catch {
                BrowserCookieAccessGate.recordIfNeeded(error)
                log("\(browserSource.displayName) cookie import failed: \(error.localizedDescription)")
            }
        }

        throw T3ChatUsageError.noSessionCookie
    }
}
#endif

public struct T3ChatUsageFetcher: Sendable {
    private static let log = CodexBarLog.logger(LogCategories.t3chat)
    private static let baseURL = URL(string: "https://t3.chat")!
    private static let refererURL = URL(string: "https://t3.chat/settings/customization")!
    /// Browser fingerprint defaults are only fallbacks; full cURL captures override these forwarded headers.
    private static let userAgent =
        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " +
        "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36"
    /// Captured from T3 Chat's getCustomerData tRPC request shape in May 2026.
    private static let input = #"{"0":{"json":{"sessionId":null},"meta":{"values":{"sessionId":["undefined"]}}}}"#
    private static let forwardedManualHeaders = [
        "accept": "Accept",
        "accept-language": "Accept-Language",
        "cache-control": "Cache-Control",
        "pragma": "Pragma",
        "priority": "Priority",
        "referer": "Referer",
        "sec-fetch-dest": "Sec-Fetch-Dest",
        "sec-fetch-mode": "Sec-Fetch-Mode",
        "sec-fetch-site": "Sec-Fetch-Site",
        "trpc-accept": "trpc-accept",
        "user-agent": "User-Agent",
        "x-client-context": "x-client-context",
        "x-deployment-id": "X-Deployment-Id",
        "x-trpc-batch": "x-trpc-batch",
        "x-trpc-source": "x-trpc-source",
    ]

    public struct RequestContext: Sendable {
        public let cookieHeader: String
        public let headers: [String: String]

        public init(cookieHeader: String, headers: [String: String] = [:]) {
            self.cookieHeader = cookieHeader
            self.headers = headers
        }
    }

    public let browserDetection: BrowserDetection

    public init(browserDetection: BrowserDetection) {
        self.browserDetection = browserDetection
    }

    public func fetch(
        cookieHeaderOverride: String? = nil,
        timeout: TimeInterval = 15,
        logger: ((String) -> Void)? = nil,
        now: Date = Date(),
        transport: any ProviderHTTPTransport = ProviderHTTPClient.shared) async throws -> T3ChatUsageSnapshot
    {
        let log: (String) -> Void = { msg in logger?("[t3chat] \(msg)") }
        let context = try await self.resolveRequestContext(override: cookieHeaderOverride, logger: log)
        if let logger {
            let names = CookieHeaderNormalizer.pairs(from: context.cookieHeader).map(\.name)
            if !names.isEmpty {
                logger("[t3chat] Cookie names: \(names.joined(separator: ", "))")
            }
            if !context.headers.isEmpty {
                let headerNames = context.headers.keys.sorted().joined(separator: ", ")
                logger("[t3chat] Forwarding captured headers: \(headerNames)")
            }
        }
        return try await Self.fetchCustomerData(
            context: context,
            timeout: timeout,
            now: now,
            transport: transport)
    }

    public func debugRawProbe(cookieHeaderOverride: String? = nil) async -> String {
        let stamp = ISO8601DateFormatter().string(from: Date())
        var lines: [String] = []
        lines.append("=== T3 Chat Debug Probe @ \(stamp) ===")
        lines.append("")

        do {
            let snapshot = try await self.fetch(
                cookieHeaderOverride: cookieHeaderOverride,
                logger: { msg in lines.append(msg) })
            lines.append("")
            lines.append("Fetch Success")
            lines.append("subTier=\(snapshot.customerData.subTier ?? "nil")")
            lines.append("usageBand=\(snapshot.customerData.usageBand ?? "nil")")
            lines
                .append(
                    "usageFourHourPercentage=\(snapshot.customerData.usageFourHourPercentage?.description ?? "nil")")
            lines.append("usageMonthPercentage=\(snapshot.customerData.usageMonthPercentage?.description ?? "nil")")
            lines.append("usagePeriodPercentage=\(snapshot.customerData.usagePeriodPercentage?.description ?? "nil")")
            lines
                .append(
                    "usageFourHourNextResetAt=\(snapshot.customerData.usageFourHourNextResetAt?.description ?? "nil")")
            lines.append("billingNextResetAt=\(snapshot.customerData.billingNextResetAt?.description ?? "nil")")
        } catch {
            lines.append("")
            lines.append("Probe Failed: \(error.localizedDescription)")
        }

        return lines.joined(separator: "\n")
    }

    public static func fetchCustomerData(
        cookieHeader: String,
        timeout: TimeInterval = 15,
        now: Date = Date(),
        transport: any ProviderHTTPTransport = ProviderHTTPClient.shared) async throws -> T3ChatUsageSnapshot
    {
        guard let normalizedCookieHeader = CookieHeaderNormalizer.normalize(cookieHeader) else {
            throw T3ChatUsageError.noSessionCookie
        }
        return try await self.fetchCustomerData(
            context: RequestContext(cookieHeader: normalizedCookieHeader),
            timeout: timeout,
            now: now,
            transport: transport)
    }

    public static func fetchCustomerData(
        context: RequestContext,
        timeout: TimeInterval = 15,
        now: Date = Date(),
        transport: any ProviderHTTPTransport = ProviderHTTPClient.shared) async throws -> T3ChatUsageSnapshot
    {
        guard let normalizedCookieHeader = CookieHeaderNormalizer.normalize(context.cookieHeader) else {
            throw T3ChatUsageError.noSessionCookie
        }

        let url = try self.customerDataURL()
        var request = URLRequest(url: url)
        request.httpMethod = "GET"
        request.timeoutInterval = timeout
        self.applyDefaultHeaders(to: &request)
        for (name, value) in context.headers {
            request.setValue(value, forHTTPHeaderField: name)
        }
        request.setValue(self.baseURL.absoluteString, forHTTPHeaderField: "Origin")
        request.setValue(normalizedCookieHeader, forHTTPHeaderField: "Cookie")

        let response = try await transport.response(for: request)
        let data = response.data
        guard response.statusCode == 200 else {
            let body = String(data: data.prefix(200), encoding: .utf8) ?? "<binary>"
            Self.log.error("T3 Chat API returned \(response.statusCode): \(body)")
            if response.statusCode == 401 || response.statusCode == 403 {
                throw T3ChatUsageError.invalidCredentials
            }
            if response.statusCode == 429,
               response.response.value(forHTTPHeaderField: "x-vercel-mitigated") == "challenge"
            {
                throw T3ChatUsageError.vercelChallenge
            }
            throw T3ChatUsageError.apiError("HTTP \(response.statusCode)")
        }

        do {
            return try T3ChatUsageParser.parseJSONLines(data, now: now)
        } catch {
            let preview = String(data: data.prefix(500), encoding: .utf8) ?? "<binary>"
            Self.log.error("T3 Chat parse failed: \(error.localizedDescription) response=\(preview)")
            throw error
        }
    }

    private func resolveRequestContext(
        override: String?,
        logger: ((String) -> Void)?) async throws -> RequestContext
    {
        if let override = Self.requestContext(from: override) {
            let source = override.headers.isEmpty ? "manual cookie header" : "manual cURL capture"
            logger?("[t3chat] Using \(source)")
            return override
        }

        #if os(macOS)
        let session = try T3ChatCookieImporter.importSession(
            browserDetection: self.browserDetection,
            logger: logger)
        logger?("[t3chat] Using cookies from \(session.sourceLabel)")
        return RequestContext(cookieHeader: session.cookieHeader)
        #else
        throw T3ChatUsageError.noSessionCookie
        #endif
    }

    static func requestContext(from raw: String?) -> RequestContext? {
        guard let raw = raw?.trimmingCharacters(in: .whitespacesAndNewlines), !raw.isEmpty else { return nil }
        let headerFields = Self.headerFields(from: raw)
        guard let cookieHeader = Self.cookieHeader(from: headerFields) ?? CookieHeaderNormalizer.normalize(raw) else {
            return nil
        }
        let headers = Self.forwardedHeaders(from: headerFields)
        return RequestContext(cookieHeader: cookieHeader, headers: headers)
    }

    private static func applyDefaultHeaders(to request: inout URLRequest) {
        request.setValue("*/*", forHTTPHeaderField: "Accept")
        request.setValue("application/jsonl", forHTTPHeaderField: "trpc-accept")
        request.setValue("web-client", forHTTPHeaderField: "x-trpc-source")
        request.setValue("true", forHTTPHeaderField: "x-trpc-batch")
        request.setValue("en-US,en;q=0.9", forHTTPHeaderField: "Accept-Language")
        request.setValue(self.userAgent, forHTTPHeaderField: "User-Agent")
        request.setValue(self.refererURL.absoluteString, forHTTPHeaderField: "Referer")
        request.setValue("empty", forHTTPHeaderField: "Sec-Fetch-Dest")
        request.setValue("cors", forHTTPHeaderField: "Sec-Fetch-Mode")
        request.setValue("same-origin", forHTTPHeaderField: "Sec-Fetch-Site")
        request.setValue("u=4", forHTTPHeaderField: "Priority")
        request.setValue("no-cache", forHTTPHeaderField: "Pragma")
        request.setValue("no-cache", forHTTPHeaderField: "Cache-Control")
    }

    private static func forwardedHeaders(from fields: [String]) -> [String: String] {
        var headers: [String: String] = [:]
        for field in fields {
            guard let colon = field.firstIndex(of: ":") else { continue }
            let rawName = field[..<colon].trimmingCharacters(in: .whitespacesAndNewlines)
            let value = field[field.index(after: colon)...].trimmingCharacters(in: .whitespacesAndNewlines)
            guard !rawName.isEmpty, !value.isEmpty else { continue }
            guard let canonical = self.forwardedManualHeaders[rawName.lowercased()] else { continue }
            headers[canonical] = value
        }
        return headers
    }

    private static func cookieHeader(from fields: [String]) -> String? {
        for field in fields {
            guard let colon = field.firstIndex(of: ":") else { continue }
            let rawName = field[..<colon].trimmingCharacters(in: .whitespacesAndNewlines)
            guard rawName.caseInsensitiveCompare("Cookie") == .orderedSame else { continue }
            let value = field[field.index(after: colon)...].trimmingCharacters(in: .whitespacesAndNewlines)
            if let normalized = CookieHeaderNormalizer.normalize(String(value)) {
                return normalized
            }
        }
        return nil
    }

    private static func headerFields(from raw: String) -> [String] {
        var fields: [String] = []
        let pattern =
            #"(?s)(?:^|\s)(?:-H|--header)(?:\s+|=|(?=['"$]))"# +
            #"(?:\$'((?:\\.|[^'])*)'|'([^']*)'|"((?:\\.|[^"])*)"|(\S+))"#
        guard let regex = try? NSRegularExpression(pattern: pattern, options: []) else { return fields }
        let range = NSRange(raw.startIndex..<raw.endIndex, in: raw)
        for match in regex.matches(in: raw, options: [], range: range) {
            if let ansi = self.capture(1, in: match, raw: raw) {
                fields.append(self.unescapeShellSegment(ansi, ansi: true))
            } else if let single = self.capture(2, in: match, raw: raw) {
                fields.append(single)
            } else if let double = self.capture(3, in: match, raw: raw) {
                fields.append(self.unescapeShellSegment(double, ansi: false))
            } else if let bare = self.capture(4, in: match, raw: raw) {
                fields.append(self.unescapeShellSegment(bare, ansi: false))
            }
        }
        return fields
    }

    private static func capture(_ index: Int, in match: NSTextCheckingResult, raw: String) -> String? {
        guard match.numberOfRanges > index,
              let range = Range(match.range(at: index), in: raw)
        else {
            return nil
        }
        return String(raw[range])
    }

    private static func unescapeShellSegment(_ raw: String, ansi: Bool) -> String {
        var output = ""
        var index = raw.startIndex
        while index < raw.endIndex {
            guard raw[index] == "\\" else {
                output.append(raw[index])
                index = raw.index(after: index)
                continue
            }
            let next = raw.index(after: index)
            guard next < raw.endIndex else { return output }
            switch raw[next] {
            case "n" where ansi:
                output.append("\n")
            case "r" where ansi:
                output.append("\r")
            case "t" where ansi:
                output.append("\t")
            case "\n":
                break
            default:
                output.append(raw[next])
            }
            index = raw.index(after: next)
        }
        return output
    }

    private static func customerDataURL() throws -> URL {
        var components = URLComponents(string: "https://t3.chat/api/trpc/getCustomerData")!
        components.queryItems = [
            URLQueryItem(name: "batch", value: "1"),
            URLQueryItem(name: "input", value: self.input),
        ]
        guard let url = components.url else {
            throw T3ChatUsageError.apiError("Failed to build customer data URL.")
        }
        return url
    }
}