Simply Patrick Hopes can always go up, tears can only come down.

pub mod flags {
    pub const C: u8 = 0b0000_0001; // Carry
    pub const Z: u8 = 0b0000_0010; // Zero
    pub const I: u8 = 0b0000_0100; // IRQ Disable
    pub const D: u8 = 0b0000_1000; // Decimal (ignored on 2A03)
    pub const B: u8 = 0b0001_0000; // Break
    pub const U: u8 = 0b0010_0000; // Unused (always 1)
    pub const V: u8 = 0b0100_0000; // Overflow
    pub const N: u8 = 0b1000_0000; // Negative
}

pub struct Cpu {
    pub a: u8,
    pub x: u8,
    pub y: u8,
    pub pc: u16,
    pub sp: u8,
    pub p: u8,
    pub cycles: u64,
    pub bus: Bus,
}

#[derive(Clone, Copy, Debug)]
pub struct Instruction {
    pub kind: OpKind,
    pub mnemonic: &'static str,
    pub mode: AddrMode,
    pub cycles: u8,
    pub page_cross_penalty: bool,
}

pub fn get_opcodes() -> &'static [Instruction; 256] {
    use std::sync::OnceLock;
    static TABLE: OnceLock<[Instruction; 256]> = OnceLock::new();
    TABLE.get_or_init(build_table)
}

let mut t = [KIL; 256]; // 預設全部填 KIL（CPU halt）

macro_rules! op {
    ($byte:expr, $kind:expr, $mne:expr, $mode:expr, $cyc:expr) => {
        t[$byte] = Instruction::new($kind, $mne, $mode, $cyc, false);
    };
    ($byte:expr, $kind:expr, $mne:expr, $mode:expr, $cyc:expr, page) => {
        t[$byte] = Instruction::new($kind, $mne, $mode, $cyc, true);
    };
}

// ── LDA ──
op!(0xA9, Lda, "LDA", Immediate,  2);
op!(0xA5, Lda, "LDA", ZeroPage,   3);
op!(0xBD, Lda, "LDA", AbsoluteX,  4, page); // page-crossing +1
op!(0xB1, Lda, "LDA", IndirectY,  5, page);
// ...256 行填完所有指令

pub fn step(&mut self) -> String {
    let log_line = self.log_state();

    let opcode_byte = self.bus.read(self.pc);
    self.pc = self.pc.wrapping_add(1);

    let instr = get_opcodes()[opcode_byte as usize];
    let (addr, page_crossed) = self.resolve_addr(instr.mode);

    let extra = if instr.page_cross_penalty && page_crossed { 1u64 } else { 0 };
    let cost = instr.cycles as u64 + extra;

    // Add cycle cost BEFORE execute so that PPU catch-up during
    // bus reads sees the correct CPU cycle count.
    self.cycles += cost;

    self.execute(instr, addr);

    log_line
}

fn resolve_addr(&mut self, mode: AddrMode) -> (u16, bool) {
    match mode {
        AddrMode::Implied | AddrMode::Accumulator => (0, false),

        AddrMode::Immediate => {
            let addr = self.pc;
            self.pc = self.pc.wrapping_add(1);
            (addr, false)
        }

        AddrMode::AbsoluteX => {
            let lo = self.bus.read(self.pc) as u16;
            let hi = self.bus.read(self.pc.wrapping_add(1)) as u16;
            self.pc = self.pc.wrapping_add(2);
            let base = (hi << 8) | lo;
            let addr = base.wrapping_add(self.x as u16);
            let page_crossed = (base & 0xFF00) != (addr & 0xFF00);
            (addr, page_crossed)
        }

        // ...其他 9 種模式
    }
}

AddrMode::Indirect => {
    // 6502 page-wrap bug: if low byte of pointer is 0xFF,
    // high byte is read from the SAME page (wraps around).
    let lo = self.bus.read(self.pc) as u16;
    let hi = self.bus.read(self.pc.wrapping_add(1)) as u16;
    self.pc = self.pc.wrapping_add(2);
    let ptr = (hi << 8) | lo;
    let lo2 = self.bus.read(ptr) as u16;
    let hi2 = self.bus.read((ptr & 0xFF00) | ((ptr + 1) & 0x00FF)) as u16;
    ((hi2 << 8) | lo2, false)
}

fn branch(&mut self, condition: bool, offset: u16) {
    if condition {
        let offset_signed = offset as i8 as i32;
        let new_pc = (self.pc as i32 + offset_signed) as u16;
        self.cycles += if (self.pc & 0xFF00) != (new_pc & 0xFF00) { 2 } else { 1 };
        self.pc = new_pc;
    }
}

pub fn read(&mut self, addr: u16) -> u8 {
    match addr {
        0x0000..=0x1FFF => self.ram[(addr & 0x07FF) as usize],
        0x2000..=0x3FFF => {
            if let Some(io) = &mut self.io {
                io.read(0x2000 + (addr & 0x0007))
            } else {
                0xFF
            }
        }
        0x6000..=0xFFFF => {
            if let Some(m) = &self.mapper {
                m.borrow().read_prg(addr)
            } else {
                0xFF
            }
        }
        _ => 0xFF, // open bus
    }
}

#[test]
fn nestest() {
    let rom = INesRom::load("roms/nestest.nes").expect("failed to load nestest ROM");
    let bus = Bus::from_rom(rom);
    let mut cpu = Cpu::new(bus);

    let reference_log = std::fs::read_to_string("roms/nestest.log")
        .expect("failed to load nestest log");
    let ref_lines: Vec<&str> = reference_log.lines().collect();
    let mut our_lines: Vec<String> = Vec::new();

    loop {
        let log_line = cpu.step();
        our_lines.push(log_line);
        if cpu.pc == 0xC66E { break; }
    }

    // 檢查通過條件
    let official = cpu.bus.read(0x0002);
    let unofficial = cpu.bus.read(0x0003);
    assert_eq!(official, 0, "official opcodes failed: ${official:02X}");
    assert_eq!(unofficial, 0, "unofficial opcodes failed: ${unofficial:02X}");

    // 逐行比對 log
    for (i, (ours, reference)) in our_lines.iter().zip(ref_lines.iter()).enumerate() {
        assert!(cpu_columns_match(ours, reference),
            "log mismatch at line {}:\n  OURS: {}\n  REF:  {}", i + 1, ours, reference);
    }
}

// 309 bytes 的 Snake 遊戲機器碼
const SNAKE_ROM: [u8; 309] = [
    0x20, 0x06, 0x06, 0x20, 0x38, 0x06, 0x20, 0x0d, 0x06, ...
];

self.cpu.bus.write(0xFF, last_key);
self.cpu.bus.write(0xFE, rng.gen_range(1..16));

for _ in 0..STEPS_PER_TICK {
    self.cpu.step();
    if self.cpu.bus.read(self.cpu.pc) == 0x00 { // BRK = game over
        self.game_over = true;
        break;
    }
}