import { beforeAll, describe, expect, it } from "vitest";
import { existsSync, readFileSync } from "node:fs";
import { CrystalAssets } from "../src/game/rom/assets";
import { TrainerData } from "../src/game/rom/trainers";
import { Battle, type BattleOptions } from "../src/game/battle/battle";
import { C } from "../src/game/battle/constants";
import { generatePartyMon, type PartyMon } from "../src/game/party/pokemon";
import { battleOptions, battleSteps, playBattle } from "./battle-driver";

const romPath =
  process.env.CRYSTAL_ROM_PATH ??
  "Pokemon - Crystal Version (UE) (V1.1) [C][!].gbc";

// constants/move_constants.asm
const DOUBLESLAP = 3,
  PAY_DAY = 6,
  STOMP = 23,
  DOUBLE_KICK = 24,
  JUMP_KICK = 26,
  FURY_ATTACK = 31,
  HORN_DRILL = 32,
  TACKLE = 33,
  TWINEEDLE = 41,
  SONICBOOM = 49,
  EMBER = 52,
  COUNTER = 68,
  SEISMIC_TOSS = 69,
  DRAGON_RAGE = 82,
  CONFUSION = 93,
  HYPNOSIS = 95,
  NIGHT_SHADE = 101,
  MINIMIZE = 107,
  SELFDESTRUCT = 120,
  DREAM_EATER = 138,
  PSYWAVE = 149,
  SPLASH = 150,
  TRI_ATTACK = 161,
  SUPER_FANG = 162,
  TRIPLE_KICK = 167,
  THIEF = 168,
  FLAME_WHEEL = 172,
  FLAIL = 175,
  FALSE_SWIPE = 206,
  SWAGGER = 207,
  RETURN = 216,
  PRESENT = 217,
  FRUSTRATION = 218,
  MAGNITUDE = 222,
  HIDDEN_POWER = 237,
  MIRROR_COAT = 243,
  BEAT_UP = 251,
  ICE_BEAM = 58,
  RAZOR_WIND = 13,
  GUST = 16,
  FLY = 19,
  WRAP = 35,
  THRASH = 37,
  HYPER_BEAM = 63,
  SOLARBEAM = 76,
  EARTHQUAKE = 89,
  DIG = 91,
  DEFENSE_CURL = 111,
  BIDE = 117,
  SKULL_BASH = 130,
  MIND_READER = 170,
  ROLLOUT = 205,
  FURY_CUTTER = 210,
  PURSUIT = 228,
  SWORDS_DANCE = 0x0e,
  GROWL = 0x2d,
  DISABLE = 0x32,
  MIST = 0x36,
  LEECH_SEED = 0x49,
  POISONPOWDER = 0x4d,
  TOXIC = 0x5c,
  RECOVER = 0x69,
  HAZE = 0x72,
  FOCUS_ENERGY = 0x74,
  REST = 0x9c,
  NIGHTMARE = 0xab,
  CURSE = 0xae,
  SPITE = 0xb4,
  PROTECT = 0xb6,
  BELLY_DRUM = 0xbb,
  SPIKES = 0xbf,
  DESTINY_BOND = 0xc2,
  PERISH_SONG = 0xc3,
  ENDURE = 0xcb,
  MEAN_LOOK = 0xd4,
  ATTRACT = 0xd5,
  HEAL_BELL = 0xd7,
  SAFEGUARD = 0xdb,
  PAIN_SPLIT = 0xdc,
  ENCORE = 0xe3,
  RAPID_SPIN = 0xe5,
  PSYCH_UP = 0xf4,
  ANCIENTPOWER = 0xf6,
  FUTURE_SIGHT = 0xf8,
  RAIN_DANCE = 0xf0,
  SUNNY_DAY = 0xf1,
  SANDSTORM = 0xc9,
  SUBSTITUTE = 0xa4,
  TRANSFORM = 0x90,
  MIMIC = 0x66,
  METRONOME = 0x76,
  MIRROR_MOVE = 0x77,
  SLEEP_TALK = 0xd6,
  SNORE = 0xad,
  CONVERSION = 0xa0,
  CONVERSION2 = 0xb0,
  SKETCH = 0xa6,
  BATON_PASS = 0xe2,
  ROAR = 0x2e,
  TELEPORT = 0x64,
  WATER_GUN = 0x37,
  SYNTHESIS = 0xeb;
// Species and items
const PIDGEY = 16,
  RATTATA = 19,
  GEODUDE = 74,
  GASTLY = 92,
  SNORLAX = 143,
  JOLTEON = 135,
  ABRA = 63,
  MEOWTH = 52,
  HITMONLEE = 106,
  LAPRAS = 131,
  CYNDAQUIL = 155,
  TOTODILE = 158,
  PIDGEOT = 18,
  ARBOK = 24,
  SANDSLASH = 28,
  DIGLETT = 50,
  ONIX = 95,
  SCYTHER = 123,
  TAUROS = 128,
  HOUNDOUR = 228,
  BULBASAUR = 1,
  GENGAR = 0x5e,
  NIDORAN_F = 0x1d,
  NIDORAN_M = 0x20,
  STARMIE = 0x79,
  FORRETRESS = 0xcd,
  DITTO = 0x84,
  SMEARGLE = 0xeb,
  PORYGON = 0x89;
const AMULET_COIN = 0x5b,
  LEFTOVERS = 0x92,
  FOCUS_BAND = 0x77,
  FLOWER_MAIL = 0x9e;
const FRZ = 1 << C.FRZ,
  PSN = 1 << C.PSN;

describe.skipIf(!existsSync(romPath))("move effects with the local ROM", () => {
  let assets: CrystalAssets, trainers: TrainerData;
  beforeAll(() => {
    assets = new CrystalAssets(new Uint8Array(readFileSync(romPath)));
    trainers = new TrainerData(assets.reader);
  });
  const mon = (
    species: number,
    level: number,
    moves: number[],
    extra: Partial<PartyMon> = {},
  ): PartyMon => {
    const result = generatePartyMon(assets.pokemon, {
      species,
      level,
      item: 0,
      otId: 1234,
      ot: "CHRIS",
      dvs: 0x823b,
      caughtData: 0,
    });
    result.moves = [0, 1, 2, 3].map((i) => moves[i] ?? 0) as PartyMon["moves"];
    result.pp = result.moves.map((move) =>
      move ? assets.pokemon.move(move).pp : 0,
    ) as PartyMon["pp"];
    return Object.assign(result, extra);
  };
  /** A battle against a trainer with this party and no AI layers, so a
   * Pokémon with one move always uses it. */
  const duel = (
    party: PartyMon[],
    enemy: PartyMon[] | { wild: { species: number; level: number } },
    { seed = 1, ...options }: { seed?: number } & Partial<BattleOptions> = {},
  ) => {
    const base = battleOptions(
      assets,
      trainers,
      party,
      { wild: { species: PIDGEY, level: 2 } },
      { seed },
    );
    return new Battle({
      ...base,
      ...(Array.isArray(enemy)
        ? {
            wild: undefined,
            trainer: {
              name: "JOEY",
              className: "YOUNGSTER",
              party: enemy,
              aiFlags: 0,
              switchFlags: 0,
              reward: 40,
            },
          }
        : enemy),
      ...options,
    });
  };
  /** Play the first turn: the texts from FIGHT with the first move until
   * the next battle menu or the end. */
  const firstTurn = (battle: Battle) => {
    const steps = battleSteps(battle);
    const before = steps.texts.length;
    steps.answer({ action: "fight", move: 0 });
    return { steps, texts: steps.texts.slice(before) };
  };
  /** Play turns with FIGHT and these move slots; a locked-in Pokémon
   * plays on without a menu. Returns the texts after the first menu. */
  const turns = (battle: Battle, moves: number[]) => {
    const steps = battleSteps(battle);
    const before = steps.texts.length;
    for (const move of moves) {
      if (steps.done) break;
      expect(steps.prompt?.kind).toBe("action");
      steps.answer({ action: "fight", move });
    }
    return { steps, texts: steps.texts.slice(before) };
  };
  /** The first seed whose first turn passes `test`. */
  const findSeed = (
    make: (seed: number) => Battle,
    test: (texts: string[], battle: Battle) => boolean,
  ) => {
    for (let seed = 1; seed < 500; seed++) {
      const battle = make(seed);
      const { texts, steps } = firstTurn(battle);
      if (test(texts, battle)) return { seed, battle, texts, steps };
    }
    throw new Error("No seed found.");
  };

  describe("multi-hit moves", () => {
    it("hits two to five times and says how often", () => {
      const counts = new Set<number>();
      for (let seed = 1; seed < 60; seed++) {
        const battle = duel([mon(CYNDAQUIL, 30, [FURY_ATTACK])], [mon(SNORLAX, 50, [SPLASH])], { seed });
        const { texts } = firstTurn(battle);
        const missed = texts.some((text) => text.includes("attack missed"));
        const hit = texts.map((text) => /^Hit (\d) times!$/.exec(text)).find(Boolean);
        if (missed) {
          expect(hit).toBeUndefined();
          continue;
        }
        const n = Number(hit![1]);
        counts.add(n);
        expect(n).toBeGreaterThanOrEqual(2);
        expect(n).toBeLessThanOrEqual(5);
        // The loop counter and the hit count are spent; the high byte of
        // the user's damage taken is cleared again.
        expect(battle.player.rolloutCount).toBe(0);
        expect(battle.player.damageTaken >> 8).toBe(0);
        expect(battle.player.has(3, C.SUBSTATUS_IN_LOOP)).toBe(false);
      }
      expect([...counts].sort()).toEqual([2, 3, 4, 5]);
    });

    it("hits twice with Double Kick and Twineedle, and only says effectiveness once", () => {
      for (const move of [DOUBLE_KICK, TWINEEDLE]) {
        const { texts } = findSeed(
          (seed) => duel([mon(HITMONLEE, 30, [move])], [mon(GEODUDE, 50, [SPLASH])], { seed }),
          (texts) => texts.includes("Hit 2 times!"),
        );
        const effectiveness = texts.filter((text) => /effective/.test(text));
        // Double Kick is super effective against Geodude; Twineedle is
        // neutral. Either way the loop's later hits say nothing.
        expect(effectiveness).toHaveLength(move === DOUBLE_KICK ? 1 : 0);
      }
    });

    it("stops without the hit count when the target faints mid-loop", () => {
      const enemy = mon(RATTATA, 2, [SPLASH]);
      enemy.hp = 1;
      const battle = duel([mon(CYNDAQUIL, 30, [DOUBLESLAP])], [enemy]);
      const { texts } = playBattle(battle);
      expect(texts.join(" ")).toContain("fainted");
      expect(texts.some((text) => text.startsWith("Hit "))).toBe(false);
      expect(battle.player.has(3, C.SUBSTATUS_IN_LOOP)).toBe(false);
    });

    it("kicks up to three times with growing damage", () => {
      const counts = new Set<number>();
      for (let seed = 1; seed < 40; seed++) {
        const battle = duel([mon(HITMONLEE, 30, [TRIPLE_KICK])], [mon(SNORLAX, 60, [SPLASH])], { seed });
        const { texts } = firstTurn(battle);
        const hit = texts.map((text) => /^Hit (\d) times!$/.exec(text)).find(Boolean);
        if (hit) counts.add(Number(hit[1]));
      }
      expect([...counts].sort()).toEqual([1, 2, 3]);
    });

    it("beats up with each healthy member, by nickname, skipping fainted and statused ones", () => {
      const party = [
        mon(CYNDAQUIL, 30, [BEAT_UP], { nickname: "ALPHA" }),
        mon(TOTODILE, 20, [TACKLE], { nickname: "BRAVO", hp: 0 }),
        mon(PIDGEY, 20, [TACKLE], { nickname: "CHARLIE", status: PSN }),
        mon(RATTATA, 20, [TACKLE], { nickname: "DELTA" }),
      ];
      const { texts } = firstTurn(duel(party, [mon(SNORLAX, 60, [SPLASH])]));
      const attacks = texts.filter((text) => text.endsWith("'s attack!"));
      expect(attacks).toEqual(["ALPHA's attack!", "DELTA's attack!"]);
      expect(texts.some((text) => text.startsWith("Hit "))).toBe(false);
    });

    it("lets a lone Pokémon beat up once, then ends the move", () => {
      const { texts } = firstTurn(duel([mon(CYNDAQUIL, 30, [BEAT_UP], { nickname: "ALPHA" })], [mon(SNORLAX, 60, [SPLASH])]));
      expect(texts.filter((text) => text.endsWith("'s attack!"))).toEqual(["ALPHA's attack!"]);
      expect(texts).not.toContain("But it failed!");
    });

    it("names a trainer's members by species", () => {
      const enemy = [mon(SNORLAX, 60, [BEAT_UP]), mon(GEODUDE, 20, [SPLASH])];
      const { texts } = firstTurn(duel([mon(PIDGEY, 60, [SPLASH])], enemy));
      expect(texts.filter((text) => text.endsWith("'s attack!"))).toEqual(["SNORLAX's attack!", "GEODUDE's attack!"]);
    });
  });

  describe("fixed and special damage", () => {
    const damageTo = (move: number, enemy: PartyMon, level = 30) => {
      const battle = duel([mon(ABRA, level, [move])], [enemy]);
      const before = enemy.hp;
      const { texts } = firstTurn(battle);
      return { damage: before - battle.enemy.mon.hp, texts, battle };
    };
    it("deals the level, 20 or 40 HP, or half the target's HP", () => {
      expect(damageTo(SEISMIC_TOSS, mon(SNORLAX, 50, [SPLASH]), 37).damage).toBe(37);
      expect(damageTo(NIGHT_SHADE, mon(GEODUDE, 50, [SPLASH]), 41).damage).toBe(41);
      expect(damageTo(SONICBOOM, mon(SNORLAX, 50, [SPLASH])).damage).toBe(20);
      expect(damageTo(DRAGON_RAGE, mon(SNORLAX, 50, [SPLASH])).damage).toBe(40);
      const snorlax = mon(SNORLAX, 50, [SPLASH]);
      const half = snorlax.hp >> 1;
      expect(damageTo(SUPER_FANG, snorlax).damage).toBe(half);
    });
    it("misses an immune type", () => {
      const normal = damageTo(NIGHT_SHADE, mon(SNORLAX, 50, [SPLASH]));
      expect(normal.damage).toBe(0);
      expect(normal.texts.join(" ")).toContain("doesn't affect");
      const ghost = damageTo(SEISMIC_TOSS, mon(GASTLY, 50, [SPLASH]));
      expect(ghost.damage).toBe(0);
      expect(ghost.texts.join(" ")).toContain("doesn't affect");
    });
    it("rolls Psywave below one and a half times the level", () => {
      for (let seed = 1; seed < 20; seed++) {
        const enemy = mon(SNORLAX, 50, [SPLASH]);
        const battle = duel([mon(ABRA, 40, [PSYWAVE])], [enemy], { seed });
        firstTurn(battle);
        const damage = enemy.hp - battle.enemy.mon.hp;
        if (!damage) continue;
        expect(damage).toBeGreaterThan(0);
        expect(damage).toBeLessThan(60);
      }
    });
    it("hits harder with Flail at low HP and resets its power", () => {
      const full = damageTo(FLAIL, mon(SNORLAX, 50, [SPLASH]));
      const low = (() => {
        const user = mon(ABRA, 30, [FLAIL]);
        user.hp = 1;
        const enemy = mon(SNORLAX, 50, [SPLASH]);
        const battle = duel([user], [enemy]);
        firstTurn(battle);
        return { damage: enemy.hp - battle.enemy.mon.hp, battle };
      })();
      expect(low.damage).toBeGreaterThan(full.damage * 4);
      expect(low.battle.player.move.power).toBe(1);
    });
    it("knocks out in one hit or is unaffected against a higher level", () => {
      const { texts, battle } = findSeed(
        (seed) => duel([mon(SNORLAX, 60, [HORN_DRILL])], [mon(LAPRAS, 20, [SPLASH])], { seed }),
        (texts) => texts.includes("It's a one-hit KO!"),
      );
      expect(battle.enemy.mon.hp).toBe(0);
      expect(texts).toContain("It's a one-hit KO!");
      const higher = firstTurn(duel([mon(SNORLAX, 20, [HORN_DRILL])], [mon(LAPRAS, 60, [SPLASH])]));
      expect(higher.texts.join(" ")).toContain("unaffected");
    });
    it("leaves 1 HP with False Swipe", () => {
      const enemy = mon(RATTATA, 3, [SPLASH]);
      const battle = duel([mon(SNORLAX, 60, [FALSE_SWIPE])], [enemy]);
      firstTurn(battle);
      expect(battle.enemy.mon.hp).toBe(1);
    });
    it("crashes on a missed Jump Kick for an eighth of the damage", () => {
      const { texts, battle } = findSeed(
        (seed) => duel([mon(HITMONLEE, 30, [JUMP_KICK])], [mon(SNORLAX, 50, [SPLASH])], { seed }),
        (texts) => texts.some((text) => text.includes("crashed")),
      );
      expect(battle.player.mon.hp).toBeLessThan(battle.player.mon.maxHp);
      expect(texts.join(" ")).toContain("missed");
    });
    it("doubles Stomp's damage against a minimized target", () => {
      const battle = duel([mon(SNORLAX, 40, [STOMP])], [mon(GASTLY, 50, [MINIMIZE])]);
      firstTurn(battle);
      expect(battle.enemy.minimized).toBe(1);
    });
    it("sets Hidden Power's type and power from the DVs", () => {
      // DVs $823b: Poison, 55 power.
      const battle = duel([mon(ABRA, 30, [HIDDEN_POWER])], [mon(GEODUDE, 50, [SPLASH])]);
      const { texts } = firstTurn(battle);
      expect(battle.player.move.type).toBe(C.POISON);
      expect(texts.join(" ")).toContain("not very effective");
    });
    it("deals no damage with Return at very low happiness or Frustration at very high", () => {
      for (const [move, happiness] of [[RETURN, 2], [FRUSTRATION, 255]]) {
        const enemy = mon(SNORLAX, 50, [SPLASH]);
        const battle = duel([mon(ABRA, 30, [move], { happiness })], [enemy]);
        firstTurn(battle);
        expect(battle.enemy.mon.hp).toBe(enemy.hp);
      }
      const enemy = mon(SNORLAX, 50, [SPLASH]);
      const battle = duel([mon(ABRA, 30, [RETURN], { happiness: 255 })], [enemy]);
      firstTurn(battle);
      expect(battle.enemy.mon.hp).toBeLessThan(enemy.hp);
    });
    it("announces Magnitude 4 to 10", () => {
      const seen = new Set<string>();
      for (let seed = 1; seed < 60; seed++) {
        const { texts } = firstTurn(duel([mon(GEODUDE, 30, [MAGNITUDE])], [mon(SNORLAX, 50, [SPLASH])], { seed }));
        const text = texts.find((t) => t.startsWith("Magnitude "));
        if (text) seen.add(text);
      }
      expect([...seen].sort()).toEqual(
        ["Magnitude 10!", "Magnitude 4!", "Magnitude 5!", "Magnitude 6!", "Magnitude 7!", "Magnitude 8!", "Magnitude 9!"],
      );
    });
    it("heals the target with a Present, which a full target refuses only with animations off", () => {
      const healed = findSeed(
        (seed) => {
          const enemy = mon(SNORLAX, 50, [SPLASH]);
          enemy.hp = 20;
          return duel([mon(ABRA, 30, [PRESENT])], [enemy], { seed });
        },
        (texts) => texts.some((text) => text.includes("regained health")),
      );
      const quarter = healed.battle.enemy.mon.maxHp >> 2;
      expect(healed.battle.enemy.mon.hp).toBe(20 + quarter);
      expect(healed.texts.join(" ")).toContain("SNORLAX regained health");
      const refused = (battleScene: boolean) =>
        firstTurn(duel([mon(ABRA, 30, [PRESENT])], [mon(SNORLAX, 50, [SPLASH])], { seed: healed.seed, battleScene })).texts;
      expect(refused(false).join(" ")).toContain("refused the gift");
      expect(refused(true).join(" ")).not.toContain("refused the gift");
    });
  });


  describe("multi-turn moves", () => {
    it("charges Solarbeam on the first turn and fires it on the second, without a menu", () => {
      const enemy = mon(SNORLAX, 50, [SPLASH]);
      const battle = duel([mon(ABRA, 40, [SOLARBEAM])], [enemy]);
      const { texts, steps } = turns(battle, [0]);
      expect(texts[0]).toBe("ABRA took in sunlight!");
      expect(texts).toContain("ABRA used SOLARBEAM!");
      expect(texts.filter((text) => text === "Enemy SNORLAX used SPLASH!")).toHaveLength(2);
      expect(battle.enemy.mon.hp).toBeLessThan(enemy.hp);
      expect(steps.prompt?.kind).toBe("action");
      expect(battle.player.mon.pp[0]).toBe(assets.pokemon.move(SOLARBEAM).pp - 1);
    });
    it("lowers Skull Bash's head with a Defense raise, then attacks", () => {
      const { texts, battle } = (() => {
        const battle = duel([mon(ONIX, 40, [SKULL_BASH])], [mon(SNORLAX, 50, [SPLASH])]);
        return { ...turns(battle, [0]), battle };
      })();
      expect(texts.slice(0, 2)).toEqual(["ONIX lowered its head!", "ONIX's DEFENSE went up!"]);
      expect(texts).toContain("ONIX used SKULL BASH!");
      expect(battle.player.levels[C.DEFENSE]).toBe(8);
    });
    it("flies out of reach of most moves, but not Gust", () => {
      const tackled = turns(duel([mon(PIDGEOT, 50, [FLY])], [mon(SNORLAX, 40, [TACKLE])]), [0]);
      expect(tackled.texts[0]).toBe("PIDGEOT flew up high!");
      expect(tackled.texts[1]).toBe("Enemy SNORLAX used TACKLE!");
      expect(tackled.texts[2]).toContain("attack missed");
      expect(tackled.texts).toContain("PIDGEOT used FLY!");
      const player = mon(PIDGEOT, 50, [FLY]);
      const gusted = duel([player], [mon(PIDGEOT, 30, [GUST])]);
      turns(gusted, [0]);
      expect(gusted.player.mon.hp).toBeLessThan(player.stats[0]);
    });
    it("digs out of reach, where Earthquake hits twice as hard", () => {
      const quake = (dig: boolean) => {
        const player = mon(SANDSLASH, 60, [dig ? DIG : SPLASH]);
        const battle = duel([player], [mon(GEODUDE, 20, [EARTHQUAKE])]);
        firstTurn(battle);
        return player.stats[0] - battle.player.mon.hp;
      };
      const dug = quake(true),
        plain = quake(false);
      expect(dug).toBeGreaterThan(plain * 1.5);
    });
    it("recharges after Hyper Beam", () => {
      const { texts, steps } = turns(duel([mon(TAUROS, 50, [HYPER_BEAM])], [mon(SNORLAX, 60, [SPLASH])]), [0]);
      expect(texts).toContain("TAUROS used HYPER BEAM!");
      expect(texts).toContain("TAUROS must recharge!");
      expect(steps.prompt?.kind).toBe("action");
    });
    it("thrashes for two or three turns, then is confused", () => {
      const battle = duel([mon(TAUROS, 50, [THRASH])], [mon(SNORLAX, 70, [SPLASH])]);
      const { texts } = turns(battle, [0]);
      const thrashes = texts.filter((text) => text === "TAUROS used THRASH!").length;
      expect(thrashes === 2 || thrashes === 3).toBe(true);
      expect(battle.player.has(3, C.SUBSTATUS_CONFUSED)).toBe(true);
      expect(battle.player.has(3, C.SUBSTATUS_RAMPAGE)).toBe(false);
    });
    it("rolls out with doubling damage for up to five turns", () => {
      const enemy = mon(SNORLAX, 100, [SPLASH]);
      const battle = duel([mon(SANDSLASH, 30, [ROLLOUT])], [enemy]);
      const steps = battleSteps(battle);
      const hp: number[] = [battle.enemy.mon.hp];
      steps.answer({ action: "fight", move: 0 });
      // The next menu comes after the rollout ends.
      expect(steps.texts.filter((text) => text === "SANDSLASH used ROLLOUT!").length).toBeGreaterThan(1);
      hp.push(battle.enemy.mon.hp);
      expect(hp[1]).toBeLessThan(hp[0]);
      expect(battle.player.has(1, C.SUBSTATUS_ROLLOUT)).toBe(false);
    });
    it("doubles Fury Cutter for each hit in a row", () => {
      for (let seed = 1; seed < 30; seed++) {
        const battle = duel([mon(SCYTHER, 30, [FURY_CUTTER])], [mon(SNORLAX, 100, [SPLASH])], { seed });
        const steps = battleSteps(battle);
        const damage: number[] = [];
        let hp = battle.enemy.mon.hp;
        for (let turn = 0; turn < 3; turn++) {
          steps.answer({ action: "fight", move: 0 });
          damage.push(hp - battle.enemy.mon.hp);
          hp = battle.enemy.mon.hp;
        }
        const critical = steps.texts.some((text) => text.includes("critical"));
        if (damage.every(Boolean)) {
          expect(battle.player.furyCutterCount).toBe(3);
          // Four times the first hit, give or take the damage variation.
          if (!critical) expect(damage[2]).toBeGreaterThan(damage[0] * 3);
        } else if (!damage[2]) expect(battle.player.furyCutterCount).toBe(0);
      }
    });
    it("bides its time and unleashes twice the damage taken", () => {
      const player = mon(SNORLAX, 60, [BIDE]);
      const enemy = mon(TAUROS, 40, [TACKLE]);
      const battle = duel([player], [enemy]);
      const steps = battleSteps(battle);
      steps.answer({ action: "fight", move: 0 });
      // Bide starts counting after the hit taken before its first turn.
      const before = battle.player.mon.hp;
      // FIGHT keeps the move while biding.
      while (battle.player.has(3, C.SUBSTATUS_BIDE)) {
        expect(battle.fightKeepsMove).toBe(true);
        steps.answer({ action: "fight", move: 3 });
      }
      const texts = steps.texts;
      expect(texts).toContain("SNORLAX is storing energy!");
      expect(texts).toContain("SNORLAX unleashed energy!");
      // The faster Tauros tackles before each of Snorlax's turns, so all
      // the damage taken is unleashed.
      const taken = before - battle.player.mon.hp;
      expect(texts.lastIndexOf("Enemy TAUROS used TACKLE!")).toBeLessThan(texts.indexOf("SNORLAX unleashed energy!"));
      expect(enemy.hp - battle.enemy.mon.hp).toBe(Math.min(enemy.hp, taken * 2));
      expect(battle.player.damageTaken).toBe(0);
    });
    it("wraps the target, hurting it each turn until it is released", () => {
      const enemy = mon(SNORLAX, 60, [SPLASH]);
      const { battle, texts } = findSeed(
        (seed) => duel([mon(ARBOK, 30, [WRAP])], [enemy], { seed }),
        (texts) => texts.some((text) => text.includes("was WRAPPED by")),
      );
      expect(battle.enemy.trappingMove).toBe(WRAP);
      expect(texts.at(-1)).toBe("Enemy SNORLAX's hurt by WRAP!");
      // The wrap's own damage, then a sixteenth of the maximum HP.
      const hurt = texts.indexOf("Enemy SNORLAX's hurt by WRAP!");
      expect(hurt).toBeGreaterThan(texts.findIndex((text) => text.includes("was WRAPPED by")));
      expect(battle.enemy.wrapCount).toBeGreaterThanOrEqual(2);
      // Keep wrapping until it is released.
      const steps = battleSteps(battle);
      void steps;
    });
    it("cannot miss after Mind Reader", () => {
      for (let seed = 1; seed < 15; seed++) {
        const battle = duel([mon(SNORLAX, 60, [MIND_READER, HORN_DRILL])], [mon(PIDGEY, 30, [SPLASH])], { seed });
        const steps = battleSteps(battle);
        steps.answer({ action: "fight", move: 0 });
        expect(steps.texts).toContain("SNORLAX took aim!");
        expect(battle.enemy.has(5, C.SUBSTATUS_LOCK_ON)).toBe(true);
        steps.answer({ action: "fight", move: 1 });
        expect(steps.texts).toContain("It's a one-hit KO!");
      }
    });
    it("hits a withdrawn Pokémon with Pursuit before the switch, at double power", () => {
      const first = mon(ABRA, 30, [SPLASH]);
      const battle = duel([first, mon(SNORLAX, 30, [SPLASH])], [mon(HOUNDOUR, 40, [PURSUIT])]);
      const steps = battleSteps(battle);
      steps.answer({ action: "pkmn" }).answer(1);
      const texts = steps.texts;
      const used = texts.indexOf("Enemy HOUNDOUR used PURSUIT!");
      expect(used).toBeGreaterThan(-1);
      expect(used).toBeLessThan(texts.findIndex((text) => text.startsWith("Go! SNORLAX")));
      expect(texts.filter((text) => text.includes("used PURSUIT"))).toHaveLength(1);
      expect(first.hp).toBeLessThan(first.stats[0]);
      expect(battle.player.mon.species).toBe(SNORLAX);
    });
  });

  describe("status and field moves", () => {
    /** Play turns choosing these move slots, returning the texts. */
    const play = (battle: Battle, moves: number[]) => {
      const steps = battleSteps(battle);
      for (const move of moves) {
        if (steps.done || steps.prompt?.kind !== "action") break;
        steps.answer({ action: "fight", move });
      }
      return steps;
    };
    it("badly poisons with Toxic, one more sixteenth each turn", () => {
      const enemy = mon(SNORLAX, 60, [SPLASH]);
      const { battle, steps } = findSeed(
        (seed) => duel([mon(GENGAR, 40, [TOXIC, SPLASH])], [enemy], { seed }),
        (texts) => texts.some((text) => text.includes("badly poisoned")),
      );
      const sixteenth = (enemy.stats[0] >> 2) >> 2;
      expect(battle.enemy.mon.hp).toBe(enemy.stats[0] - sixteenth);
      steps.answer({ action: "fight", move: 1 });
      expect(battle.enemy.mon.hp).toBe(enemy.stats[0] - sixteenth * 3);
      steps.answer({ action: "fight", move: 1 });
      expect(battle.enemy.mon.hp).toBe(enemy.stats[0] - sixteenth * 6);
      expect(battle.enemy.toxicCount).toBe(3);
    });
    it("seeds the target, draining an eighth to the seeder each turn, but not a Grass type", () => {
      const { battle, texts } = findSeed(
        (seed) => {
          const player = mon(BULBASAUR, 60, [LEECH_SEED]);
          player.hp = 10;
          return duel([player], [mon(SNORLAX, 30, [SPLASH])], { seed });
        },
        (texts) => texts.some((text) => text.includes("was seeded")),
      );
      const eighth = (battle.enemy.mon.maxHp >> 2) >> 1;
      expect(battle.enemy.mon.maxHp - battle.enemy.mon.hp).toBe(eighth);
      expect(battle.player.mon.hp).toBe(10 + eighth);
      expect(texts).toContain("LEECH SEED saps Enemy SNORLAX!");
      const grass = firstTurn(duel([mon(BULBASAUR, 40, [LEECH_SEED])], [mon(BULBASAUR, 40, [SPLASH])]));
      expect(grass.texts.join(" ")).toContain("doesn't affect");
    });
    it("gives a sleeping target a nightmare that costs a quarter each turn", () => {
      const enemy = mon(SNORLAX, 60, [SPLASH], { status: 5 });
      const battle = duel([mon(GENGAR, 40, [NIGHTMARE])], [enemy]);
      const { texts } = firstTurn(battle);
      expect(texts.join(" ")).toContain("started to have a NIGHTMARE");
      expect(battle.enemy.mon.hp).toBe(enemy.stats[0] - (enemy.stats[0] >> 2));
      const awake = firstTurn(duel([mon(GENGAR, 40, [NIGHTMARE])], [mon(SNORLAX, 60, [SPLASH])]));
      expect(awake.texts).toContain("But it failed!");
    });
    it("curses differently for Ghost types", () => {
      const ghost = mon(GENGAR, 40, [CURSE]);
      const enemy = mon(SNORLAX, 60, [SPLASH]);
      const battle = duel([ghost], [enemy]);
      const { texts } = firstTurn(battle);
      expect(texts.join(" ")).toContain("put a CURSE");
      expect(ghost.hp).toBe(ghost.stats[0] - (ghost.stats[0] >> 1));
      expect(battle.enemy.mon.hp).toBe(enemy.stats[0] - (enemy.stats[0] >> 2));
      const other = duel([mon(SNORLAX, 40, [CURSE])], [mon(SNORLAX, 60, [SPLASH])]);
      const curse = firstTurn(other);
      expect(other.player.levels.slice(0, 3)).toEqual([8, 8, 6]);
      const used = curse.texts.indexOf("SNORLAX used CURSE!");
      expect(curse.texts.slice(used + 1, used + 4)).toEqual(["SNORLAX's SPEED fell!", "SNORLAX's ATTACK went up!", "SNORLAX's DEFENSE went up!"]);
    });
    it("takes the attacker down with Destiny Bond", () => {
      // Starmie moves first, so its Destiny Bond holds through Snorlax's hit.
      const player = mon(STARMIE, 20, [DESTINY_BOND]);
      const battle = duel([player], [mon(SNORLAX, 60, [TACKLE])]);
      const { texts } = playBattle(battle);
      expect(texts.join(" ")).toContain("took down with it");
      expect(battle.enemy.mon.hp).toBe(0);
    });
    it("protects against a move, with less chance on each use in a row", () => {
      const battle = duel([mon(STARMIE, 40, [PROTECT])], [mon(SNORLAX, 30, [TACKLE])]);
      const { texts } = firstTurn(battle);
      expect(texts).toContain("STARMIE PROTECTED itself!");
      expect(texts).toContain("STARMIE's PROTECTING itself!");
      let failures = 0;
      for (let seed = 1; seed < 40; seed++) {
        const steps = play(duel([mon(STARMIE, 40, [PROTECT])], [mon(SNORLAX, 30, [TACKLE])], { seed }), [0, 0, 0]);
        failures += steps.texts.filter((text) => text === "But it failed!").length;
      }
      expect(failures).toBeGreaterThan(0);
    });
    it("endures a knockout hit with 1 HP", () => {
      const player = mon(RATTATA, 10, [ENDURE]);
      const battle = duel([player], [mon(SNORLAX, 60, [TACKLE])]);
      const { texts } = firstTurn(battle);
      expect(texts.join(" ")).toContain("braced itself");
      expect(texts.join(" ")).toContain("ENDURED the hit");
      expect(battle.player.mon.hp).toBe(1);
    });
    it("spites the last move's PP, in the trainer's party struct too", () => {
      const enemy = mon(SNORLAX, 60, [TACKLE]);
      const battle = duel([mon(GENGAR, 40, [SPITE])], [enemy]);
      const { texts } = turns(battle, [0, 0]);
      const spite = texts.find((text) => text.includes("was reduced by"));
      const amount = Number(/reduced by (\d)/.exec(spite!)![1]);
      expect(amount).toBeGreaterThanOrEqual(2);
      // Two Tackles and the Spite in between, in the party struct too.
      expect(battle.enemy.mon.pp[0]).toBe(assets.pokemon.move(TACKLE).pp - 2 - amount);
      expect(enemy.pp[0] & 63).toBe(assets.pokemon.move(TACKLE).pp - 2 - amount);
    });
    it("cures the whole party with Heal Bell", () => {
      const party = [mon(CYNDAQUIL, 40, [HEAL_BELL], { status: PSN }), mon(PIDGEY, 10, [TACKLE], { status: 1 << C.PAR })];
      const battle = duel(party, [mon(SNORLAX, 60, [SPLASH])]);
      const { texts } = firstTurn(battle);
      expect(texts.join(" ")).toContain("A bell chimed!");
      expect(party.map((member) => member.status)).toEqual([0, 0]);
    });
    it("disables the target's last move, leaving it to Struggle", () => {
      const battle = duel([mon(GENGAR, 60, [DISABLE])], [mon(SNORLAX, 20, [TACKLE])]);
      // Disable fails before Snorlax has moved; the Tackle it already chose
      // is then stopped, and Struggle follows.
      const { texts } = turns(battle, [0, 0, 0]);
      expect(texts).toContain("Enemy SNORLAX's TACKLE was DISABLED!");
      expect(texts).toContain("Enemy SNORLAX's TACKLE is DISABLED!");
      expect(texts).toContain("Enemy SNORLAX used STRUGGLE!");
    });
    it("encores the target into repeating its last move", () => {
      const enemy = mon(SNORLAX, 30, [SPLASH, TACKLE]);
      const battle = duel([mon(STARMIE, 60, [ENCORE, SWORDS_DANCE])], [enemy]);
      const steps = battleSteps(battle);
      steps.answer({ action: "fight", move: 1 });
      const lastMove = battle.enemy.lastMove;
      steps.answer({ action: "fight", move: 0 });
      expect(steps.texts.join(" ")).toContain("got an ENCORE");
      expect(battle.enemy.has(5, C.SUBSTATUS_ENCORED)).toBe(true);
      steps.answer({ action: "fight", move: 1 });
      const used = steps.texts.filter((text) => text.startsWith("Enemy SNORLAX used")).slice(-1)[0];
      expect(used).toBe(`Enemy SNORLAX used ${assets.pokemon.moveName(lastMove)}!`);
    });
    it("keeps the player's encored move whatever FIGHT chooses", () => {
      const battle = duel([mon(SNORLAX, 30, [TACKLE, SPLASH])], [mon(STARMIE, 60, [ENCORE])]);
      // Starmie's first Encore fails, as Snorlax has not moved yet.
      const steps = battleSteps(battle);
      steps.answer({ action: "fight", move: 1 }).answer({ action: "fight", move: 1 });
      expect(battle.player.has(5, C.SUBSTATUS_ENCORED)).toBe(true);
      expect(battle.fightKeepsMove).toBe(true);
      steps.answer({ action: "fight", move: 0 });
      expect(steps.texts.filter((text) => text === "SNORLAX used SPLASH!")).toHaveLength(3);
      expect(steps.texts).not.toContain("SNORLAX used TACKLE!");
    });
    it("makes the opposite gender fall in love, which may stop it", () => {
      const { battle } = findSeed(
        (seed) => duel([mon(NIDORAN_M, 40, [ATTRACT])], [mon(NIDORAN_F, 40, [TACKLE])], { seed }),
        (texts) => texts.some((text) => text.includes("fell in love")),
      );
      expect(battle.enemy.has(1, C.SUBSTATUS_IN_LOVE)).toBe(true);
      const same = firstTurn(duel([mon(NIDORAN_M, 40, [ATTRACT])], [mon(NIDORAN_M, 40, [SPLASH])]));
      expect(same.texts).toContain("But it failed!");
      const immobile = findSeed(
        (seed) => duel([mon(NIDORAN_M, 40, [ATTRACT, SPLASH])], [mon(NIDORAN_F, 40, [TACKLE])], { seed }),
        (texts) => texts.some((text) => text.includes("infatuation kept it from attacking")),
      );
      expect(immobile.texts.join(" ")).toContain("is in love with");
    });
    it("shrouds the user in Mist against stat drops, and pumps it up with Focus Energy", () => {
      const battle = duel([mon(STARMIE, 60, [MIST, FOCUS_ENERGY])], [mon(SNORLAX, 30, [GROWL])]);
      const steps = battleSteps(battle);
      steps.answer({ action: "fight", move: 0 });
      expect(steps.texts.join(" ")).toContain("shrouded in MIST");
      expect(steps.texts.join(" ")).toContain("protected by MIST");
      expect(battle.player.levels[C.ATTACK]).toBe(7);
      steps.answer({ action: "fight", move: 1 });
      expect(steps.texts.join(" ")).toContain("getting pumped");
      expect(battle.player.has(4, C.SUBSTATUS_FOCUS_ENERGY)).toBe(true);
    });
    it("eliminates all stat changes with Haze", () => {
      const battle = duel([mon(STARMIE, 60, [SWORDS_DANCE, HAZE])], [mon(SNORLAX, 30, [GROWL])]);
      const steps = battleSteps(battle);
      steps.answer({ action: "fight", move: 0 });
      steps.answer({ action: "fight", move: 1 });
      expect(steps.texts.join(" ")).toContain("All stat changes were eliminated!");
      expect(battle.player.levels).toEqual([7, 7, 7, 7, 7, 7, 7]);
    });
    it("recovers half its HP, or all of it with Rest and two turns of sleep", () => {
      const player = mon(STARMIE, 60, [RECOVER, REST]);
      player.hp = 20;
      const battle = duel([player], [mon(SNORLAX, 10, [SPLASH])]);
      const steps = battleSteps(battle);
      steps.answer({ action: "fight", move: 0 });
      expect(battle.player.mon.hp).toBe(20 + (player.stats[0] >> 1));
      steps.answer({ action: "fight", move: 1 });
      expect(steps.texts.join(" ")).toContain("STARMIE went to sleep!");
      expect(battle.player.mon.hp).toBe(player.stats[0]);
      expect(battle.player.mon.status).toBe(C.REST_SLEEP_TURNS + 1);
      const full = firstTurn(duel([mon(STARMIE, 60, [RECOVER])], [mon(SNORLAX, 10, [SPLASH])]));
      expect(full.texts).toContain("STARMIE's HP is full!");
    });
    it("stops the player running after Mean Look", () => {
      const battle = duel([mon(STARMIE, 60, [SPLASH])], { wild: { species: GENGAR, level: 5 } });
      const internal = battle as unknown as { enemy: { mon: { moves: number[] } } };
      void internal;
      const steps = battleSteps(battle);
      battle.enemy.set(5, C.SUBSTATUS_CANT_RUN);
      steps.answer({ action: "run" });
      expect(steps.texts).toContain("Can't escape!");
    });
    it("shares pain to the average HP", () => {
      const player = mon(GENGAR, 40, [PAIN_SPLIT]);
      player.hp = 10;
      const enemy = mon(SNORLAX, 60, [SPLASH]);
      const battle = duel([player], [enemy]);
      firstTurn(battle);
      const average = (10 + enemy.stats[0]) >> 1;
      expect(battle.enemy.mon.hp).toBe(average);
      expect(battle.player.mon.hp).toBe(Math.min(average, player.stats[0]));
    });
    it("drums up the highest Attack for half the HP, keeping two stages when it fails", () => {
      const drummer = mon(SNORLAX, 40, [BELLY_DRUM]);
      const battle = duel([drummer], [mon(PIDGEY, 10, [SPLASH])]);
      firstTurn(battle);
      expect(battle.player.levels[C.ATTACK]).toBe(13);
      expect(drummer.hp).toBe(drummer.stats[0] - (drummer.stats[0] >> 1));
      const weak = mon(SNORLAX, 40, [BELLY_DRUM]);
      weak.hp = 10;
      const failed = duel([weak], [mon(PIDGEY, 10, [SPLASH])]);
      expect(firstTurn(failed).texts).toContain("But it failed!");
      expect(failed.player.levels[C.ATTACK]).toBe(9);
    });
    it("copies the target's stat changes with Psych Up", () => {
      const battle = duel([mon(STARMIE, 60, [PSYCH_UP])], [mon(SNORLAX, 30, [SWORDS_DANCE])]);
      const steps = battleSteps(battle);
      steps.answer({ action: "fight", move: 0 });
      expect(steps.texts).toContain("But it failed!");
      steps.answer({ action: "fight", move: 0 });
      expect(steps.texts.join(" ")).toContain("copied the stat changes of Enemy SNORLAX");
      expect(battle.player.levels[C.ATTACK]).toBe(9);
    });
    it("guards against status with Safeguard for five turns", () => {
      const battle = duel([mon(STARMIE, 60, [SAFEGUARD, SPLASH])], [mon(SNORLAX, 30, [POISONPOWDER])]);
      const steps = battleSteps(battle);
      steps.answer({ action: "fight", move: 0 });
      expect(steps.texts.join(" ")).toContain("covered by a veil");
      expect(steps.texts.join(" ")).toContain("protected by SAFEGUARD");
      for (let turn = 0; turn < 4; turn++) steps.answer({ action: "fight", move: 1 });
      expect(steps.texts.join(" ")).toContain("SAFEGUARD faded");
    });
    it("counts Perish Song down until both faint", () => {
      const battle = duel([mon(STARMIE, 60, [PERISH_SONG, SPLASH]), mon(PIDGEY, 10, [TACKLE])], [mon(SNORLAX, 60, [SPLASH])]);
      const steps = battleSteps(battle);
      steps.answer({ action: "fight", move: 0 });
      for (let turn = 0; turn < 3 && steps.prompt?.kind === "action"; turn++)
        steps.answer({ action: "fight", move: 1 });
      const counts = steps.texts.filter((text) => text.includes("PERISH count is"));
      expect(counts.slice(0, 2)).toEqual(["STARMIE's PERISH count is 3!", "Enemy SNORLAX's PERISH count is 3!"]);
      expect(steps.texts.join(" ")).toContain("PERISH count is 0!");
      expect(battle.enemy.mon.hp).toBe(0);
    });
    it("hurts the next Pokémon sent onto Spikes, which Rapid Spin blows away", () => {
      const lead = mon(PIDGEY, 5, [TACKLE]);
      lead.hp = 1;
      const next = mon(SNORLAX, 30, [SPLASH]);
      const battle = duel([mon(FORRETRESS, 60, [SPIKES, TACKLE])], [lead, next]);
      const steps = battleSteps(battle);
      steps.answer({ action: "fight", move: 0 });
      expect(steps.texts.join(" ")).toContain("SPIKES scattered all around Enemy PIDGEY");
      steps.answer({ action: "fight", move: 1 });
      expect(steps.texts.join(" ")).toContain("hurt by SPIKES");
      expect(battle.enemy.mon.maxHp - battle.enemy.mon.hp).toBe((next.stats[0] >> 2) >> 1);
      const spinner = duel([mon(FORRETRESS, 60, [RAPID_SPIN])], [mon(FORRETRESS, 60, [SPIKES])]);
      const spun = turns(spinner, [0, 0]);
      expect(spun.texts.join(" ")).toContain("blew away SPIKES");
    });
    it("may raise every stat with AncientPower", () => {
      const { battle } = findSeed(
        (seed) => duel([mon(ONIX, 60, [ANCIENTPOWER])], [mon(SNORLAX, 60, [SPLASH])], { seed }),
        (texts) => texts.some((text) => text.includes("SPCL.DEF went up")),
      );
      expect(battle.player.levels.slice(0, 5)).toEqual([8, 8, 8, 8, 8]);
    });
    it("hits two turns later with Future Sight", () => {
      const battle = duel([mon(STARMIE, 60, [FUTURE_SIGHT, SPLASH])], [mon(SNORLAX, 60, [SPLASH])]);
      const steps = battleSteps(battle);
      steps.answer({ action: "fight", move: 0 });
      expect(steps.texts.join(" ")).toContain("foresaw an attack");
      const full = battle.enemy.mon.hp;
      steps.answer({ action: "fight", move: 0 });
      expect(steps.texts).toContain("But it failed!");
      steps.answer({ action: "fight", move: 1 });
      expect(steps.texts.at(-1)).toBe("Enemy SNORLAX was hit by FUTURE SIGHT!");
      expect(battle.enemy.mon.hp).toBeLessThan(full);
    });
  });

  describe("weather, substitutes and moves that copy or switch", () => {
    it("makes it rain for five turns, strengthening Water moves", () => {
      const damage = (rain: boolean) => {
        const enemy = mon(SNORLAX, 60, [SPLASH]);
        const battle = duel([mon(STARMIE, 40, [rain ? RAIN_DANCE : SPLASH, WATER_GUN])], [enemy], { seed: 3 });
        const steps = battleSteps(battle);
        steps.answer({ action: "fight", move: 0 }).answer({ action: "fight", move: 1 });
        return { taken: enemy.hp - battle.enemy.mon.hp, steps, battle };
      };
      const rain = damage(true),
        dry = damage(false);
      expect(rain.steps.texts.join(" ")).toContain("A downpour started!");
      expect(rain.steps.texts.join(" ")).toContain("Rain continues to fall.");
      expect(rain.taken).toBeGreaterThan(dry.taken * 1.3);
      for (let turn = 0; turn < 3; turn++) rain.steps.answer({ action: "fight", move: 1 });
      expect(rain.steps.texts).toContain("The rain stopped.");
      expect(rain.battle.weather).toBe(C.WEATHER_NONE);
    });
    it("skips Solarbeam's charge and heals more with Synthesis in the sun", () => {
      const player = mon(BULBASAUR, 60, [SUNNY_DAY, SOLARBEAM, SYNTHESIS]);
      player.hp = 20;
      const battle = duel([player], [mon(SNORLAX, 60, [SPLASH])]);
      const steps = battleSteps(battle);
      steps.answer({ action: "fight", move: 0 });
      expect(steps.texts.join(" ")).toContain("The sunlight got bright!");
      steps.answer({ action: "fight", move: 1 });
      expect(steps.texts).not.toContain("BULBASAUR took in sunlight!");
      expect(steps.texts).toContain("BULBASAUR used SOLARBEAM!");
      const hp = battle.player.mon.hp;
      steps.answer({ action: "fight", move: 2 });
      // Synthesis gives half the maximum HP by day, all of it in the sun.
      expect(battle.player.mon.hp).toBe(Math.min(player.stats[0], hp + player.stats[0]));
    });
    it("buffets Pokémon other than Rock, Ground and Steel types in a sandstorm", () => {
      const battle = duel([mon(GEODUDE, 40, [SANDSTORM, SPLASH])], [mon(SNORLAX, 60, [SPLASH])]);
      const steps = battleSteps(battle);
      steps.answer({ action: "fight", move: 0 }).answer({ action: "fight", move: 1 });
      expect(steps.texts).toContain("A SANDSTORM brewed!");
      expect(steps.texts).toContain("The SANDSTORM hits Enemy SNORLAX!");
      expect(steps.texts).not.toContain("The SANDSTORM hits GEODUDE!");
      // Two turns' worth: the turn it started and the next.
      expect(battle.enemy.mon.maxHp - battle.enemy.mon.hp).toBe(((battle.enemy.mon.maxHp >> 2) >> 1) * 2);
      steps.answer({ action: "fight", move: 0 });
      expect(steps.texts).toContain("But it failed!");
    });
    it("makes a substitute that takes the hits and blocks status moves", () => {
      const player = mon(SNORLAX, 60, [SUBSTITUTE, SPLASH]);
      const battle = duel([player], [mon(PIDGEY, 30, [TACKLE])]);
      const steps = battleSteps(battle);
      steps.answer({ action: "fight", move: 0 });
      const quarter = player.stats[0] >> 2;
      expect(steps.texts.join(" ")).toContain("made a SUBSTITUTE");
      expect(battle.player.mon.hp).toBe(player.stats[0] - quarter);
      expect(steps.texts.join(" ")).toContain("The SUBSTITUTE took damage");
      expect(battle.player.mon.hp).toBe(player.stats[0] - quarter);
      expect(battle.player.substituteHp).toBeLessThan(quarter);
      steps.answer({ action: "fight", move: 0 });
      expect(steps.texts).toContain("SNORLAX has a SUBSTITUTE!");
      const status = firstTurn(duel([mon(SNORLAX, 60, [SUBSTITUTE])], [mon(PIDGEY, 30, [POISONPOWDER])]));
      expect(status.texts).toContain("It didn't affect SNORLAX!");
      const weak = mon(SNORLAX, 60, [SUBSTITUTE]);
      weak.hp = weak.stats[0] >> 2;
      expect(firstTurn(duel([weak], [mon(PIDGEY, 30, [SPLASH])])).texts.join(" ")).toContain("Too weak to make a SUBSTITUTE");
      // A fast Jolteon's substitute, then a strong Tackle that breaks it.
      const breaker = duel([mon(JOLTEON, 30, [SUBSTITUTE])], [mon(SNORLAX, 60, [TACKLE])]);
      const broken = firstTurn(breaker);
      expect(broken.texts.join(" ")).toContain("SUBSTITUTE faded");
      expect(breaker.player.has(4, C.SUBSTATUS_SUBSTITUTE)).toBe(false);
    });
    it("transforms into the target with 5 PP per move", () => {
      const battle = duel([mon(DITTO, 40, [TRANSFORM])], [mon(SNORLAX, 60, [SPLASH, TACKLE])]);
      const { texts } = firstTurn(battle);
      expect(texts.join(" ")).toContain("TRANSFORMED into SNORLAX");
      expect(battle.player.mon.species).toBe(SNORLAX);
      expect(battle.player.mon.moves.slice(0, 2)).toEqual([SPLASH, TACKLE]);
      expect(battle.player.mon.pp.slice(0, 3)).toEqual([5, 5, 0]);
    });
    it("catches a transformed wild Pokémon as a Ditto with its own DVs", () => {
      const party = [mon(SNORLAX, 40, [SPLASH])];
      const bag = { items: [], balls: [{ item: C.MASTER_BALL, quantity: 1 }], keyItems: [] };
      const battle = duel(party, { wild: { species: DITTO, level: 10 } }, { bag, caughtData: () => 0 });
      const steps = battleSteps(battle);
      const dvs = battle.enemy.mon.dvs;
      steps.answer({ action: "fight", move: 0 });
      expect(battle.enemy.has(5, C.SUBSTATUS_TRANSFORMED)).toBe(true);
      steps.answer({ action: "item", item: C.MASTER_BALL, slot: 0 });
      while (!steps.done) steps.answer(steps.prompt?.kind === "yesno" ? 0 : undefined);
      expect(party[1].species).toBe(DITTO);
      expect(party[1].dvs).toBe(dvs);
      expect(party[1].moves[0]).toBe(TRANSFORM);
    });
    it("mimics the target's last move for the battle", () => {
      const player = mon(STARMIE, 60, [MIMIC]);
      const battle = duel([player], [mon(SNORLAX, 30, [TACKLE])]);
      const { texts } = turns(battle, [0, 0]);
      expect(texts.join(" ")).toContain("learned TACKLE");
      expect(battle.player.mon.moves[0]).toBe(TACKLE);
      expect(player.moves[0]).toBe(MIMIC);
    });
    it("calls a random move with Metronome", () => {
      const { texts } = firstTurn(duel([mon(STARMIE, 60, [METRONOME])], [mon(SNORLAX, 60, [SPLASH])]));
      expect(texts[0]).toBe("STARMIE used METRONOME!");
      expect(texts[1]).toMatch(/^STARMIE used /);
      expect(texts[1]).not.toBe("STARMIE used METRONOME!");
    });
    it("mirrors the target's last move", () => {
      const battle = duel([mon(SNORLAX, 30, [MIRROR_MOVE])], [mon(STARMIE, 60, [TACKLE])]);
      const { texts } = firstTurn(battle);
      const used = texts.indexOf("SNORLAX used MIRROR MOVE!");
      expect(texts[used + 1]).toBe("SNORLAX used TACKLE!");
      const first = firstTurn(duel([mon(STARMIE, 60, [MIRROR_MOVE])], [mon(SNORLAX, 30, [TACKLE])]));
      expect(first.texts.join(" ")).toContain("MIRROR MOVE failed");
    });
    it("talks in its sleep with another move, and snores only when asleep", () => {
      const sleeper = mon(SNORLAX, 60, [SLEEP_TALK, TACKLE, SNORE], { status: 7 });
      const { texts } = firstTurn(duel([sleeper], [mon(PIDGEY, 30, [SPLASH])]));
      expect(texts).toContain("SNORLAX used SLEEP TALK!");
      expect(texts.some((text) => text === "SNORLAX used TACKLE!" || text === "SNORLAX used SNORE!")).toBe(true);
      const awake = firstTurn(duel([mon(SNORLAX, 60, [SNORE])], [mon(PIDGEY, 30, [SPLASH])]));
      expect(awake.texts).toContain("But it failed!");
    });
    it("changes its type with Conversion and Conversion2", () => {
      const battle = duel([mon(PORYGON, 40, [CONVERSION, WATER_GUN])], [mon(SNORLAX, 60, [SPLASH])]);
      const { texts } = firstTurn(battle);
      expect(texts.join(" ")).toContain("transformed into the WATER-type");
      expect(battle.player.mon.types).toEqual([21, 21]);
      // Jolteon moves first, so its Tackle is the last move to resist.
      const resist = duel([mon(PORYGON, 30, [CONVERSION2])], [mon(JOLTEON, 20, [TACKLE])]);
      firstTurn(resist);
      const [type] = resist.player.mon.types;
      expect([5, 8, 9]).toContain(type); // Rock, Ghost or Steel
    });
    it("sketches the target's last move for good", () => {
      // Jolteon moves first, so Sketch has a move to copy.
      const player = mon(SMEARGLE, 20, [SKETCH]);
      const battle = duel([player], [mon(JOLTEON, 30, [TACKLE])]);
      const { texts } = firstTurn(battle);
      expect(texts.join(" ")).toContain("SKETCHED TACKLE");
      expect(player.moves[0]).toBe(TACKLE);
      expect(player.pp[0]).toBe(assets.pokemon.move(TACKLE).pp);
    });
    it("passes stat changes and the substitute along with Baton Pass", () => {
      const party = [mon(STARMIE, 60, [SWORDS_DANCE, BATON_PASS]), mon(SNORLAX, 30, [TACKLE])];
      const battle = duel(party, [mon(PIDGEY, 30, [SPLASH])]);
      const steps = battleSteps(battle);
      steps.answer({ action: "fight", move: 0 }).answer({ action: "fight", move: 1 });
      expect(steps.prompt?.kind).toBe("party");
      steps.answer(0).answer(1);
      expect(steps.texts).toContain("STARMIE is already out.");
      expect(battle.player.mon.species).toBe(SNORLAX);
      expect(battle.player.levels[C.ATTACK]).toBe(9);
      const [numerator, denominator] = [2, 1];
      expect(battle.player.mon.stats[C.ATTACK]).toBe(Math.min(999, Math.floor((party[1].stats[1] * numerator) / denominator)));
    });
    it("ends a wild battle with Roar or Teleport, and drags out a trainer's Pokémon", () => {
      const roar = duel([mon(SNORLAX, 60, [ROAR])], { wild: { species: PIDGEY, level: 5 } });
      const roared = playBattle(roar);
      expect(roared.result).toBe(C.DRAW);
      expect(roared.texts).toContain("Enemy PIDGEY fled in fear!");
      const teleport = duel([mon(STARMIE, 60, [TELEPORT])], { wild: { species: PIDGEY, level: 5 } });
      const teleported = playBattle(teleport);
      expect(teleported.result).toBe(C.DRAW);
      expect(teleported.texts.join(" ")).toContain("fled from battle");
      const trainer = duel([mon(SNORLAX, 30, [ROAR])], [mon(PIDGEY, 30, [SPLASH]), mon(RATTATA, 30, [SPLASH])]);
      const dragged = firstTurn(trainer);
      expect(dragged.texts.join(" ")).toContain("was dragged out");
      expect(trainer.enemy.mon.species).toBe(RATTATA);
    });
  });

  describe("Counter and Mirror Coat", () => {
    it("returns twice a physical hit taken first", () => {
      const player = mon(SNORLAX, 40, [COUNTER]);
      const enemy = mon(JOLTEON, 40, [TACKLE]);
      const battle = duel([player], [enemy]);
      firstTurn(battle);
      const taken = player.stats[0] - battle.player.mon.hp;
      expect(taken).toBeGreaterThan(0);
      expect(enemy.hp - battle.enemy.mon.hp).toBe(taken * 2);
    });
    it("fails against special moves, and Mirror Coat the other way round", () => {
      const counter = duel([mon(SNORLAX, 40, [COUNTER])], [mon(JOLTEON, 40, [EMBER])]);
      expect(firstTurn(counter).texts.join(" ")).toContain("missed");
      const enemy = mon(JOLTEON, 40, [EMBER]);
      const mirror = duel([mon(SNORLAX, 40, [MIRROR_COAT])], [enemy]);
      firstTurn(mirror);
      const taken = mirror.player.mon.maxHp - mirror.player.mon.hp;
      expect(enemy.hp - mirror.enemy.mon.hp).toBe(taken * 2);
    });
  });

  describe("statuses", () => {
    it("freezes with an ice move, and the frozen Pokémon cannot move", () => {
      const { battle, texts } = findSeed(
        (seed) => duel([mon(LAPRAS, 40, [ICE_BEAM])], [mon(SNORLAX, 60, [TACKLE])], { seed }),
        (texts) => texts.some((text) => text.includes("frozen solid")),
      );
      expect(battle.enemy.mon.status & FRZ).toBeTruthy();
      expect(texts.join(" ")).not.toContain("SNORLAX used");
    });
    it("thaws a frozen target with a fire move, whatever the burn chance", () => {
      const enemy = mon(SNORLAX, 60, [SPLASH], { status: FRZ });
      const battle = duel([mon(CYNDAQUIL, 30, [EMBER])], [enemy]);
      const { texts } = firstTurn(battle);
      expect(texts.join(" ")).toContain("was defrosted");
      expect(battle.enemy.mon.status).toBe(0);
      expect(enemy.status).toBe(0);
    });
    it("thaws a frozen user of Flame Wheel", () => {
      const player = mon(CYNDAQUIL, 30, [FLAME_WHEEL], { status: FRZ });
      const battle = duel([player], [mon(SNORLAX, 60, [SPLASH])]);
      const { texts } = firstTurn(battle);
      expect(texts.join(" ")).toContain("was defrosted");
      expect(player.status).toBe(0);
    });
    it("may paralyze, freeze or burn with Tri Attack", () => {
      const seen = new Set<string>();
      for (let seed = 1; seed < 400 && seen.size < 3; seed++) {
        const { texts } = firstTurn(duel([mon(ABRA, 40, [TRI_ATTACK])], [mon(SNORLAX, 60, [SPLASH])], { seed }));
        for (const [pattern, name] of [[/paralyzed/, "par"], [/frozen solid/, "frz"], [/burned/, "brn"]] as const)
          if (texts.some((text) => pattern.test(text))) seen.add(name);
      }
      expect([...seen].sort()).toEqual(["brn", "frz", "par"]);
    });
    it("confuses with Confusion's added effect", () => {
      const { battle } = findSeed(
        (seed) => duel([mon(ABRA, 40, [CONFUSION])], [mon(SNORLAX, 60, [SPLASH])], { seed }),
        (texts) => texts.some((text) => text.includes("became confused")),
      );
      expect(battle.enemy.has(3, C.SUBSTATUS_CONFUSED)).toBe(true);
    });
    it("eats the dream of a sleeping target only", () => {
      const asleep = mon(SNORLAX, 60, [SPLASH], { status: 3 });
      const user = mon(ABRA, 40, [DREAM_EATER]);
      user.hp = 10;
      const battle = duel([user], [asleep]);
      const { texts } = firstTurn(battle);
      expect(texts.join(" ")).toContain("dream was eaten");
      expect(battle.player.mon.hp).toBeGreaterThan(10);
      const awake = firstTurn(duel([mon(ABRA, 40, [DREAM_EATER])], [mon(SNORLAX, 60, [SPLASH])]));
      expect(awake.texts.join(" ")).not.toContain("dream was eaten");
    });
    it("raises the target's Attack and confuses it with Swagger", () => {
      const { battle, texts } = findSeed(
        (seed) => duel([mon(ABRA, 40, [SWAGGER])], [mon(SNORLAX, 60, [SPLASH])], { seed }),
        (texts) => texts.some((text) => text.includes("became confused")),
      );
      expect(battle.enemy.levels[C.ATTACK]).toBe(9);
      expect(texts.join(" ")).toContain("ATTACK went way up");
    });
    it("sleeps with Hypnosis and the target stays asleep", () => {
      const { battle } = findSeed(
        (seed) => duel([mon(ABRA, 40, [HYPNOSIS])], [mon(SNORLAX, 60, [TACKLE])], { seed }),
        (texts) => texts.some((text) => text.includes("fell asleep")),
      );
      expect(battle.enemy.mon.status & C.SLP_MASK).toBeTruthy();
    });
  });

  describe("items and money", () => {
    it("steals the target's item with Thief, but not MAIL", () => {
      const player = mon(MEOWTH, 30, [THIEF]);
      const enemy = mon(SNORLAX, 60, [SPLASH], { item: LEFTOVERS });
      const { battle, texts } = findSeed(
        (seed) => {
          player.item = 0;
          enemy.item = LEFTOVERS;
          return duel([player], [enemy], { seed });
        },
        (texts) => texts.some((text) => text.includes("stole")),
      );
      expect(texts.join(" ")).toContain("stole LEFTOVERS");
      expect(player.item).toBe(LEFTOVERS);
      expect(battle.player.mon.item).toBe(LEFTOVERS);
      expect(battle.enemy.mon.item).toBe(0);
      expect(enemy.item).toBe(0);
      const mail = mon(SNORLAX, 60, [SPLASH], { item: FLOWER_MAIL });
      const thief = mon(MEOWTH, 30, [THIEF]);
      firstTurn(duel([thief], [mail]));
      expect(thief.item).toBe(0);
    });
    it("loses the player's item to a trainer's Thief for good", () => {
      const player = mon(SNORLAX, 60, [SPLASH], { item: LEFTOVERS });
      const { battle } = findSeed(
        (seed) => {
          player.item = LEFTOVERS;
          return duel([player], [mon(MEOWTH, 30, [THIEF])], { seed });
        },
        (texts) => texts.some((text) => text.includes("stole")),
      );
      expect(player.item).toBe(0);
      expect(battle.enemy.mon.item).toBe(LEFTOVERS);
    });
    it("scatters coins with Pay Day and pays them out after a win, doubled by an Amulet Coin", () => {
      for (const item of [0, AMULET_COIN]) {
        const enemy = mon(SNORLAX, 30, [SPLASH]);
        enemy.hp = 1;
        const battle = duel([mon(MEOWTH, 20, [PAY_DAY], { item })], [enemy]);
        const { texts } = playBattle(battle);
        expect(texts).toContain("Coins scattered everywhere!");
        const picked = texts.find((text) => text.includes("picked up"));
        expect(picked).toBe(`CHRIS picked up ¥${item ? 80 : 40}!`);
      }
    });
    it("checks the Amulet Coin on every send-out", () => {
      const enemy = mon(SNORLAX, 30, [SPLASH]);
      enemy.hp = 1;
      const fainted = mon(PIDGEY, 5, [TACKLE], { hp: 0 });
      const battle = duel([mon(PIDGEY, 20, [SPLASH]), mon(MEOWTH, 20, [PAY_DAY], { item: AMULET_COIN }), fainted], [enemy]);
      const { texts } = playBattle(battle, {
        action: [{ action: "pkmn" }, { action: "fight", move: 0 }],
        party: [1],
      });
      expect(texts.find((text) => text.includes("picked up"))).toBe("CHRIS picked up ¥80!");
    });
  });

  describe("Selfdestruct", () => {
    it("faints the user even if it misses", () => {
      const player = mon(GEODUDE, 30, [SELFDESTRUCT]);
      const battle = duel([player, mon(PIDGEY, 30, [TACKLE])], [mon(GASTLY, 60, [SPLASH])]);
      const { texts } = firstTurn(battle);
      expect(texts.join(" ")).toContain("doesn't affect");
      expect(player.hp).toBe(0);
    });
  });

  it("holds on at 1 HP with a Focus Band", () => {
    const { texts, battle } = findSeed(
      (seed) => {
        const enemy = mon(SNORLAX, 60, [SPLASH], { item: FOCUS_BAND });
        enemy.hp = 1;
        return duel([mon(JOLTEON, 40, [TACKLE])], [enemy], { seed });
      },
      (texts) => texts.some((text) => text.includes("hung on")),
    );
    expect(battle.enemy.mon.hp).toBe(1);
    expect(texts.join(" ")).toContain("FOCUS BAND");
  });
});