import { afterEach, expect, test, vi } from "vitest"

import {
  Barrier,
  BrokenBarrierError,
  CoordinationAbortError,
  CoordinationTimeoutError,
} from "#Source/orchestration/index.ts"

const getRejectedReason = async (promise: Promise<unknown>): Promise<unknown> => {
  try {
    await promise
  } catch (error: unknown) {
    return error
  }

  throw new Error("Expected promise to reject.")
}

afterEach(() => {
  vi.clearAllTimers()
  vi.useRealTimers()
})

test("Barrier completes generations and can be reused", async () => {
  const barrier = new Barrier(2)
  const firstGenerationWait = barrier.signalAndWait()

  expect(barrier.getParticipantCount()).toBe(2)
  expect(barrier.getGeneration()).toBe(0)
  expect(barrier.getPendingCount()).toBe(1)
  expect(barrier.getRemainingCount()).toBe(1)

  const secondArrivalGeneration = await barrier.signalAndWait()
  const firstArrivalGeneration = await firstGenerationWait

  expect(firstArrivalGeneration).toBe(0)
  expect(secondArrivalGeneration).toBe(0)
  expect(barrier.getGeneration()).toBe(1)
  expect(barrier.getPendingCount()).toBe(0)
  expect(barrier.getRemainingCount()).toBe(2)

  const thirdArrivalGenerationPromise = barrier.signalAndWait()
  const fourthArrivalGeneration = await barrier.signalAndWait()

  expect(await thirdArrivalGenerationPromise).toBe(1)
  expect(fourthArrivalGeneration).toBe(1)
  expect(barrier.getGeneration()).toBe(2)
})

test("Barrier timeout breaks the current generation for all waiting participants", async () => {
  vi.useFakeTimers()

  const barrier = new Barrier(3)
  const firstWait = barrier.signalAndWait()
  const secondWait = barrier.signalAndWait({ timeout: 25 })
  const firstWaitReasonPromise = getRejectedReason(firstWait)
  const secondWaitReasonPromise = getRejectedReason(secondWait)

  expect(barrier.getPendingCount()).toBe(2)
  expect(barrier.getRemainingCount()).toBe(1)

  await vi.advanceTimersByTimeAsync(25)

  const timeoutError = await secondWaitReasonPromise
  const brokenError = await firstWaitReasonPromise

  expect(timeoutError).toBeInstanceOf(CoordinationTimeoutError)
  expect(brokenError).toBeInstanceOf(BrokenBarrierError)

  if (!(brokenError instanceof BrokenBarrierError)) {
    throw new Error("Expected brokenError to be an instance of BrokenBarrierError.")
  }

  expect(brokenError.reason).toBe(timeoutError)
  expect(barrier.getGeneration()).toBe(1)
  expect(barrier.getPendingCount()).toBe(0)
  expect(barrier.getRemainingCount()).toBe(3)
})

test("Barrier abort rejects the failing participant and breaks peers", async () => {
  const barrier = new Barrier(3)
  const abortController = new AbortController()
  const firstWait = barrier.signalAndWait()
  const secondWait = barrier.signalAndWait({ abortSignal: abortController.signal })
  const firstWaitReasonPromise = getRejectedReason(firstWait)
  const secondWaitReasonPromise = getRejectedReason(secondWait)

  abortController.abort("cancelled")

  const abortError = await secondWaitReasonPromise
  const brokenError = await firstWaitReasonPromise

  expect(abortError).toBeInstanceOf(CoordinationAbortError)
  expect(brokenError).toBeInstanceOf(BrokenBarrierError)

  if (!(brokenError instanceof BrokenBarrierError)) {
    throw new Error("Expected brokenError to be an instance of BrokenBarrierError.")
  }

  expect(brokenError.reason).toBe(abortError)
  expect(barrier.getGeneration()).toBe(1)
  expect(barrier.getPendingCount()).toBe(0)
})