import { expect, test } from "vitest"

import {
  symbolCreateGlobal,
  symbolCreateLocal,
  symbolGetDescription,
  symbolGetKey,
  symbolHasDescription,
  symbolIsAnonymous,
  symbolIsGlobal,
  symbolIsLocal,
  symbolIsWellKnown,
  symbolToString,
} from "#Source/basic/index.ts"

test("symbolCreateLocal creates unique symbols", () => {
  const first = symbolCreateLocal("demo")
  const second = symbolCreateLocal("demo")
  expect(typeof first).toBe("symbol")
  expect(first === second).toBe(false)
})

test("symbolCreateGlobal returns registry symbols", () => {
  const first = symbolCreateGlobal("demo")
  const second = symbolCreateGlobal("demo")
  expect(typeof first).toBe("symbol")
  expect(first === second).toBe(true)
  expect(first === Symbol.for("demo")).toBe(true)
})

test("symbolGetKey returns global key", () => {
  expect(symbolGetKey(Symbol.for("demo"))).toBe("demo")
  expect(symbolGetKey(Symbol("demo"))).toBeUndefined()
})

test("symbolIsGlobal checks registry membership", () => {
  expect(symbolIsGlobal(Symbol.for("demo"))).toBe(true)
  expect(symbolIsGlobal(Symbol("demo"))).toBe(false)
})

test("symbolIsLocal checks non-registry symbols", () => {
  expect(symbolIsLocal(Symbol.for("demo"))).toBe(false)
  expect(symbolIsLocal(Symbol("demo"))).toBe(true)
})

test("symbolHasDescription checks description presence", () => {
  expect(symbolHasDescription(Symbol("demo"))).toBe(true)
  // oxlint-disable-next-line symbol-description
  expect(symbolHasDescription(Symbol())).toBe(false)
})

test("symbolGetDescription reads description", () => {
  expect(symbolGetDescription(Symbol("demo"))).toBe("demo")
  // oxlint-disable-next-line symbol-description
  expect(symbolGetDescription(Symbol())).toBeUndefined()
})

test("symbolIsAnonymous checks empty description", () => {
  expect(symbolIsAnonymous(Symbol("demo"))).toBe(false)
  // oxlint-disable-next-line symbol-description
  expect(symbolIsAnonymous(Symbol())).toBe(true)
})

test("symbolIsWellKnown detects well-known symbols", () => {
  expect(symbolIsWellKnown(Symbol.iterator)).toBe(true)
  expect(symbolIsWellKnown(Symbol("iterator"))).toBe(false)
})

test("symbolToString converts to string", () => {
  expect(symbolToString(Symbol("demo"))).toBe("Symbol(demo)")
  expect(symbolToString("demo")).toBeUndefined()
})