import Foundation

#if canImport(FoundationNetworking)
import FoundationNetworking
#endif

public struct ManusCreditsResponse: Decodable, Sendable {
    public let totalCredits: Double
    public let freeCredits: Double
    public let periodicCredits: Double
    public let addonCredits: Double
    public let refreshCredits: Double
    public let maxRefreshCredits: Double
    public let proMonthlyCredits: Double
    public let eventCredits: Double
    public let nextRefreshTime: Date?
    public let refreshInterval: String?

    public init(
        totalCredits: Double,
        freeCredits: Double,
        periodicCredits: Double,
        addonCredits: Double,
        refreshCredits: Double,
        maxRefreshCredits: Double,
        proMonthlyCredits: Double,
        eventCredits: Double,
        nextRefreshTime: Date? = nil,
        refreshInterval: String? = nil)
    {
        self.totalCredits = totalCredits
        self.freeCredits = freeCredits
        self.periodicCredits = periodicCredits
        self.addonCredits = addonCredits
        self.refreshCredits = refreshCredits
        self.maxRefreshCredits = maxRefreshCredits
        self.proMonthlyCredits = proMonthlyCredits
        self.eventCredits = eventCredits
        self.nextRefreshTime = nextRefreshTime
        self.refreshInterval = refreshInterval
    }

    private enum CodingKeys: String, CodingKey {
        case totalCredits
        case freeCredits
        case periodicCredits
        case addonCredits
        case refreshCredits
        case maxRefreshCredits
        case proMonthlyCredits
        case eventCredits
        case nextRefreshTime
        case refreshInterval
    }

    public init(from decoder: any Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.totalCredits = container.decodeLossyDoubleIfPresent(forKey: .totalCredits) ?? 0
        self.freeCredits = container.decodeLossyDoubleIfPresent(forKey: .freeCredits) ?? 0
        self.periodicCredits = container.decodeLossyDoubleIfPresent(forKey: .periodicCredits) ?? 0
        self.addonCredits = container.decodeLossyDoubleIfPresent(forKey: .addonCredits) ?? 0
        self.refreshCredits = container.decodeLossyDoubleIfPresent(forKey: .refreshCredits) ?? 0
        self.maxRefreshCredits = container.decodeLossyDoubleIfPresent(forKey: .maxRefreshCredits) ?? 0
        self.proMonthlyCredits = container.decodeLossyDoubleIfPresent(forKey: .proMonthlyCredits) ?? 0
        self.eventCredits = container.decodeLossyDoubleIfPresent(forKey: .eventCredits) ?? 0
        self.nextRefreshTime = container.decodeIfPresentFlexibleDate(forKey: .nextRefreshTime)
        self.refreshInterval = try? container.decodeIfPresent(String.self, forKey: .refreshInterval)
    }
}

public enum ManusUsageFetcher {
    private static let log = CodexBarLog.logger(LogCategories.manusAPI)
    private static let creditsURL =
        URL(string: "https://api.manus.im/user.v1.UserService/GetAvailableCredits")!
    @TaskLocal static var fetchCreditsOverride:
        (@Sendable (String, Date) async throws -> ManusCreditsResponse)?

    public static func fetchCredits(
        sessionToken: String,
        now: Date = Date()) async throws -> ManusCreditsResponse
    {
        if let override = self.fetchCreditsOverride {
            return try await override(sessionToken, now)
        }

        guard !sessionToken.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
            throw ManusAPIError.missingToken
        }

        var request = URLRequest(url: self.creditsURL)
        request.httpMethod = "POST"
        request.timeoutInterval = 15
        request.httpBody = Data("{}".utf8)
        request.setValue("application/json", forHTTPHeaderField: "Accept")
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.setValue("Bearer \(sessionToken)", forHTTPHeaderField: "Authorization")
        request.setValue("https://manus.im", forHTTPHeaderField: "Origin")
        request.setValue("https://manus.im/", forHTTPHeaderField: "Referer")
        request.setValue("1", forHTTPHeaderField: "Connect-Protocol-Version")
        let userAgent = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " +
            "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36"
        request.setValue(
            userAgent,
            forHTTPHeaderField: "User-Agent")

        let response = try await ProviderHTTPClient.shared.response(for: request)
        let data = response.data
        guard response.statusCode == 200 else {
            let body = String(data: data, encoding: .utf8) ?? "<binary>"
            let truncated = body.count > 200 ? String(body.prefix(200)) + "…" : body
            Self.log.error("Manus API returned \(response.statusCode): \(truncated)")
            if response.statusCode == 401 || response.statusCode == 403 {
                throw ManusAPIError.invalidToken
            }
            throw ManusAPIError.apiError("HTTP \(response.statusCode)")
        }

        do {
            return try self.parseResponse(data)
        } catch let error as ManusAPIError {
            throw error
        } catch {
            let preview = String(data: data.prefix(500), encoding: .utf8) ?? "<binary>"
            Self.log.error("Manus parse failed: \(error) — response: \(preview)")
            throw ManusAPIError.parseFailed(error.localizedDescription)
        }
    }

    public static func parseResponse(_ data: Data) throws -> ManusCreditsResponse {
        let decoder = JSONDecoder()

        // Try envelope first — the direct decoder defaults missing fields to 0,
        // so it would "succeed" on wrapped payloads and silently return zero credits.
        if let envelope = try? decoder.decode(ManusCreditsEnvelope.self, from: data),
           let response = envelope.data ?? envelope.result ?? envelope.response ?? envelope.availableCredits
        {
            return response
        }

        let response = try decoder.decode(ManusCreditsResponse.self, from: data)
        // The custom decoder defaults every numeric field to 0, so an unrelated JSON
        // object (e.g. an error payload) would otherwise surface as a bogus zero-credit
        // snapshot. Require at least one known credits key in the raw payload.
        guard Self.payloadContainsCreditsField(data: data) else {
            throw ManusAPIError.parseFailed("response missing expected credits fields")
        }
        return response
    }

    private static let expectedCreditsKeys: Set<String> = [
        "totalCredits", "freeCredits", "periodicCredits", "addonCredits",
        "refreshCredits", "maxRefreshCredits", "proMonthlyCredits", "eventCredits",
    ]

    private static func payloadContainsCreditsField(data: Data) -> Bool {
        guard let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
            return false
        }
        return !Self.expectedCreditsKeys.isDisjoint(with: object.keys)
    }
}

extension ManusCreditsResponse {
    public func toUsageSnapshot(now: Date = Date()) -> UsageSnapshot {
        let primary: RateWindow? = if self.proMonthlyCredits > 0 {
            RateWindow(
                usedPercent: min(
                    100,
                    max(0, (self.proMonthlyCredits - self.periodicCredits) / self.proMonthlyCredits * 100)),
                windowMinutes: nil,
                resetsAt: nil,
                resetDescription: Self.monthlyDetail(totalCredits: self.totalCredits, freeCredits: self.freeCredits))
        } else {
            nil
        }

        let secondary: RateWindow? = if self.maxRefreshCredits > 0 {
            RateWindow(
                usedPercent: min(
                    100,
                    max(0, (self.maxRefreshCredits - self.refreshCredits) / self.maxRefreshCredits * 100)),
                windowMinutes: nil,
                resetsAt: self.nextRefreshTime,
                resetDescription: Self.refreshDetail(
                    refreshCredits: self.refreshCredits,
                    maxRefreshCredits: self.maxRefreshCredits,
                    refreshInterval: self.refreshInterval))
        } else {
            nil
        }

        let balance = Self.creditCountString(self.totalCredits)
        let identity = ProviderIdentitySnapshot(
            providerID: .manus,
            accountEmail: nil,
            accountOrganization: nil,
            loginMethod: "Balance: \(balance) credits")

        return UsageSnapshot(
            primary: primary,
            secondary: secondary,
            tertiary: nil,
            providerCost: nil,
            updatedAt: now,
            identity: identity)
    }

    private static func creditCountString(_ value: Double) -> String {
        let formatter = NumberFormatter()
        formatter.numberStyle = .decimal
        formatter.usesGroupingSeparator = true
        formatter.maximumFractionDigits = 0
        formatter.locale = Locale(identifier: "en_US_POSIX")
        return formatter.string(from: NSNumber(value: value.rounded())) ?? String(Int(value.rounded()))
    }

    private static func monthlyDetail(totalCredits: Double, freeCredits: Double) -> String? {
        let total = self.creditCountString(totalCredits)
        let free = self.creditCountString(freeCredits)
        return "Total \(total) • Free \(free)"
    }

    private static func refreshDetail(
        refreshCredits: Double,
        maxRefreshCredits: Double,
        refreshInterval: String?) -> String?
    {
        let refresh = self.creditCountString(refreshCredits)
        let maxRefresh = self.creditCountString(maxRefreshCredits)
        if let refreshInterval, !refreshInterval.isEmpty {
            return "\(refreshInterval.capitalized): \(refresh) / \(maxRefresh)"
        }
        return "\(refresh) / \(maxRefresh)"
    }
}

public enum ManusAPIError: LocalizedError, Equatable, Sendable {
    case missingToken
    case invalidCookie
    case invalidToken
    case networkError(String)
    case apiError(String)
    case parseFailed(String)

    public var errorDescription: String? {
        switch self {
        case .missingToken:
            "No Manus session token provided."
        case .invalidCookie:
            "Manus session cookie is invalid."
        case .invalidToken:
            "Invalid Manus session token."
        case let .networkError(message):
            "Manus network error: \(message)"
        case let .apiError(message):
            "Manus API error: \(message)"
        case let .parseFailed(message):
            "Failed to parse Manus response: \(message)"
        }
    }
}

private struct ManusCreditsEnvelope: Decodable {
    let data: ManusCreditsResponse?
    let result: ManusCreditsResponse?
    let response: ManusCreditsResponse?
    let availableCredits: ManusCreditsResponse?
}

extension KeyedDecodingContainer where K: CodingKey {
    fileprivate func decodeLossyDoubleIfPresent(forKey key: K) -> Double? {
        if let value = try? self.decodeIfPresent(Double.self, forKey: key) {
            return value
        }
        if let intValue = try? self.decodeIfPresent(Int.self, forKey: key) {
            return Double(intValue)
        }
        if let stringValue = try? self.decodeIfPresent(String.self, forKey: key) {
            return Double(stringValue.trimmingCharacters(in: .whitespacesAndNewlines))
        }
        return nil
    }

    fileprivate func decodeIfPresentFlexibleDate(forKey key: K) -> Date? {
        if let value = try? self.decodeIfPresent(Date.self, forKey: key) {
            return value
        }
        guard let stringValue = try? self.decodeIfPresent(String.self, forKey: key),
              !stringValue.isEmpty
        else {
            return nil
        }
        return ISO8601DateFormatter().date(from: stringValue)
    }
}