import { describe, expect, it } from 'vitest';
import {
  BOOKING_STATUSES,
  TransitionError,
  assertTransition,
  canTransition,
  isTerminal,
  nextStates,
} from '../src/state-machines';

describe('booking transitions', () => {
  it('walks the happy path', () => {
    expect(canTransition('booking', 'scheduled', 'in_progress')).toBe(true);
    expect(canTransition('booking', 'in_progress', 'awaiting_confirmation')).toBe(true);
    expect(canTransition('booking', 'awaiting_confirmation', 'completed')).toBe(true);
  });

  it('refuses to skip straight to completed — the payout guard', () => {
    expect(canTransition('booking', 'scheduled', 'completed')).toBe(false);
    expect(() => assertTransition('booking', 'scheduled', 'completed')).toThrow(TransitionError);
  });

  it('cannot resurrect a cancelled booking', () => {
    expect(isTerminal('booking', 'cancelled')).toBe(true);
    expect(canTransition('booking', 'cancelled', 'scheduled')).toBe(false);
  });

  it('still allows a dispute after completion', () => {
    expect(canTransition('booking', 'completed', 'disputed')).toBe(true);
  });

  it('rejects unknown states instead of silently allowing them', () => {
    expect(canTransition('booking', 'nonsense', 'completed')).toBe(false);
    expect(nextStates('booking', 'nonsense')).toEqual([]);
  });

  it('every declared status appears in the graph', () => {
    for (const status of BOOKING_STATUSES) {
      expect(() => nextStates('booking', status)).not.toThrow();
    }
  });
});

describe('payment transitions', () => {
  it('holds before it releases', () => {
    expect(canTransition('payment', 'pending', 'held')).toBe(true);
    expect(canTransition('payment', 'held', 'released')).toBe(true);
  });

  it('never releases straight from pending — money only moves after capture', () => {
    expect(canTransition('payment', 'pending', 'released')).toBe(false);
  });

  it('lets a failed payment be retried', () => {
    expect(canTransition('payment', 'failed', 'pending')).toBe(true);
  });

  it('treats a full refund as final', () => {
    expect(isTerminal('payment', 'refunded')).toBe(true);
  });
});

describe('verification transitions', () => {
  it('requires review before a pro is verified', () => {
    expect(canTransition('verification', 'draft', 'verified')).toBe(false);
    expect(canTransition('verification', 'draft', 'pending')).toBe(true);
    expect(canTransition('verification', 'pending', 'verified')).toBe(true);
  });

  it('can suspend a verified pro and reinstate them', () => {
    expect(canTransition('verification', 'verified', 'suspended')).toBe(true);
    expect(canTransition('verification', 'suspended', 'verified')).toBe(true);
  });

  it('lets a rejected pro reapply', () => {
    expect(canTransition('verification', 'rejected', 'pending')).toBe(true);
  });
});

describe('request transitions', () => {
  it('is one-shot — an accepted request cannot change', () => {
    expect(isTerminal('request', 'accepted')).toBe(true);
    expect(canTransition('request', 'accepted', 'declined')).toBe(false);
    expect(canTransition('request', 'expired', 'accepted')).toBe(false);
  });
});