import assert from "node:assert/strict"
import { test } from "node:test"

import {
  normalizeCommandCodeErrorMessage,
  normalizeCommandCodeMessage,
  redactCommandCodeErrorText,
} from "../../src/overflow.ts"

test("provider overflow wording is rewritten to pi's generic prefix", () => {
  const cases = [
    "This model's maximum context length is 1000000 tokens, however you requested 1200000 tokens",
    "prompt is too long: 210000 tokens > 200000 maximum",
    "Input tokens exceed the context window",
    "Request exceeds the maximum allowed input tokens",
  ]

  for (const message of cases) {
    assert.match(normalizeCommandCodeErrorMessage(message) ?? "", /^context_length_exceeded: /, message)
  }
})

test("retryable and quota errors are never treated as overflow", () => {
  const cases = [
    "rate limit exceeded, please retry",
    "429 Too Many Requests",
    "status: 429",
    "Service temporarily unavailable",
    "quota exceeded for this billing period",
  ]

  for (const message of cases) {
    assert.equal(normalizeCommandCodeErrorMessage(message), undefined, message)
  }
})

test("already-normalized and unrelated errors are left alone", () => {
  assert.equal(normalizeCommandCodeErrorMessage("context_length_exceeded: prompt too long"), undefined)
  assert.equal(normalizeCommandCodeErrorMessage("invalid api key"), undefined)
  assert.equal(normalizeCommandCodeErrorMessage(undefined), undefined)
})

test("message rewriting only applies to Command Code assistant errors", () => {
  const message = {
    role: "assistant",
    provider: "commandcode",
    stopReason: "error",
    errorMessage: "prompt is too long",
  }

  assert.deepEqual(normalizeCommandCodeMessage(message), {
    message: { ...message, errorMessage: "context_length_exceeded: prompt is too long" },
  })
  assert.equal(normalizeCommandCodeMessage({ ...message, stopReason: "stop" }), undefined)
  assert.equal(normalizeCommandCodeMessage({ ...message, role: "user" }), undefined)
  assert.equal(normalizeCommandCodeMessage({ ...message, provider: "anthropic" }), undefined)
  // pi asks the model's provider when the message provider differs.
  assert.ok(normalizeCommandCodeMessage({ ...message, provider: "other" }, "commandcode"))
})

test("error text never leaks API keys", () => {
  const redacted = redactCommandCodeErrorText(
    "failed with Authorization: Bearer user_abcdefgh12345678 and apiKey=user_secret_value",
  )

  assert.ok(!redacted.includes("user_abcdefgh12345678"))
  assert.ok(!redacted.includes("user_secret_value"))
  assert.match(redacted, /Bearer \[redacted\]/)
})