import assert from 'node:assert/strict';
import {
  applyAction, createGame, initializeSemutaGameForAudit, joinGame, newPlayer,
  type Action, type Game,
} from '../game/engine';
import { TERRITORIES } from '../game/board';
import { presenceAt } from '../game/force-presence';
import { nextSemutaGuildIncomeNativeStep } from './fixture-semuta-guild-income';
import { withClassicDiscoveryNexusLottery } from './fixture-discovery-classic-nexus';
import { moveSemutaEmperorCard } from './fixture-semuta-emperor-share';

export type SemutaBgUse = 'shipment' | 'cancel' | 'purchase' | 'auctionPayment';
export type SemutaBgStep = { actor: string; action: Action };
const player = (game: Game, actor: string) => game.players.find(p => p.id === actor)!;
const clean = (game: Game) => !game.response && !game.decision && !game.phaseOpening && !game.pendingTreacheryDiscard;

/** Original native BG/Richese/classic setup, actual paid Semuta, Karama and
 * Worthless auctions. Only original undealt lotteries/deck order are selected;
 * no played hand/army/wallet/phase/response is staged. */
export function createOriginalSemutaBg(use: SemutaBgUse = 'shipment', homeworlds = false) {
  let game = createGame('SEMUTABGCONVERSION', newPlayer('r', 'Richese', 'richese'), true, ['choam']);
  for (const [id, name, faction] of [['b', 'Bene Gesserit', 'beneGesserit'], ['a', 'Atreides', 'atreides'],
    ['e', 'Emperor', 'emperor'], ['g', 'Guild', 'guild']] as const) joinGame(game, newPlayer(id, name, faction));
  if (homeworlds) game = applyAction(game, 'r', { type: 'homeworlds', enabled: true });
  for (const p of game.players) game = applyAction(game, p.id, { type: 'ready' });
  game = withClassicDiscoveryNexusLottery(() => initializeSemutaGameForAudit(game));
  const actions: SemutaBgStep[] = [];
  const act = (actor: string, action: Action) => {
    actions.push({ actor, action }); game = applyAction(game, actor, action);
  };
  const reach = (until: (state: Game) => boolean) => {
    for (let n = 0; !until(game) && n < 1800; n++) {
      assert.notEqual(game.status, 'finished');
      const next = nextSemutaGuildIncomeNativeStep(game); act(next.actor, next.action);
    }
    assert.ok(until(game), `Original BG source stalled at ${game.turn}/${game.phase}/${game.decision?.kind}`);
  };
  reach(state => state.status === 'playing');
  const setup = structuredClone(game);
  const ki = game.deck.findIndex(card => card.effect === 'karama'); assert.ok(ki >= 0);
  const karama = game.deck.splice(ki, 1)[0];
  const wi = game.deck.findIndex(card => card.kind === 'worthless'); assert.ok(wi >= 0);
  const worthless = game.deck.splice(wi, 1)[0]; game.deck.unshift(karama, worthless);
  for (const position of [0, 1]) {
    const at = game.spiceDeck.findIndex((card, i) => i >= position && 'territory' in card);
    assert.ok(at >= position); game.spiceDeck.splice(position, 0, game.spiceDeck.splice(at, 1)[0]);
  }
  reach(state => state.decision?.kind === 'richeseCache');
  act('r', { type: 'decision', event: game.richeseBidding!.event, card: 'richese-semuta-drug',
    method: 'onceAround', direction: 'counterclockwise' });
  reach(state => !!state.richeseAuction && !state.richeseAuction.outcome &&
    state.richeseAuction.active === 'a' && clean(state));
  act('a', { type: 'richeseBid', event: game.richeseAuction!.event, amount: 1 });
  reach(state => player(state, 'a').hand.some(card => card.id === 'richese-semuta-drug') && clean(state));
  const boughtSemuta = structuredClone(game);
  reach(state => !!state.auction && state.auction.index === 0 && state.auction.active === 'e' && clean(state));
  act('e', { type: 'bid', amount: 1 });
  reach(state => player(state, 'e').hand.some(card => card.id === karama.id) && clean(state));
  const boughtKarama = structuredClone(game);
  reach(state => !!state.auction && state.auction.index === 1 && state.auction.active === 'b' && clean(state));
  act('b', { type: 'bid', amount: 1 });
  reach(state => player(state, 'b').hand.some(card => card.id === worthless.id) && clean(state));
  const boughtWorthless = structuredClone(game);
  let action: Action, lot: string | undefined, originalResponse: Game['response'] = null;
  let target: string | undefined;
  if (use === 'purchase' || use === 'auctionPayment') {
    reach(state => !!state.auction && state.auction.index === 2 && state.auction.active === 'b' && clean(state));
    lot = game.auction!.cards[game.auction!.index].id;
    if (use === 'purchase') action = { type: 'card', card: worthless.id, mode: 'purchase' };
    else {
      act('b', { type: 'bid', amount: player(game, 'b').spice + 1 });
      reach(state => state.decision?.kind === 'auctionPayment' && state.decision.player === 'b' && !state.response && !state.phaseOpening);
      action = { type: 'decision', karama: true, card: worthless.id };
    }
  } else {
    reach(state => state.phase === 5 && state.active === (use === 'cancel' ? 'g' : 'a') && clean(state));
    if (use === 'shipment') action = { type: 'card', card: worthless.id, mode: 'shipment', target: 'a' };
    else {
      const destination = TERRITORIES.find(t => t.type === 'sand' && t.sectors.some(s => s !== game.storm) &&
        game.players.every(p => presenceAt(p, t.id) === 0));
      assert.ok(destination); const sector = destination.sectors.find(s => s !== game.storm)!;
      target = `${destination.id}:${sector}`;
      act('g', { type: 'ship', territory: destination.id, sector, amount: 2, elite: 0, allyPayment: 0 });
      if (game.decision?.kind === 'guildShipment') act('g', { type: 'decision', allow: true });
      assert.equal(game.response?.kind, 'guildRate'); originalResponse = structuredClone(game.response);
      action = { type: 'card', card: worthless.id, mode: 'cancel' };
    }
  }
  const beforeCost = structuredClone(game);
  act('b', action);
  assert.equal(game.pendingTreacheryDiscard?.batch.cause, 'karama:conversion');
  assert.equal(game.pendingKarama, null);
  return { setup, boughtSemuta, boughtKarama, boughtWorthless, actions, beforeCost,
    game, action, use, homeworlds, lot, target, originalResponse,
    owner: 'b', holder: 'a', counter: 'e', beneficiary: 'a', guild: 'g',
    worthless, karama, semuta: 'richese-semuta-drug',
    provenance: [
      'Original five-faction Semuta setup and native BG choices; only original undealt entropy/deck order selected.',
      'Atreides pays1 for public Semuta; Emperor pays1 for normal Karama; BG pays1 for the actual normal Worthless.',
      'Real native phase/lot progression and optional native Guild declaration or actual BG overbid; no played state staged.',
    ] };
}

export function passSemutaBgResponse(state: Game, kind = 'worthlessKarama') {
  let game = state;
  for (let n = 0; game.response?.kind === kind && n < 30; n++) {
    const actor = game.players.find(p => !game.response!.passed.includes(p.id)); assert.ok(actor);
    game = applyAction(game, actor.id, { type: 'passResponse' });
  }
  assert.notEqual(game.response?.kind, kind);
  return game;
}

/** Only native already-earned arrival/inspection continuations, never another
 * shipment, bid, card spend or invented controller. */
export function settleSemutaBgNative(state: Game) {
  let game = state;
  for (let n = 0; n < 80; n++) {
    if (!game.response && !game.decision && !game.phaseOpening && !game.pendingTreacheryDiscard) return game;
    if (game.pendingTreacheryDiscard) throw Error('Resolve the actual fresh Semuta event first.');
    if (game.response) {
      const actor = game.players.find(p => !game.response!.passed.includes(p.id)); assert.ok(actor);
      game = applyAction(game, actor.id, { type: 'passResponse' });
    } else if (game.decision?.kind === 'advisor' || game.decision?.kind === 'intrusion')
      game = applyAction(game, game.decision.player, { type: 'decision', accept: false });
    else if (game.decision?.kind === 'guildShipment') game = applyAction(game, game.decision.player, { type: 'decision', allow: true });
    else if (game.decision?.kind === 'homeworldShipmentGuild') game = applyAction(game, game.decision.player,
      { type: 'decision', event: game.decision.event, allow: true });
    else throw Error(`Finish only the original native suffix: ${game.decision?.kind ?? 'phase opening'}`);
  }
  throw Error('Original BG native suffix did not settle.');
}

/** CONTROLLED acquisition/phase fixture for a real subsequent CHOAM rediscard,
 * not a synthetic discard or an original-action acquisition claim. Native
 * roles/setup/stocks/wallets are genuine and are never replaced after setup. */
export function createControlledBgClaimedPriceRefund() {
  let game = createGame('BGCLAIMEDCASHOUT', newPlayer('r', 'Richese', 'richese'), true, ['choam']);
  for (const [id, faction] of [['b', 'beneGesserit'], ['c', 'choam'], ['g', 'guild'], ['a', 'atreides']] as const)
    joinGame(game, newPlayer(id, faction, faction));
  for (const p of game.players) game = applyAction(game, p.id, { type: 'ready' });
  game = initializeSemutaGameForAudit(game);
  for (let n = 0; game.status === 'setup' && n < 300; n++) {
    const next = nextSemutaGuildIncomeNativeStep(game); game = applyAction(game, next.actor, next.action);
  }
  assert.equal(game.status, 'playing');
  for (const p of game.players) game.deck.push(...p.hand.splice(0));
  const worthless = game.deck.find(card => card.kind === 'worthless'); assert.ok(worthless);
  const karamas = game.deck.filter(card => card.effect === 'karama').slice(0, 2);
  assert.equal(karamas.length, 2);
  moveSemutaEmperorCard(game, worthless.id, 'b');
  moveSemutaEmperorCard(game, karamas[0].id, 'c');
  moveSemutaEmperorCard(game, karamas[1].id, 'g');
  moveSemutaEmperorCard(game, 'richese-semuta-drug', 'c');
  game.phase = 5; game.active = 'a'; game.order = ['a', 'b', 'c', 'g', 'r'];
  game.movementRemaining = ['a', 'b', 'c', 'g', 'r']; game.ready = [];
  game.response = null; game.decision = null; game.phaseOpening = null;
  return { game, worthless, cashout: karamas[0], stop: karamas[1], holder: 'c',
    owner: 'b', beneficiary: 'a', guild: 'g', semuta: 'richese-semuta-drug',
    provenance: ['CONTROLLED conserved later acquisition and phase after genuine native BG/CHOAM/Richese/classic setup.',
      'Original native armies/wallets retained; actual BG conversion, Semuta recovery, CHOAM cashout and Guild stop thereafter.'] };
}