struct CPU {
    register_a: u8,
    register_x: u8,
    // ... other registers (SP, Y, etc.)
    program_counter: u16,
    memory: Vec<u8>, // Simulating memory for demonstration
}

impl CPU {
    // A simplified memory read function
    fn read_byte(&self, address: u16) -> u8 {
        self.memory[address as usize] // Basic direct access for example
    }

    fn run(&mut self) {
        loop {
            let opcode = self.read_byte(self.program_counter);
            self.program_counter += 1;

            match opcode {
                // LDA (Load Accumulator) opcodes
                0xA9 => self.lda_immediate(),     // LDA #$NN
                0xA5 => self.lda_zero_page(),     // LDA $NN
                0xB5 => self.lda_zero_page_x(),   // LDA $NN,X
                0xAD => self.lda_absolute(),      // LDA $NNNN
                0xBD => self.lda_absolute_x(),    // LDA $NNNN,X
                0xB9 => self.lda_absolute_y(),    // LDA $NNNN,Y
                0xA1 => self.lda_indexed_indirect(), // LDA ($NN,X)
                0xB1 => self.lda_indirect_indexed(), // LDA ($NN),Y

                // Other opcodes would go here...
                // _ => panic!("Unhandled opcode: {:X}", opcode), // For robust emulation
            }
            // In a real emulator, you'd handle cycles, interrupts, etc. here.
        }
    }
}

impl CPU {
    // Handles LDA with Immediate Addressing Mode
    fn lda_immediate(&mut self) {
        let operand = self.read_byte(self.program_counter);
        self.program_counter += 1; // Advance PC after reading operand
        self.register_a = operand;
        // ... (update flags based on operand)
    }

    // Handles LDA with Zero Page Addressing Mode
    fn lda_zero_page(&mut self) {
        let zero_page_address = self.read_byte(self.program_counter) as u16;
        self.program_counter += 1; // Advance PC after reading address byte
        let operand = self.read_byte(zero_page_address);
        self.register_a = operand;
        // ... (update flags)
    }

    // Handles LDA with Zero Page, X Addressing Mode
    fn lda_zero_page_x(&mut self) {
        let base_zero_page_address = self.read_byte(self.program_counter) as u16;
        self.program_counter += 1; // Advance PC
        // Note: Zero Page indexed addressing wraps around 0xFF
        let effective_address = base_zero_page_address.wrapping_add(self.register_x as u16) & 0xFF; // Only lower 8 bits for ZP
        let operand = self.read_byte(effective_address);
        self.register_a = operand;
        // ... (update flags)
    }
    // ... many more lda_* functions for other modes (absolute, indirect, etc.)
}

#[derive(Debug)]
pub enum AddressingMode {
    Immediate,
    ZeroPage,
    ZeroPageX,
    ZeroPageY,
    Absolute,
    AbsoluteX,
    AbsoluteY,
    IndirectX,
    IndirectY,
    Indirect, // Exclusive to JMP opcodes
    Relative, // Exclusive to Branch opcodes
    None,
}

pub struct Opcode {
    pub value: u8,
    pub name: &'static str, // Instruction mnemonic, e.g., "LDA"
    pub size: u8,           // Number of bytes the opcode occupies (opcode + operand bytes)
    pub cycles: u8,         // Base CPU cycles for this opcode (excluding page cross penalties)
    pub mode: AddressingMode, // The addressing mode used by this opcode
}

impl Opcode {
    pub const fn new(
        value: u8,
        name: &'static str,
        size: u8,
        cycles: u8,
        mode: AddressingMode,
    ) -> Self {
        Self {
            value,
            name,
            cycles,
            size,
            mode,
        }
    }
}

use std::collections::HashMap;
use once_cell::sync::Lazy;

const OPCODES: &[Opcode] = &[

    // --- LDA opcodes ---
    Opcode::new(0xA9, "LDA", 2, 2, AddressingMode::Immediate),
    Opcode::new(0xA5, "LDA", 2, 3, AddressingMode::ZeroPage),
    Opcode::new(0xB5, "LDA", 2, 4, AddressingMode::ZeroPageX),
    Opcode::new(0xAD, "LDA", 3, 4, AddressingMode::Absolute),
    Opcode::new(0xBD, "LDA", 3, 4, AddressingMode::AbsoluteX),
    Opcode::new(0xB9, "LDA", 3, 4, AddressingMode::AbsoluteY),
    Opcode::new(0xA1, "LDA", 2, 6, AddressingMode::IndirectX),
    Opcode::new(0xB1, "LDA", 2, 5, AddressingMode::IndirectY),

    // --- Other Instructions (Example) ---
    Opcode::new(0xAA, "TAX", 1, 2, AddressingMode::Implied), // Transfer A to X
    Opcode::new(0x00, "BRK", 1, 7, AddressingMode::Implied), // Break
    Opcode::new(0xEA, "NOP", 1, 2, AddressingMode::Implied), // No Operation
    Opcode::new(0x4C, "JMP", 3, 3, AddressingMode::Absolute), // Jump Absolute
    Opcode::new(0x6C, "JMP", 3, 5, AddressingMode::Indirect), // Jump Indirect (with bug)
    Opcode::new(0x90, "BCC", 2, 2, AddressingMode::Relative), // Branch if Carry Clear

    // ... many, many more opcodes for a full 6502 implementation
];

pub static OPCODES_MAP: Lazy<HashMap<u8, &'static Opcode>> = Lazy::new(|| {
    let mut map = HashMap::new();
    for opcode in OPCODES {
        map.insert(opcode.value, opcode);
    }
    map
});

impl CPU {

    // A helper to read a 16-bit word from memory (Little Endian)
    fn read_word(&self, address: u16) -> u16 {
        let lo = self.read_byte(address) as u16;
        let hi = self.read_byte(address.wrapping_add(1)) as u16;
        (hi << 8) | lo
    }

    /// Calculates the effective memory address based on the provided addressing mode.
    /// Returns the calculated address and a boolean indicating if a page boundary was crossed.
    fn get_operand_address(&mut self, mode: &AddressingMode) -> (u16, bool) {
        match mode {
            AddressingMode::Immediate => {
                // Operand is the byte directly after the opcode.
                // PC already points to this byte before advancement.
                let addr = self.program_counter;
                self.program_counter = self.program_counter.wrapping_add(1); // Advance PC
                (addr, false)
            }
            AddressingMode::ZeroPage => {
                let zero_page_addr = self.read_byte(self.program_counter) as u16;
                self.program_counter = self.program_counter.wrapping_add(1);
                (zero_page_addr, false)
            }
            AddressingMode::ZeroPageX => {
                let zero_page_base = self.read_byte(self.program_counter);
                self.program_counter = self.program_counter.wrapping_add(1);
                let effective_addr = zero_page_base.wrapping_add(self.register_x);
                (effective_addr as u16, false) // Zero page addresses are always 8-bit, so no page crossing
            }
            AddressingMode::ZeroPageY => {
                let zero_page_base = self.read_byte(self.program_counter);
                self.program_counter = self.program_counter.wrapping_add(1);
                let effective_addr = zero_page_base.wrapping_add(self.register_y);
                (effective_addr as u16, false)
            }
            AddressingMode::Absolute => {
                let addr = self.read_word(self.program_counter);
                self.program_counter = self.program_counter.wrapping_add(2); // Read two bytes
                (addr, false)
            }
            AddressingMode::AbsoluteX => {
                let base_addr = self.read_word(self.program_counter);
                self.program_counter = self.program_counter.wrapping_add(2);
                let effective_addr = base_addr.wrapping_add(self.register_x as u16);
                let page_crossed = (base_addr & 0xFF00) != (effective_addr & 0xFF00);
                (effective_addr, page_crossed)
            }
            AddressingMode::AbsoluteY => {
                let base_addr = self.read_word(self.program_counter);
                self.program_counter = self.program_counter.wrapping_add(2);
                let effective_addr = base_addr.wrapping_add(self.register_y as u16);
                let page_crossed = (base_addr & 0xFF00) != (effective_addr & 0xFF00);
                (effective_addr, page_crossed)
            }
            AddressingMode::IndirectX => {
                let zero_page_idx = self.read_byte(self.program_counter);
                self.program_counter = self.program_counter.wrapping_add(1);

                // Add X to the zero-page index, wrapping within the zero page
                let ptr_base = zero_page_idx.wrapping_add(self.register_x);

                // Read the actual 16-bit address from the zero page
                // The HI byte is read from ptr_base + 1, *wrapping within zero page*
                let lo = self.read_byte(ptr_base as u16) as u16;
                let hi = self.read_byte(ptr_base.wrapping_add(1) as u16) as u16; // Zero-page wrap

                let effective_addr = (hi << 8) | lo;
                (effective_addr, false) // IndirectX itself doesn't cause page cross penalty for operand fetch
            }
            AddressingMode::IndirectY => {
                let zero_page_addr = self.read_byte(self.program_counter);
                self.program_counter = self.program_counter.wrapping_add(1);

                // Read the base 16-bit address from the zero page (handles zero-page wrap for high byte)
                let lo = self.read_byte(zero_page_addr as u16) as u16;
                let hi = self.read_byte(zero_page_addr.wrapping_add(1) as u16) as u16; // Zero-page wrap
                let base_ptr = (hi << 8) | lo;

                // Add Y to this 16-bit pointer
                let effective_addr = base_ptr.wrapping_add(self.register_y as u16);
                let page_crossed = (base_ptr & 0xFF00) != (effective_addr & 0xFF00);
                (effective_addr, page_crossed)
            }
            AddressingMode::Indirect => {
                // NOTE: Only used by JMP. This mode has a famous bug on real 6502 hardware
                // if the indirect vector falls on a page boundary (e.g., $xxFF).
                // In such cases, the LSB is fetched from $xxFF, but the MSB is fetched from $xx00.
                let indirect_vec_addr = self.read_word(self.program_counter);
                self.program_counter = self.program_counter.wrapping_add(2);

                let effective_addr = if indirect_vec_addr & 0x00FF == 0x00FF {
                    // Page boundary bug: high byte from $xx00
                    let lo = self.read_byte(indirect_vec_addr) as u16;
                    let hi = self.read_byte(indirect_vec_addr & 0xFF00) as u16;
                    (hi << 8) | lo
                } else {
                    self.read_word(indirect_vec_addr)
                };
                (effective_addr, false) // Indirect JMP doesn't incur page crossing penalty for *itself*
            }
            AddressingMode::Relative => {
                // Used by branch instructions.
                // The offset is a signed 8-bit value, relative to PC + 2 (opcode + 1 byte operand)
                let offset = self.read_byte(self.program_counter) as i8;
                self.program_counter = self.program_counter.wrapping_add(1); // Read offset byte

                // Branch target is calculated relative to the *address of the next instruction*
                let base_pc_for_branch = self.program_counter;
                let addr = base_pc_for_branch.wrapping_add_signed(offset as i16);
                let page_crossed = (base_pc_for_branch & 0xFF00) != (addr & 0xFF00);
                (addr, page_crossed)
            }
        }
    }
    // ...
}

impl CPU {
    /// Executes the LDA instruction, handling all its addressing modes.
    fn lda(&mut self, opcode: &Opcode) {
        let (address, page_crossed) = self.get_operand_address(&opcode.mode);

        let operand = self.read_byte(address);
        self.register_a = operand;

        // Update CPU flags based on the value loaded into A
        self.update_zero_and_negative_flags(self.register_a);

        // Crucial for cycle accuracy: Add a penalty if a page was crossed
        if page_crossed {
            self.add_cycles(1); // Add 1 cycle for page cross penalty
        }
    }

    // Placeholders
    fn update_zero_and_negative_flags(&mut self, value: u8) { /* ... */ }
    fn add_cycles(&mut self, cycles: u8) { /* ... */ }
}

impl CPU {
    // ...
    fn run(&mut self) {
        loop {
            let opcode_value = self.read_byte(self.program_counter);
            self.program_counter += 1; // Advance PC past the opcode byte

            // Look up the opcode's details from our global map
            let opcode = OPCODES_MAP.get(&opcode_value).expect(&format!("Unknown opcode: {:X}", opcode_value));

            // Execute the instruction based on its name (mnemonic)
            match opcode.name {
                "LDA" => self.lda(opcode),
                "TAX" => self.tax(opcode), // Example for another instruction
                "JMP" => self.jmp(opcode), // Example for JMP with its own mode handler
                "BCC" => self.bcc(opcode), // Example for branch instructions
                // ... many more instruction matches for a full CPU
                _ => panic!("Instruction not yet implemented: {}", opcode.name),
            }

            // After executing the instruction and advancing PC for the operand(s),
            // update total cycles. Page cross penalties are handled within instruction functions.
            self.add_cycles(opcode.cycles);

            // In a full emulator, this loop would also handle
            // interrupts, external events, etc.
        }
    }

    // Placeholder for other instruction implementations
    fn tax(&mut self, opcode: &Opcode) { /* ... */ }
    fn jmp(&mut self, opcode: &Opcode) { /* ... */ }
    fn bcc(&mut self, opcode: &Opcode) { /* ... */ }
}