import { describe, expect, test } from "bun:test"
import { errorData, errorFormat, errorMessage } from "../../src/util/error"

describe("util.error", () => {
  test("keeps the server error reference available for log correlation", () => {
    const error = {
      name: "UnknownError",
      data: {
        message: "Unexpected server error. Check server logs for details.",
        ref: "err_1234abcd",
      },
    }
    expect(errorMessage(error)).toBe(
      "Unexpected server error. Check server logs for details.\nError reference: err_1234abcd",
    )
    expect(errorMessage(new Error("HTTP request failed", { cause: { body: error } }))).toBe(errorMessage(error))
    expect(errorData(error).message).toContain("err_1234abcd")
  })

  test("explains provider configuration errors instead of displaying an opaque object", () => {
    expect(
      errorMessage({
        name: "ProviderModelNotFoundError",
        data: { providerID: "test", modelID: "missing", suggestions: ["available"] },
      }),
    ).toContain("Did you mean: available")
    expect(errorMessage({ name: "UnknownError", data: { message: "failure" } })).toBe("failure")
  })

  test("formats native Error instances", () => {
    const err = new Error("boom")
    expect(errorMessage(err)).toBe("boom")
    expect(errorFormat(err)).toContain("boom")

    const data = errorData(err)
    expect(data.type).toBe("Error")
    expect(data.message).toBe("boom")
    expect(String(data.formatted)).toContain("boom")
  })

  test("extracts message from record-like values", () => {
    const err = { message: "bad input", code: "E_BAD" }
    expect(errorMessage(err)).toBe("bad input")

    const data = errorData(err)
    expect(data.message).toBe("bad input")
    expect(data.code).toBe("E_BAD")
  })

  test("never returns bare {} for opaque object errors", () => {
    expect(errorFormat({})).not.toBe("{}")
    expect(errorFormat({})).toContain("no message")

    class OpaqueError {}
    const opaque = new OpaqueError()
    Object.defineProperty(opaque, "secret", { value: "hidden", enumerable: false })
    expect(errorFormat(opaque)).not.toBe("{}")
    expect(errorFormat(opaque)).toContain("OpaqueError")
  })

  test("handles opaque throwables with custom toString", () => {
    const err = {
      toString() {
        return "ResolveMessage: Cannot resolve module"
      },
    }

    expect(errorMessage(err)).toBe("ResolveMessage: Cannot resolve module")

    const data = errorData(err)
    expect(data.message).toBe("ResolveMessage: Cannot resolve module")
    expect(String(data.formatted)).toContain("ResolveMessage")
  })
})