use flate2::read::DeflateDecoder;
use flate2::write::DeflateEncoder;
use flate2::Compression;
use std::fs::File;
use std::io::{Read, Write};
use tempfile::tempfile;
const TEST_OUTPUT_SAMPLE_DIR: &str = "../resources/test/";

pub fn compress_string(input: &str) -> Vec<u8> {
    let mut encoder = DeflateEncoder::new(Vec::new(), Compression::default());
    encoder
        .write_all(input.as_bytes())
        .expect("Failed to write data");
    encoder.finish().expect("Failed to finish compression")
}

pub fn decompress_to_string(compressed_data: &[u8]) -> Result<String, std::io::Error> {
    let mut decoder = DeflateDecoder::new(compressed_data);
    let mut decompressed = String::new();
    decoder.read_to_string(&mut decompressed)?;
    Ok(decompressed)
}

/// Read a compressed test result and return the expected result
/// as a string
pub fn read_compressed_test_result(suffix: &str) -> String {
    let full_path = std::env::current_dir().unwrap().display().to_string()
        + "/"
        + &*TEST_OUTPUT_SAMPLE_DIR.to_owned()
        + suffix
        + ".deflated";
    println!("LOADING {}", full_path);
    let mut compressed_file = File::open(&full_path)
        .expect(format!("Unable to load test result [{}]", full_path.clone()).as_str());
    let mut compressed_data = Vec::new();
    compressed_file
        .read_to_end(&mut compressed_data)
        .expect("Unable to compress data");

    decompress_to_string(&compressed_data).unwrap()
}

pub fn load_compressed_result(suffix: &str) -> String {
    read_compressed_test_result(suffix)
}
pub fn read_test_result(suffix: &str) -> String {
    panic!("THIS SHOULD BE COMPRESSED.");
    // let full_path = TEST_OUTPUT_SAMPLE_DIR.to_owned() + suffix;
    // println!("READING TEST RESULTS FROM {}", full_path);
    // std::fs::read_to_string(full_path).unwrap()
}

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

fn load_result(to_load: &str) -> String {
    panic!("THIS SHOULD BE COMPRESSED.");
    // let full_path = format!(
    //     "{}/../resources/test/state/{}",
    //     std::env::current_dir().unwrap().display(),
    //     to_load
    // );
    // println!("CURRENT DIR: {:?}", std::env::current_dir());
    // println!("Loading state => (([{}]))", full_path);
    // std::fs::read_to_string(full_path).unwrap()
}

#[cfg(test)]
mod tests {
    use super::*;

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

    #[test]
    fn compression_round_trip() {
        let to_compress = "The quick brown fox jumps over the lazy dog.";

        let compressed_text = compress_string(to_compress);
        let decompressed_text = decompress_to_string(&compressed_text).unwrap();
        assert_eq!(to_compress, decompressed_text);
    }

    #[test]
    fn file_compression_round_trip() {
        // compress string to file...
        let string_to_compress = "The quick brown fox jumps over the lazy dog.";
        let compressed_string = compress_string(string_to_compress);
        let temp_target = tempfile().unwrap();

        //
        // ...decompress from file...
        //
        // ...verify its the same.
    }
}