mod test_utils;
use crate::test_utils::load_compressed_result;
use crate::test_utils::load_rom;
use gemma::chip8::computer::Chip8Computer;
use gemma::chip8::computer_manager::Chip8ComputerManager;
use gemma::chip8::quirk_modes::QuirkMode;
use gemma::chip8::quirk_modes::QuirkMode::{Chip8, SChipModern, XOChip};
use gemma::chip8::registers::Chip8Registers;
use gemma::constants::{CHIP8_VIDEO_MEMORY, TEST_ROM_ROOT};
use std::path::Path;

#[test]
fn smoke() {
    assert!(true)
}
#[test]
fn reset_clears_video() {
    let mut x = Chip8Computer::new();

    for i in 0..CHIP8_VIDEO_MEMORY {
        x.video_memory.poke(i as u16, i % 2 == 0);
    }

    x.reset(gemma::chip8::quirk_modes::QuirkMode::Chip8);
    x.video_memory.reset();

    assert_eq!(x.dump_video_to_string(), x.video_memory.format_as_string());

    for i in 0..CHIP8_VIDEO_MEMORY {
        assert!(!x.video_memory.peek(i as u16));
    }
}

#[test]
fn level1_test() {
    let mut x = Chip8Computer::new();
    let level_1_rom = load_rom("1-chip8-logo");
    x.load_bytes_to_memory(0x200, &level_1_rom);

    // run for 0x40 cycles
    while x.num_cycles < 0x40 {
        x.step_system();
    }
    assert_eq!(
        x.dump_video_to_string(),
        load_compressed_result("gemma_integration_level_1_test")
    );
}

#[test]
fn level2_test() {
    let mut x = Chip8Computer::new();
    // Load the IBM rom and run it.
    // it takes 39 cycles to get to the end so lets run it 40.
    x.load_bytes_to_memory(0x200, &load_rom("2-ibm-logo"));
    for _ in 0..40 {
        x.step_system();
    }
    // ...then verify that the current video memory of the chip-8
    // simulator matches what we expect it to be

    assert_eq!(
        x.dump_video_to_string(),
        load_compressed_result("gemma_integration_ibm_rom_output")
    );
}

#[test]
fn level3_test() {
    let mut x = Chip8Computer::new();

    x.load_bytes_to_memory(0x200, &load_rom("3-corax+"));
    for _ in 0..0x180 {
        x.step_system();
    }

    assert_eq!(
        x.dump_video_to_string(),
        load_compressed_result("gemma_integration_corax_plus")
    );
}

#[test]
fn level3_compressed_test() {
    let mut x = Chip8Computer::new();

    x.load_bytes_to_memory(0x200, &load_rom("3-corax+"));
    for _ in 0..0x180 {
        x.step_system();
    }

    assert_eq!(
        x.dump_video_to_string(),
        load_compressed_result("gemma_integration.corax_plus")
    );
}

#[test]
fn rps_test() {
    let mut x = Chip8Computer::new();
    x.load_bytes_to_memory(0x200, &load_rom("RPS"));
    for _ in 0..0xF0 {
        x.step_system();
    }
    assert_eq!(
        x.dump_video_to_string(),
        load_compressed_result("gemma_integration_rps_stage1")
    );
    x.keypad.push_key(0x01);
    for _ in 0..0x200 {
        x.step_system();
    }
    assert_eq!(
        x.dump_video_to_string(),
        load_compressed_result("gemma_integration_rps_stage2")
    );
}

#[test]
fn level4_test() {
    // flags
    let mut x = Chip8Computer::new();
    x.load_bytes_to_memory(0x200, &load_rom("4-flags"));
    for _ in 0..0x400 {
        x.step_system();
    }

    assert_eq!(
        x.dump_video_to_string(),
        load_compressed_result("gemma_integration_flags")
    );
}

#[test]
fn registers_equality() {
    let data_set: Vec<(Chip8Registers, Chip8Registers, bool)> = vec![
        (Chip8Registers::default(), Chip8Registers::default(), true),
        (
            Chip8Registers {
                registers: [
                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                    0x00, 0x00, 0x00,
                ],
                i_register: 0,
                pc: 0,
            },
            Chip8Registers {
                registers: [
                    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                    0x00, 0x00, 0x00,
                ],
                i_register: 0,
                pc: 0,
            },
            false,
        ),
    ];

    for (first, second, matches) in data_set.iter() {
        assert_eq!(first == second, *matches)
    }
}

#[test]
fn default_test() {
    let new_manager = Chip8ComputerManager::default();

    assert_eq!(new_manager.core_should_run, false);
    assert_eq!(new_manager.num_cycles(), 0);
    assert_eq!(new_manager.quirks_mode(), Chip8);
}

#[test]
fn quirks_mode_test() {
    let mut new_manager = Chip8ComputerManager::default();

    assert_eq!(new_manager.quirks_mode(), Chip8);

    new_manager.reset(QuirkMode::XOChip);

    assert_eq!(new_manager.quirks_mode(), XOChip);

    new_manager.reset(QuirkMode::SChipModern);

    assert_eq!(new_manager.quirks_mode(), SChipModern);

    new_manager.reset(Chip8);

    assert_eq!(new_manager.quirks_mode(), Chip8);
}

#[test]
fn load_rom_allows_starting() {
    let mut new_manager = Chip8ComputerManager::default();
    assert!(!new_manager.core_should_run);
    let p = TEST_ROM_ROOT.to_string() + "/1-chip8-logo.ch8";
    let full_path = Path::new(p.as_str());
    new_manager.load_new_program_from_disk_to_system_memory(full_path);
    assert!(new_manager.core_should_run)
}

#[test]
fn reset_clears_run_state() {
    let mut new_manager = Chip8ComputerManager::default();
    let p = format!(
        "{}/../resources/test/roms/1-chip8-logo.ch8",
        std::env::current_dir().unwrap().display()
    );
    new_manager.load_new_program_from_disk_to_system_memory(Path::new(p.as_str()));
    new_manager.reset(QuirkMode::Chip8);
    assert!(!new_manager.core_should_run);
}

#[test]
fn tick_when_ready() {
    let mut new_manager = Chip8ComputerManager::default();
    new_manager.load_new_program_from_disk_to_system_memory(Path::new(
        format!(
            "{}/../resources/test/roms/1-chip8-logo.ch8",
            std::env::current_dir().unwrap().display()
        )
        .as_str(),
    ));
    assert!(new_manager.core_should_run);
}

#[test]
fn tick_when_not_ready() {}

#[test]
fn tick_one_step_only() {}