import assert from 'node:assert/strict';
import test from 'node:test';
import { applyAction, createGame, joinGame, newPlayer, normalizeAutomaticGame, viewGame, type Action, type Game } from '../game/engine';
import { botActions } from '../game/bots';
import { DIFFICULTIES } from '../game/bot-profiles';
import { takeKullCard } from './fixture-choam-kull';
import { nextHarkonnenBetrayalNativeStep } from './fixture-nexus-harkonnen-betrayal';
import { swapSemutaNexusTradeIdentity } from './fixture-semuta-nexus-trade';

const act = (game: Game, actor: string, action: Action) => applyAction(game, actor, action);
const seat = (game: Game, id: string) => { const player = game.players.find(row => row.id === id); assert.ok(player); return player; };
const clean = (game: Game) => !game.response && !game.decision && !game.phaseOpening;
function stock(game: Game): string[] {
  return [...game.deck, ...game.discard, ...(game.auction?.cards.slice(game.auction.index) ?? []),
    ...(game.ixAuction?.cards ?? []), ...game.players.flatMap(player => player.hand)].map(card => card.id).sort();
}
function advance(game: Game, until: (game: Game) => boolean): Game {
  for (let n = 0; n < 1800; n++) {
    if (until(game)) return game;
    assert.notEqual(game.status, 'finished');
    if (game.pendingGuildBetrayal) {
      const pending = game.pendingGuildBetrayal, actor = pending.required.find(id => !pending.passed.includes(id)); assert.ok(actor);
      game = act(game, actor, {type:'guildBetrayalPass',event:pending.invoice.event});
      continue;
    }
    const next = nextHarkonnenBetrayalNativeStep(game);
    try { game = act(game, next.actor, next.action); }
    catch (error) { throw Error(`Native ${game.status}/${game.turn}/${game.phase}/${game.decision?.kind}: ${JSON.stringify(next)}: ${String(error)}`); }
  }
  throw Error(`Native Ixian Nexus Kull journey stalled: ${game.turn}/${game.phase}`);
}
function orderSpice(game: Game, kinds: readonly ('land'|'worm')[]): void {
  for (const [position, kind] of kinds.entries()) {
    const index = game.spiceDeck.findIndex((card, i) => i >= position &&
      (kind === 'land' ? 'territory' in card : 'worm' in card && !card.greatMaker && !card.suppressed));
    assert.ok(index >= position); game.spiceDeck.splice(position, 0, game.spiceDeck.splice(index, 1)[0]);
  }
}

/** Public native setup, real alliance and two earned Nexus draws. Unopened
 * Spice order, identities of genuinely drawn Nexus cards, board positions and
 * physical Treachery holdings are staged while conserving every component. */
function fixture() {
  let game = createGame('NXKULLIX', newPlayer('ix','Ixians','ixians'), false, ['ix','choam']);
  for (const [id,faction] of [['t','tleilaxu'],['c','choam'],['a','atreides'],['g','guild']] as const)
    joinGame(game, newPlayer(id,faction,faction));
  game = act(game,'ix',{type:'moduleOption',module:'nexusCards',enabled:true});
  for (const player of game.players) game = act(game,player.id,{type:'ready'});
  game = act(game,'ix',{type:'start'});
  assert.equal(game.kullPreview,true); assert.equal(game.nexusKullPreview,true);
  assert.equal(game.nexusIxianBetrayalPreview,true);
  game = advance(game,state => state.status === 'playing');
  const original = stock(game);
  for (const player of game.players) {
    player.reserves += Object.values(player.forces).reduce((sum,n)=>sum+n,0); player.forces = {};
    if (player.elites) { player.elites.reserves += Object.values(player.elites.forces).reduce((sum,n)=>sum+n,0); player.elites.forces={}; }
  }
  orderSpice(game,['land','land']);
  game = advance(game,state=>state.turn===2 && state.phase===1 && clean(state));
  orderSpice(game,['worm','land','land']);
  game = advance(game,state=>state.nexus && !state.spiceWindow && !state.spiceResolution && clean(state));
  game = act(game,'ix',{type:'alliance',target:'t'}); game = act(game,'t',{type:'alliance',target:'ix'});
  game = advance(game,state=>state.nexusCards?.phase?.stage==='drawing' && clean(state));
  for (const id of ['a','c']) {
    assert.ok(game.nexusCards!.phase!.eligible.includes(id));
    game = act(game,id,{type:'nexusCardChoice',turn:game.turn,card:null,choice:'draw',ownRedraws:0});
    swapSemutaNexusTradeIdentity(game,id,id==='a'?'ixians':'choam');
  }
  game = advance(game,state=>state.phase===2 && clean(state));
  for (const player of game.players) game.deck.push(...player.hand.splice(0));
  const originalKarama = takeKullCard(game,'karama'); seat(game,'g').hand.push(originalKarama);
  const counter = takeKullCard(game,'karama'); seat(game,'a').hand.push(counter);
  game = advance(game,state=>state.response?.kind==='ixAuction');
  assert.equal(game.ixAuction?.cards.length,0);
  // Stage conserved held cards at the open native response, after CHOAM's
  // earlier market opportunity cannot sell the intended physical Kull.
  const printed = takeKullCard(game,'ix-kull-wahad'); seat(game,'c').hand.push(printed);
  const fuel = takeKullCard(game,'ix-hunter-seeker'); seat(game,'c').hand.push(fuel);
  assert.deepEqual(stock(game),original);
  game = act(game,'g',{type:'card',mode:'cancel',card:originalKarama.id});
  assert.ok(game.pendingKull); assert.equal(game.pendingKull.resume.response?.kind,'ixAuction');
  return {game,original,printed:printed.id,fuel:fuel.id,karama:originalKarama.id,counter:counter.id,event:game.pendingKull.event};
}
function passKullCounter(state: Game): Game {
  let game=state;
  while (game.pendingKull) {
    const actor = game.players.find(player => { const controls=viewGame(game,player.id).responseControls;
      return controls && !controls.hasPassed && controls.cancelCards.length > 0; });
    game = actor ? act(game,actor.id,{type:'passResponse'}) : normalizeAutomaticGame(game);
  }
  return game;
}

for (const source of ['printed','nexus'] as const) void test(
  `Basic native Ixian Nexus auction survives ${source} Kull success and original Nexus response`, () => {
    const f=fixture();
    for (const difficulty of DIFFICULTIES) {
      const view=viewGame(f.game,'c'); view.players.find(player=>player.id==='c')!.bot=difficulty;
      const choice=botActions(view).find(action=>action.type==='kullDecision'); assert.ok(choice);
      assert.doesNotThrow(()=>act(f.game,'c',choice));
    }
    assert.ok(viewGame(f.game,'c').kullReaction?.plays.some(play => play.source === source && play.card.id === (source==='printed'?f.printed:f.fuel)),
      `Missing ${source} option; hand: ${seat(f.game,'c').hand.map(card=>card.id).join(', ')}; discard: ${f.game.discard.map(card=>card.id).join(', ')}`);
    let game=act(f.game,'c',{type:'kullDecision',event:f.event,source,card:source==='printed'?f.printed:f.fuel});
    game=passKullCounter(game);
    assert.equal(game.pendingKull,null);
    assert.equal(seat(game,'g').hand.some(card=>card.id===f.karama),true);
    assert.equal(game.discard.filter(card=>card.id===(source==='printed'?f.printed:f.fuel)).length,1);
    game=advance(game,state=>!!state.pendingNexusIxianBetrayal);
    const nexus=game.pendingNexusIxianBetrayal!;
    assert.equal(viewGame(game,'a').nexusIxianBetrayalReaction?.canUse,true);
    for (const use of [false,true]) {
      let resumed = structuredClone(game);
      if (use) resumed=act(resumed,'a',{type:'nexusIxianBetrayalUse',event:nexus.source.event});
      else while (resumed.pendingNexusIxianBetrayal) {
        const pending=resumed.pendingNexusIxianBetrayal;
        const actor=pending.required.find(id=>!pending.passed.includes(id)); assert.ok(actor);
        resumed=act(resumed,actor,{type:'nexusIxianBetrayalPass',event:pending.source.event});
      }
      assert.equal(resumed.pendingNexusIxianBetrayal,null);
      if (!use) {
        assert.equal(resumed.decision?.kind,'ixAuction'); assert.ok(resumed.ixAuction?.cards.length);
        resumed=act(resumed,'ix',{type:'decision',card:resumed.ixAuction.cards[0].id,position:'top'});
      }
      assert.equal(resumed.ixAuction,null); assert.ok(resumed.auction);
      assert.deepEqual(stock(resumed),f.original);
    }
  });

for (const counter of [false,true]) void test(
  `Basic native Ixian auction resumes original cancellation after Kull ${counter?'counter':'decline'}`, () => {
    const f=fixture();
    let game=counter ? act(f.game,'c',{type:'kullDecision',event:f.event,source:'nexus',card:f.fuel})
      : act(f.game,'c',{type:'kullDecision',event:f.event,decline:true});
    if (counter) game=act(game,'a',{type:'card',mode:'cancel',card:f.counter});
    assert.equal(game.pendingKull,null); assert.equal(game.pendingNexusIxianBetrayal,null);
    assert.equal(game.ixAuction,null); assert.ok(game.auction);
    assert.equal(game.discard.some(card=>card.id===f.karama),true);
    assert.equal(seat(game,'c').hand.some(card=>card.id===f.fuel),true);
    assert.equal(game.nexusCards!.cards!.hands.c,counter?null:'choam');
    assert.deepEqual(stock(game),f.original);
  });