import { describe, expect, it } from "vitest";
import {
  applyCommand,
  activePlayer,
  createGame,
  redactEvent,
  BASE_MOVEMENT,
  HAND_LIMIT,
  STARTING_LIFE,
  type Command,
  type GameState,
  type PlayerId,
} from "../src/game";
import { cellKey, stepTarget, SIDES, type Side } from "../src/board";
import { isNumberCard } from "../src/cards";

function newGame(seed = 42, players = ["alice", "bob"]) {
  return createGame({ playerIds: players, seed, sets: ["basic"] });
}

function must(state: GameState, player: PlayerId, command: Command): GameState {
  const result = applyCommand(state, player, command);
  if (!result.ok) throw new Error(`command failed: ${result.error}`);
  return result.state;
}

/** Find a direction the active player can actually step. */
function openDirection(state: GameState): Side {
  const p = activePlayer(state);
  for (const side of SIDES) {
    if (stepTarget(state.board, p.position, side).kind !== "blocked") return side;
  }
  throw new Error("no open direction");
}

describe("game setup", () => {
  it("is deterministic for a given seed", () => {
    const a = newGame(7);
    const b = newGame(7);
    expect(JSON.stringify(a.state)).toEqual(JSON.stringify(b.state));
    expect(a.events).toEqual(b.events);
  });

  it("deals 7 non-TRAP cards to each player, 15 life, wizard on home star", () => {
    const { state } = newGame();
    for (const p of state.players) {
      expect(p.hand.length).toBe(HAND_LIMIT);
      expect(p.hand.some((c) => c.cardId === "trap")).toBe(false);
      expect(p.life).toBe(STARTING_LIFE);
      expect(cellKey(p.position)).toBe(cellKey(p.home));
    }
    // Two treasures per player, on the sector's treasure spaces.
    expect(state.treasures.length).toBe(4);
    // Full deck conservation: deck + discard + hands = 125.
    const total =
      state.deck.length + state.discard.length +
      state.players.reduce((sum, p) => sum + p.hand.length, 0);
    expect(total).toBe(125);
  });

  it("redacts private deal events for other players", () => {
    const { events } = newGame();
    const alicePrivate = events.find(
      (e) => e.type === "cardsDealtPrivate" && e.visibleTo === "alice",
    )!;
    expect(redactEvent(alicePrivate, "bob")).toBeNull();
    expect(redactEvent(alicePrivate, "alice")).toBe(alicePrivate);
  });
});

describe("movement", () => {
  it("allows 3 steps, then stops until a number card is played", () => {
    let { state } = newGame();
    const me = activePlayer(state).id;
    for (let i = 0; i < BASE_MOVEMENT; i++) {
      state = must(state, me, { type: "move", direction: openDirection(state) });
    }
    const refused = applyCommand(state, me, { type: "move", direction: openDirection(state) });
    expect(refused.ok).toBe(false);

    const numberCard = activePlayer(state).hand.find((c) => isNumberCard(c.cardId));
    if (numberCard) {
      state = must(state, me, { type: "playNumberForMovement", instanceId: numberCard.instanceId });
      const again = applyCommand(state, me, { type: "move", direction: openDirection(state) });
      expect(again.ok).toBe(true);
    }
  });

  it("rejects out-of-turn commands", () => {
    const { state } = newGame();
    const notMe = state.players.find((p) => p.id !== activePlayer(state).id)!.id;
    const result = applyCommand(state, notMe, { type: "move", direction: "N" });
    expect(result.ok).toBe(false);
  });
});

describe("turns and combat", () => {
  it("forbids combat in round 1, allows punching in round 2 in the same square", () => {
    let { state } = newGame();
    // Round 1: even a hypothetical punch is refused before target checks.
    const r1 = applyCommand(state, activePlayer(state).id, {
      type: "punch",
      targetId: state.players.find((p) => p.id !== activePlayer(state).id)!.id,
    });
    expect(r1.ok).toBe(false);
    expect((r1 as { error: string }).error).toMatch(/first round/);

    // March both players' turns forward into round 2.
    state = must(state, activePlayer(state).id, { type: "endTurn", draw: 0 });
    state = must(state, activePlayer(state).id, { type: "endTurn", draw: 0 });
    expect(state.turn.round).toBe(2);

    // Teleport the opponent into the active player's square (test surgery),
    // then punch: 1 damage, and a second punch the same turn is refused.
    const attacker = activePlayer(state);
    const victim = state.players.find((p) => p.id !== attacker.id)!;
    victim.position = { ...attacker.position };
    state = must(state, attacker.id, { type: "punch", targetId: victim.id });
    // Punches enter the counteraction stack (BLUNT/ABSORB work on physical
    // damage); the defender passes and the punch resolves.
    state = must(state, victim.id, { type: "pass" });
    const v = state.players.find((p) => p.id === victim.id)!;
    expect(v.life).toBe(STARTING_LIFE - 1);
    const secondPunch = applyCommand(state, attacker.id, {
      type: "punch",
      targetId: victim.id,
    });
    expect(secondPunch.ok).toBe(false);
  });

  it("cannot punch yourself", () => {
    let { state } = newGame();
    state = must(state, activePlayer(state).id, { type: "endTurn", draw: 0 });
    state = must(state, activePlayer(state).id, { type: "endTurn", draw: 0 });
    const me = activePlayer(state).id;
    const result = applyCommand(state, me, { type: "punch", targetId: me });
    expect(result.ok).toBe(false);
  });

  it("kill transfers the dead player's cards and forces a discard to 7", () => {
    let { state } = newGame();
    state = must(state, activePlayer(state).id, { type: "endTurn", draw: 0 });
    state = must(state, activePlayer(state).id, { type: "endTurn", draw: 0 });
    const attacker = activePlayer(state);
    const victim = state.players.find((p) => p.id !== attacker.id)!;
    victim.position = { ...attacker.position };
    victim.life = 1; // test surgery: one punch kills
    state = must(state, attacker.id, { type: "punch", targetId: victim.id });
    state = must(state, victim.id, { type: "pass" });

    const s = state;
    expect(s.players.find((p) => p.id === victim.id)!.alive).toBe(false);
    const a = s.players.find((p) => p.id === attacker.id)!;
    expect(a.hand.length).toBe(14);
    expect(s.pendingDiscard).toBe(attacker.id);
    // Game over check: 2 players, one dead -> last standing wins.
    expect(s.phase).toBe("finished");
    expect(s.winner).toBe(attacker.id);
  });

  it("draws up to two cards at end of turn, respecting the hand limit", () => {
    let { state } = newGame();
    const me = activePlayer(state).id;
    const deckBefore = state.deck.length;
    // Hand is full (7): drawing 2 is capped to 0.
    state = must(state, me, { type: "endTurn", draw: 2 });
    expect(state.deck.length).toBe(deckBefore);

    // Next player discards one, then ends turn drawing 2 -> capped to 1.
    const p2 = activePlayer(state);
    const discardOne = p2.hand[0]!.instanceId;
    state = must(state, p2.id, { type: "discard", instanceIds: [discardOne] });
    state = must(state, p2.id, { type: "endTurn", draw: 2 });
    const p2After = state.players.find((p) => p.id === p2.id)!;
    expect(p2After.hand.length).toBe(HAND_LIMIT);
  });
});

describe("treasures and victory", () => {
  it("stealing two enemy treasures to your home wins the game", () => {
    let { state } = newGame();
    const me = activePlayer(state);
    const enemy = state.players.find((p) => p.id !== me.id)!;
    const [t1, t2] = state.treasures.filter((t) => t.owner === enemy.id);

    // Test surgery: place the wizard on an enemy treasure, pick it up (which
    // ends the turn's actions), walk it home across turns via direct position
    // edits (movement itself is tested elsewhere).
    me.position = { ...t1!.position! };
    state = must(state, me.id, { type: "pickUpTreasure" });
    // Actions ended: further movement refused.
    expect(applyCommand(state, me.id, { type: "move", direction: "N" }).ok).toBe(false);
    state = must(state, me.id, { type: "endTurn", draw: 0 });
    state = must(state, activePlayer(state).id, { type: "endTurn", draw: 0 });

    let p = state.players.find((p) => p.id === me.id)!;
    p.position = { ...p.home };
    state = must(state, me.id, { type: "dropTreasure" });
    expect(state.phase).toBe("playing");

    p = state.players.find((p) => p.id === me.id)!;
    p.position = { ...t2!.position! };
    state = must(state, me.id, { type: "pickUpTreasure" });
    state = must(state, me.id, { type: "endTurn", draw: 0 });
    state = must(state, activePlayer(state).id, { type: "endTurn", draw: 0 });

    p = state.players.find((p) => p.id === me.id)!;
    p.position = { ...p.home };
    state = must(state, me.id, { type: "dropTreasure" });
    expect(state.phase).toBe("finished");
    expect(state.winner).toBe(me.id);
  });

  it("only one treasure may be carried at a time", () => {
    const { state } = newGame();
    const me = activePlayer(state);
    const enemy = state.players.find((p) => p.id !== me.id)!;
    const [t1, t2] = state.treasures.filter((t) => t.owner === enemy.id);
    me.position = { ...t1!.position! };
    const s1 = must(state, me.id, { type: "pickUpTreasure" });
    const p = s1.players.find((p) => p.id === me.id)!;
    p.position = { ...t2!.position! };
    p; // actions ended by pickup — but even without that, a second pickup is illegal:
    const result = applyCommand(s1, me.id, { type: "pickUpTreasure" });
    expect(result.ok).toBe(false);
  });
});