UsageDataModel.swift

import Foundation

/// Model representing Claude usage data
struct UsageData {
    let usedPct: Int
    let leftPct: Int
    let remainingMinutes: Int
    let elapsedMinutes: Int
    let totalTokens: Int
    let tokensLeft: Int
    let costUsed: Double
    let costLeft: Double
    let resetTime: String
}

/// Configuration for display options
struct DisplayOptions {
    var percentage: Bool
    var timeLeft: Bool
    var tokens: Bool
    var money: Bool
    var showUsed: Bool

    static let defaultOptions = DisplayOptions(
        percentage: true,
        timeLeft: true,
        tokens: false,
        money: false,
        showUsed: true
    )
}

/// Service for fetching and parsing usage data
class UsageDataService {
    private let blockDurationMinutes = 300 // 5 hours

    func fetchUsageData() async throws -> UsageData {
        let ccusagePath = ProcessInfo.processInfo.environment["CCUSAGE_PATH"] ?? "npx"
        let arguments = ccusagePath == "npx" ? ["npx", "ccusage"] : [ccusagePath]

        let process = Process()
        process.executableURL = URL(fileURLWithPath: "/usr/bin/env")
        process.arguments = arguments + ["blocks", "--active", "--json", "--token-limit", "max"]

        let pipe = Pipe()
        process.standardOutput = pipe

        try process.run()
        process.waitUntilExit()

        let data = pipe.fileHandleForReading.readDataToEndOfFile()
        guard let output = String(data: data, encoding: .utf8),
              let jsonData = output.data(using: .utf8),
              let json = try? JSONSerialization.jsonObject(with: jsonData) as? [String: Any],
              let blocks = json["blocks"] as? [[String: Any]],
              let block = blocks.first else {
            throw UsageError.noData
        }

        return parseUsageData(from: block)
    }

    private func parseUsageData(from block: [String: Any]) -> UsageData {
        let totalTokens = block["totalTokens"] as? Int ?? 1
        let projection = block["projection"] as? [String: Any]
        let projectedTotal = projection?["totalTokens"] as? Int ?? totalTokens
        let remainingMinutes = projection?["remainingMinutes"] as? Int ?? 0
        let costUsed = block["costUSD"] as? Double ?? 0.0
        let projectedCost = projection?["totalCost"] as? Double ?? 0.0

        let tokenLimitStatus = block["tokenLimitStatus"] as? [String: Any]
        let limit = tokenLimitStatus?["limit"] as? Int ?? totalTokens

        let elapsedMinutes = blockDurationMinutes - remainingMinutes

        let actualPercentUsed = (Double(totalTokens) / Double(limit)) * 100.0
        let usedPct = Int(actualPercentUsed.rounded())
        let leftPct = max(0, 100 - usedPct)

        let tokensLeft = max(0, limit - totalTokens)
        let costLeft = projectedCost - costUsed

        return UsageData(
            usedPct: usedPct,
            leftPct: leftPct,
            remainingMinutes: remainingMinutes,
            elapsedMinutes: elapsedMinutes,
            totalTokens: totalTokens,
            tokensLeft: tokensLeft,
            costUsed: costUsed,
            costLeft: costLeft,
            resetTime: formatResetTime(remainingMinutes: remainingMinutes)
        )
    }

    private func formatResetTime(remainingMinutes: Int) -> String {
        let now = Date()
        let resetDate = Calendar.current.date(byAdding: .minute, value: remainingMinutes, to: now)!

        let formatter = DateFormatter()
        formatter.dateFormat = "MMM d, h:mm a"
        return formatter.string(from: resetDate)
    }
}

/// Formatter for usage display
class UsageFormatter {
    func formatTokens(_ tokens: Int) -> String {
        if tokens >= 1_000_000 {
            return String(format: "%.1fM", Double(tokens) / 1_000_000)
        } else if tokens >= 1_000 {
            return String(format: "%.1fK", Double(tokens) / 1_000)
        } else {
            return "\(tokens)"
        }
    }

    func buildDisplayString(from usage: UsageData, options: DisplayOptions) -> [String] {
        var display: [String] = []

        if options.percentage {
            display.append("\(options.showUsed ? usage.usedPct : usage.leftPct)%")
        }

        if options.timeLeft {
            let minutes = options.showUsed ? usage.elapsedMinutes : usage.remainingMinutes
            display.append("\(minutes / 60)h \(minutes % 60)m")
        }

        if options.tokens {
            let tokens = options.showUsed ? usage.totalTokens : usage.tokensLeft
            display.append("\(formatTokens(tokens))t")
        }

        if options.money && options.showUsed {
            display.append("$\(String(format: "%.2f", usage.costUsed))")
        }

        return display
    }
}

enum UsageError: Error {
    case noData
    case invalidData
    case processError
}