import test from 'node:test';
import assert from 'node:assert/strict';
import {
  applyAction,
  createGame,
  joinGame,
  newPlayer,
  viewGame,
  type Game,
} from '../game/engine';
import { baseDeck, spiceDeck } from '../game/cards';
import { territory, location } from '../game/board';
import { botActions } from '../game/bots';
import { DIFFICULTIES } from '../game/bot-profiles';
const cards = baseDeck();
const karamas = cards.filter((c) => c.effect === 'karama');
const t = 'the_great_flat';
const key = location(t, territory(t).sectors[0]);
const lands = spiceDeck().filter((c) => 'territory' in c);
function fixture() {
  let g = createGame('SUMMON22', newPlayer('f', 'Fremen', 'fremen'));
  joinGame(g, newPlayer('e', 'Emperor', 'emperor'));
  joinGame(g, newPlayer('g', 'Guild', 'guild'));
  g.players.forEach((p) => (p.ready = true));
  g = applyAction(g, 'f', { type: 'start' });
  for (const p of g.players)
    if (p.traitorChoices.length)
      g = applyAction(g, p.id, {
        type: 'traitor',
        leader: p.traitorChoices[0],
      });
  g = applyAction(g, 'f', {
    type: 'fremenSetup',
    placements: { sietch_tabr: 10 },
  });
  g.advanced = true;
  g.phase = 1;
  g.turn = 2;
  g.storm = 18;
  g.spiceDeck = [...lands];
  g.spiceDiscard = [[], []];
  g.players.forEach((p) => {
    p.forces = {};
    p.reserves = 20;
    p.hand = [];
  });
  g.players[0].hand = [karamas[0]];
  g.players[0].forces = { [key]: 4 };
  g.players[0].reserves = 16;
  g.players[0].elites = {
    reserves: 2,
    tanks: 0,
    forces: { [key]: 1 },
    revived: 0,
  };
  g.players[1].forces = { [key]: 5 };
  g.players[1].reserves = 15;
  g.spice[key] = 8;
  return g;
}
const summon = (g: Game, target = t) =>
  applyAction(g, 'f', {
    type: 'card',
    mode: 'special',
    card: karamas[0].id,
    territory: target,
  });
function allow(state: Game) {
  let g = state;
  while (g.response)
    g = applyAction(
      g,
      g.players.find((p) => !g.response!.passed.includes(p.id))!.id,
      { type: 'passResponse' },
    );
  return g;
}
function ready(state: Game) {
  let g = state;
  for (const p of state.players)
    if (!g.ready.includes(p.id)) g = applyAction(g, p.id, { type: 'ready' });
  return g;
}
function finish(state: Game) {
  let g = allow(state);
  g = ready(g);
  while (g.decision?.kind === 'wormRide')
    g = applyAction(g, 'f', { type: 'decision', accept: false });
  return g;
}
void test('special worm devours forces and spice, preserves Fremen elites and pauses before changing either spice pile', () => {
  const before = fixture();
  before.players[2].hand = [karamas[1]];
  let g = summon(before);
  assert.equal(g.response?.kind, 'wormSurvival');
  assert.equal(g.players[0].specialKaramaUsed, true);
  assert.equal(g.players[1].tanks, 0);
  g = allow(g);
  assert.equal(g.players[1].tanks, 5);
  assert.equal(g.players[0].forces[key], 4);
  assert.equal(g.players[0].elites?.forces[key], 1);
  assert.equal(g.spice[key], undefined);
  assert.equal(g.nexus, false);
  assert.equal(g.summonedBeforeBlow, true);
  assert.deepEqual(g.spiceDeck, before.spiceDeck);
  assert.deepEqual(g.spiceDiscard, before.spiceDiscard);
  assert.deepEqual(g.wormRides, [t]);
  assert.equal(g.discard.filter((c) => c.id === karamas[0].id).length, 1);
  assert.deepEqual(before.players[1].forces, { [key]: 5 });
});
void test('before-draw summon defers Nexus until the first blow is accepted, then rides precede the second blow', () => {
  const before = fixture();
  before.ready = ['e'];
  let g = allow(summon(before));
  assert.equal(g.summonedWorm, null);
  assert.equal(g.nexus, false);
  assert.deepEqual(g.ready, []);
  assert.throws(
    () => applyAction(g, 'f', { type: 'alliance', target: 'e' }),
    /Nexus/,
  );
  g = ready(g);
  assert.ok(g.spiceWindow?.event);
  assert.deepEqual(g.spiceWindow, { ...lands[0], event:g.spiceWindow.event, harvested: false });
  assert.equal(g.nexus, true);
  g = ready(g);
  assert.equal(g.spiceWindow, null);
  assert.equal(g.decision, null);
  g = ready(g);
  assert.equal(g.decision?.kind, 'wormRide');
  g = applyAction(g, 'f', {
    type: 'decision',
    accept: true,
    territory: 'polar_sink',
    sector: 0,
    forces: { [key]: 3 },
    eliteForces: { [key]: 1 },
  });
  assert.equal(g.players[0].forces['polar_sink:0'], 3);
  assert.equal(g.players[0].elites?.forces['polar_sink:0'], 1);
  assert.ok(g.spiceWindow?.event);
  assert.deepEqual(g.spiceWindow, { ...lands[1], event:g.spiceWindow.event, harvested: false });
  g = ready(g);
  assert.equal(g.phase, 2);
});
void test('normal Karama can cancel Fremen survival without canceling the special summon or Nexus', () => {
  const before = fixture();
  before.players[2].hand = [karamas[1]];
  let g = summon(before);
  g = applyAction(g, 'g', {
    type: 'card',
    mode: 'cancel',
    card: karamas[1].id,
  });
  assert.equal(g.players[0].tanks, 4);
  assert.equal(g.players[0].elites?.tanks, 1);
  assert.equal(g.players[1].tanks, 5);
  assert.equal(g.nexus, false);
  assert.equal(g.summonedBeforeBlow, true);
  assert.deepEqual(g.wormRides, []);
  g = ready(g);
  assert.equal(g.summonedWorm, null);
  assert.equal(g.phase, 1);
});
void test('ally protection and Fremen survival retain separate cancellation windows', () => {
  const before = fixture();
  before.players[2].hand = [karamas[1]];
  before.players[0].ally = 'e';
  before.players[1].ally = 'f';
  let g = summon(before);
  assert.equal(g.decision?.kind, 'wormProtection');
  g = applyAction(g, 'f', { type: 'decision', accept: true });
  assert.equal(g.response?.kind, 'wormAllyProtection');
  const protectedGame = allow(g);
  assert.equal(protectedGame.players[1].forces[key], 5);
  g = applyAction(g, 'g', {
    type: 'card',
    mode: 'cancel',
    card: karamas[1].id,
  });
  assert.equal(g.response, null); // No cancellation card remains for the separate survival power.
  g = allow(g);
  assert.equal(g.players[1].tanks, 5);
  assert.equal(g.players[0].tanks, 0);
});
void test('summoning during an open Nexus merges its ride and clears old confirmations without creating another spice draw', () => {
  const before = fixture();
  before.nexus = true;
  before.ready = ['e'];
  before.spiceSequence = { pile: 1, skipped: [] };
  before.wormRides = ['red_chasm'];
  const g = allow(summon(before));
  assert.equal(g.summonedWorm, null);
  assert.equal(g.nexus, true);
  assert.deepEqual(g.ready, []);
  assert.deepEqual(g.wormRides, ['red_chasm', t]);
  assert.deepEqual(g.spiceSequence, before.spiceSequence);
  assert.deepEqual(g.spiceDeck, before.spiceDeck);
});
void test('an interrupted fresh blow and its pile position persist, but devoured spice cannot be harvested afterward', () => {
  const before = fixture();
  const blow = lands.find((c) => c.territory === t)!;
  before.spiceWindow = { ...blow, harvested: false };
  before.spiceSequence = { pile: 1, skipped: [] };
  before.players[1].hand = [cards.find((c) => c.effect === 'harvester')!];
  const g = allow(JSON.parse(JSON.stringify(summon(before))));
  assert.equal(g.spiceSequence?.pile, 1);
  assert.equal(g.spiceWindow?.harvested, true);
  assert.equal(g.spiceWindow?.territory, t);
  assert.throws(
    () => applyAction(g, 'e', { type: 'card', card: g.players[1].hand[0].id }),
    /immediately after a spice blow/,
  );
});
void test('suspended responses preserve passes and private fields without projection leakage', () => {
  const before = fixture();
  before.players[2].hand = [karamas[1]];
  before.response = {
    kind: 'wormSurvival',
    owner: 'f',
    location: 'red_chasm',
    passed: ['e'],
  };
  before.spiceSequence = { pile: 0, skipped: [] };
  before.spiceResolution = { skipped: [] };
  before.nexus = true;
  const pending = summon(before);
  const view = viewGame(pending, 'e');
  assert.deepEqual(view.summonedWorm, { territory: t });
  assert.equal('resume' in view.summonedWorm!, false);
  let g = pending;
  while (g.summonedWorm)
    g = applyAction(
      g,
      g.players.find((p) => !g.response!.passed.includes(p.id))!.id,
      { type: 'passResponse' },
    );
  assert.deepEqual(g.response, before.response);
  assert.deepEqual(g.spiceResolution, before.spiceResolution);
  assert.deepEqual(g.spiceSequence, before.spiceSequence);
  assert.equal(g.nexus, true);
});
void test('the called worm can interrupt a pending additional-worm choice without consuming a draw or its placement allowance', () => {
  const before = fixture();
  before.decision = { kind: 'wormPlacement', player: 'f' };
  before.spiceResolution = { skipped: [] };
  before.spiceSequence = { pile: 1, skipped: [] };
  before.nexus = true;
  before.wormPlacementCanceledTurn = before.turn;
  const g = allow(summon(before));
  assert.deepEqual(g.decision, before.decision);
  assert.deepEqual(g.spiceDeck, before.spiceDeck);
  assert.equal(g.wormPlacementCanceledTurn, before.turn);
});
void test('invalid territory, phase, basic mode and repeated special use are atomic', () => {
  const before = fixture();
  for (const target of ['arrakeen', 'polar_sink', 'unknown'])
    assert.throws(() => summon(before, target), /sand territory/);
  const wrong = structuredClone(before);
  wrong.phase = 5;
  assert.throws(() => summon(wrong), /Spice Blow/);
  wrong.phase = 1;
  wrong.advanced = false;
  assert.throws(() => summon(wrong), /advanced game/);
  assert.equal(before.players[0].hand[0].id, karamas[0].id);
  const g = finish(summon(before));
  g.turn++;
  g.players[0].hand = [karamas[0]];
  assert.throws(() => summon(g), /already been used/);
});
void test('first-turn special summons are not discarded as first-turn drawn worm cards', () => {
  const before = fixture();
  before.turn = 1;
  const g = allow(summon(before));
  assert.equal(g.players[1].tanks, 5);
  assert.equal(g.summonedBeforeBlow, true);
  assert.deepEqual(g.spiceDeck, before.spiceDeck);
});
void test('all AI difficulties use public sand-territory threats and can continue the summoned-worm sequence', () => {
  for (const difficulty of DIFFICULTIES) {
    const before = fixture();
    before.players[0].bot = difficulty;
    const action = botActions(viewGame(before, 'f'))[0];
    assert.equal(action.mode, 'special');
    assert.equal(action.territory, t);
    const g = applyAction(before, 'f', action);
    assert.equal(g.response, null);
    assert.equal(g.summonedWorm, null);
    assert.equal(g.players[1].tanks, 5);
    assert.equal(g.players[0].tanks, 0);
    const other = structuredClone(before);
    other.players[1].hand = cards.slice(0, 4);
    other.spiceDeck.reverse();
    assert.deepEqual(botActions(viewGame(other, 'f'))[0], action);
  }
});
void test('a summon while a ride is awaiting input reopens Nexus before preserving both ride opportunities', () => {
  const before = fixture();
  before.nexus = true;
  before.spiceSequence = { pile: 1, skipped: [] };
  before.decision = { kind: 'wormRide', player: 'f', territory: t };
  before.ready = before.players.map((p) => p.id);
  let g = allow(summon(before));
  assert.equal(g.decision, null);
  assert.equal(g.nexus, true);
  assert.deepEqual(g.ready, []);
  assert.deepEqual(g.wormRides, [t, t]);
  g = ready(g);
  g = applyAction(g, 'f', {
    type: 'decision',
    accept: true,
    territory: 'polar_sink',
    sector: 0,
    forces: { [key]: 2 },
    eliteForces: { [key]: 1 },
  });
  assert.equal(g.decision?.kind, 'wormRide');
  assert.equal(g.players[0].forces[key], 2);
  g = applyAction(g, 'f', { type: 'decision', accept: false });
  assert.equal(g.phase, 2);
});
void test('summoning during a ride intrusion resolves that decision before reopening Nexus and offering the new ride', () => {
  const before = fixture();
  const bg = newPlayer('b', 'Bene Gesserit', 'beneGesserit');
  bg.forces = { 'carthag:11': 1 };
  before.players[0].forces['carthag:11'] = 1;
  before.players[0].reserves--;
  bg.reserves = 19;
  before.players.push(bg);
  before.order.push('b');
  before.nexus = true;
  before.spiceSequence = { pile: 1, skipped: [] };
  before.decision = {
    kind: 'intrusion',
    player: 'b',
    territory: 'carthag',
    wormRide: true,
  };
  let g = allow(summon(before));
  assert.equal(g.decision?.kind, 'intrusion');
  assert.equal(g.summonedNexusBeforeRides, true);
  g = applyAction(g, 'b', { type: 'decision', accept: false });
  assert.equal(g.decision, null);
  assert.equal(g.nexus, true);
  assert.equal(g.summonedNexusBeforeRides, false);
  assert.deepEqual(g.ready, []);
  g = ready(g);
  assert.equal(g.decision?.kind, 'wormRide');
});
void test('a suspended Worthless conversion and its original worm response are restored together and remain private', () => {
  const before = fixture();
  before.players[2].hand = [karamas[1]];
  const bg = newPlayer('b', 'Bene Gesserit', 'beneGesserit');
  const worthless = cards.find((c) => c.kind === 'worthless')!;
  bg.hand = [worthless];
  before.players.push(bg);
  before.order.push('b');
  before.response = {
    kind: 'wormSurvival',
    owner: 'f',
    location: 'red_chasm',
    passed: ['e'],
  };
  before.spiceResolution = { skipped: [] };
  before.spiceSequence = { pile: 0, skipped: [] };
  before.nexus = true;
  const converting = applyAction(before, 'b', {
    type: 'card',
    mode: 'cancel',
    card: worthless.id,
  });
  let g = summon(converting);
  assert.equal(g.pendingKarama, null);
  assert.equal('resume' in viewGame(g, 'e').summonedWorm!, false);
  while (g.summonedWorm)
    g = applyAction(
      g,
      g.players.find((p) => !g.response!.passed.includes(p.id))!.id,
      { type: 'passResponse' },
    );
  assert.deepEqual(g.response, converting.response);
  assert.deepEqual(g.pendingKarama, converting.pendingKarama);
  assert.equal('pendingKarama' in viewGame(g, 'e'), false);
});