import test from 'node:test';
import assert from 'node:assert/strict';
import { applyAction, viewGame, type Action, type Game, type GameView } from '../game/engine';
import { homeworldContext, homeworldGameIntegrity } from '../game/homeworld-game';
import { homeworldForceGroups } from '../game/homeworld-custody';
import { quoteHomeworldShipment } from '../game/homeworld-shipment';
import { homeworldShipmentChoice } from '../game/homeworld-shipment-options';
import { guildHomeworldShipmentChoice } from '../game/guild-homeworld-shipment-options';
import { junctionTransportChoice } from '../game/junction-transport-options';
import {
  createNativeGuildHomeworldRate, createNativeGuildHomeworldRateScene,
  createNativeImmuneJunctionRate, nativeGuildHomeworldAction,
  passNativeGuildHomeworldResponses, type NativeGuildHomeworldRateFixture,
  createControlledGuildCunningHomeworldRateScene,
} from './fixture-native-guild-homeworld-rate';
import { pairedE3NexusPlayer as player, stepPairedE3Nexus } from './fixture-paired-e3-nexus-modules';

const act = (g: Game, actor: string, action: Action) => applyAction(structuredClone(g), actor, action);
function context(g: Game, nativeGuildRateCanceled?: boolean) {
  return { ...homeworldContext(g), nativeGuildRateCanceled,
    players: homeworldContext(g).players.map(p => ({ ...p, ally: player(g, p.id).ally })),
    storm: g.storm, mobileStronghold: g.mobileStronghold?.location ?? null,
    discoveries: g.discoveries,
    board: Object.fromEntries(g.players.map(p => [p.id, { forces: p.forces, eliteForces: p.elites?.forces ?? {} }])),
  };
}
function assertUnpaid(f: NativeGuildHomeworldRateFixture, state: Game) {
  const before = f.beforeAction;
  assert.deepEqual(state.homeworlds, before.homeworlds);
  assert.deepEqual(state.aid, before.aid);
  for (const id of [f.guild, f.entrant]) {
    assert.equal(player(state, id).spice, player(before, id).spice);
    assert.equal(player(state, id).reserves, player(before, id).reserves);
    assert.deepEqual(player(state, id).forces, player(before, id).forces);
    assert.equal(player(state, id).shipped, player(before, id).shipped);
  }
  assert.ok(!state.pendingArrivalReaction);
  assert.ok(!state.pendingAmbassador);
}
function assertPaid(f: NativeGuildHomeworldRateFixture, paid: Game, amount: number, cost: number) {
  const before = f.beforeAction;
  const old = player(before, f.guild), guild = player(paid, f.guild);
  // A Guild shipper pays its own share to the bank. The approved Moritani
  // share independently earns the Guild its existing FAQ contributor income.
  const settled = passNativeGuildHomeworldResponses(paid, 'guildIncome').game;
  assert.equal(player(settled, f.guild).spice, old.spice - cost + 2);
  // Pledging already debited the donor wallet before this declaration.
  assert.equal(player(settled, f.entrant).spice, player(before, f.entrant).spice);
  assert.equal(settled.aid[f.entrant].amount, 0);
  assert.equal(guild.shipped, true);
  assert.equal(guild.reserves, old.reserves + (f.route === 'return' ? amount : f.route === 'world' ? -amount : 0));
  if (f.route !== 'world')
    assert.equal(guild.forces[f.source] ?? 0, old.forces[f.source] - amount);
  else assert.deepEqual(guild.forces, old.forces);
  if (f.route !== 'return') {
    assert.deepEqual(settled.homeworlds!.custody!.visitors[f.destination][f.guild], { normal: amount, elite: 0 });
  } else assert.equal(settled.homeworlds!.custody!.visitors[f.destination]?.[f.guild], undefined);
  assert.ok(!settled.pendingHomeworldShipment);
  assert.ok(!settled.pendingArrivalReaction);
  assert.ok(!settled.pendingAmbassador);
  homeworldGameIntegrity(settled);
  const worlds = homeworldForceGroups(context(settled), settled.homeworlds!.custody!);
  const physical = Object.values(player(settled, f.guild).forces).reduce((n, count) => n + count, 0) +
    worlds.reduce((n, w) => n + (w.forces[f.guild]?.normal ?? 0) + (w.forces[f.guild]?.elite ?? 0), 0);
  assert.equal(physical, 20);
  return settled;
}

for (const route of ['world', 'arrakisForeign', 'return'] as const) {

  void test(`original native Homeworld ${route}: actual auctioned Ecaz Karama precedes every debit and physical transfer`, () => {
    const scene = createNativeGuildHomeworldRateScene(route);
    assertUnpaid(scene, scene.game);
    assert.equal(scene.game.pendingHomeworldShipment?.cost, 2);
    assert.equal(scene.game.pendingHomeworldShipment?.allyPayment, 1);
    assert.deepEqual(scene.game.pendingHomeworldShipment?.sources, scene.sources);
    const stored = structuredClone(scene.game);
    assert.throws(() => act(stored, scene.entrant, scene.cancel.action));
    assert.deepEqual(stored, scene.game);
    const canceled = stepPairedE3Nexus(scene.game, scene.cancel);
    const settled = assertPaid(scene, canceled, 3, 3);
    assert.equal(settled.discard.filter(c => c.id === scene.karama).length, 1);
    assert.throws(() => act(settled, scene.guild, scene.action));
    const next = act(settled, scene.guild, { type: 'endMovement' });
    assert.notEqual(next.active, scene.guild);
    assert.deepEqual(player(next, scene.guild).forces, player(settled, scene.guild).forces);
  });

  void test(`original native Homeworld ${route}: passing preserves the rounded half tariff and original approved split`, () => {
    const scene = createNativeGuildHomeworldRateScene(route);
    assertUnpaid(scene, scene.game);
    const allowed = passNativeGuildHomeworldResponses(scene.game, 'guildRate').game;
    const settled = assertPaid(scene, allowed, 3, 2);
    assert.ok(player(settled, scene.ecaz).hand.some(c => c.id === scene.karama));
  });

  void test(`original native Homeworld ${route}: unaffordable cancellation releases unchanged typed custody and supports a full-price replacement`, () => {
    const scene = createNativeGuildHomeworldRateScene(route, { unaffordable: true });
    assert.equal(player(scene.beforeAction, scene.guild).spice, 1);
    assertUnpaid(scene, scene.game);
    const released = stepPairedE3Nexus(scene.game, scene.cancel);
    assertUnpaid(scene, released);
    assert.ok(!released.pendingHomeworldShipment);
    assert.equal(released.response, null);
    assert.equal(released.decision, null);
    assert.equal(viewGame(released, scene.guild).guildRateCanceled, true);
    assert.equal(viewGame(released, scene.ecaz).guildRateCanceled, false);
    const view = viewGame(released, scene.guild);
    const consumer = route === 'world' ? homeworldShipmentChoice : guildHomeworldShipmentChoice;
    const unchanged = consumer(view, scene.destination, scene.sources, 1);
    assert.equal(unchanged.cost, 3);
    assert.equal(unchanged.ownPayment, 2);
    assert.ok(unchanged.blocked);
    const action = nativeGuildHomeworldAction(scene, released, 2, 1);
    assert.deepEqual(action.sources, { [scene.source]: { normal: 2, elite: 0 } });
    let replacement = act(released, scene.guild, action);
    if (replacement.decision?.kind === 'homeworldShipmentGuild')
      replacement = act(replacement, scene.guild, { type: 'decision', event: replacement.decision.event, allow: true });
    assert.notEqual(replacement.response?.kind, 'guildRate');
    const settled = assertPaid(scene, replacement, 2, 2);
    assert.equal(settled.discard.filter(c => c.id === scene.karama).length, 1);
  });
}

void test('non-Guild world-to-world remains full price; controlled Secret Ally owner quote stays independent of native cancellation', () => {
  const f = createNativeGuildHomeworldRate('world'), g = f.beforeAction;
  const intent = { player: f.ecaz, destination: 'homeworld:moritani',
    sources: { 'homeworld:ecaz': { normal: 3, elite: 0 } } };
  assert.equal(quoteHomeworldShipment(context(g, true), g.homeworlds!.custody!, intent).cost, 3);
  // Narrow controlled presentation fixture, not an original action producer:
  // Secret Ally legally requires Guild absent, no alliance, and an owned card.
  const original = viewGame(g, f.ecaz);
  const event = JSON.stringify(['nexusGuildSecretAlly', original.turn, f.ecaz]);
  const view = { ...original, active: f.ecaz, guildRateCanceled: true,
    players: original.players.filter(p => p.id !== f.guild).map(p => ({ ...p, ally: null, shipped: false })),
    homeworlds: { ...original.homeworlds!, worlds: original.homeworlds!.worlds!.filter(w => w.native !== f.guild) },
    homeworldShipment: { event: 'controlled-secret-world-quote', blocked: null },
    nexusCards: { ...original.nexusCards!, card: 'guild', waiting: [] },
    nexusGuildSecretAlly: { event, blocked: null },
  } as GameView;
  const ordinary = homeworldShipmentChoice(view, intent.destination, intent.sources);
  const secret = homeworldShipmentChoice(view, intent.destination, intent.sources, 0, event);
  assert.equal(ordinary.cost, 3);
  assert.equal(secret.cost, 2);
  assert.equal(secret.blocked, null);
});

for (const rate of ['half', 'full'] as const) {
  void test(`original immune Junction ${rate} offer after actual native cancellation keeps its printed tariff and no second rate queue`, () => {
    const f = createNativeImmuneJunctionRate(rate), before = f.beforeAction;
    const cost = rate === 'half' ? 2 : 3;
    assert.equal(viewGame(before, f.entrant).guildRateCanceled, true);
    const view = viewGame(before, f.entrant);
    assert.equal(junctionTransportChoice(view, f.destination, f.sources).cost, cost);
    const done = act(before, f.entrant, f.action);
    assert.notEqual(done.response?.kind, 'guildRate');
    assert.equal(done.decision, null);
    assert.ok(!done.pendingHomeworldShipment);
    assert.equal(player(done, f.entrant).spice, player(before, f.entrant).spice - cost);
    assert.equal(player(done, f.guild).spice, player(before, f.guild).spice);
    assert.equal(player(done, f.entrant).reserves, player(before, f.entrant).reserves + 3);
    assert.equal(player(done, f.entrant).forces[f.source], player(before, f.entrant).forces[f.source] - 3);
    assert.equal(player(done, f.entrant).shipped, true);
    assert.equal(done.discard.filter(c => c.id === f.karama).length, 1);
    homeworldGameIntegrity(done);
  });
}

for (const outcome of ['allow', 'cancel', 'unaffordable'] as const) {
  void test(`controlled Cunning Homeworld ${outcome}: the native rate retains one original second-shipment allowance`, () => {
    const f = createControlledGuildCunningHomeworldRateScene(outcome === 'unaffordable');
    const before = f.beforeAction, record = before.nexusGuildCunningHistory!.at(-1)!;
    assert.equal(record.stage, 'secondShipment');
    assert.equal(record.shipment, undefined);
    assert.deepEqual(f.game.homeworlds, before.homeworlds);
    assert.equal(player(f.game, f.owner).spice, player(before, f.owner).spice);
    assert.equal(player(f.game, f.owner).reserves, player(before, f.owner).reserves);
    assert.equal(f.game.nexusGuildCunningHistory!.at(-1)!.shipment?.stage, 'pending');
    assert.equal(f.game.pendingHomeworldShipment?.guildNexusEvent, record.receipt.event);
    let done = outcome === 'allow'
      ? passNativeGuildHomeworldResponses(f.game, 'guildRate').game
      : stepPairedE3Nexus(f.game, f.cancel);
    if (outcome === 'unaffordable') {
      assert.equal(player(done, f.owner).spice, 2);
      assert.deepEqual(done.homeworlds, before.homeworlds);
      assert.equal(player(done, f.owner).reserves, player(before, f.owner).reserves);
      assert.equal(done.nexusGuildCunningHistory!.at(-1)!.stage, 'secondShipment');
      assert.equal(done.nexusGuildCunningHistory!.at(-1)!.shipment, undefined);
      assert.ok(!done.pendingHomeworldShipment);
      const choice = homeworldShipmentChoice(viewGame(done, f.owner), f.destination,
        { 'homeworld:guild': { normal: 2, elite: 0 } }, 0);
      assert.equal(choice.cost, 2);
      assert.ok(choice.action);
      done = act(done, f.owner, choice.action);
      assert.notEqual(done.response?.kind, 'guildRate');
    }
    const amount = outcome === 'unaffordable' ? 2 : 3;
    const cost = outcome === 'cancel' ? 3 : 2;
    assert.equal(player(done, f.owner).spice, player(before, f.owner).spice - cost);
    assert.equal(player(done, f.owner).reserves, player(before, f.owner).reserves - amount);
    assert.deepEqual(done.homeworlds!.custody!.visitors[f.destination][f.owner], { normal: amount, elite: 0 });
    assert.equal(done.nexusGuildCunningHistory!.at(-1)!.shipment?.stage, 'complete');
    assert.equal(done.nexusGuildCunningHistory!.at(-1)!.receipt.event, record.receipt.event);
    assert.equal(done.nexusCards!.cards!.discard.filter(card => card === 'guild').length, 1);
    assert.equal(done.discard.filter(card => card.id === f.karama).length, outcome === 'allow' ? 0 : 1);
    const another = homeworldShipmentChoice(viewGame(done, f.owner), f.destination,
      { 'homeworld:guild': { normal: 1, elite: 0 } }, 0);
    assert.equal(another.action, null);
    assert.ok(another.blocked);
    homeworldGameIntegrity(done);
  });
}