import { expect, test } from "vitest"

import { DownCountSelector } from "#Source/orchestration/index.ts"

test("DownCountSelector getId returns the configured selector id", () => {
  const selector = new DownCountSelector({
    id: "selector-1",
    itemList: ["alpha"],
  })

  expect(selector.getId()).toBe("selector-1")
})

test("DownCountSelector getItem distinguishes no choice, no available, and reset-driven reuse", async () => {
  const emptySelector = new DownCountSelector<string>({
    id: "empty",
    itemList: [],
  })

  const emptyResult = await emptySelector.getItem()

  expect(emptyResult.isLeft()).toBe(true)
  expect(emptyResult.assertLeft().getLeft()).toEqual({
    code: "NO_CHOICE",
  })

  const noAvailableSelector = new DownCountSelector({
    id: "no-available",
    itemList: ["alpha", "beta"],
    resetAllWhenNoAvailable: false,
  })

  const firstResult = await noAvailableSelector.getItem()

  expect(firstResult.isRight()).toBe(true)

  firstResult.assertRight().getRight().markUnavailable()

  const secondResult = await noAvailableSelector.getItem()

  expect(secondResult.isRight()).toBe(true)
  expect(secondResult.assertRight().getRight().item).toBe("beta")

  secondResult.assertRight().getRight().markUnavailable()

  const noAvailableResult = await noAvailableSelector.getItem()

  expect(noAvailableResult.isLeft()).toBe(true)
  expect(noAvailableResult.assertLeft().getLeft()).toEqual({
    code: "NO_AVAILABLE",
  })

  const resetSelector = new DownCountSelector({
    id: "reset",
    itemList: ["only"],
  })

  const resetFirstResult = await resetSelector.getItem()

  expect(resetFirstResult.isRight()).toBe(true)

  resetFirstResult.assertRight().getRight().markUnavailable()

  const resetSecondResult = await resetSelector.getItem()

  expect(resetSecondResult.isRight()).toBe(true)
  expect(resetSecondResult.assertRight().getRight().item).toBe("only")

  resetSecondResult.assertRight().getRight().markUnavailable()

  const recoveredResult = await resetSelector.getItem()

  expect(recoveredResult.isRight()).toBe(true)

  recoveredResult.assertRight().getRight().markAvailable()

  const availableAgainResult = await resetSelector.getItem()

  expect(availableAgainResult.isRight()).toBe(true)
  expect(availableAgainResult.assertRight().getRight().item).toBe("only")
})