pub use self::rom::Rom;
use self::{
    mmio::{
        apu::ApuSaveState,
        gpu::{Colour, GpuSaveState},
        serial::SerialSaveState,
        Apu, Gpu, Joypad, Serial, Timer,
    },
    rom::RomSaveState,
};
use crate::{
    connect::{AudioOutput, JoypadState, Renderer, SerialTarget},
    processor::SplitRegister,
    verbose_println, Cpu,
};

mod interrupts;
pub use interrupts::{Interrupt, Interrupts};
use serde::{Deserialize, Serialize};
pub mod mmio;
pub(crate) mod rom;

pub(crate) type Address = u16;

pub struct Memory<ColourFormat: From<Colour> + Clone> {
    bootrom: Option<Vec<u8>>,
    rom: Rom,
    ram: [u8; 8192],
    cpu_ram: [u8; 128],
    pub(super) interrupts: Interrupts,
    pub(super) ime: bool,
    pub(super) ime_scheduled: u8,
    dma_addr: u8,
    joypad: Joypad,
    gpu: Gpu<ColourFormat>,
    apu: Apu,
    serial: Serial,
    timers: Timer,
}

#[serde_with::serde_as]
#[derive(Serialize, Deserialize)]
pub struct MemorySaveState<ColourFormat: From<Colour> + Clone> {
    rom: RomSaveState,
    #[serde_as(as = "[_; 8192]")]
    ram: [u8; 8192],
    #[serde_as(as = "[_; 128]")]
    cpu_ram: [u8; 128],
    pub(super) interrupts: Interrupts,
    pub(super) ime: bool,
    pub(super) ime_scheduled: u8,
    dma_addr: u8,
    joypad: Joypad,
    gpu: GpuSaveState<ColourFormat>,
    apu: ApuSaveState,
    serial: SerialSaveState,
    timers: Timer,
}

impl<ColourFormat: From<Colour> + Clone> MemorySaveState<ColourFormat> {
    pub fn create(memory: &Memory<ColourFormat>) -> Self {
        Self {
            rom: RomSaveState::create(&memory.rom),
            ram: memory.ram,
            cpu_ram: memory.cpu_ram,
            interrupts: memory.interrupts,
            ime: memory.ime,
            ime_scheduled: memory.ime_scheduled,
            dma_addr: memory.dma_addr,
            joypad: memory.joypad,
            gpu: GpuSaveState::create(&memory.gpu),
            apu: ApuSaveState::create(&memory.apu),
            serial: SerialSaveState::create(&memory.serial),
            timers: memory.timers,
        }
    }
}

impl<ColourFormat: From<Colour> + Clone> Memory<ColourFormat> {
    pub fn init(
        bootrom: Option<Vec<u8>>,
        rom: Rom,
        window: Box<dyn Renderer<ColourFormat>>,
        output: AudioOutput,
        serial_target: SerialTarget,
        tile_window: Option<Box<dyn Renderer<ColourFormat>>>,
    ) -> Self {
        Self {
            bootrom,
            rom,
            ram: [0x0; 8192],
            cpu_ram: [0x0; 128],
            interrupts: Interrupts::default(),
            ime: false,
            ime_scheduled: 0x0,
            dma_addr: 0xFF,
            joypad: Joypad::default(),
            gpu: Gpu::new(window, tile_window),
            apu: Apu::new(output),
            serial: Serial::new(serial_target),
            timers: Timer::init(),
        }
    }

    pub fn get(&self, address: Address) -> u8 {
        match address {
            0x0..0x8000 => {
                // rom access
                // todo - switchable rom banks
                if let Some(bootrom) = &self.bootrom && (address as usize) < bootrom.len() {
                    bootrom[address as usize]
                } else {
                    self.rom.get(address)
                }
            }
            0x8000..0xA000 => self.gpu.vram.get(address),
            0xA000..0xC000 => {
                // cart ram
                self.rom.get_ram(address)
            }
            0xC000..0xE000 => self.ram[(address - 0xC000) as usize],
            0xE000..0xFE00 => self.ram[(address - 0xE000) as usize],
            0xFE00..0xFEA0 => self.gpu.oam.get(address),
            0xFEA0..0xFF00 => 0xFF,
            0xFF00..0xFF4C => self.get_io(address),
            0xFF4C..0xFF80 => 0xFF,
            0xFF80..0xFFFF => self.cpu_ram[(address - 0xFF80) as usize],
            0xFFFF => self.interrupts.get_enable_register(),
        }
    }

    pub fn set(&mut self, address: Address, data: u8) {
        match address {
            0x0..0x8000 => {
                // change this with MBC code...
                self.rom.set(address, data);
                if self.rom.can_rumble() {
                    // rumble
                    self.gpu.window.set_rumble(self.rom.is_rumbling())
                }
            }
            0x8000..0xA000 => self.gpu.vram.set(address, data),
            0xA000..0xC000 => self.rom.set_ram(address, data),
            0xC000..0xE000 => self.ram[(address - 0xC000) as usize] = data,
            0xE000..0xFE00 => self.ram[(address - 0xE000) as usize] = data,
            0xFE00..0xFEA0 => self.gpu.oam.set(address, data),
            0xFEA0..0xFF00 => {}
            0xFF00..0xFF4C => self.set_io(address, data),
            0xFF50 => self.bootrom = None,
            0xFF4C..0xFF50 | 0xFF51..0xFF80 => {}
            0xFF80..0xFFFF => self.cpu_ram[(address - 0xFF80) as usize] = data,
            0xFFFF => {
                verbose_println!("interrupts set to {:#b}", data);
                verbose_println!("                / {:#X}", data);
                self.interrupts.set_enable_register(data);
            }
        }
    }

    fn get_io(&self, address: Address) -> u8 {
        // range: 0xFF00 - 0xFF4B inclusive
        match address {
            0xFF00 => self.joypad.as_register(),
            0xFF01 => self.serial.get_queued(),
            0xFF02 => self.serial.get_control(),
            0xFF04 => self.timers.get_div(),
            0xFF05 => self.timers.get_tima(),
            0xFF06 => self.timers.get_tma(),
            0xFF07 => self.timers.get_timer_control(),
            0xFF0F => self.interrupts.get_flag_register(),
            0xFF10..0xFF40 => self.apu.get_register(address),
            0xFF40 => self.gpu.get_lcdc(),
            0xFF41 => self.gpu.get_lcd_status(),
            0xFF42 => self.gpu.get_scy(),
            0xFF43 => self.gpu.get_scx(),
            0xFF44 => self.gpu.get_ly(),
            0xFF45 => self.gpu.get_lyc(),
            0xFF46 => self.dma_addr,
            0xFF47 => self.gpu.get_bg_palette(),
            0xFF48 => self.gpu.get_obj_palette_0(),
            0xFF49 => self.gpu.get_obj_palette_1(),
            0xFF4A => self.gpu.get_wy(),
            0xFF4B => self.gpu.get_wx(),
            0xFF03 | 0xFF08..0xFF0F => 0xFF,
            0x0..0xFF00 | 0xFF4C..=0xFFFF => panic!("passed wrong address to get_io"),
        }
    }

    fn set_io(&mut self, address: Address, data: u8) {
        // range: 0xFF00 - 0xFF4B inclusive
        match address {
            0xFF00 => {
                // joypad
                self.joypad.mmio_write(data);
            }
            0xFF01 => self.serial.update_queued(data),
            0xFF02 => self.serial.update_control(data),
            0xFF04 => self.timers.update_div(),
            0xFF05 => self.timers.update_tima(data),
            0xFF06 => self.timers.update_tma(data),
            0xFF07 => self.timers.update_timer_control(data),
            0xFF0F => self.interrupts.set_flag_register(data),
            0xFF10..0xFF40 => self.apu.mmio_write(address, data),
            0xFF40 => self.gpu.update_lcdc(data),
            0xFF41 => self.gpu.update_lcd_status(data),
            0xFF42 => self.gpu.update_scy(data),
            0xFF43 => self.gpu.update_scx(data),
            0xFF45 => self.gpu.update_lyc(data),
            0xFF46 => {
                if data > 0xDF {
                    panic!("dma transfer out of bounds: {data:#X}");
                }
                self.dma_addr = data;
                let mut addr: u16 = 0x0;
                addr.set_high(data);
                for l in 0x0..0xA0 {
                    addr.set_low(l);
                    self.gpu.oam.data[l as usize] = self.get(addr);
                }
            }
            0xFF47 => self.gpu.update_bg_palette(data),
            0xFF48 => self.gpu.update_obj_palette_0(data),
            0xFF49 => self.gpu.update_obj_palette_1(data),
            0xFF4A => self.gpu.update_wy(data),
            0xFF4B => self.gpu.update_wx(data),
            0xFF03 | 0xFF08..0xFF0F | 0xFF44 => {
                // read-only addresses
                verbose_println!("BANNED write: {data:#X} to {address:#X}");
            }
            0x0..0xFF00 | 0xFF4C..=u16::MAX => panic!("passed wrong address to set_io"),
        }
    }

    pub fn update_pressed_keys(&mut self, latest_state: JoypadState) -> bool {
        self.joypad.update_pressed_keys(latest_state)
    }

    pub(super) fn cpu_ram_init(&mut self) {
        self.set(0xFF04, 0xAD);
        // self.set(0xFF10, 0x80);
        // self.set(0xFF11, 0xBF);
        // self.set(0xFF12, 0xF3);
        // self.set(0xFF14, 0xBF);
        // self.set(0xFF16, 0x3F);
        // self.set(0xFF19, 0xBF);
        // self.set(0xFF1A, 0x7F);
        // self.set(0xFF1B, 0xFF);
        // self.set(0xFF1C, 0x9F);
        // self.set(0xFF1E, 0xBF);
        // self.set(0xFF20, 0xFF);
        // self.set(0xFF23, 0xBF);
        // self.set(0xFF24, 0x77);
        // self.set(0xFF25, 0xF3);
        // self.set(0xFF26, 0xF1);
        self.set(0xFF40, 0x91);
        self.set(0xFF47, 0xFC);
        self.set(0xFF48, 0xFF);
        self.set(0xFF49, 0xFF);
        for i in 0xC000..0xE000 {
            self.set(i, if rand::random() { 0xFF } else { 0x00 });
        }
    }

    pub fn flush_rom(&mut self) {
        self.rom.flush();
    }

    pub fn is_audio_buffer_full(&self) -> bool {
        self.apu.is_buffer_full()
    }

    pub fn replace_output(&mut self, new: AudioOutput) {
        self.apu.replace_output(new);
    }

    pub fn from_save_state(
        state: MemorySaveState<ColourFormat>,
        data: Vec<u8>,
        window: Box<dyn Renderer<ColourFormat>>,
        output: AudioOutput,
        serial_target: SerialTarget,
    ) -> Self {
        Self {
            bootrom: None,
            rom: Rom::from_save_state(state.rom, data),
            ram: state.ram,
            cpu_ram: state.cpu_ram,
            interrupts: state.interrupts,
            ime: state.ime,
            ime_scheduled: state.ime_scheduled,
            dma_addr: state.dma_addr,
            joypad: state.joypad,
            gpu: Gpu::from_save_state(state.gpu, window, None),
            apu: Apu::from_save_state(state.apu, output),
            serial: Serial::from_save_state(state.serial, serial_target),
            timers: state.timers,
        }
    }
}

impl<ColourFormat: From<Colour> + Clone> Cpu<ColourFormat> {
    pub fn increment_timers(&mut self, machine_cycles: u8) {
        let steps = (machine_cycles as usize) * 4;

        let timer_return = self.memory.timers.tick(steps);

        for _ in 0..timer_return.num_apu_ticks {
            self.memory.apu.div_apu_tick();
        }

        if timer_return.timer_interrupt {
            self.memory.interrupts.set_interrupt(Interrupt::Timer, true);
        }

        self.memory.apu.tick(steps);

        let serial_interrupt = self.memory.serial.tick(steps, self.memory.ime);
        self.memory
            .interrupts
            .set_interrupt(Interrupt::Serial, serial_interrupt);

        let gpu_interrupts = self.memory.gpu.tick(steps);

        self.memory
            .interrupts
            .set_interrupt(Interrupt::Vblank, gpu_interrupts.vblank);
        self.memory
            .interrupts
            .set_interrupt(Interrupt::LcdStat, gpu_interrupts.lcd_stat);

        if gpu_interrupts.vblank {
            let latest_state = self.memory.gpu.window.latest_joypad_state();
            let joypad_interrupt = self.memory.update_pressed_keys(latest_state);
            self.memory
                .interrupts
                .set_interrupt(Interrupt::Joypad, joypad_interrupt);
        }
    }
}