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

struct Player<'a> {
    weapon: &'a mut Weapon,  // ← lifetime 要標
}

struct World<'a> {
    player: Player<'a>,
    weapons: Vec<Weapon>,     // ← player.weapon 借自這裡？
    // 🔴 weapons 和 player 不能同時存在於 World 裡
}

fn movement_system(mut query: Query<(&mut Position, &Velocity)>) {
    for (mut pos, vel) in &mut query {
        pos.x += vel.x;
        pos.y += vel.y;
    }
}

pub struct System {
    pub cpu: Cpu,                           // CPU 獨佔擁有
    pub ppu: Rc<RefCell<Ppu>>,              // 共享擁有
    pub apu: Rc<RefCell<Apu>>,              // 共享擁有
    pub joypad1: Rc<RefCell<Joypad>>,       // 共享擁有
    cpu_cycles: Rc<Cell<u64>>,              // 共享計數器
    ppu_cycles: Rc<Cell<u64>>,              // 共享計數器
}

fn step(&mut self) {
    // ... 執行 CPU 指令 ...

    // 借用 APU 來 tick
    let mut apu = self.apu.borrow_mut();
    for _ in 0..total_cpu_cycles {
        apu.tick();
    }

    // DMC 需要從 CPU bus 讀資料
    if let Some(addr) = apu.dmc_sample_request() {
        drop(apu);  // ← 先還回去！
        let val = self.cpu.bus.read(addr);  // 現在可以用 Bus 了
        let mut apu = self.apu.borrow_mut();  // 重新借
        apu.dmc_load_sample(val);
    }
}

// Cell — 直接 get/set，沒有借用追蹤
self.cpu_cycles.set(self.cpu.cycles);
let ppu_cycles = self.ppu_cycles.get();

// RefCell — 需要 borrow/borrow_mut，有執行期開銷
let mut ppu = self.ppu.borrow_mut();
ppu.tick();

// 🔴 編譯錯誤：NesSystem 不是 Send
fn my_system(nes: ResMut<NesSystem>) { ... }

// ✅ 編譯通過：Bevy 保證只在主執行緒執行
fn run_emulation_frame(
    mut nes: NonSendMut<NesSystem>,
    nes_input: Res<NesInput>,
    audio_buf: Res<AudioBuffer>,
    // ...
) {
    nes.sys.joypad1.borrow_mut().set_buttons(nes_input.0);
    nes.sys.run_until_frame();
}

#[derive(Resource, Clone)]
pub struct AudioBuffer {
    pub buffer: Arc<Mutex<VecDeque<f32>>>,
}

pub fn setup_emulation(world: &mut World) {
    let rom_path = world.resource::<RomPath>();
    let rom = std::fs::read(&rom_path.0).expect("Failed to read ROM");
    let sys = System::new(rom, sample_rate);

    world.insert_non_send_resource(NesSystem {
        sys,
        paused: false,
        accumulator: 0.0,
    });
}

pub struct CrtPlugin;

impl Plugin for CrtPlugin {
    fn build(&self, app: &mut App) {
        load_internal_asset!(app, CRT_SHADER_HANDLE,
            "../assets/shaders/crt.wgsl", Shader::from_wgsl);
        app.add_plugins(Material2dPlugin::<CrtMaterial>::default());
    }
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins.set(WindowPlugin { ... }))
        .add_plugins(CrtPlugin)
        .add_plugins(DebugUiPlugin)
        .insert_resource(AudioBuffer { ... })
        .insert_resource(NesInput(0))
        .add_systems(Startup, (setup_emulation, setup_video, setup_audio).chain())
        .add_systems(Update, (read_input, run_emulation_frame).chain())
        .run();
}

#[derive(Asset, TypePath, AsBindGroup, Debug, Clone)]
pub struct CrtMaterial {
    #[uniform(0)]
    pub params: LinearRgba,
    #[texture(1)]
    #[sampler(2)]
    pub source_texture: Option<Handle<Image>>,
}

impl Material2d for CrtMaterial {
    fn fragment_shader() -> ShaderRef {
        CRT_SHADER_HANDLE.into()
    }
}

@group(2) @binding(0) var<uniform> params: vec4<f32>;
@group(2) @binding(1) var source_texture: texture_2d<f32>;
@group(2) @binding(2) var source_sampler: sampler;

class BusDevice {
public:
    virtual uint8_t read(uint16_t addr) = 0;
    virtual void write(uint16_t addr, uint8_t val) = 0;
};

pub trait BusIo {
    fn read(&mut self, addr: u16) -> u8;
    fn write(&mut self, addr: u16, val: u8);
}

pub struct ApuCompositeBusIo {
    pub inner: CompositeBusIo,       // PPU + Joypad
    pub apu: Rc<RefCell<Apu>>,
}

impl BusIo for ApuCompositeBusIo {
    fn read(&mut self, addr: u16) -> u8 {
        match addr {
            0x4015 => self.apu.borrow_mut().read_register(addr),
            _ => self.inner.read(addr),
        }
    }
}

const NTSC_FRAME_SECS: f64 = 1.0 / 60.0988;

pub fn run_emulation_frame(
    mut nes: NonSendMut<NesSystem>,
    time: Res<Time>,
    audio_buf: Res<AudioBuffer>,
    // ...
) {
    if nes.paused {
        nes.accumulator = 0.0;
        return;
    }

    nes.accumulator += time.delta_secs_f64();
    // 防止 spiral of death：最多追趕 4 幀
    nes.accumulator = nes.accumulator.min(NTSC_FRAME_SECS * 4.0);

    let mut frames_run = 0;
    while nes.accumulator >= NTSC_FRAME_SECS {
        nes.sys.joypad1.borrow_mut().set_buttons(nes_input.0);
        nes.sys.run_until_frame();

        // 把 APU 產生的 sample 送到音訊 ring buffer
        let samples = nes.sys.apu.borrow_mut().drain_samples();
        if let Ok(mut buf) = audio_buf.buffer.lock() {
            if buf.len() < 8192 {
                buf.extend(samples.iter());
            }
        }

        nes.accumulator -= NTSC_FRAME_SECS;
        frames_run += 1;
    }

    if frames_run > 0 {
        // 把 PPU framebuffer 複製到 GPU 材質
        copy_framebuffer_to_texture(&nes, &mut images, &fb_handle);
    }
}

pub fn setup_emulation(world: &mut World) {
    // exclusive world access，只在初始化時呼叫一次
    let sys = System::new(rom, sample_rate);
    world.insert_non_send_resource(NesSystem {
        sys,
        paused: false,
        accumulator: 0.0,
    });
}

fn copy_framebuffer_to_texture(nes: &NesSystem, images: &mut Assets<Image>, handle: &FramebufferHandle) {
    let ppu = nes.sys.ppu.borrow();
    let fb = ppu.framebuffer();
    if let Some(image) = images.get_mut(&handle.0) {
        for (i, &color) in fb.iter().enumerate() {
            let (r, g, b) = PALETTE[color as usize];
            image.data[i * 4]     = r;
            image.data[i * 4 + 1] = g;
            image.data[i * 4 + 2] = b;
            image.data[i * 4 + 3] = 255;
        }
    }
}

fn barrel_distort(uv: vec2<f32>, curvature: f32) -> vec2<f32> {
    let centered = uv - 0.5;
    let dist = dot(centered, centered);
    let distorted = centered * (1.0 + dist * curvature);
    return distorted + 0.5;
}

let scanline = 1.0 - scanline_intensity * 0.5 * (1.0 - cos(uv.y * 240.0 * 3.14159));

let mask_pos = i32(uv.x * 768.0) % 3;
var mask = vec3<f32>(0.8, 0.8, 0.8);
if mask_pos == 0 { mask.r = 1.0; }
else if mask_pos == 1 { mask.g = 1.0; }
else { mask.b = 1.0; }

let vignette = 1.0 - vignette_intensity * dot(centered, centered) * 2.0;

pub fn setup_audio(mut commands: Commands) {
    let buffer = Arc::new(Mutex::new(VecDeque::with_capacity(4096)));
    let buf_clone = buffer.clone();

    let stream = device.build_output_stream(
        &config,
        move |data: &mut [f32], _| {
            let mut buf = buf_clone.lock().unwrap();
            for frame in data.chunks_mut(channels) {
                let sample = buf.pop_front().unwrap_or(0.0);
                for ch in frame.iter_mut() {
                    *ch = sample;
                }
            }
        },
        |err| eprintln!("Audio error: {err}"),
        None,
    ).unwrap();
    // ...
}

pub fn read_input(
    keyboard: Res<ButtonInput<KeyCode>>,
    gamepads: Query<&Gamepad>,
    mut nes_input: ResMut<NesInput>,
) {
    let mut state = 0u8;

    // 鍵盤
    if keyboard.pressed(KeyCode::ArrowUp)   { state |= 1 << 4; }
    if keyboard.pressed(KeyCode::ArrowDown) { state |= 1 << 5; }
    if keyboard.pressed(KeyCode::KeyZ)      { state |= 1 << 0; } // A
    if keyboard.pressed(KeyCode::KeyX)      { state |= 1 << 1; } // B

    // 手把（第一支）
    if let Some(gamepad) = gamepads.iter().next() {
        if gamepad.pressed(GamepadButton::DPadUp) { state |= 1 << 4; }
        // 類比搖桿 → 方向鍵（deadzone 0.5）
        if let Some(axis) = gamepad.get(GamepadAxis::LeftStickY) {
            if axis > 0.5 { state |= 1 << 4; }  // up
            if axis < -0.5 { state |= 1 << 5; }  // down
        }
        // ...
    }

    nes_input.0 = state;
}

pub fn save(nes: &NesSystem, path: &Path) -> Result<Vec<u8>> {
    let mut cpu_state = Vec::new();
    nes.sys.cpu.save_state(&mut cpu_state);

    let mut ppu_state = Vec::new();
    nes.sys.ppu.borrow().save_state(&mut ppu_state);

    let mut apu_state = Vec::new();
    nes.sys.apu.borrow().save_state(&mut apu_state);

    // ... mapper, joypad ...

    let state = NesState {
        version: 2,
        cpu: &cpu_state,
        ram: &ram_data,
        mapper: &mapper_state,
        ppu: &ppu_state,
        apu: &apu_state,
        // ...
    };

    let mut builder = planus::Builder::new();
    let offset = state.prepare(&mut builder);
    builder.finish(offset, None);
    Ok(builder.as_slice().to_vec())
}

const DUTY_TABLE: [[u8; 8]; 4] = [
    [0, 0, 0, 0, 0, 0, 0, 1], // 12.5%
    [0, 0, 0, 0, 0, 0, 1, 1], // 25%
    [0, 0, 0, 0, 1, 1, 1, 1], // 50%
    [1, 1, 1, 1, 1, 1, 0, 0], // 75%
];

pub fn tick(&mut self, timer_period: u16) -> Option<u16> {
    let target = self.target_period(timer_period);
    let muted = timer_period < 8 || target > 0x7FF;

    if self.divider == 0 && self.enabled && self.shift > 0 && !muted {
        Some(target)
    } else {
        if self.divider == 0 || self.reload {
            self.divider = self.period;
            self.reload = false;
        } else {
            self.divider -= 1;
        }
        None
    }
}

pub enum NegateMode {
    OnesComplement,  // Pulse 1：-change - 1
    TwosComplement,  // Pulse 2：-change
}

pub fn output(&self) -> u8 {
    TRIANGLE_TABLE[self.sequence_pos as usize]
}

pub fn tick(&mut self) {
    if self.length_counter.value() > 0 && self.linear_counter > 0 {
        self.sequence_pos = (self.sequence_pos + 1) % 32;
    }
}

pub fn tick(&mut self) {
    if self.timer == 0 {
        self.timer = self.timer_period;

        let bit = if self.mode {
            (self.shift & 1) ^ ((self.shift >> 6) & 1)  // 短模式
        } else {
            (self.shift & 1) ^ ((self.shift >> 1) & 1)  // 長模式
        };

        self.shift >>= 1;
        self.shift |= bit << 14;
    } else {
        self.timer -= 1;
    }
}

pub fn output(&self) -> u8 {
    if self.shift & 1 == 1 || self.length_counter.value() == 0 {
        0
    } else {
        self.envelope.output()
    }
}

const NOISE_PERIOD_TABLE: [u16; 16] = [
    4, 8, 16, 32, 64, 96, 128, 160,
    202, 254, 380, 508, 762, 1016, 2034, 4068,
];

pub fn tick(&mut self) {
    if self.start {
        self.start = false;
        self.decay_level = 15;
        self.divider = self.divider_period;
    } else if self.divider == 0 {
        self.divider = self.divider_period;
        if self.decay_level > 0 {
            self.decay_level -= 1;
        } else if self.loop_flag {
            self.decay_level = 15;  // 循環：回到最大音量
        }
    } else {
        self.divider -= 1;
    }
}

pub fn tick(&mut self) -> Option<u16> {
    let mut sample_request = None;

    if self.timer == 0 {
        self.timer = self.timer_period;

        if self.bits_remaining > 0 {
            if self.shift_register & 1 == 1 {
                if self.output_level <= 125 {
                    self.output_level += 2;  // bit=1: 音量 +2
                }
            } else {
                if self.output_level >= 2 {
                    self.output_level -= 2;  // bit=0: 音量 -2
                }
            }
            self.shift_register >>= 1;
            self.bits_remaining -= 1;
        }

        // 需要新的 sample byte
        if self.bits_remaining == 0 && self.bytes_remaining > 0 {
            sample_request = Some(self.current_address);
            // ...
        }
    } else {
        self.timer -= 1;
    }

    sample_request
}

const DMC_RATE_TABLE: [u16; 16] = [
    428, 380, 340, 320, 286, 254, 226, 214,
    190, 160, 142, 128, 106, 84, 72, 54,
];

pub fn tick(&mut self) -> FrameEvent {
    self.cycle += 1;

    let event = if self.mode == 0 {
        // 4-step mode
        match self.cycle {
            3729 => FrameEvent::quarter(),
            7457 => FrameEvent::quarter_and_half(),
            11186 => FrameEvent::quarter(),
            14914 => { /* set IRQ if not inhibited */ }
            14915 => {
                self.cycle = 0;
                FrameEvent::quarter_and_half()
            }
            _ => FrameEvent::none(),
        }
    } else {
        // 5-step mode
        match self.cycle {
            3729 => FrameEvent::quarter(),
            7457 => FrameEvent::quarter_and_half(),
            11186 => FrameEvent::quarter(),
            18641 => {
                self.cycle = 0;
                FrameEvent::quarter_and_half()
            }
            _ => FrameEvent::none(),
        }
    };

    event
}

impl Mixer {
    pub fn new() -> Self {
        let mut pulse_table = [0.0f32; 31];
        for n in 1..31 {
            pulse_table[n] = 95.52 / (8128.0 / n as f32 + 100.0);
        }

        let mut tnd_table = [0.0f32; 203];
        for n in 1..203 {
            tnd_table[n] = 163.67 / (24329.0 / n as f32 + 100.0);
        }

        Self { pulse_table, tnd_table }
    }
}

pub fn tick(&mut self) {
    // ... tick 各聲道 ...

    self.sample_counter += 1.0;
    if self.sample_counter >= self.sample_period {
        self.sample_counter -= self.sample_period;

        let mixed = self.mixer.mix(p1, p2, tri, noise, dmc);

        // 一階高通濾波，去除 DC offset
        let filtered = self.hpf_alpha * (self.hpf_prev_out + mixed - self.hpf_prev_in);
        self.hpf_prev_in = mixed;
        self.hpf_prev_out = filtered;

        self.sample_buffer.push(filtered);
    }
}

fn step(&mut self) {
    // APU tick
    self.apu.borrow_mut().tick();

    // 檢查 DMC 是否需要 sample
    if let Some(addr) = self.apu.borrow().dmc_sample_request() {
        let val = self.cpu.bus_read(addr); // 從 CPU memory 讀取
        self.apu.borrow_mut().dmc_load_sample(val);
        // 真實硬體這裡會偷 4 個 CPU cycle
    }

    // 檢查 APU 的 IRQ
    if self.apu.borrow().irq_pending() {
        self.cpu.irq();
    }
}

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
}