////  MiniMaxServiceUsage.swift//  CodexBarCore////  Created by Sisyphus on 2026-03-25.// import Foundation /// Represents the usage information for a specific MiniMax service.////// This struct encapsulates all the relevant details about how much of a particular/// MiniMax service has been used within its quota window, including reset timing/// and localized display strings.public struct MiniMaxServiceUsage: Sendable {    /// The service identifier (e.g., "text-generation", "text-to-speech", "image")    public let serviceType: String     /// The type of time window for the quota (e.g., "5 hours" or "Today")    /// This should be a localized string.    public let windowType: String     /// The specific time range for the current quota window.    /// For hourly quotas: "10:00-15:00(UTC+8)"    /// For daily quotas: full date range string    public let timeRange: String     /// The amount of quota that has been used.    public let usage: Int     /// The total quota limit for this service in the current window    public let limit: Int     /// The percentage of quota used (0-100)    public let percent: Double     /// Whether this quota window is explicitly unlimited.    public let isUnlimited: Bool     /// The timestamp when the quota will reset, if available    public let resetsAt: Date?     /// A localized description of when the quota resets (e.g., "Resets in 2 hours 30 minutes")    public let resetDescription: String     /// The remaining quota available (limit - usage)    public var remaining: Int {        max(0, self.limit - self.usage)    }     /// The display name for this service    public var displayName: String {        let normalized = self.serviceType.lowercased()        return switch normalized {        case "general":            "General"        case "video":            "Video"        case "text-generation":            "Text Generation"        case "text-to-speech":            "Text to Speech"        case "image":            "Image"        case "text generation":            "Text Generation"        case "text to speech":            "Text to Speech"        case "image generation":            "Image Generation"        case "text to video":            "Text to Video"        case "image to video":            "Image to Video"        case "music generation":            "Music Generation"        case "music generation · v2.6":            "Music Generation · v2.6"        case "music cover":            "Music Cover"        case "lyrics generation":            "Lyrics Generation"        case "image understanding":            "Image Understanding"        default:            self.serviceType        }    }     public var isPrimaryTextQuotaLane: Bool {        let normalized = self.serviceType.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()        return normalized == "general" || self.displayName == "Text Generation"    }     /// Creates a new MiniMaxServiceUsage instance.    ///    /// - Parameters:    ///   - serviceType: The service identifier    ///   - windowType: The type of time window (localized)    ///   - timeRange: The specific time range string    ///   - usage: The amount of quota used    ///   - limit: The total quota limit    ///   - percent: The percentage used (0-100)    ///   - resetsAt: Optional reset timestamp    ///   - resetDescription: Localized reset description    public init(        serviceType: String,        windowType: String,        timeRange: String,        usage: Int,        limit: Int,        percent: Double,        isUnlimited: Bool = false,        resetsAt: Date?,        resetDescription: String)    {        self.serviceType = serviceType        self.windowType = windowType        self.timeRange = timeRange        self.usage = usage        self.limit = limit        self.percent = percent        self.isUnlimited = isUnlimited        self.resetsAt = resetsAt        self.resetDescription = resetDescription    }} extension MiniMaxServiceUsage {    public static func parseWindowType(_ windowType: String) -> (windowType: String, windowMinutes: Int?) {        switch windowType.lowercased() {        case "5 hours", "5 小时":            return ("5 hours", 300)        case "today", "今日":            return ("Today", 1440)        default:            // Try to extract hours from string like "X hours"            if let hours = Int(windowType.components(separatedBy: .whitespaces).first ?? "") {                return (windowType, hours * 60)            }            return (windowType, nil)        }    }     public static func parseTimeRange(_ timeRange: String, now: Date) -> Date? {        let calendar = Calendar.current         // Handle "10:00-15:00(UTC+8)" format        if timeRange.contains("-"), timeRange.contains("("), timeRange.contains(")") {            // Extract the time part before the timezone            let components = timeRange.split(separator: "(")            guard components.count >= 1 else { return nil }            let timePart = String(components[0]).trimmingCharacters(in: .whitespaces)             // Split by "-" to get start and end times            let timeComponents = timePart.split(separator: "-")            guard timeComponents.count == 2 else { return nil }             let endTimeStr = String(timeComponents[1]).trimmingCharacters(in: .whitespaces)             // Parse end time (HH:mm format)            let timeFormatter = DateFormatter()            timeFormatter.dateFormat = "HH:mm"            timeFormatter.timeZone = TimeZone.current             guard let endTime = timeFormatter.date(from: endTimeStr) else { return nil }             // Get today's date components            let nowComponents = calendar.dateComponents([.year, .month, .day], from: now)            let endTimeComponents = calendar.dateComponents([.hour, .minute], from: endTime)             // Combine today's date with end time            var combinedComponents = DateComponents()            combinedComponents.year = nowComponents.year            combinedComponents.month = nowComponents.month            combinedComponents.day = nowComponents.day            combinedComponents.hour = endTimeComponents.hour            combinedComponents.minute = endTimeComponents.minute             guard let resultDate = calendar.date(from: combinedComponents) else { return nil }             // If the result date is in the past (before now), add one day            if resultDate < now {                return calendar.date(byAdding: .day, value: 1, to: resultDate)            }             return resultDate        }         // Handle "2026/03/25 00:00 - 2026/03/26 00:00" format        if timeRange.contains(" - ") {            let dateComponents = timeRange.split(separator: " - ")            guard dateComponents.count == 2 else { return nil }             let endDateStr = String(dateComponents[1]).trimmingCharacters(in: .whitespaces)             let dateFormatter = DateFormatter()            dateFormatter.dateFormat = "yyyy/MM/dd HH:mm"            dateFormatter.timeZone = TimeZone.current             return dateFormatter.date(from: endDateStr)        }         return nil    }     public static func generateResetDescription(resetsAt: Date, now: Date = Date()) -> String {        let calendar = Calendar.current        let components = calendar.dateComponents([.hour, .minute], from: now, to: resetsAt)         guard let hours = components.hour, let minutes = components.minute else {            return "Resets soon"        }         if hours > 0, minutes > 0 {            return "Resets in \(hours) hours \(minutes) minutes"        } else if hours > 0 {            return "Resets in \(hours) hour\(hours > 1 ? "s" : "")"        } else if minutes > 0 {            return "Resets in \(minutes) minute\(minutes > 1 ? "s" : "")"        } else {            return "Resets now"        }    }}