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

pub trait Mapper {
    fn read_prg(&self, addr: u16) -> u8;      // CPU 讀程式碼/資料
    fn write_prg(&mut self, addr: u16, val: u8); // CPU 寫入（觸發 bank switch）
    fn read_chr(&self, addr: u16) -> u8;       // PPU 讀圖形資料
    fn write_chr(&mut self, addr: u16, val: u8); // PPU 寫 CHR-RAM
    fn mirroring(&self) -> Mirroring;          // Nametable 鏡像模式
    fn as_irq(&mut self) -> Option<&mut dyn MapperIrq> { None }
}

pub fn from_rom(rom: &INesRom) -> anyhow::Result<Box<dyn Mapper>> {
    match rom.mapper {
        0 => Ok(Box::new(nrom::Nrom::new(rom))),
        1 => Ok(Box::new(mmc1::Mmc1::new(rom))),
        2 => Ok(Box::new(uxrom::UxRom::new(rom))),
        3 => Ok(Box::new(cnrom::Cnrom::new(rom))),
        4 => Ok(Box::new(mmc3::Mmc3::new(rom))),
        7 => Ok(Box::new(axrom::AxRom::new(rom))),
        n => anyhow::bail!("Unsupported mapper: {n}"),
    }
}

pub struct Nrom {
    prg_rom: Vec<u8>,
    prg_ram: [u8; 8192],  // $6000-$7FFF
    chr: Vec<u8>,
    chr_ram: bool,
    mirroring: Mirroring,
}

impl Mapper for Nrom {
    fn read_prg(&self, addr: u16) -> u8 {
        match addr {
            0x6000..=0x7FFF => self.prg_ram[(addr - 0x6000) as usize],
            0x8000..=0xFFFF => {
                let offset = (addr - 0x8000) as usize % self.prg_rom.len();
                self.prg_rom[offset]
            }
            _ => 0,
        }
    }
}

pub struct Mmc1 {
    prg_rom: Vec<u8>,
    prg_ram: [u8; 8192],
    chr: Vec<u8>,
    chr_ram: bool,

    // 5-bit 串列 shift register
    shift: u8,
    shift_count: u8,

    // 內部暫存器
    control: u8,     // 鏡像模式 + PRG/CHR 模式
    chr_bank_0: u8,  // CHR 低 4KB bank
    chr_bank_1: u8,  // CHR 高 4KB bank
    prg_bank: u8,    // PRG bank 選擇
}

fn write_prg(&mut self, addr: u16, val: u8) {
    match addr {
        0x8000..=0xFFFF => {
            if val & 0x80 != 0 {
                // 高位元 = reset
                self.shift = 0;
                self.shift_count = 0;
                self.control |= 0x0C; // 重置到 PRG mode 3
                return;
            }

            // 每次寫入送 1 bit，LSB first
            self.shift |= (val & 1) << self.shift_count;
            self.shift_count += 1;

            if self.shift_count == 5 {
                let value = self.shift;
                // 用位址的 bits 14-13 決定目標暫存器
                match (addr >> 13) & 0x03 {
                    0 => self.control = value,    // $8000-$9FFF
                    1 => self.chr_bank_0 = value, // $A000-$BFFF
                    2 => self.chr_bank_1 = value, // $C000-$DFFF
                    _ => self.prg_bank = value,   // $E000-$FFFF
                }
                self.shift = 0;
                self.shift_count = 0;
            }
        }
        // ...
    }
}

fn read_prg(&self, addr: u16) -> u8 {
    match addr {
        0x8000..=0xBFFF => {
            let bank = match self.prg_mode() {
                0 | 1 => (self.prg_bank as usize & 0xFE) % self.prg_bank_count,
                2 => 0,                                          // 固定第一個
                _ => (self.prg_bank as usize) % self.prg_bank_count,
            };
            let offset = bank * 0x4000 + (addr - 0x8000) as usize;
            self.prg_rom[offset % self.prg_rom.len()]
        }
        0xC000..=0xFFFF => {
            let bank = match self.prg_mode() {
                0 | 1 => ((self.prg_bank as usize & 0xFE) + 1) % self.prg_bank_count,
                2 => (self.prg_bank as usize) % self.prg_bank_count,
                _ => self.prg_bank_count - 1,                    // 固定最後一個
            };
            let offset = bank * 0x4000 + (addr - 0xC000) as usize;
            self.prg_rom[offset % self.prg_rom.len()]
        }
        // ...
    }
}

fn mirroring(&self) -> Mirroring {
    match self.control & 0x03 {
        0 => Mirroring::SingleScreenLower,
        1 => Mirroring::SingleScreenUpper,
        2 => Mirroring::Vertical,
        _ => Mirroring::Horizontal,
    }
}

fn read_prg(&self, addr: u16) -> u8 {
    match addr {
        0x8000..=0xFFFF => {
            let offset = self.prg_bank * 0x8000 + (addr - 0x8000) as usize;
            self.prg_rom[offset % self.prg_rom.len()]
        }
        _ => 0,
    }
}

fn write_prg(&mut self, addr: u16, val: u8) {
    if let 0x8000..=0xFFFF = addr {
        self.prg_bank = (val as usize & 0x07) % self.prg_bank_count;
        self.mirroring = if val & 0x10 != 0 {
            Mirroring::SingleScreenUpper
        } else {
            Mirroring::SingleScreenLower
        };
    }
}

pub struct Mmc3 {
    prg_rom: Vec<u8>,
    prg_ram: [u8; 8192],
    chr: Vec<u8>,
    chr_ram: bool,

    bank_select: u8,       // 目標暫存器 + 模式控制
    bank_regs: [u8; 8],    // 8 個 bank 暫存器
    mirroring: Mirroring,

    // Scanline IRQ
    irq_latch: u8,
    irq_counter: u8,
    irq_reload: bool,
    irq_enabled: bool,
    irq_pending: bool,
}

fn write_prg(&mut self, addr: u16, val: u8) {
    match addr {
        0x8000..=0x9FFF => {
            if addr & 1 == 0 {
                self.bank_select = val;        // 選擇目標 + 設定模式
            } else {
                let target = (self.bank_select & 0x07) as usize;
                self.bank_regs[target] = val;  // 寫入選中的暫存器
            }
        }
        // ...
    }
}

fn prg_offset(&self, addr: u16) -> usize {
    let second_last = self.prg_bank_count - 2;
    let last = self.prg_bank_count - 1;
    let r6 = (self.bank_regs[6] as usize) % self.prg_bank_count;
    let r7 = (self.bank_regs[7] as usize) % self.prg_bank_count;

    let bank = match addr {
        0x8000..=0x9FFF => if self.prg_mode() { second_last } else { r6 },
        0xA000..=0xBFFF => r7,
        0xC000..=0xDFFF => if self.prg_mode() { r6 } else { second_last },
        _ => last, // $E000-$FFFF 永遠是最後一個 bank
    };

    bank * 0x2000 + (addr & 0x1FFF) as usize
}

fn chr_offset(&self, addr: u16) -> usize {
    let slot = (addr >> 10) as usize; // 0-7

    let bank = if !self.chr_inversion() {
        match slot {
            0 => (self.bank_regs[0] & 0xFE) as usize, // R0 low
            1 => (self.bank_regs[0] | 0x01) as usize,  // R0 high
            2 => (self.bank_regs[1] & 0xFE) as usize, // R1 low
            3 => (self.bank_regs[1] | 0x01) as usize,  // R1 high
            4 => self.bank_regs[2] as usize,           // R2
            5 => self.bank_regs[3] as usize,           // R3
            6 => self.bank_regs[4] as usize,           // R4
            _ => self.bank_regs[5] as usize,           // R5
        }
    } else {
        // 反轉：R2-R5 和 R0-R1 的位置交換
        match slot {
            0 => self.bank_regs[2] as usize,
            1 => self.bank_regs[3] as usize,
            2 => self.bank_regs[4] as usize,
            3 => self.bank_regs[5] as usize,
            4 => (self.bank_regs[0] & 0xFE) as usize,
            5 => (self.bank_regs[0] | 0x01) as usize,
            6 => (self.bank_regs[1] & 0xFE) as usize,
            _ => (self.bank_regs[1] | 0x01) as usize,
        }
    };

    let bank = bank % self.chr_bank_count;
    bank * 0x0400 + (addr & 0x03FF) as usize
}

impl MapperIrq for Mmc3 {
    fn clock_scanline(&mut self) {
        if self.irq_counter == 0 || self.irq_reload {
            self.irq_counter = self.irq_latch;
            self.irq_reload = false;
        } else {
            self.irq_counter -= 1;
        }

        if self.irq_counter == 0 && self.irq_enabled {
            self.irq_pending = true;
        }
    }

    fn take_irq(&mut self) -> bool {
        let pending = self.irq_pending;
        self.irq_pending = false;
        pending
    }
}

fn make_mmc3(prg_8k_banks: usize, chr_1k_banks: usize) -> Mmc3 {
    let mut prg_rom = vec![0u8; prg_8k_banks * 0x2000];
    // 每個 8KB bank 填充自己的 bank 編號
    for bank in 0..prg_8k_banks {
        for i in 0..0x2000 {
            prg_rom[bank * 0x2000 + i] = bank as u8;
        }
    }
    // ...
}

pub struct Joypad {
    /// 即時按鈕狀態（bit N = Button N 被按下）
    button_state: u8,
    /// 鎖存快照——strobe 下降沿時凍結
    shift_register: u8,
    /// 下一次讀取要回傳的 bit 位置（0-7，之後回傳 open bus）
    read_index: u8,
    /// strobe 信號狀態
    strobe: bool,
}

#[repr(u8)]
pub enum Button {
    A = 0, B = 1, Select = 2, Start = 3,
    Up = 4, Down = 5, Left = 6, Right = 7,
}

pub fn write_strobe(&mut self, val: u8) {
    let new_strobe = val & 1 != 0;
    if self.strobe && !new_strobe {
        // Falling edge: 鎖存並重置
        self.shift_register = self.button_state;
        self.read_index = 0;
    }
    self.strobe = new_strobe;
    if self.strobe {
        self.shift_register = self.button_state;
    }
}

pub fn read_bit(&mut self) -> u8 {
    if self.strobe {
        return self.button_state & 1; // strobe 開著時永遠回傳 A 鍵
    }
    if self.read_index < 8 {
        let bit = (self.shift_register >> self.read_index) & 1;
        self.read_index += 1;
        bit
    } else {
        1 // open bus
    }
}

pub struct CompositeBusIo {
    pub ppu_io: PpuBusIo,
    pub joypad1: Rc<RefCell<Joypad>>,
    pub joypad2: Rc<RefCell<Joypad>>,
}

impl BusIo for CompositeBusIo {
    fn read(&mut self, addr: u16) -> u8 {
        match addr {
            addr::JOYPAD1 => self.joypad1.borrow_mut().read_bit(),
            addr::JOYPAD2 => self.joypad2.borrow_mut().read_bit(),
            _ => self.ppu_io.read(addr),
        }
    }

    fn write(&mut self, addr: u16, val: u8) {
        match addr {
            addr::JOYPAD1 => {
                // Strobe 同時鎖存兩個控制器
                self.joypad1.borrow_mut().write_strobe(val);
                self.joypad2.borrow_mut().write_strobe(val);
            }
            _ => self.ppu_io.write(addr, val),
        }
    }
}

pub fn keyboard_to_buttons(window: &minifb::Window) -> u8 {
    let mut state = 0u8;
    if window.is_key_down(Key::Up)    { state |= 1 << Button::Up as u8; }
    if window.is_key_down(Key::Down)  { state |= 1 << Button::Down as u8; }
    if window.is_key_down(Key::Left)  { state |= 1 << Button::Left as u8; }
    if window.is_key_down(Key::Right) { state |= 1 << Button::Right as u8; }
    if window.is_key_down(Key::Z)     { state |= 1 << Button::A as u8; }
    if window.is_key_down(Key::X)     { state |= 1 << Button::B as u8; }
    if window.is_key_down(Key::A)     { state |= 1 << Button::Select as u8; }
    if window.is_key_down(Key::S)     { state |= 1 << Button::Start as u8; }
    state
}

// 左搖桿 deadzone = 0.5
if let Some(axis) = gp.axis_data(Axis::LeftStickX) {
    if axis.value() < -0.5 { state |= 1 << Button::Left as u8; }
    if axis.value() > 0.5  { state |= 1 << Button::Right as u8; }
}

pub struct System {
    pub cpu: Cpu,
    pub ppu: Rc<RefCell<Ppu>>,
    pub joypad1: Rc<RefCell<Joypad>>,
    pub joypad2: Rc<RefCell<Joypad>>,
    cpu_cycles: Rc<Cell<u64>>,
    ppu_cycles: Rc<Cell<u64>>,
}

cpu.reset();
cpu_cycles.set(cpu.cycles);
let reset_ppu_dots = cpu.cycles * 3;
{
    let mut p = ppu.borrow_mut();
    for _ in 0..reset_ppu_dots {
        p.tick();
    }
}
ppu_cycles.set(reset_ppu_dots);

window.set_target_fps(60);

while window.is_open() && !window.is_key_down(Key::Escape) {
    // 1. 讀取輸入
    let mut p1_state = keyboard_to_buttons(&window);
    #[cfg(feature = "gamepad")]
    if let (Some(ref mut gilrs), Some(gp_id)) = (&mut gilrs_ctx, gamepad_id) {
        while gilrs.next_event().is_some() {} // drain events
        p1_state |= gamepad_to_buttons(gilrs, gp_id);
    }
    sys.joypad1.borrow_mut().set_buttons(p1_state);

    // 2. 跑一幀
    sys.run_until_frame();

    // 3. 更新畫面
    let ppu = sys.ppu.borrow();
    window.update_with_buffer(&*ppu.framebuffer, WIDTH, HEIGHT)?;
}

#[test]
fn read_order_matches_button_enum() {
    let mut jp = Joypad::new();
    jp.set_buttons(1 << Button::Start as u8);
    jp.write_strobe(1);
    jp.write_strobe(0);

    assert_eq!(jp.read_bit(), 0); // A
    assert_eq!(jp.read_bit(), 0); // B
    assert_eq!(jp.read_bit(), 0); // Select
    assert_eq!(jp.read_bit(), 1); // Start ← 只有這個是 1
    assert_eq!(jp.read_bit(), 0); // Up
    assert_eq!(jp.read_bit(), 0); // Down
    assert_eq!(jp.read_bit(), 0); // Left
    assert_eq!(jp.read_bit(), 0); // Right
}

#[test]
fn open_bus_after_8_reads() {
    let mut jp = Joypad::new();
    jp.write_strobe(1);
    jp.write_strobe(0);
    for _ in 0..8 { jp.read_bit(); }
    assert_eq!(jp.read_bit(), 1); // open bus
    assert_eq!(jp.read_bit(), 1); // 一直是 1
}

pub struct Ppu {
    // 控制暫存器
    pub ctrl: u8,    // $2000: NMI enable, sprite size, pattern table...
    pub mask: u8,    // $2001: background/sprite enable, color emphasis
    pub status: u8,  // $2002: VBlank, sprite 0 hit, overflow

    // Loopy scroll 暫存器
    pub v: u16,      // 當前 VRAM 位址 (15-bit)
    pub t: u16,      // 暫存 VRAM 位址 (15-bit)
    pub fine_x: u8,  // X fine scroll (0-7 pixels)
    pub addr_latch: bool, // 寫入對切換

    // 記憶體
    pub vram: [u8; 2048],    // 2 個 nametable
    pub palette: [u8; 32],   // 調色盤
    pub oam: [u8; 256],      // Sprite 記憶體 (64 sprites × 4 bytes)

    // 時序
    pub scanline: i16,  // 0-261
    pub dot: u16,       // 0-340
    pub odd_frame: bool,

    // NMI（edge-triggered）
    pub nmi_output: bool,      // $2000 bit 7
    pub nmi_occurred: bool,    // VBlank flag
    pub nmi_pending: bool,     // Edge-detected NMI
    pub nmi_line: bool,        // 前一次 NMI line 狀態
    pub nmi_pending_age: u16,  // NMI 設定後經過的 PPU ticks
    pub nmi_write_delay: u8,   // Register-write 觸發的延遲

    // 背景 shift registers
    bg_pattern_lo: u16,
    bg_pattern_hi: u16,
    bg_attr_lo: u16,
    bg_attr_hi: u16,

    // 渲染輸出
    pub framebuffer: Box<[u32; 256 * 240]>,
    // ...
}

pub struct System {
    pub cpu: Cpu,
    pub ppu: Rc<RefCell<Ppu>>,
    cpu_cycles: Rc<Cell<u64>>,
    ppu_cycles: Rc<Cell<u64>>,
    // ...
}

pub fn step(&mut self) -> u64 {
    if self.ppu.borrow_mut().take_nmi() {
        self.cpu.nmi();
        self.cpu_cycles.set(self.cpu.cycles);
    }

    let dma_cycles = self.handle_dma();

    // 預讀指令的 base cycle cost，這樣 PPU catch-up
    // 在 bus read 時能看到正確的 CPU cycle 數
    let opcode = self.cpu.bus.peek(self.cpu.pc);
    let instr = nes_cpu::opcodes::get_opcodes()[opcode as usize];
    let base_cost = instr.cycles as u64;
    self.cpu_cycles.set(self.cpu.cycles + base_cost);

    let prev_cycles = self.cpu.cycles;
    let _ = self.cpu.step();
    let elapsed = self.cpu.cycles - prev_cycles;

    self.cpu_cycles.set(self.cpu.cycles);

    // 補跑 PPU 尚未 tick 的部分
    let target_ppu = self.cpu.cycles * 3;
    let current_ppu = self.ppu_cycles.get();
    if target_ppu > current_ppu {
        let remaining = target_ppu - current_ppu;
        let mut ppu = self.ppu.borrow_mut();
        for _ in 0..remaining {
            ppu.tick();
        }
        self.ppu_cycles.set(target_ppu);
    }

    elapsed + dma_cycles
}

impl BusIo for PpuBusIo {
    fn read(&mut self, addr: u16) -> u8 {
        let target = self.cpu_cycles.get() * 3;

        if addr == 0x2002 {
            // 先 catch-up 到 target-1
            let split_target = target.saturating_sub(1);
            self.catch_up_to(split_target);

            let mut ppu = self.ppu.borrow_mut();

            // 如果 PPU 現在在 (241, 0)，下一個 tick 就要設 VBlank
            // 此時讀 $2002 會抑制 VBlank
            if ppu.scanline == timing::VBLANK_LINE && ppu.dot == 0 {
                ppu.suppress_vbl = true;
            }

            let val = ppu.read_register(addr);
            ppu.tick(); // 最後一個 tick
            self.ppu_cycles.set(target);
            val
        } else {
            self.catch_up_to(target);
            self.ppu.borrow_mut().read_register(addr)
        }
    }
}

if self.scanline == timing::VBLANK_LINE && self.dot == timing::EVENT_DOT {
    if self.suppress_vbl {
        self.suppress_vbl = false; // 消費 flag，不設 VBlank
    } else {
        self.status |= status::VBLANK;
        self.nmi_occurred = true;
        self.update_nmi(true);
    }
}

fn update_nmi(&mut self, from_tick: bool) {
    let active = self.nmi_output && self.nmi_occurred;
    if active && !self.nmi_line {
        // Rising edge: NMI 線剛從 inactive → active
        self.nmi_pending = true;
        self.nmi_pending_age = 0;
    } else if !active && self.nmi_line {
        // Falling edge: 只有 tick 產生的才能取消 pending NMI
        if from_tick && self.nmi_write_delay == 0 {
            self.nmi_pending = false;
        }
    }
    self.nmi_line = active;
}

pub fn take_nmi(&mut self) -> bool {
    if self.nmi_write_delay > 0 {
        self.nmi_write_delay -= 1;
        if self.nmi_write_delay == 0 && self.nmi_pending {
            self.nmi_pending = false;
            return true;
        }
        return false;
    }
    // NMI 必須存在夠久（≥3 PPU ticks），CPU 才能在
    // penultimate cycle 偵測到
    if self.nmi_pending && self.nmi_pending_age >= 3 {
        self.nmi_pending = false;
        return true;
    }
    false
}

if (self.dot >= 1 && self.dot <= 256) || (self.dot >= 321 && self.dot <= 336) {
    self.update_bg_shifters();
    match self.dot % 8 {
        1 => self.fetch_nametable_byte(),   // Tile ID
        3 => self.fetch_attribute_byte(),   // 調色盤 bits
        5 => self.fetch_pattern_lo(),       // Pattern bitplane 0
        7 => self.fetch_pattern_hi(),       // Pattern bitplane 1
        0 => self.load_bg_shifters(),       // 載入 16-bit shift register
        _ => {}
    }
}

fn render_pixel(&mut self) {
    let x = (self.dot - 1) as usize;
    let y = self.scanline as usize;

    let (bg_pixel, bg_palette) = if self.mask & mask::SHOW_BG != 0 {
        let bit_select = 15 - self.fine_x as u16;
        let lo = (self.bg_pattern_lo >> bit_select) & 1;
        let hi = (self.bg_pattern_hi >> bit_select) & 1;
        let pixel = ((hi << 1) | lo) as u8;
        let attr_lo = (self.bg_attr_lo >> bit_select) & 1;
        let attr_hi = (self.bg_attr_hi >> bit_select) & 1;
        let palette = ((attr_hi << 1) | attr_lo) as u8;
        (pixel, palette)
    } else {
        (0, 0)
    };

    // Sprite compositing + priority multiplexer...
}

// Dot 256: 增加 fine Y → coarse Y（換到下一行）
if self.dot == 256 {
    self.increment_scroll_y();
}
// Dot 257: 從 t 複製水平捲動位元到 v
if self.dot == 257 {
    self.copy_horizontal_bits();
}
// Pre-render scanline, dots 280-304: 從 t 複製垂直捲動位元到 v
if prerender && self.dot >= 280 && self.dot <= 304 {
    self.copy_vertical_bits();
}

fn evaluate_sprites(&mut self) {
    let sprite_height: i16 = if self.ctrl & ctrl::SPRITE_SIZE != 0 { 16 } else { 8 };

    self.sprite_count = 0;
    self.sprite_zero_on_line = false;

    for i in 0..64 {
        let y = self.oam[i * 4] as i16;
        let diff = self.scanline - y;
        if diff < 0 || diff >= sprite_height { continue; }
        if self.sprite_count >= 8 {
            self.status |= status::SPRITE_OVERFLOW;
            break;
        }

        // 載入 tile pattern，處理垂直/水平翻轉
        let flip_v = attr & 0x80 != 0;
        let flip_h = attr & 0x40 != 0;
        // ...取 pattern bitplane、reverse_bits() 做水平翻轉

        if i == 0 { self.sprite_zero_on_line = true; }
        self.sprite_count += 1;
    }
}

loop {
    total_cycles += sys.step();

    let sig0 = sys.cpu.bus.read(0x6001);
    let sig1 = sys.cpu.bus.read(0x6002);
    let sig2 = sys.cpu.bus.read(0x6003);

    if sig0 == 0xDE && sig1 == 0xB0 && sig2 == 0x61 {
        let status = sys.cpu.bus.read(0x6000);
        if status != 0x80 {
            let message = read_result_message(&mut sys);
            if status == 0x00 {
                println!("PASS");
            } else {
                println!("FAIL: {}", message);
            }
        }
    }
}

if self.scanline == timing::PRERENDER_LINE
    && self.dot == timing::ODD_SKIP_DOT  // dot 339
    && self.odd_frame
    && self.rendering_enabled()
{
    self.dot = timing::LAST_DOT; // 跳到 340
    // 下一個 tick 會增到 341，觸發 scanline wrap
}

let mut sys = System::from_rom(rom)?;

window.set_target_fps(60);

while window.is_open() && !window.is_key_down(Key::Escape) {
    sys.run_until_frame();
    let ppu = sys.ppu.borrow();
    window.update_with_buffer(&*ppu.framebuffer, WIDTH, HEIGHT)?;
}

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;
    }
}

pub trait ComicReader: Send + Sync + std::fmt::Debug {
    fn title(&self) -> &str;
    fn page_count(&self) -> usize;
    fn extract_page(&self, index: usize) -> Result<iced::widget::image::Handle, String>;
}

pub fn open(path: &Path) -> Result<Box<dyn ComicReader>, String> {
    match path
        .extension()
        .and_then(|e| e.to_str())
        .map(str::to_lowercase)
        .as_deref()
    {
        Some("cbz") => cbz::CbzReader::open(path).map(|r| Box::new(r) as Box<dyn ComicReader>),
        Some("cbr") => cbr::CbrReader::open(path).map(|r| Box::new(r) as Box<dyn ComicReader>),
        Some("cb7") => cb7::Cb7Reader::open(path).map(|r| Box::new(r) as Box<dyn ComicReader>),
        ext => Err(format!("Unsupported format: {}", ext.unwrap_or("none"))),
    }
}

Task::perform(
    async move { smol::unblock(move || reader::open(&path).map(Arc::from)).await },
    Message::ComicLoaded,
)

#[derive(Debug)]
pub struct CbzReader {
    title: String,
    pages: Vec<String>,      // 排序後的圖片檔名列表
    archive_bytes: Vec<u8>,  // 整份 .cbz 的原始位元組
}

impl ComicReader for CbzReader {
    fn extract_page(&self, index: usize) -> Result<image::Handle, String> {
        let filename = self.pages.get(index)
            .ok_or_else(|| format!("Page index {index} out of bounds"))?;
        let cursor = std::io::Cursor::new(&self.archive_bytes);
        let mut archive = zip::ZipArchive::new(cursor).map_err(|e| e.to_string())?;
        let mut file = archive.by_name(filename).map_err(|e| e.to_string())?;
        let mut bytes = Vec::new();
        file.read_to_end(&mut bytes).map_err(|e| e.to_string())?;
        Ok(image::Handle::from_bytes(bytes))
    }
}

#[derive(Debug)]
pub struct Cb7Reader {
    title: String,
    pages: Vec<Vec<u8>>,  // 每頁的原始圖片位元組，開檔時全部解壓好
}

impl Cb7Reader {
    pub fn open(path: &Path) -> Result<Self, String> {
        let mut reader = SevenZReader::open(path, Password::empty())
            .map_err(|e| e.to_string())?;

        let mut entries: Vec<(String, Vec<u8>)> = Vec::new();
        reader.for_each_entries(|entry, reader| {
            if entry.is_directory() || !super::is_image_file(entry.name()) {
                return Ok(true); // 跳過，繼續
            }
            let mut bytes = Vec::new();
            reader.read_to_end(&mut bytes).map_err(sevenz_rust::Error::from)?;
            entries.push((entry.name().to_owned(), bytes));
            Ok(true)
        }).map_err(|e| e.to_string())?;

        entries.sort_by(|(a, _), (b, _)| a.cmp(b));
        // ...
    }
}

impl CbrReader {
    pub fn open(_path: &Path) -> Result<Self, String> {
        Err(
            "CBR (RAR) format is not yet supported. \
             Consider converting to CBZ using Calibre or 7-Zip."
                .to_string(),
        )
    }
}

const CACHE_CAPACITY: usize = 7;

struct PageCache {
    entries: HashMap<usize, image::Handle>,
}

impl PageCache {
    fn insert(&mut self, index: usize, handle: image::Handle, current_page: usize) {
        if !self.entries.contains_key(&index) && self.entries.len() >= CACHE_CAPACITY {
            // 找距離 current_page 最遠的 key
            let evict = *self
                .entries
                .keys()
                .max_by_key(|&&k| k.abs_diff(current_page))
                .expect("cache is non-empty");
            self.entries.remove(&evict);
        }
        self.entries.insert(index, handle);
    }
}

// usize is Copy，所以可以在可變借用前先把 key 複製出來
let evict = *self
    .entries
    .keys()
    .max_by_key(|&&k| k.abs_diff(current_page))
    .expect("cache is non-empty");
self.entries.remove(&evict);  // 這裡才開始可變借用

#[derive(Debug, Clone)]
enum Message {
    OpenFile,
    FileSelected(Option<PathBuf>),
    ComicLoaded(Result<Arc<dyn reader::ComicReader>, String>),
    NextPage,
    PrevPage,
    PagePreloaded(usize, Option<image::Handle>),
}

// 第一步：呼叫原生對話框
Message::OpenFile => {
    Task::perform(
        async {
            rfd::AsyncFileDialog::new()
                .add_filter("Comic Book Archive", &["cbz", "cbr", "cb7"])
                .pick_file()
                .await
                .map(|f| f.path().to_owned())
        },
        Message::FileSelected,  // 完成後產生 FileSelected(Option<PathBuf>)
    )
}
// 第二步：在執行緒池解壓縮並建立 Reader
Message::FileSelected(Some(path)) => Task::perform(
    async move { smol::unblock(move || reader::open(&path).map(Arc::from)).await },
    Message::ComicLoaded,  // 完成後產生 ComicLoaded(Result<Arc<...>, String>)
),

// 背景預載的單頁提取
let comic = Arc::clone(comic);
Task::perform(
    async move {
        let handle = smol::unblock(move || comic.extract_page(idx).ok()).await;
        (idx, handle)
    },
    |(idx, handle)| Message::PagePreloaded(idx, handle),
)

fn preload_adjacent(&self, around: usize) -> Task<Message> {
    let Some(comic) = &self.comic else { return Task::none(); };
    let page_count = comic.page_count();

    let start = around.saturating_sub(PRELOAD_LOOKAHEAD);  // 避免 usize 下溢
    let end = (around + PRELOAD_LOOKAHEAD).min(page_count - 1);

    let candidates: Vec<usize> = (start..=end)
        .filter(|&i| i != around && !self.page_cache.contains(i))
        .collect();

    if candidates.is_empty() {
        return Task::none();
    }

    let tasks: Vec<Task<Message>> = candidates
        .into_iter()
        .map(|idx| {
            let comic = Arc::clone(comic);
            Task::perform(
                async move {
                    let handle = smol::unblock(move || comic.extract_page(idx).ok()).await;
                    (idx, handle)
                },
                |(idx, handle)| Message::PagePreloaded(idx, handle),
            )
        })
        .collect();

    Task::batch(tasks)  // 並行啟動所有預載任務
}

let can_prev = self.current_page > 0;
let can_next = self
    .comic
    .as_ref()
    .is_some_and(|c| self.current_page + 1 < c.page_count());

let prev_btn = button(text("◄ Previous").size(14))
    .on_press_maybe((has_comic && can_prev).then_some(Message::PrevPage));

let next_btn = button(text("Next ►").size(14))
    .on_press_maybe((has_comic && can_next).then_some(Message::NextPage));

fn nav_button_style(_theme: &Theme, status: button::Status) -> button::Style {
    let bg = match status {
        button::Status::Hovered | button::Status::Pressed => iced::color!(0x565f89),
        button::Status::Disabled => iced::color!(0x292e42),  // 暗色，表示禁用
        _ => iced::color!(0x414868),
    };
    let text_color = match status {
        button::Status::Disabled => iced::color!(0x3d4168),  // 文字也變暗
        _ => iced::color!(0xc0caf5),
    };
    // ...
}

fn subscription(&self) -> Subscription<Message> {
    iced::keyboard::on_key_press(|key, _modifiers| match key.as_ref() {
        iced::keyboard::Key::Named(Named::ArrowRight)
        | iced::keyboard::Key::Named(Named::PageDown) => Some(Message::NextPage),
        iced::keyboard::Key::Named(Named::ArrowLeft)
        | iced::keyboard::Key::Named(Named::PageUp) => Some(Message::PrevPage),
        _ => None,
    })
}