use std::fs::File;
use flate2::write::{GzDecoder, GzEncoder};
use flate2::Compression;
use gemma::chip8::computer::Chip8Computer;
use gemma::chip8::util::InstructionUtil;
use std::io;
use std::io::prelude::*;

fn load_result(to_load: &str) -> String {
    let full_path = format!("../resources/test/state/{}", to_load);
    println!("Loading state => (([{}]))", full_path);
    std::fs::read_to_string(full_path).unwrap()
}

fn load_compressed_result(file_path: &str) -> io::Result<String> {
    let full_path = format!("../resources/test/state/{}", file_path);
    println!(
        "ATTEMPTING TO LOAD {} AS A COMPRESSED TEST RESULT.",
        full_path
    );
    InstructionUtil::decompress_file_to_string(full_path)
}

fn load_rom(to_load: &str) -> Vec<u8> {
    std::fs::read(format!("resources/test/roms/{}", to_load)).unwrap()
}

#[test]
fn test_serialization_round_trip() {
    let original_computer = Chip8Computer::new();
    let expected_json = load_result("smoke_001_round_trip_serialize_deserialize.json");

    // Serialize the Chip8Computer instance
    let serialized = Chip8Computer::serialize(&original_computer);
    let deserialized = Chip8Computer::deserialize(expected_json.clone());

    // Compare the serialized output to the expected JSON
    println!("Serialized Output: [{}]", serialized);

    assert_eq!(
        serialized.trim(),
        expected_json.clone().trim(),
        "Serialized output does not match expected JSON"
    );

    // Deserialize back to Chip8Computer and assert equality
    assert_eq!(
        deserialized, original_computer,
        "Deserialized instance does not match the original"
    );
}

#[test]
fn computer_001_system_zero_state() {
    let x = Chip8Computer::new();
    let expected_string = load_compressed_result("computer_001_system_zero_state.tct")
        .expect("Unable to read result");
    let serialized = x.serialize();
    assert_eq!(serialized, expected_string);
}