import assert from 'node:assert/strict';
import test from 'node:test';
import { viewGame, type Game } from '../game/engine';
import { act, advance, clean, createKullRicheseSemutaFixture, player } from './fixture-kull-richese-semuta';

/** Account for the current sold card as a historical auction reference, not a
 * second physical card. Unopened lots remain in the original auction custody. */
function inventory(game: Game): string[] {
  const cards = [...game.deck, ...game.discard, ...(game.richeseCache ?? []),
    ...(game.richeseRemoved ?? []), ...game.players.flatMap(seat => seat.hand),
    ...(game.auction?.cards.slice(game.auction.index + Number(!!game.currentAuctionSale)) ?? [])]
    .map(card => card.id).sort();
  assert.equal(new Set(cards).size, cards.length);
  return cards;
}

/** Public Basic four-seat setup and actual first-turn paid Semuta acquisition.
 * In turn two Richese announces its compulsory auction last, then Harkonnen
 * purchases an actual normal lot with its own spice; no live purse, hand,
 * auction, response or promise is staged. */
function source() {
  const f = createKullRicheseSemutaFixture();
  let game = advance(f.game, state => state.turn === 2 && state.phase === 3 &&
    !state.response && !state.phaseOpening && state.decision?.kind === 'richeseDeclaration');
  const round = game.richeseBidding; assert.ok(round);
  game = act(game, 'richese', {type:'decision', event:round.event, position:'last'});
  game = advance(game, state => state.phase === 3 && !!state.auction &&
    state.auction.active === 'harkonnen' && state.auction.bid === 0 && clean(state));
  const index = game.auction!.index, lot = game.auction!.cards[index].id;
  const beforeSpice = player(game,'harkonnen').spice;
  game = act(game,'harkonnen',{type:'bid',amount:1,allyPayment:0});
  game = advance(game,state => state.response?.kind === 'harkonnenBonus');
  assert.equal(game.currentAuctionSale?.origin,'normal');
  assert.equal(game.currentAuctionSale?.winner,'harkonnen');
  assert.equal(game.auction?.index,index);
  assert.equal(game.auction?.cards[index].id,lot);
  assert.ok(player(game,'harkonnen').hand.some(card => card.id === lot));
  assert.equal(player(game,'harkonnen').spice,beforeSpice-1);
  assert.ok(player(game,'choam').hand.some(card => card.id === f.kull));
  assert.ok(player(game,'emperor').hand.some(card => card.id === f.karama));
  assert.ok(player(game,'harkonnen').hand.some(card => card.id === f.counter));
  assert.ok(player(game,'richese').hand.some(card => card.id === f.semuta));
  assert.deepEqual(inventory(game),f.originalCards);
  return {...f,game,index,lot,paidSpice:player(game,'harkonnen').spice,
    buyerCount:player(game,'harkonnen').hand.length};
}

function passDiscard(game: Game): Game {
  const pending = game.pendingTreacheryDiscard; assert.ok(pending?.reaction?.stage === 'offer');
  const event = pending.batch.event;
  for (let count=0;game.pendingTreacheryDiscard?.batch.event===event && count<game.players.length;count++) {
    const reaction = game.pendingTreacheryDiscard!.reaction; assert.ok(reaction?.stage === 'offer');
    const seat = game.players.find(row => !reaction.passed.includes(row.id)); assert.ok(seat);
    game = act(game,seat.id,{type:'semutaPass',event});
  }
  assert.notEqual(game.pendingTreacheryDiscard?.batch.event,event);
  return game;
}
function claimDiscard(game: Game, card: string): Game {
  const pending = game.pendingTreacheryDiscard; assert.ok(pending?.reaction?.stage === 'offer');
  assert.ok(pending.batch.entries.some(entry => entry.card.id === card));
  assert.equal(viewGame(game,'richese').semutaReaction?.canCommit,true);
  const event=pending.batch.event;
  game=act(game,'richese',{type:'semutaCommit',event});
  if (game.pendingTreacheryDiscard?.reaction?.stage === 'select')
    game=act(game,'richese',{type:'semutaSelect',event,card});
  assert.notEqual(game.pendingTreacheryDiscard?.batch.event,event);
  return game;
}

for (const outcome of ['decline','success','counter'] as const)
  for (const claim of [false,true])
    void test(`normal Harkonnen paid bonus: Kull ${outcome}, Semuta ${claim?'claim':'pass'}`,()=>{
      const f=source(); let game=f.game;
      assert.ok(viewGame(game,'emperor').responseControls?.cancelCards.includes(f.karama));
      game=act(game,'emperor',{type:'card',mode:'cancel',card:f.karama});
      const reaction=viewGame(game,'choam').kullReaction; assert.ok(reaction);
      assert.ok(reaction.plays.some(play=>play.source==='printed' && play.card.id===f.kull));
      game=outcome==='decline'
        ? act(game,'choam',{type:'kullDecision',event:reaction.event,decline:true})
        : act(game,'choam',{type:'kullDecision',event:reaction.event,source:'printed',card:f.kull});
      if (outcome==='counter') {
        assert.ok(viewGame(game,'harkonnen').responseControls?.cancelCards.includes(f.counter));
        game=act(game,'harkonnen',{type:'card',mode:'cancel',card:f.counter});
        game=passDiscard(game);
      }
      if (outcome==='success') game=advance(game,state=>!!state.pendingTreacheryDiscard);
      const discarded=outcome==='success'?f.kull:f.karama;
      assert.ok(game.pendingTreacheryDiscard?.batch.entries.some(entry=>entry.card.id===discarded));
      game=claim?claimDiscard(game,discarded):passDiscard(game);
      assert.equal(game.pendingKull ?? null,null);
      assert.equal(game.currentAuctionSale ?? null,null);
      assert.notEqual(game.response?.kind,'harkonnenBonus');
      assert.equal(game.auction?.index,f.index+1);
      assert.equal(player(game,'harkonnen').spice,f.paidSpice);
      assert.ok(player(game,'harkonnen').hand.some(card=>card.id===f.lot));
      assert.equal(player(game,'harkonnen').hand.length,
        f.buyerCount+Number(outcome==='success')-Number(outcome==='counter'));
      assert.equal(player(game,'emperor').hand.some(card=>card.id===f.karama),outcome==='success');
      assert.equal(player(game,'richese').hand.some(card=>card.id===discarded),claim);
      assert.equal(player(game,'richese').hand.some(card=>card.id===f.semuta),!claim);
      assert.deepEqual(inventory(game),f.originalCards);
    });