export interface Attempt {
  id: string
  durationMs: number
  input?: number
  output?: number
  estimatedCost?: number
}

export class UsageLedger {
  private readonly attempts = new Map<string, Attempt>()
  constructor(private readonly limit = 100) {}

  add(attempt: Attempt) {
    if (!Number.isSafeInteger(this.limit) || this.limit < 1) {
      throw new Error("limit 必须是正整数")
    }
    for (const value of [
      attempt.durationMs,
      attempt.input,
      attempt.output,
      attempt.estimatedCost,
    ]) {
      if (value !== undefined && (!Number.isFinite(value) || value < 0)) {
        throw new Error("指标必须是非负有限数")
      }
    }
    if (!this.attempts.has(attempt.id) && this.attempts.size >= this.limit) {
      throw new Error("尝试数量超过上限")
    }
    // 同一次尝试用最终值覆盖，避免累计 usage 更新被反复相加。
    this.attempts.set(attempt.id, { ...attempt })
  }

  summary() {
    const rows = [...this.attempts.values()]
    const total = (key: "input" | "output" | "estimatedCost") => {
      const values = rows.map((row) => row[key])
      return {
        known: values.reduce<number>((sum, value) => sum + (value ?? 0), 0),
        missing: values.filter((value) => value === undefined).length,
      }
    }
    return {
      attempts: rows.length,
      input: total("input"),
      output: total("output"),
      estimatedCost: total("estimatedCost"),
    }
  }
}

export async function timed<T>(operation: () => Promise<T>, clock = () => performance.now()) {
  const started = clock()
  const value = await operation()
  return { value, durationMs: Math.max(0, clock() - started) }
}