import assert from 'node:assert/strict';
import test from 'node:test';
import { applyAction, type Action, type Game } from '../game/engine';
import { DIFFICULTIES } from '../game/bot-profiles';
import type { FactionId } from '../game/catalog';
import { LEADER_SKILL_CARDS } from '../game/leader-skill-cards';
import { homeworldContext } from '../game/homeworld-game';
import { homeworldForceGroups } from '../game/homeworld-custody';
import type { HomeworldCombatLossContext } from '../game/homeworld-combat-loss';
import { quoteSukPhysicalRescue, type SukReserveDestinations } from '../game/suk-graduate';
import {
  advanceClassicHomeworldSkills as advance, assertClassicHomeworldSkillsCustody as custody,
  classicHomeworldSkillsBotOffers as offers, classicHomeworldSkillsPlayer as player,
  createClassicHomeworldSkillsFixture as fixture, createClassicHomeworldSkillsSetup as setup,
  quoteClassicHomeworldSkillsBattle as quoteBattle, revealClassicHomeworldSkillsBattle as reveal,
  settleClassicHomeworldSkillsBattle as settle,
} from './fixture-homeworld-classic-skills';

function legalOffers(game: Game, actor: string): void {
  for (const level of DIFFICULTIES) {
    const actions = offers(game, actor, level); assert.ok(actions.length, `${level} has a real supported offer`);
    for (const action of actions) custody(applyAction(game, actor, action));
  }
}
function context(game: Game): HomeworldCombatLossContext {
  return { advanced: game.advanced, players: game.players.map(p => {
    const total = Object.values(p.forces).reduce((a, b) => a + b, 0);
    const elite = Object.values(p.elites?.forces ?? {}).reduce((a, b) => a + b, 0);
    return { id: p.id, faction: p.faction, reserves: p.reserves, eliteReserves: p.elites?.reserves ?? 0,
      tanks: p.tanks, eliteTanks: p.elites?.tanks ?? 0, battleLosses: p.battleLosses,
      boardForces: { normal: total - elite, elite } };
  }) };
}
function pool(game: Game, actor: string, location: string) {
  return homeworldForceGroups(homeworldContext(game), game.homeworlds!.custody!)
    .find(home => home.id === location)!.forces[actor] ?? { normal: 0, elite: 0 };
}
function reject(game: Game, actor: string, action: Action): void {
  const before = structuredClone(game); assert.throws(() => applyAction(game, actor, action)); assert.deepEqual(game, before);
}
function rescueChoice(game: Game, elite: boolean): number {
  const decision = game.decision; assert.equal(decision?.kind, 'sukRescue');
  if (decision?.kind !== 'sukRescue') throw Error('A real rescue choice is required');
  const maximum = Math.max(...decision.options.map(option => option.normal + option.elite));
  const choice = decision.options.findIndex(option => option.normal + option.elite === maximum &&
    (elite ? option.elite > 0 && option.kept?.kind === 'elite' : option.kept?.kind === 'normal'));
  assert.ok(choice >= 0); return choice;
}
function splitReturn(game: Game, choice: number): SukReserveDestinations | undefined {
  const decision = game.decision; assert.ok(decision?.kind === 'sukRescue');
  if (!decision.reserveHomes) return undefined;
  const option = decision.options[choice];
  const normal = option.normal - (option.kept?.kind === 'normal' ? 1 : 0);
  const elite = option.elite - (option.kept?.kind === 'elite' ? 1 : 0);
  if (!normal && !elite) return undefined;
  // Deliberately NOT the revival mapping: any returned ordinary pieces go to
  // Salusa and any returned Sardaukar go to Kaitain. This application placement
  // choice exercises exact two-home conservation, not a publisher ruling.
  return Object.fromEntries(decision.reserveHomes.map(home => [home.id,
    home.secondary ? { normal, elite: 0 } : { normal: 0, elite }]));
}

void test('original Basic/Advanced two-through-six classic Homeworld setups retain starting hands and all fourteen physical skills', () => {
  const roster: FactionId[] = ['emperor', 'guild', 'atreides', 'harkonnen', 'fremen', 'beneGesserit'];
  for (const advanced of [false, true]) for (let seats = 2; seats <= 6; seats++) {
    const f = setup({ advanced, roster: roster.slice(0, seats) });
    const physical = f.offered.leaderSkills!;
    assert.deepEqual([...physical.deck, ...Object.values(physical.offers).flatMap(o => o.cards), ...physical.assignments.map(a => a.skill)].sort(), LEADER_SKILL_CARDS.map(c => c.id).sort());
    for (const p of f.afterSetup.players) {
      assert.equal(p.hand.length, p.faction === 'harkonnen' ? 2 : 1);
    }
    for (const p of f.offered.players) legalOffers(f.offered, p.id);
    custody(f.offered); custody(f.afterSetup);
  }
});

void test('every physical skill remains selectable through actual Emperor offers', () => {
  for (const advanced of [false, true]) for (const card of LEADER_SKILL_CARDS) {
    const f = setup({ advanced, roster: ['emperor', 'guild'], skill: card.id });
    assert.equal(f.afterSetup.leaderSkills!.assignments.find(a => a.owner === 'emperor')!.skill, card.id);
    legalOffers(f.offered, 'emperor');
    custody(f.afterSetup);
  }
});


for (const advanced of [false, true]) {
  void test(`${advanced ? 'Advanced' : 'Basic'} trained native and invader add the actual Mentat bonus without turning native strength into counters`, () => {
    for (const kind of ['native-bonus', 'visitor-bonus'] as const) {
      const f = fixture({ kind, advanced });
      for (const actor of [f.owner, f.opponent]) legalOffers(f.game, actor);
      const revealed = reveal(f), quote = quoteBattle(revealed);
      const own = revealed.battle!.attacker === f.owner ? 'attacker' : 'defender';
      const leader = player(revealed, f.owner).leaders.find(l => l.id === f.trainer)!;
      const alternative = player(f.game, f.owner).leaders.find(disc => disc.id !== f.trainer && !disc.dead)!;
      const untrained = reveal({ ...f, plans: f.plans.map(step => step.actor === f.owner
        ? { ...step, action: { ...step.action, leader: alternative.id } } : step) });
      const untrainedQuote = quoteBattle(untrained);
      assert.equal(quote.scores![own] - untrainedQuote.scores![own], leader.strength - alternative.strength + 2);
      const beforePool = pool(revealed, f.owner, f.territory);
      const completed = settle(revealed);
      assert.equal(completed.lastBattleContext!.winner, f.owner);
      const losses = player(completed, f.owner).tanks - player(revealed, f.owner).tanks;
      const afterPool = pool(completed, f.owner, f.territory);
      assert.equal(beforePool.normal + beforePool.elite - afterPool.normal - afterPool.elite, losses);
      assert.equal(player(completed, f.owner).leaders.find(l => l.id === f.trainer)!.dead, false);
      custody(completed);
    }
  });

  void test(`${advanced ? 'Advanced' : 'Basic'} actual lethal native and invader plans kill the trained disc and return its one physical skill exactly once`, () => {
    for (const kind of ['native-death', 'visitor-death'] as const) {
      const f = fixture({ kind, advanced }), revealed = reveal(f);
      assert.equal(quoteBattle(revealed).leaderDeaths[revealed.battle!.attacker === f.owner ? 'attacker' : 'defender'], true);
      const done = settle(revealed);
      assert.equal(player(done, f.owner).leaders.find(l => l.id === f.trainer)!.dead, true);
      assert.ok(!done.leaderSkills!.assignments.some(a => a.leader === f.trainer));
      assert.equal(done.leaderSkills!.deck.filter(id => id === 'mentat').length, 1);
      const ended = advance(done, game => game.turn > done.turn);
      assert.equal(ended.leaderSkills!.deck.filter(id => id === 'mentat').length, 1);
      custody(done); custody(ended);
    }
  });

  void test(`${advanced ? 'Advanced' : 'Basic'} native Homeworld trained Suk saves actual counters in their same reserve pool`, () => {
    const f = fixture({ kind: 'native-suk', advanced }), revealed = reveal(f), pending = settle(revealed, 'suk');
    assert.equal(pending.pendingSukRescue!.territory, f.territory);
    assert.equal(pending.pendingSukRescue!.skill.mode, 'skilled');
    assert.equal(pending.pendingSukRescue!.pool.length, 1);
    const choice = rescueChoice(pending, advanced);
    assert.ok(pending.decision?.kind === 'sukRescue');
    assert.equal(pending.decision.reserveHomes, undefined, 'Native rescue cannot offer a free Emperor internal move');
    legalOffers(pending, f.owner);
    const before = pool(pending, f.owner, f.territory), option = pending.decision.options[choice];
    reject(pending, f.owner, { type: 'decision', event: pending.decision.event, choice,
      destinations: { 'homeworld:emperor': { normal: advanced ? 0 : 1, elite: advanced ? 1 : 0 } } });
    const done = applyAction(JSON.parse(JSON.stringify(pending)), f.owner, { type: 'decision', event: pending.decision.event, choice });
    const completed = settle(done), after = pool(completed, f.owner, f.territory);
    assert.equal(before.normal - after.normal, pending.pendingSukRescue!.losses!.normal - option.normal);
    assert.equal(before.elite - after.elite, pending.pendingSukRescue!.losses!.elite - option.elite);
    if (advanced) assert.deepEqual(completed.homeworlds!.custody!.salusa, pending.homeworlds!.custody!.salusa,
      'Three dialed native Sardaukar saved at Salusa never leave Salusa or duplicate their reserve totals');
    custody(completed);
  });

  void test(`${advanced ? 'Advanced' : 'Basic'} visitor Homeworld and Arrakis trained Suk conserve typed casualties, board/visitor pools and native return allocations`, () => {
    for (const kind of ['visitor-suk', 'arrakis-suk'] as const) {
      const f = fixture({ kind, advanced }), revealed = reveal(f);
      let pending = settle(revealed, 'suk');
      assert.ok(pending.decision?.kind === 'sukRescue');
      const choice = rescueChoice(pending, false), option = pending.decision.options[choice];
      const destinations = splitReturn(pending, choice), original = pending.pendingSukRescue!;
      assert.equal(original.skill.mode, 'skilled');
      if (advanced) assert.equal(pending.decision.reserveHomes?.length, 2);
      if (advanced) {
        assert.equal(original.losses!.normal, 2);
        assert.equal(original.losses!.elite, 1);
      }
      legalOffers(pending, f.owner);
      const physical = quoteSukPhysicalRescue(context(pending), pending.homeworlds!.custody!, {
        player: f.owner, territory: f.territory, skill: original.skill, pool: original.pool,
        losses: original.losses!, option, destinations,
      });
      assert.equal(physical.receipt.source, kind === 'visitor-suk' ? 'visitor-homeworld' : 'arrakis');
      if (advanced) {
        const incomplete = { 'homeworld:emperor': { normal: 0, elite: 0 } };
        reject(pending, f.owner, { type: 'decision', event: pending.decision.event, choice, destinations: incomplete });
        reject(pending, f.owner, { type: 'decision', event: pending.decision.event, choice, destinations: { 'homeworld:guild': { normal: 2, elite: 0 } } });
        reject(pending, f.owner, { type: 'decision', event: pending.decision.event, choice });
      }
      const before = player(pending, f.owner);
      pending = applyAction(JSON.parse(JSON.stringify(pending)), f.owner, { type: 'decision', event: pending.decision.event, choice, ...(destinations ? { destinations } : {}) });
      const done = settle(pending), after = player(done, f.owner);
      assert.equal(after.tanks - before.tanks, original.losses!.normal + original.losses!.elite - option.normal - option.elite);
      assert.deepEqual(done.homeworlds!.custody, physical.custody);
      assert.equal(after.reserves, physical.players.find(p => p.id === f.owner)!.reserves);
      assert.equal(after.elites?.reserves, physical.players.find(p => p.id === f.owner)!.eliteReserves);
      assert.equal(done.pendingSukRescue ?? null, null);
      custody(done);
    }
  });

  void test(`${advanced ? 'Advanced' : 'Basic'} real empty-territory Smuggler shipment withdraws six physical counters priced as five and presents the actual Bureaucrat payer invoice`, () => {
    const f = fixture({ kind: 'smuggler-payment', advanced });
    const before = f.beforeShipment!, after = f.afterShipment!;
    assert.equal(player(after, f.owner).reserves, player(before, f.owner).reserves - 6);
    assert.equal(player(after, f.owner).spice, player(before, f.owner).spice - 5);
    assert.equal(Object.values(player(after, f.owner).forces).reduce((a, b) => a + b, 0), 6);
    if (advanced) assert.equal(player(after, f.owner).elites!.reserves, player(before, f.owner).elites!.reserves - 2);
    legalOffers(before, f.owner);
    const invoice = advance(after, game => game.decision?.kind === 'bureaucratPayment');
    const payment = invoice.bureaucratPayments!.pending!.source;
    assert.equal(payment.kind, 'shipment'); assert.equal(payment.payer, f.owner);
    assert.equal(payment.payee, f.opponent); assert.equal(payment.amount, 5);
    const bureaucrat = invoice.decision!.player;
    assert.notEqual(bureaucrat, payment.payer); assert.notEqual(bureaucrat, payment.payee);
    legalOffers(invoice, bureaucrat);
    const paid = applyAction(JSON.parse(JSON.stringify(invoice)), bureaucrat, { type: 'decision', event: invoice.decision!.kind === 'bureaucratPayment' ? invoice.decision!.event : '', redirect: true });
    const done = advance(paid, game => !game.response && !game.decision && !game.phaseOpening);
    assert.equal(player(done, f.opponent).spice, player(before, f.opponent).spice + 3);
    assert.equal(player(done, f.owner).spice, player(before, f.owner).spice - 5);
    assert.equal(done.bureaucratPayments!.used.length, 1);
    assert.deepEqual(player(done, f.owner).forces, player(after, f.owner).forces, 'Invoice settlement cannot replay physical arrival');
    custody(done);
  });
}