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    }}