//! Synthetic WRAM traces for every accessor.
//!
//! The encodings under test are the ones `docs/design/macros-wram.md` records: big-endian HP,
//! packed PP, a BCD wallet, sprite coordinates biased by four, a one-based move list, and a
//! passable-tile list walked out of ROM bank 0.

use super::*;
use crate::pokemon_red::fake_wram::{self, REDS_HOUSE_1F, WALL_TILE, Wram};
use crate::pokemon_red::macros::cartridge::MacroState;
use crate::pokemon_red::macros::state::{BattleKind, BattleMenu, ShopScreen, Sign};

/// A walkable tile id from `RedsHouse1_Coll`.
const FLOOR: u8 = 0x01;

#[test]
fn the_player_reads_its_map_tile_and_facing() {
    let mut wram = Wram::overworld();
    let here = player(&mut wram).expect("a loaded map");
    assert_eq!((here.map, here.x, here.y), (REDS_HOUSE_1F, 3, 6));
    assert_eq!(here.facing, Facing::Down);

    for (byte, facing) in [
        (0x00, Facing::Down),
        (0x04, Facing::Up),
        (0x08, Facing::Left),
        (0x0c, Facing::Right),
    ] {
        wram.facing(byte);
        assert_eq!(player(&mut wram).unwrap().facing, facing, "sprite facing {byte:#04x}");
        assert_eq!(facing.delta(), match facing {
            Facing::Down => (0, 1),
            Facing::Up => (0, -1),
            Facing::Left => (-1, 0),
            Facing::Right => (1, 0),
        });
    }
}

#[test]
fn a_map_is_measured_in_tiles_not_blocks() {
    let mut wram = Wram::overworld();
    assert_eq!(map_size(&mut wram), Some(MapSize { width: 8, height: 8 }));

    // Pallet Town is 10 by 9 blocks.
    wram.map(0x00, 10, 9, 5, 6);
    assert_eq!(map_size(&mut wram), Some(MapSize { width: 20, height: 18 }));

    // An unloaded header is no size at all, rather than a zero-sized map.
    wram.set(ram::wCurMapWidth, 0);
    assert_eq!(map_size(&mut wram), None);
    assert_eq!(player(&mut wram), None);
}

#[test]
fn the_player_is_none_when_its_coordinates_are_outside_the_map() {
    let mut wram = Wram::overworld();
    wram.set(ram::wYCoord, 8);
    assert_eq!(player(&mut wram), None);
}

#[test]
fn a_party_member_reads_species_level_hp_status_and_moves() {
    let mut wram = Wram::overworld();
    // Charmander, level 7, 14 of 22 HP, asleep for 3 turns, SCRATCH with 34 PP and one PP Up,
    // GROWL with 40.
    wram.party_mon(0, 4, 7, 14, 22, 0b011, &[(10, 0b01_100010), (45, 40)]);

    let team = party(&mut wram);
    assert_eq!(team.mons.len(), 1);
    let mon = team.mons[0];
    assert_eq!(mon.slot, 0);
    assert_eq!(mon.species, 4);
    assert_eq!(mon.level, 7);
    assert_eq!(mon.hp, 14);
    assert_eq!(mon.max_hp, 22);
    assert_eq!(mon.status, Status::Sleep(3));
    assert_eq!(mon.moves[0], Some(Move { id: 10, pp: 34, pp_up: 1 }));
    assert_eq!(mon.moves[1], Some(Move { id: 45, pp: 40, pp_up: 0 }));
    assert_eq!(mon.moves[2], None);
    assert_eq!(mon.moves[3], None);
    assert!(!mon.fainted());
    assert!((mon.hp_fraction() - 14.0 / 22.0).abs() < 1e-12);

    // Outside a battle there is no active Pokémon.
    assert_eq!(team.active, None);
}

#[test]
fn hp_is_big_endian() {
    let mut wram = Wram::overworld();
    // 0x0102 = 258: a byte-swapped read would say 513.
    wram.party_mon(0, 6, 36, 258, 300, 0, &[]);
    assert_eq!(party(&mut wram).mons[0].hp, 258);
    assert_eq!(wram.peek(ram::wPartyMon1 + 1), 0x01);
    assert_eq!(wram.peek(ram::wPartyMon1 + 2), 0x02);
}

#[test]
fn every_status_byte_reads_as_its_ailment() {
    let mut wram = Wram::overworld();
    for (byte, status) in [
        (0x00, Status::Healthy),
        (0x01, Status::Sleep(1)),
        (0x07, Status::Sleep(7)),
        (1 << 3, Status::Poison),
        (1 << 4, Status::Burn),
        (1 << 5, Status::Freeze),
        (1 << 6, Status::Paralysis),
    ] {
        wram.party_mon(0, 4, 5, 19, 19, byte, &[]);
        assert_eq!(party(&mut wram).mons[0].status, status, "status byte {byte:#04x}");
    }
}

#[test]
fn a_full_party_reads_six_members_in_slot_order() {
    let mut wram = Wram::overworld();
    for slot in 0..6u8 {
        wram.party_mon(slot, 10 + slot, 5 + slot, u16::from(slot) + 1, 20, 0, &[(33, 35)]);
    }
    let team = party(&mut wram);
    assert_eq!(team.mons.len(), 6);
    for slot in 0..6usize {
        assert_eq!(team.mons[slot].slot, slot as u8);
        assert_eq!(team.mons[slot].species, 10 + slot as u8);
    }
    // A count the cartridge cannot produce reads as no party at all, not as garbage.
    wram.set(ram::wPartyCount, 9);
    assert!(party(&mut wram).mons.is_empty());
}

#[test]
fn the_healthiest_reserve_is_the_highest_fraction_that_is_not_out_and_not_fainted() {
    let mut wram = Wram::overworld();
    wram.party_mon(0, 4, 10, 30, 30, 0, &[]); // out, full
    wram.party_mon(1, 7, 10, 0, 30, 0, &[]); // fainted
    wram.party_mon(2, 16, 10, 10, 40, 0, &[]); // 0.25
    wram.party_mon(3, 19, 10, 15, 30, 0, &[]); // 0.50
    wram.set(ram::wIsInBattle, 1).set(ram::wPlayerMonNumber, 0);

    let team = party(&mut wram);
    assert_eq!(team.active, Some(0));
    assert_eq!(team.active_mon().map(|mon| mon.species), Some(4));
    assert_eq!(team.healthiest_reserve().map(|mon| mon.slot), Some(3));

    // Ties go to the lower slot, which is `macros.md` section 3's "ties by index".
    let mut wram = Wram::overworld();
    wram.party_mon(0, 4, 10, 30, 30, 0, &[]);
    wram.party_mon(1, 7, 10, 20, 40, 0, &[]);
    wram.party_mon(2, 16, 10, 10, 20, 0, &[]);
    wram.set(ram::wIsInBattle, 1).set(ram::wPlayerMonNumber, 0);
    assert_eq!(party(&mut wram).healthiest_reserve().map(|mon| mon.slot), Some(1));

    // A party of one has no reserve.
    let mut wram = Wram::overworld();
    wram.party_mon(0, 4, 10, 30, 30, 0, &[]);
    wram.set(ram::wIsInBattle, 1);
    assert!(party(&mut wram).healthiest_reserve().is_none());
}

#[test]
fn a_battle_reports_its_kind_its_own_mon_and_the_enemy() {
    let mut wram = Wram::overworld();
    wram.party_mon(0, 4, 7, 14, 22, 0, &[(10, 35)])
        .battle_mon(0, 4, 7, 14, 22, 0, &[(10, 35), (45, 40)])
        .enemy_mon(19, 3, 5, 11)
        .battle(1);

    let fight = battle(&mut wram).expect("a wild battle");
    assert_eq!(fight.kind, BattleKind::Wild);
    assert_eq!(fight.own.map(|mon| (mon.species, mon.hp, mon.max_hp)), Some((4, 14, 22)));
    assert_eq!(fight.own.unwrap().moves[1], Some(Move { id: 45, pp: 40, pp_up: 0 }));
    assert_eq!(
        fight.enemy,
        Some(EnemyMon { species: 19, level: 3, hp: 5, max_hp: 11 })
    );
    assert_eq!(fight.menu, BattleMenu::None);
    assert!(!fight.own_turn);

    wram.set(ram::wIsInBattle, 2);
    assert_eq!(battle(&mut wram).unwrap().kind, BattleKind::Trainer);

    // Outside a battle there is nothing to report.
    wram.set(ram::wIsInBattle, 0);
    assert!(battle(&mut wram).is_none());
}

#[test]
fn the_battle_menu_cursor_maps_to_fight_pkmn_item_run() {
    for (right_column, current, expected) in
        [(false, 0, 0u8), (false, 1, 1), (true, 0, 2), (true, 1, 3)]
    {
        let mut wram = Wram::overworld();
        wram.battle_mon(0, 4, 7, 14, 22, 0, &[(10, 35)]).battle(1).battle_menu(
            right_column,
            current,
        );
        let fight = battle(&mut wram).unwrap();
        assert_eq!(
            fight.menu,
            BattleMenu::Main { cursor: expected },
            "right={right_column} current={current}"
        );
        assert!(fight.own_turn);
        assert!(!fight.forced_switch);
    }
}

#[test]
fn the_move_list_is_reported_zero_based() {
    let mut wram = Wram::overworld();
    wram.battle_mon(0, 4, 7, 14, 22, 0, &[(10, 35), (45, 40), (33, 30)]).battle(1);

    for slot in 0..3u8 {
        wram.move_menu(slot, 3);
        assert_eq!(
            battle(&mut wram).unwrap().menu,
            BattleMenu::Moves { cursor: Some(slot), count: 3 },
            "move slot {slot}"
        );
    }

    // The game's list is one-based, so index 0 names no move and neither does one past the end.
    wram.move_menu(0, 3).set(ram::wCurrentMenuItem, 0);
    assert_eq!(battle(&mut wram).unwrap().menu, BattleMenu::Moves { cursor: None, count: 3 });
    wram.move_menu(0, 3).set(ram::wCurrentMenuItem, 4);
    assert_eq!(battle(&mut wram).unwrap().menu, BattleMenu::Moves { cursor: None, count: 3 });
}

/// Row 50: the move list is the box on screen, not the cursor bytes it left behind.
///
/// `MoveSelectionMenu` writes `wTopMenuItemY` 12 and `wTopMenuItemX` 5 and **nothing in the game
/// clears them**, exactly as the two-option box's geometry outlives its box (`yes_no_prompt`).
/// `SelectMenuItem` then decrements `wCurrentMenuItem` back to the 0-based slot on its way out,
/// which lands straight back inside the one-based range this accessor reads -- so a frame of battle
/// text read as an open move list with a placeable cursor, the pad dealt `MOVE 1..4` on it, and the
/// cursor step pressed at a list nobody was reading until its budget ran out: `MOVE n` reported
/// `blocked` 890 times in 1,431 macros on the cartridge.
///
/// Surveyed with one rollback pulse per battle frame (`examples/scene_probe.rs`,
/// `FLY_PROBE_CATCH=accept`, 3,102 frames at the rung-9 forest checkpoint): by the cursor bytes
/// alone a real directional press moved the cursor on 264 frames, and by the cursor bytes **and**
/// the box on screen on 231 of 231.
#[test]
fn a_move_list_is_the_box_on_screen_and_not_the_cursor_bytes_it_left_behind() {
    let battler = |wram: &mut Wram| {
        wram.party_mon(0, 4, 7, 14, 22, 0, &[(10, 35)]);
        wram.battle_mon(0, 4, 7, 14, 22, 0, &[(10, 35), (45, 40), (33, 30)])
            .enemy_mon(19, 3, 5, 11)
            .battle(1);
    };

    // The list drawn: the fly's own turn, on the slot the cursor is on.
    let mut wram = Wram::overworld();
    battler(&mut wram);
    wram.move_menu(2, 3);
    let fight = battle(&mut wram).unwrap();
    assert_eq!(fight.menu, BattleMenu::Moves { cursor: Some(2), count: 3 });
    assert!(fight.own_turn, "a move list with its box on screen is the fly's turn");

    // The same bytes with the box gone -- every frame of the turn's text, animation and reply.
    // Not a move list at all, so not the own turn, so the pad is the between-turns `NEXT`.
    let mut wram = Wram::overworld();
    battler(&mut wram);
    wram.move_menu_stale(2, 3);
    let fight = battle(&mut wram).unwrap();
    assert_eq!(fight.menu, BattleMenu::None, "the cursor bytes alone are not a move list");
    assert!(!fight.own_turn, "cursor bytes with no box are between turns");

    // The exact shape row 50 was measured in: `SelectMenuItem` decrements on its way out, so the
    // slot the fly chose reads back one lower and stays inside the one-based range for ever.
    let mut wram = Wram::overworld();
    battler(&mut wram);
    wram.move_menu(3, 3).set(ram::wCurrentMenuItem, 3);
    assert!(battle(&mut wram).unwrap().own_turn, "with the box drawn this is a real slot");
    let mut wram = Wram::overworld();
    battler(&mut wram);
    wram.move_menu_stale(3, 3).set(ram::wCurrentMenuItem, 3);
    assert!(!battle(&mut wram).unwrap().own_turn, "the same byte, no box, no turn");

    // Half a figure is not a box. The junction tile at (10, 12) is the one `MoveSelectionMenu`
    // writes over its own border, and a run of horizontals there is an ordinary text box.
    let mut wram = Wram::overworld();
    battler(&mut wram);
    wram.move_menu(1, 3).screen_tile(poke::MOVE_LIST_JOIN, 12, poke::frame::HORIZONTAL);
    assert_eq!(battle(&mut wram).unwrap().menu, BattleMenu::None, "the junction tile is read");

    // And the pads the two frames are dealt, which is what row 50 costs: the four move buttons and
    // `BACK` where a list is open (section 13.1), and the one `NEXT` that advances text where the
    // turn is resolving (section 12.10).
    use crate::pokemon_red::macros::palette::{MacroKind, scene_set};
    let pad = |wram: &mut Wram| {
        let scene = crate::pokemon_red::scene::detect(wram);
        let mut poke = PokeState::new(wram);
        scene_set(scene, &mut poke)
    };

    let mut wram = Wram::overworld();
    battler(&mut wram);
    wram.move_menu(1, 3);
    assert_eq!(
        pad(&mut wram),
        vec![
            MacroKind::Move1,
            MacroKind::Move2,
            MacroKind::Move3,
            MacroKind::Move4,
            MacroKind::Back
        ],
        "an open move list"
    );

    let mut wram = Wram::overworld();
    battler(&mut wram);
    wram.move_menu_stale(1, 3);
    assert_eq!(pad(&mut wram), vec![MacroKind::Next], "the same bytes with no box on screen");
}

#[test]
fn a_forced_switch_is_the_party_list_that_cannot_be_cancelled() {
    let mut wram = Wram::overworld();
    wram.party_mon(0, 4, 7, 0, 22, 0, &[(10, 35)]);
    wram.party_mon(1, 16, 8, 24, 24, 0, &[(33, 35)]);
    wram.battle_mon(0, 4, 7, 0, 22, 0, &[(10, 35)]).battle(2).party_list(1, true);

    let fight = battle(&mut wram).unwrap();
    assert_eq!(fight.menu, BattleMenu::Party { cursor: 1 });
    assert!(fight.forced_switch);
    assert!(!fight.own_turn);

    let mut wram = Wram::overworld();
    wram.party_mon(0, 4, 7, 14, 22, 0, &[(10, 35)]);
    wram.party_mon(1, 16, 8, 24, 24, 0, &[(33, 35)]);
    wram.battle_mon(0, 4, 7, 14, 22, 0, &[(10, 35)]).battle(2).party_list(1, false);
    let fight = battle(&mut wram).unwrap();
    assert_eq!(fight.menu, BattleMenu::Party { cursor: 1 });
    assert!(!fight.forced_switch);
    assert!(cursor(&mut wram).cancellable());
}

/// Section 12.10: **a battle frame with a cursor accepting input is the fly's turn.**
///
/// The four menus a battle waits on are the top-level one, the move list, the party list and the
/// bag, and each of them is the game asking the player to choose. `own_turn` answered `false` for
/// the bag, which put it on the between-turns row whose one button is the `NEXT` that advances
/// text -- and on an open bag that same A press uses whatever the cursor holds.
///
/// The two frames that are correctly *not* the fly's turn are here too: a move list whose cursor
/// the seam cannot place (row 30b, a battle's opening frames) and a frame with no menu at all.
#[test]
fn a_battle_frame_with_a_cursor_accepting_input_is_the_flys_turn() {
    let battler = |wram: &mut Wram| {
        wram.party_mon(0, 4, 7, 14, 22, 0, &[(10, 35)]);
        wram.party_mon(1, 16, 8, 24, 24, 0, &[(33, 35)]);
        wram.battle_mon(0, 4, 7, 14, 22, 0, &[(10, 35), (45, 40), (33, 30)])
            .enemy_mon(19, 3, 5, 11)
            .battle(1);
    };

    // The top-level menu.
    let mut wram = Wram::overworld();
    battler(&mut wram);
    wram.battle_menu(false, 0);
    assert!(battle(&mut wram).unwrap().own_turn, "the top-level menu");

    // The move list, with a cursor the seam can place.
    let mut wram = Wram::overworld();
    battler(&mut wram);
    wram.move_menu(1, 3);
    assert!(battle(&mut wram).unwrap().own_turn, "the move list");

    // The party list, chosen rather than forced.
    let mut wram = Wram::overworld();
    battler(&mut wram);
    wram.party_list(1, false);
    let fight = battle(&mut wram).unwrap();
    assert!(!fight.forced_switch);
    assert!(fight.own_turn, "the party list outside a forced switch");

    // The bag, which `DisplayListMenuID` opens from the menu's ITEM entry. It is the one menu that
    // read as nobody's turn, and it is what section 12.10 is about.
    let mut wram = Wram::overworld();
    battler(&mut wram);
    wram.bag(&[(crate::pokemon_red::macros::cartridge::item::POTION, 2)]).set(ram::wListMenuID, poke::ITEM_LIST_MENU);
    let fight = battle(&mut wram).unwrap();
    assert_eq!(fight.menu, BattleMenu::Bag { cursor: 0, count: 1 });
    assert!(fight.own_turn, "the battle bag is a cursor accepting input");

    // And the two frames that are not a choice. A move list whose cursor cannot be placed is a
    // battle's opening frames (row 30b), and no menu at all is text, an animation or a turn
    // resolving.
    let mut wram = Wram::overworld();
    battler(&mut wram);
    wram.move_menu(0, 3).set(ram::wCurrentMenuItem, 0);
    let fight = battle(&mut wram).unwrap();
    assert_eq!(fight.menu, BattleMenu::Moves { cursor: None, count: 3 });
    assert!(!fight.own_turn, "a cursor the seam cannot place is not accepting input");

    let mut wram = Wram::overworld();
    battler(&mut wram);
    assert_eq!(battle(&mut wram).unwrap().menu, BattleMenu::None);
    assert!(!battle(&mut wram).unwrap().own_turn, "no menu, no turn");

    // A forced switch is a cursor accepting input and it is *not* the own turn, because it has a
    // pad of its own: the exception 12.6 named, kept here so the invariant reads honestly.
    let mut wram = Wram::overworld();
    battler(&mut wram);
    wram.party_list(1, true);
    let fight = battle(&mut wram).unwrap();
    assert!(fight.forced_switch);
    assert!(!fight.own_turn, "a forced switch has its own pad");
}

#[test]
fn a_text_box_is_open_from_the_font_flag_and_waiting_from_the_box() {
    let mut wram = Wram::overworld();
    assert_eq!(text_box(&mut wram), TextBox { open: false, waiting: false });

    wram.set(ram::wFontLoaded, poke::BIT_FONT_LOADED);
    assert_eq!(text_box(&mut wram), TextBox { open: true, waiting: false });

    wram.dialogue_box();
    assert_eq!(text_box(&mut wram), TextBox { open: true, waiting: true });

    // One stray frame tile on the map is not a text box; four corners are.
    let mut wram = Wram::overworld();
    wram.set(ram::wFontLoaded, poke::BIT_FONT_LOADED)
        .screen_tile(0, 12, poke::frame::TOP_LEFT);
    assert!(!text_box(&mut wram).waiting);
}

/// Row 56: a two-option box is the one Red drew, not the one row 41 pinned.
///
/// Row 41 read the border at (11, 6)-(19, 11) because that is where the Pokémon Center's script
/// puts it, and named the limit in its own residual. The Pewter Gym guide's "Let me take you to the
/// top!" draws the same menu at **(14, 7)-(19, 11)** with the cursor at column 15, so the pinned
/// reading answered `false` on all 260 frames of a surveyed conversation while the box was drawn on
/// ten of them (`examples/scene_probe.rs`, `FLY_PROBE_CATCH=dialog`). The pad was therefore
/// `NEXT, YES, NO` on a box that was a choice -- two channels for one A press, 12.10's forbidden
/// pair -- and the reopened-prompt exclusion never armed, because it only judges an answer to a
/// prompt this crate can read.
///
/// What is the same in both boxes is a fact about `DisplayTwoOptionMenu` rather than about a
/// script: the cursor goes in the box's first interior column. The top is not, so it is found.
#[test]
fn a_yes_no_prompt_is_the_box_drawn_around_the_cursor_wherever_red_draws_it() {
    // The centre's own box, which row 41 surveyed: still a prompt.
    let mut wram = Wram::overworld();
    wram.yes_no_prompt();
    assert!(yes_no_prompt(&mut wram), "the box at (11, 6)-(19, 11)");

    // The gym guide's, three columns over and one row shorter. This is row 56.
    let mut wram = Wram::overworld();
    wram.gym_yes_no_prompt();
    assert!(yes_no_prompt(&mut wram), "the box at (14, 7)-(19, 11)");

    // Both halves stay load-bearing: the cursor bytes outlive the box on every other frame of the
    // conversation, and a frame with no box drawn is not a choice.
    let mut wram = Wram::overworld();
    wram.dialogue_box().yes_no_cursor(poke::GYM_GUIDE_YES_NO_CURSOR_X);
    assert!(!yes_no_prompt(&mut wram), "the cursor bytes with no box are not a prompt");

    // The font flag gates it, exactly as it gates `waiting`.
    let mut wram = Wram::overworld();
    wram.gym_yes_no_prompt().set(ram::wFontLoaded, 0);
    assert!(!yes_no_prompt(&mut wram), "no text display, no prompt");

    // A box the cursor is not parked in is not the cursor's box: the left edge is one column left
    // of the first item, and that is the whole of what ties the two together.
    let mut wram = Wram::overworld();
    wram.dialogue_box()
        .draw_box(4, 7, 9, 11)
        .yes_no_cursor(poke::GYM_GUIDE_YES_NO_CURSOR_X);
    assert!(!yes_no_prompt(&mut wram), "a box somewhere else on the screen");

    // And a menu of more than two options is not this menu, box or no box.
    let mut wram = Wram::overworld();
    wram.gym_yes_no_prompt().set(ram::wMaxMenuItem, 2);
    assert!(!yes_no_prompt(&mut wram), "three options is not a two-option box");

    // The pads the two frames are dealt: a readable choice is the choice's own answers and `NEXT`
    // is off it (12.10 in a dialog), and a plain box of the same conversation keeps all three.
    use crate::pokemon_red::macros::palette::{MacroKind, scene_set};
    let pad = |wram: &mut Wram| {
        let scene = crate::pokemon_red::scene::detect(wram);
        let mut poke = PokeState::new(wram);
        scene_set(scene, &mut poke)
    };

    let mut wram = Wram::overworld();
    wram.gym_yes_no_prompt();
    assert_eq!(
        pad(&mut wram),
        vec![MacroKind::Yes, MacroKind::No],
        "the guide's box is a choice, so the pad is its answers"
    );

    let mut wram = Wram::overworld();
    wram.dialogue_box().yes_no_cursor(poke::GYM_GUIDE_YES_NO_CURSOR_X);
    assert_eq!(
        pad(&mut wram),
        vec![MacroKind::Next, MacroKind::Yes, MacroKind::No],
        "a plain box of the same conversation"
    );
}

#[test]
fn the_start_menu_counts_its_items() {
    let mut wram = Wram::overworld();
    wram.start_menu();
    let menu = start_menu(&mut wram).expect("the start menu");
    assert_eq!(menu.items, 7, "the Pokédex entry is there");
    assert_eq!(menu.cursor.top_x, 11);
    assert!(menu.cursor.cancellable());

    let mut wram = Wram::overworld();
    wram.set(ram::wFontLoaded, poke::BIT_FONT_LOADED)
        .draw_box(10, 0, 19, 13)
        .cursor(2, 11, 0, 6, poke::pad::A | poke::pad::B);
    assert_eq!(start_menu(&mut wram).unwrap().items, 6);

    // The box without the font flag is a repaint, not a menu.
    let mut wram = Wram::overworld();
    wram.draw_box(10, 0, 19, 15).cursor(2, 11, 0, 7, poke::pad::A);
    assert!(start_menu(&mut wram).is_none());
}

#[test]
fn a_mart_reports_which_of_its_screens_is_up() {
    let mut wram = Wram::overworld();
    wram.set(ram::wFontLoaded, poke::BIT_FONT_LOADED)
        .set(ram::wTextBoxID, poke::BUY_SELL_QUIT_MENU);
    assert_eq!(shop(&mut wram).map(|shop| shop.screen), Some(ShopScreen::BuySellQuit));

    wram.set(ram::wListMenuID, poke::ITEM_LIST_MENU);
    assert_eq!(shop(&mut wram).map(|shop| shop.screen), Some(ShopScreen::Selling));

    // The priced list byte with the item window drawn is the buy list.
    wram.set(ram::wListMenuID, poke::PRICED_ITEM_LIST_MENU)
        .screen_tile(poke::MART_NAME_COLUMN, poke::MART_NAME_ROW, poke::CHAR_UPPER_A);
    assert_eq!(shop(&mut wram).map(|shop| shop.screen), Some(ShopScreen::Buying));

    // The bag list on its own is the start menu's, not a mart's.
    let mut wram = Wram::overworld();
    wram.set(ram::wFontLoaded, poke::BIT_FONT_LOADED)
        .set(ram::wListMenuID, poke::ITEM_LIST_MENU);
    assert!(shop(&mut wram).is_none());
}

/// Row 55: the byte that says "the priced buy list" outlives the list, so which screen is up is
/// read from what is drawn.
///
/// Surveyed in the Pewter mart from the live checkpoint: `wListMenuID` held
/// `PRICEDITEMLISTMENU` on **every frame of the visit** -- the counter menu and the clerk's own
/// text boxes included -- because the mart prints its text from inside
/// `DisplayPokemartDialogue_` rather than through `DisplayTextIDInit`. The two things that do
/// change are the figure on screen: the full-width dialogue box for the clerk, and the item
/// window for the list.
#[test]
fn the_clerks_text_box_is_not_the_marts_buy_list() {
    // The frame the stream looped on: the counter open, the priced-list byte stale, and the
    // clerk's "Here you are! Thank you!" waiting for a press.
    let mut wram = Wram::overworld();
    wram.set(ram::wListMenuID, poke::PRICED_ITEM_LIST_MENU)
        .screen_tile(poke::MART_NAME_COLUMN, poke::MART_NAME_ROW, poke::CHAR_UPPER_A)
        .dialogue_box();
    assert_eq!(
        shop(&mut wram).map(|shop| shop.screen),
        Some(ShopScreen::Talking),
        "a dialogue box waiting for a press is the clerk, whatever the list byte says"
    );

    // The same counter with the box gone and the item window drawn: the buy list.
    let mut wram = Wram::overworld();
    wram.set(ram::wFontLoaded, poke::BIT_FONT_LOADED)
        .set(ram::wListMenuID, poke::PRICED_ITEM_LIST_MENU)
        .screen_tile(poke::MART_NAME_COLUMN, poke::MART_NAME_ROW, poke::CHAR_UPPER_A);
    assert_eq!(shop(&mut wram).map(|shop| shop.screen), Some(ShopScreen::Buying));

    // And with the item window blank: the BUY / SELL / QUIT menu underneath it.
    wram.screen_tile(poke::MART_NAME_COLUMN, poke::MART_NAME_ROW, poke::frame::HORIZONTAL);
    assert_eq!(
        shop(&mut wram).map(|shop| shop.screen),
        Some(ShopScreen::BuySellQuit),
        "no item name in the window means the list is not the thing on screen"
    );
}

#[test]
fn a_pc_is_the_generic_pc_bit() {
    let mut wram = Wram::overworld();
    assert!(pc(&mut wram).is_none());
    wram.set(ram::wMiscFlags, poke::BIT_USING_GENERIC_PC).cursor(2, 4, 1, 3, poke::pad::A);
    assert_eq!(pc(&mut wram).map(|pc| pc.cursor.current), Some(1));
    // Another flag in the same byte is not a PC.
    wram.set(ram::wMiscFlags, 1 << 4);
    assert!(pc(&mut wram).is_none());
}

#[test]
fn money_is_three_bytes_of_bcd() {
    let mut wram = Wram::overworld();
    assert_eq!(money(&mut wram), 0);

    for amount in [1u32, 9, 10, 99, 100, 3000, 12_345, 999_999] {
        wram.money(amount);
        assert_eq!(money(&mut wram), amount, "{amount}");
    }

    // The starting wallet, written the way the cartridge writes it.
    wram.set(ram::wPlayerMoney, 0x00).set(ram::wPlayerMoney + 1, 0x30).set(
        ram::wPlayerMoney + 2,
        0x00,
    );
    assert_eq!(money(&mut wram), 3000);

    // A nibble above 9 is not BCD: a half-written frame must not read as a plausible number.
    wram.set(ram::wPlayerMoney + 1, 0xfa);
    assert_eq!(money(&mut wram), 0);
}

#[test]
fn the_bag_reads_pairs_up_to_its_terminator() {
    let mut wram = Wram::overworld();
    assert!(bag(&mut wram).is_empty());

    wram.bag(&[(4, 1), (20, 3)]);
    assert_eq!(
        bag(&mut wram),
        vec![BagItem { id: 4, count: 1 }, BagItem { id: 20, count: 3 }]
    );

    // The terminator wins over the count, which is what stops a stale slot being read as an item.
    wram.set(ram::wNumBagItems, 4).set(ram::wBagItems + 2, 0xff);
    assert_eq!(bag(&mut wram), vec![BagItem { id: 4, count: 1 }]);

    // A count past BAG_ITEM_CAPACITY is not a bag.
    wram.bag(&[(4, 1)]);
    wram.set(ram::wNumBagItems, 21);
    assert!(bag(&mut wram).is_empty());
}

#[test]
fn an_npc_reads_its_map_tile_and_facing() {
    let mut wram = Wram::overworld();
    assert!(npcs(&mut wram).is_empty());

    // Oak's aide at (4, 3) facing left, and a second sprite at (1, 7) facing down.
    wram.npc(1, 0x0d, 4, 3, 0x08).npc(2, 0x02, 1, 7, 0x00);
    let sprites = npcs(&mut wram);
    assert_eq!(sprites.len(), 2);
    assert_eq!((sprites[0].slot, sprites[0].x, sprites[0].y), (1, 4, 3));
    assert_eq!(sprites[0].facing, Facing::Left);
    assert_eq!(sprites[0].picture, 0x0d);
    assert_eq!((sprites[1].x, sprites[1].y, sprites[1].facing), (1, 7, Facing::Down));

    // The coordinates are stored plus four, so a reader that forgot the bias would say (8, 7).
    assert_eq!(wram.peek(ram::wSpriteStateData2 + 16 + 4), 7);
    assert_eq!(wram.peek(ram::wSpriteStateData2 + 16 + 5), 8);

    // Slot 0 is the player and is never an NPC.
    wram.npc(0, 0x01, 3, 6, 0x00);
    assert_eq!(npcs(&mut wram).len(), 2);

    // A slot the map does not use carries $ff in its image index.
    wram.set(ram::wSpriteStateData1 + 16 + 2, 0xff);
    assert_eq!(npcs(&mut wram).len(), 1);

    // And wNumSprites bounds the walk.
    wram.set(ram::wNumSprites, 0);
    assert!(npcs(&mut wram).is_empty());
}

#[test]
fn a_still_sprite_is_an_object_and_everything_below_it_is_a_person() {
    let mut wram = Wram::overworld();
    // SPRITE_OAK ($03), SPRITE_SEEL ($3c, the last person), SPRITE_POKE_BALL ($3d, the first
    // still sprite) and SPRITE_GAMBLER_ASLEEP ($48, the last): FIRST_STILL_SPRITE is the line.
    wram.npc(1, 0x03, 1, 1, 0).npc(2, 0x3c, 2, 1, 0).npc(3, 0x3d, 3, 1, 0).npc(4, 0x48, 4, 1, 0);
    let people: Vec<u8> =
        npcs(&mut wram).iter().filter(|npc| npc.person()).map(|npc| npc.picture).collect();
    assert_eq!(people, vec![0x03, 0x3c]);
    let objects: Vec<u8> =
        npcs(&mut wram).iter().filter(|npc| !npc.person()).map(|npc| npc.picture).collect();
    assert_eq!(objects, vec![0x3d, 0x48]);
}

#[test]
fn the_sign_table_reads_y_then_x_with_no_bias() {
    let mut wram = Wram::overworld();
    assert!(signs(&mut wram).is_empty(), "a map with no bg_events has no signs");

    // `bg_event 2, 0, TEXT_A` emits `db \2, \1, \3`: Y first, and — unlike `object_event` —
    // with no +4, because the loader copies the two bytes straight across and
    // IsSpriteOrSignInFrontOfPlayer compares them against raw tile coordinates.
    wram.signs(&[(2, 0, 7), (5, 3, 8)]);
    assert_eq!(wram.peek(ram::wSignCoords), 0, "the Y comes first");
    assert_eq!(wram.peek(ram::wSignCoords + 1), 2, "and it is not biased by four");
    assert_eq!(
        signs(&mut wram),
        vec![Sign { x: 2, y: 0, text_id: 7 }, Sign { x: 5, y: 3, text_id: 8 }]
    );

    // MAX_BG_EVENTS bounds the walk, so a garbage count cannot read past the array.
    wram.set(ram::wNumSigns, 200);
    assert_eq!(signs(&mut wram).len(), 16);
}

#[test]
fn the_warp_table_reads_y_then_x() {
    let mut wram = Wram::overworld();
    assert!(warps(&mut wram).is_empty());

    // Red's bedroom declares `warp_event 7, 1, REDS_HOUSE_1F, 3`, which the macro emits as
    // Y then X: the ROM-gated test asserts the same two bytes on a real cartridge.
    wram.warps(&[(7, 1, 3, REDS_HOUSE_1F)]);
    assert_eq!(wram.peek(ram::wWarpEntries), 1, "the Y comes first");
    assert_eq!(wram.peek(ram::wWarpEntries + 1), 7);
    assert_eq!(
        warps(&mut wram),
        vec![Warp { x: 7, y: 1, destination_warp: 3, destination_map: REDS_HOUSE_1F }]
    );

    // MAX_WARP_EVENTS bounds the walk, so a garbage count cannot read past the array.
    wram.set(ram::wNumberOfWarps, 200);
    assert_eq!(warps(&mut wram).len(), 32);
}

#[test]
fn the_connection_bitmask_names_the_four_edges() {
    let mut wram = Wram::overworld();
    assert_eq!(connections(&mut wram), Connections::default());
    assert!(!connections(&mut wram).any());

    for (bits, expected) in [
        (poke::CONNECTION_EAST, Connections { east: true, ..Connections::default() }),
        (poke::CONNECTION_WEST, Connections { west: true, ..Connections::default() }),
        (poke::CONNECTION_SOUTH, Connections { south: true, ..Connections::default() }),
        (poke::CONNECTION_NORTH, Connections { north: true, ..Connections::default() }),
    ] {
        wram.set(ram::wCurMapConnections, bits);
        assert_eq!(connections(&mut wram), expected, "bits {bits:#04b}");
    }

    wram.set(ram::wCurMapConnections, 0x0f);
    assert_eq!(
        connections(&mut wram),
        Connections { north: true, south: true, east: true, west: true }
    );
}

#[test]
fn a_walkable_tile_is_one_in_the_tilesets_passable_list() {
    let mut wram = Wram::overworld();
    // The tile the player stands on, opened.
    wram.map_tile(3, 6, FLOOR);
    assert_eq!(walkable(&mut wram, 3, 6), Walkable::Yes);

    // Its neighbours are walls until they are opened.
    assert_eq!(walkable(&mut wram, 3, 5), Walkable::No);
    wram.map_tile(3, 5, FLOOR);
    assert_eq!(walkable(&mut wram, 3, 5), Walkable::Yes);

    // Every id in RedsHouse1_Coll is passable and one that is in no list is not.
    for tile in crate::pokemon_red::fake_wram::REDS_HOUSE_COLL {
        wram.map_tile(2, 6, tile);
        assert_eq!(walkable(&mut wram, 2, 6), Walkable::Yes, "tile {tile:#04x}");
    }
    wram.map_tile(2, 6, WALL_TILE);
    assert_eq!(walkable(&mut wram, 2, 6), Walkable::No);
}

#[test]
fn walkability_is_unknown_outside_the_screens_window() {
    let mut wram = Wram::new();
    // A map big enough to have tiles off screen: Pallet Town, 20 by 18 tiles, player at (5, 6).
    wram.started().map(0x00, 10, 9, 5, 6).facing(0).house_collision().fill_screen(FLOOR);

    // The window is x - 4 ..= x + 5 and y - 4 ..= y + 4.
    assert_eq!(walkable(&mut wram, 1, 6), Walkable::Yes);
    assert_eq!(walkable(&mut wram, 10, 6), Walkable::Yes);
    assert_eq!(walkable(&mut wram, 0, 6), Walkable::Unknown);
    assert_eq!(walkable(&mut wram, 11, 6), Walkable::Unknown);
    assert_eq!(walkable(&mut wram, 5, 2), Walkable::Yes);
    assert_eq!(walkable(&mut wram, 5, 10), Walkable::Yes);
    assert_eq!(walkable(&mut wram, 5, 1), Walkable::Unknown);
    assert_eq!(walkable(&mut wram, 5, 11), Walkable::Unknown);

    // The window follows the player, it is not the map: the same 8 by 8 indoor map is answerable
    // whole from its middle and only in part from a corner. An A* over it has to treat Unknown as
    // impassable and re-plan as the player moves, which is what the per-step check in
    // `docs/design/macros.md` section 4 already requires.
    let mut wram = Wram::overworld();
    wram.map(REDS_HOUSE_1F, 4, 4, 4, 4).fill_screen(FLOOR);
    for y in 0..8u8 {
        for x in 0..8u8 {
            assert_eq!(walkable(&mut wram, x, y), Walkable::Yes, "centred: ({x}, {y})");
        }
    }
    wram.map(REDS_HOUSE_1F, 4, 4, 3, 6);
    assert_eq!(walkable(&mut wram, 3, 2), Walkable::Yes, "four rows up is in the window");
    assert_eq!(walkable(&mut wram, 3, 1), Walkable::Unknown, "five is not");
    assert_eq!(walkable(&mut wram, 3, 0), Walkable::Unknown);
}

#[test]
fn walkability_is_no_off_the_map_and_unknown_when_the_screen_is_not_the_map() {
    let mut wram = Wram::overworld();
    wram.fill_screen(FLOOR);
    // Off the map is not a tile to stand on: the tiles a connection leads through are the map's
    // own edge rows, which are inside it.
    assert_eq!(walkable(&mut wram, 8, 6), Walkable::No);
    assert_eq!(walkable(&mut wram, 3, 8), Walkable::No);

    // While a text box is up the screen buffer holds the box.
    wram.set(ram::wFontLoaded, poke::BIT_FONT_LOADED);
    assert_eq!(walkable(&mut wram, 3, 6), Walkable::Unknown);

    // And in a battle it holds the battle.
    let mut wram = Wram::overworld();
    wram.fill_screen(FLOOR).set(ram::wIsInBattle, 1);
    assert_eq!(walkable(&mut wram, 3, 6), Walkable::Unknown);

    // An unloaded map answers nothing.
    let mut wram = Wram::overworld();
    wram.fill_screen(FLOOR).set(ram::wCurMapWidth, 0);
    assert_eq!(walkable(&mut wram, 3, 6), Walkable::Unknown);
}

#[test]
fn a_collision_pointer_outside_rom_bank_zero_is_not_followed() {
    let mut wram = Wram::overworld();
    wram.fill_screen(FLOOR);
    assert_eq!(walkable(&mut wram, 3, 6), Walkable::Yes);

    // Banked ROM: a MemoryReader reads whichever bank is mapped, which is not an answer.
    wram.set(ram::wTilesetCollisionPtr, 0x00).set(ram::wTilesetCollisionPtr + 1, 0x40);
    assert_eq!(walkable(&mut wram, 3, 6), Walkable::Unknown);

    // A null pointer, which is what an unloaded tileset header looks like.
    wram.set(ram::wTilesetCollisionPtr, 0).set(ram::wTilesetCollisionPtr + 1, 0);
    assert_eq!(walkable(&mut wram, 3, 6), Walkable::Unknown);

    // A list with no terminator inside the bound is unknown rather than an answer.
    let mut wram = Wram::overworld();
    wram.fill_screen(FLOOR);
    for offset in 0..80u16 {
        wram.set(0x1749 + offset, 0x42);
    }
    assert_eq!(walkable(&mut wram, 3, 6), Walkable::Unknown);
}

#[test]
fn the_live_implementation_answers_the_whole_trait() {
    // One pass over every method of `GameState`, through `PokeState`, so the trait's shape is
    // exercised the way agent B's executor will hold it.
    let mut wram = Wram::overworld();
    wram.fill_screen(FLOOR)
        .party_mon(0, 4, 7, 14, 22, 0, &[(10, 35)])
        .money(3000)
        .bag(&[(4, 1)])
        .npc(1, 0x0d, 4, 3, 0x08)
        .signs(&[(2, 0, 7)])
        .warps(&[(7, 1, 3, REDS_HOUSE_1F)])
        .set(ram::wCurMapConnections, poke::CONNECTION_SOUTH);

    let mut state = PokeState::new(&mut wram);
    assert_eq!(state.scene(), Scene::Overworld);
    assert_eq!(state.player().map(|player| (player.x, player.y)), Some((3, 6)));
    assert_eq!(state.map_size(), Some(MapSize { width: 8, height: 8 }));
    assert_eq!(state.party().mons.len(), 1);
    assert!(state.battle().is_none());
    assert_eq!(state.text_box(), TextBox { open: false, waiting: false });
    assert!(state.start_menu().is_none());
    assert!(state.shop().is_none());
    assert!(state.pc().is_none());
    assert_eq!(state.money(), 3000);
    assert_eq!(state.bag().len(), 1);
    assert_eq!(state.npcs().len(), 1);
    assert_eq!(state.signs().len(), 1);
    assert_eq!(state.walkable(3, 6), Walkable::Yes);
    assert_eq!(state.warps().len(), 1);
    assert!(state.connections().south);
}

/// A map ten blocks by nine — twenty tiles by eighteen, wider than the ten-by-nine window — with
/// a wall down one column of blocks, and a screen buffer that agrees with it.
///
/// The three tables the grid is decoded from, all synthetic: block ids in `wOverworldMap`, a
/// blockset in a ROM bank that is not bank 0, and a collision list in bank 0 where
/// `wTilesetCollisionPtr` points.
fn town() -> (Wram, Vec<u8>, Vec<[u8; 16]>) {
    Wram::town()
}

#[test]
fn the_whole_map_decodes_from_the_block_and_collision_tables() {
    let (mut wram, _, _) = town();
    let grid = map_grid(&mut wram).expect("a decodable map");
    assert_eq!((grid.width(), grid.height()), (20, 18));
    assert_eq!(grid.unknown_count(), 0);
    // The far corner of the map, which the window predicate cannot answer for at all: the grid
    // does, and that is the whole of section 15.
    assert_eq!(walkable(&mut wram, 19, 17), Walkable::Unknown);
    assert_eq!(grid.walkable(19, 17), Walkable::Yes);
    // The wall column, again outside the window.
    assert_eq!(grid.walkable(10, 17), Walkable::No);
    assert_eq!(grid.walkable(11, 17), Walkable::No);
    // Inside the window the two readings agree tile for tile, which is what the reader checks
    // itself with before it trusts a decode.
    for y in 0..18u8 {
        for x in 0..20u8 {
            if let Some(tile) = map_tile_id(&mut wram, x, y) {
                assert_eq!(grid.tile_id(x, y), Some(tile), "({x}, {y})");
                assert_eq!(grid.walkable(x, y), walkable(&mut wram, x, y), "({x}, {y})");
            }
        }
    }
}

#[test]
fn a_frame_mid_step_is_read_from_the_tile_the_screen_is_centred_on() {
    // Row 54 of `infra/docs/macros-traps.md`, measured on the cartridge: `wXCoord` and `wYCoord`
    // change at the *end* of a step, so for fifteen frames of every sixteen the screen buffer is
    // centred one tile ahead of them. The old cross-check compared the decode of the fly's tile
    // against the screen's reading of the tile ahead and refused; Pewter City decoded on 118 of
    // 120 standing frames and on none of the moving ones, and every walk the fly actually took was
    // planned over the ten-by-nine window instead.
    let (mut wram, blocks, blockset) = town();
    wram.mid_step(-1, 0, &blocks, &blockset);

    // The trap itself, stated as a reading: the two answers for a tile beside the fly disagree.
    let naive = map_tile_id(&mut wram, 2, 4);
    let grid = map_grid(&mut wram).expect("a mid-step frame still decodes");
    assert_ne!(grid.tile_id(2, 4), naive, "the screen is one column ahead of the coordinates");
    assert_eq!(grid.tile_id(1, 4), naive, "and that column is the one the step is landing on");

    // Which is what the reader now says out loud, for the stood ledger.
    assert_eq!(step_destination(&mut wram, &grid), Some((2, 4)));
    // Standing still there is no step to name.
    let (mut still, _, _) = town();
    let standing = map_grid(&mut still).expect("a decodable map");
    assert_eq!(step_destination(&mut still, &standing), None);
}

#[test]
fn a_decode_the_screen_disagrees_with_is_refused_mid_step_too() {
    // The check has to keep refusing a decode that is simply wrong, and the anchor search is what
    // could have weakened it: five anchors instead of one. A wrong stride, a wrong quadrant or a
    // half-loaded map agrees with none of them, because the whole neighbourhood has to agree under
    // one anchor rather than each tile finding an anchor of its own.
    let (mut wram, blocks, blockset) = town();
    wram.mid_step(-1, 0, &blocks, &blockset);
    wram.map_tile(3, 4, 0x77);
    assert_eq!(map_grid(&mut wram), Err(GridRefusal::ScreenDisagrees));
}

#[test]
fn a_decode_the_screen_disagrees_with_is_refused() {
    let (mut wram, _, _) = town();
    // One screen tile the block data does not account for: a wrong stride, a wrong quadrant or a
    // half-loaded map all look like this, and all of them answer plausibly.
    wram.map_tile(3, 4, 0x77);
    assert_eq!(map_grid(&mut wram), Err(GridRefusal::ScreenDisagrees));
}

#[test]
fn without_a_cartridge_behind_the_seam_there_is_no_grid() {
    let (mut wram, blocks, _) = town();
    // The same WRAM with no blockset in any bank: `read_rom` answers `None`, which is what every
    // reader that is not the emulator answers, and the grid narrows to nothing rather than
    // decoding the map out of whatever bytes were to hand.
    let mut bare = Wram::new();
    bare.started()
        .map(fake_wram::PALLET_TOWN, 10, 9, 3, 4)
        .facing(0)
        .house_collision()
        .map_blocks(&blocks)
        .fill_screen(WALL_TILE);
    assert_eq!(map_grid(&mut bare), Err(GridRefusal::NoBlockset));
    // And the window predicate still answers, which is the fallback the whole thing rests on.
    assert_eq!(walkable(&mut wram, 3, 4), Walkable::Yes);
}

#[test]
fn a_frame_that_is_not_showing_the_map_has_no_grid_to_check() {
    let (mut wram, _, _) = town();
    // `wOverworldMap` shares its bytes with the picture buffer (`ram/wram.asm`'s own union), so a
    // battle is exactly when the blocks under it belong to somebody else. Nothing can be
    // cross-checked then, and a decode nothing can check is refused.
    wram.battle(1);
    assert_eq!(map_grid(&mut wram), Err(GridRefusal::NoScreen));

    let (mut wram, _, _) = town();
    wram.dialogue_box();
    assert_eq!(map_grid(&mut wram), Err(GridRefusal::NoScreen));
}

#[test]
fn a_frame_with_no_map_header_has_no_grid() {
    let mut wram = Wram::new();
    wram.started();
    assert_eq!(map_grid(&mut wram), Err(GridRefusal::NoHeader));
    assert_eq!(GridRefusal::NoHeader.label(), "no map header");
}

#[test]
fn the_grid_is_decoded_once_per_map_and_dropped_on_arrival_somewhere_else() {
    let (mut wram, blocks, blockset) = town();
    let mut grids = MapGrids::default();
    {
        let mut state = PokeState::new(&mut wram).caching_grid(&mut grids);
        let first = state.map_grid().expect("a decodable map");
        let again = state.map_grid().expect("the cached map");
        assert!(std::sync::Arc::ptr_eq(&first, &again), "the second question is the same grid");
    }
    assert_eq!(grids.held(), Some(fake_wram::PALLET_TOWN));

    // Walking through a door: another map id, so the cache is somebody else's and is dropped.
    wram.map(fake_wram::OAKS_LAB, 10, 9, 3, 4)
        .map_blocks(&blocks)
        .screen_from_blocks(&blocks, &blockset);
    {
        let mut state = PokeState::new(&mut wram).caching_grid(&mut grids);
        let grid = state.map_grid().expect("a decodable map");
        assert_eq!(grid.map(), fake_wram::OAKS_LAB);
    }
    assert_eq!(grids.held(), Some(fake_wram::OAKS_LAB));
}

#[test]
fn a_state_with_no_cache_still_answers_and_a_state_with_no_cartridge_answers_none() {
    let (mut wram, _, _) = town();
    let mut state = PokeState::new(&mut wram);
    assert!(state.map_grid().is_some(), "no cache is slower, not blinder");

    let mut bare = Wram::overworld();
    let mut state = PokeState::new(&mut bare);
    assert!(state.map_grid().is_none(), "no blockset, no grid");
    // Which is the frame the window predicate is for.
    assert_eq!(state.walkable(3, 6), Walkable::No);
}

#[test]
fn a_sprite_the_cartridge_hides_off_the_screen_is_still_on_the_map() {
    // Row 58, the Pewter Gym from its doormat at (4, 13). The cartridge draws the guide; BROCK at
    // (4, 1) and the Jr. Trainer at (3, 6) are outside `CheckSpriteAvailability`'s window, so it
    // writes `$ff` into their image index and `npcs` -- which reports what is drawn -- skips them.
    const STAY: u8 = 0xff;
    let mut wram = Wram::overworld();
    wram.map(0x36, 5, 7, 4, 13)
        .npc(3, 0x2b, 7, 10, 0x00)
        .npc_undrawn(1, 0x1f, 4, 1, STAY)
        .npc_undrawn(2, 0x0e, 3, 6, STAY)
        // Undrawn *inside* the window: switched off, or under a text box -- not the screen's doing.
        .npc_undrawn(4, 0x05, 5, 11, STAY)
        // Undrawn outside it, but a scripted mover, which the window test never hides.
        .npc_undrawn(5, 0x05, 8, 1, 0x00);
    let drawn: Vec<u8> = npcs(&mut wram).iter().map(|npc| npc.slot).collect();
    assert_eq!(drawn, vec![3]);
    let off: Vec<(u8, u8, u8)> =
        offscreen_npcs(&mut wram).iter().map(|npc| (npc.slot, npc.x, npc.y)).collect();
    assert_eq!(off, vec![(1, 4, 1), (2, 3, 6)], "the leader and the trainer, where they stand");

    // Walk up the room and the trainer is inside the window: a `$ff` there is not the screen's.
    wram.map(0x36, 5, 7, 4, 8);
    let off: Vec<u8> = offscreen_npcs(&mut wram).iter().map(|npc| npc.slot).collect();
    assert_eq!(off, vec![1], "only the leader is still off the screen from (4, 8)");
}

/// Row 60's cartridge rows, as `data/moves/moves.asm` has them: `(id, effect, power, type)`.
const TACKLE: (u8, u8, u8, u8) = (0x21, 0x00, 35, 0x00);
const TAIL_WHIP: (u8, u8, u8, u8) = (0x27, 0x13, 0, 0x00);
const GROWL: (u8, u8, u8, u8) = (0x2d, 0x12, 0, 0x00);
const SCREECH: (u8, u8, u8, u8) = (0x67, 0x3b, 0, 0x00);
const WITHDRAW: (u8, u8, u8, u8) = (0x6e, 0x0b, 0, 0x15);
const SAND_ATTACK: (u8, u8, u8, u8) = (0x1c, 0x16, 0, 0x00);
const SLEEP_POWDER: (u8, u8, u8, u8) = (0x4f, 0x20, 0, 0x16);
const POISONPOWDER: (u8, u8, u8, u8) = (0x4d, 0x42, 0, 0x03);
const THUNDER_WAVE: (u8, u8, u8, u8) = (0x56, 0x43, 0, 0x17);
/// `AURORA_BEAM`: a damaging move with a stat side effect, which always does something.
const AURORA_BEAM: (u8, u8, u8, u8) = (0x3e, 0x44, 65, 0x19);

fn stage_battle() -> Wram {
    let mut wram = Wram::new();
    wram.battle_mon(0, 0xb1, 5, 8, 20, 0, &[(0x21, 35), (0x27, 30)])
        .enemy_mon(0x24, 2, 13, 13)
        .battle(1)
        .normal_stages()
        .move_table(&[
            TACKLE,
            TAIL_WHIP,
            GROWL,
            SCREECH,
            WITHDRAW,
            SAND_ATTACK,
            SLEEP_POWDER,
            POISONPOWDER,
            THUNDER_WAVE,
            AURORA_BEAM,
        ]);
    wram
}

#[test]
fn the_move_table_is_read_by_id_and_checked_against_its_own_first_byte() {
    let mut wram = stage_battle();
    let tail_whip = move_data(&mut wram, TAIL_WHIP.0).expect("a row");
    assert_eq!((tail_whip.effect, tail_whip.power), (0x13, 0));
    assert_eq!(move_data(&mut wram, 0), None, "no move zero");
    assert_eq!(move_data(&mut wram, 0xa6), None, "past STRUGGLE");
    assert_eq!(move_data(&mut wram, 0x22), None, "a row the cartridge image does not answer");
    // A table that is not where the disassembly says: a row that does not open with its own id
    // is somebody else's row, and it is not read as this one.
    let mut shifted = Wram::new();
    shifted.move_table(&[(0x28, 0x13, 0, 0)]);
    let base = poke::moves::TABLE_ADDRESS + 0x26 * poke::moves::ROW_BYTES;
    for offset in 0..6 {
        let byte = shifted.read_rom(poke::moves::TABLE_BANK, base + 6 + offset).unwrap();
        shifted.rom_byte(poke::moves::TABLE_BANK, base + offset, byte);
    }
    assert_eq!(move_data(&mut shifted, 0x27), None);
    assert!(move_data(&mut shifted, 0x28).is_some());
}

#[test]
fn tail_whip_does_nothing_at_minus_six_and_something_before() {
    // Row 60: the Pidgey's DEFENSE stage walked down from 7 to 1 by TAIL WHIP after TAIL WHIP.
    let mut wram = stage_battle();
    for stage in 2..=7 {
        wram.set(ram::wEnemyMonStatMods + 1, stage);
        assert_eq!(move_without_effect(&mut wram, TAIL_WHIP.0), Some(false), "stage {stage}");
    }
    wram.set(ram::wEnemyMonStatMods + 1, 1);
    assert_eq!(move_without_effect(&mut wram, TAIL_WHIP.0), Some(true));
    // The -2 variant reads the same stage.
    assert_eq!(move_without_effect(&mut wram, SCREECH.0), Some(true));
    // TACKLE deals damage whatever the stages say.
    assert_eq!(move_without_effect(&mut wram, TACKLE.0), Some(false));
    // And a damaging move with a stat side effect is never "nothing".
    wram.set(ram::wEnemyMonStatMods + 3, 1);
    assert_eq!(move_without_effect(&mut wram, AURORA_BEAM.0), Some(false));
    // GROWL reads ATTACK's stage, not DEFENSE's.
    assert_eq!(move_without_effect(&mut wram, GROWL.0), Some(false));
    wram.set(ram::wEnemyMonStatMods, 1);
    assert_eq!(move_without_effect(&mut wram, GROWL.0), Some(true));
    // SAND-ATTACK reads ACCURACY's, which has no stat value behind it.
    assert_eq!(move_without_effect(&mut wram, SAND_ATTACK.0), Some(false));
    wram.set(ram::wEnemyMonStatMods + 4, 1);
    assert_eq!(move_without_effect(&mut wram, SAND_ATTACK.0), Some(true));
}

#[test]
fn a_stat_already_at_one_or_nine_hundred_ninety_nine_refuses_before_the_stage_does() {
    // `StatModifierDownEffect` restores the stage and prints "Nothing happened!" when the stat
    // itself is already 1 -- a level-2 Pidgey's DEFENSE gets there before -6.
    let mut wram = stage_battle();
    wram.set(ram::wEnemyMonStatMods + 1, 4).set_word_be(ram::wEnemyMonAttack + 2, 1);
    assert_eq!(move_without_effect(&mut wram, TAIL_WHIP.0), Some(true));
    wram.set_word_be(ram::wEnemyMonAttack + 2, 2);
    assert_eq!(move_without_effect(&mut wram, TAIL_WHIP.0), Some(false));
    // Raising: +6, or a stat of 999.
    wram.set(ram::wPlayerMonStatMods + 1, 12);
    assert_eq!(move_without_effect(&mut wram, WITHDRAW.0), Some(false));
    wram.set(ram::wPlayerMonStatMods + 1, 13);
    assert_eq!(move_without_effect(&mut wram, WITHDRAW.0), Some(true));
    wram.set(ram::wPlayerMonStatMods + 1, 9).set_word_be(ram::wBattleMonAttack + 2, 999);
    assert_eq!(move_without_effect(&mut wram, WITHDRAW.0), Some(true));
}

#[test]
fn mist_and_a_substitute_turn_a_stat_lowering_move_away() {
    let mut wram = stage_battle();
    wram.set(ram::wEnemyBattleStatus2, poke::moves::MIST);
    assert_eq!(move_without_effect(&mut wram, TAIL_WHIP.0), Some(true));
    wram.set(ram::wEnemyBattleStatus2, poke::moves::SUBSTITUTE);
    assert_eq!(move_without_effect(&mut wram, TAIL_WHIP.0), Some(true));
    assert_eq!(move_without_effect(&mut wram, POISONPOWDER.0), Some(true));
    // A raise is the user's own business.
    assert_eq!(move_without_effect(&mut wram, WITHDRAW.0), Some(false));
}

#[test]
fn a_status_move_against_a_target_it_cannot_affect_does_nothing() {
    let mut wram = stage_battle();
    for id in [SLEEP_POWDER.0, POISONPOWDER.0, THUNDER_WAVE.0] {
        assert_eq!(move_without_effect(&mut wram, id), Some(false), "healthy target, {id:#04x}");
    }
    // Any status: already asleep, poisoned, paralysed.
    wram.set(ram::wEnemyMonStatus, 1 << 6);
    for id in [SLEEP_POWDER.0, POISONPOWDER.0, THUNDER_WAVE.0] {
        assert_eq!(move_without_effect(&mut wram, id), Some(true), "statused target, {id:#04x}");
    }
    // A target that must recharge is put to sleep whatever its status (`SleepEffect`).
    wram.set(ram::wEnemyBattleStatus2, poke::moves::RECHARGE);
    assert_eq!(move_without_effect(&mut wram, SLEEP_POWDER.0), Some(false));
    // Types: a Poison type is not poisoned; a Ground type is not paralysed by an Electric move.
    let mut typed = stage_battle();
    typed.set(ram::wEnemyMonType1 + 1, poke::moves::TYPE_POISON);
    assert_eq!(move_without_effect(&mut typed, POISONPOWDER.0), Some(true));
    typed.set(ram::wEnemyMonType1 + 1, 0).set(ram::wEnemyMonType1, poke::moves::TYPE_GROUND);
    assert_eq!(move_without_effect(&mut typed, THUNDER_WAVE.0), Some(true));
    assert_eq!(move_without_effect(&mut typed, POISONPOWDER.0), Some(false));
}

#[test]
fn a_refusal_that_cannot_be_read_is_not_reported() {
    // Out of battle, no cartridge behind the seam, or a stage byte out of its 1..=13 range.
    let mut wram = stage_battle();
    wram.set(ram::wIsInBattle, 0);
    assert_eq!(move_without_effect(&mut wram, TAIL_WHIP.0), None);
    let mut bare = Wram::new();
    bare.battle(1).normal_stages().set(ram::wEnemyMonStatMods + 1, 1);
    assert_eq!(move_without_effect(&mut bare, TAIL_WHIP.0), None, "no move table");
    let mut wram = stage_battle();
    wram.set(ram::wEnemyMonStatMods + 1, 0);
    assert_eq!(move_without_effect(&mut wram, TAIL_WHIP.0), None);
    // And the seam's own answer is "leave the button where it was".
    let mut unread = Wram::new();
    assert!(!PokeState::new(&mut unread).move_without_effect(TAIL_WHIP.0));
    let mut read = stage_battle();
    read.set(ram::wEnemyMonStatMods + 1, 1);
    assert!(PokeState::new(&mut read).move_without_effect(TAIL_WHIP.0));
}