mod test_utils;
use std::path::Path;
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::constants::TEST_ROM_ROOT;
use crate::test_utils::load_compressed_result;

/// Tests the ComputerManager structure

#[test]
fn smoke() {
    assert!(true)
}


#[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 start_stop_computer() {
    let mut computer = Chip8ComputerManager::new();

    assert_eq!(computer.core_should_run, false);
    computer.start();
    assert_eq!(computer.core_should_run, true);
    computer.step();
    assert_eq!(computer.core_should_run, true);
    computer.stop();
    assert_eq!(computer.core_should_run, false);
    computer.reset(Chip8);
    assert_eq!(computer.core_should_run, false);
}


#[test]
fn state_default_matches() {
    let computer = Chip8Computer::default();
    let mut manager = Chip8ComputerManager::default();
    assert_eq!(computer, *manager.state());
}

#[test]
fn keys_test_manager() {
    let mut manager = Chip8ComputerManager::default();

    for i in 0..16 {
        assert_eq!(manager.is_key_pressed(i), false);
    }

    // press key 5
    manager.press_key(5);
    assert_eq!(manager.is_key_pressed(5), true);
    manager.release_key(5);
    assert_eq!(manager.is_key_pressed(5), false);
}

#[test]
#[ignore]
fn status_of_manager() {
    let mut manager = Chip8ComputerManager::default();
    println!("MANAGER STATUS [{}]", manager.status_as_string());
    let expected_state = load_compressed_result("test_manager_status");
    assert_eq!(expected_state, manager.status_as_string());
}