use dekejit::assembler::parser;
use dekejit::cli::{Cli, Subc::*};
use dekejit::cpu::IOBuffer;
use dekejit::cpu::CPU;
use dekejit::pretty_printers::*;

use clap::Parser;
use dekejit::loader::loader::read_binary;
use dekejit::loader::loader::{self, prepare_memory};
use dekejit::transmute_to_vecu8_as_is;
use log::{debug, info};

fn main() {
    let cli: Cli = Cli::parse();

    let loglevel = match cli.debug {
        0 => log::Level::Error,
        1 => log::Level::Warn,
        2 => log::Level::Info,
        3 => log::Level::Debug,
        _ => log::Level::Trace,
        // anything higher than 4 or equal is trace.
    };

    simple_logger::init_with_level(loglevel).unwrap();

    match cli.comm {
        Some(Run { filename }) => {
            info!("Trying to read {}", filename);

            let Ok(content) = std::fs::read(&filename) else {
                println!("File {} does not exist or cannot be read.", &filename);
                return;
            };

            let bytes = dekejit::transmute_to_vecu16_as_is(content.to_vec());

            info!("Begin parsing file {}", &filename);
            let sections = match read_binary(&bytes) {
                Ok(k) => k,
                Err(p) => {
                    println!("Parsing error: {:?}", p);
                    return;
                }
            };

            let bin = prepare_memory(sections);

            // trace!("{:?}", bin);

            let mut env = IOBuffer::default();
            //
            let mut cpu = CPU::new(&mut env);

            match cpu.run_code_raw(&bin) {
                Ok(_) => {
                    println!("Result: {}", env.output)
                }
                Err(e) => println!("Err: {:?}", e),
            };
        }
        Some(Build { filename, output }) => {
            let Ok(inp_content) = std::fs::read_to_string(filename.clone()) else {
                println!("Could not read file {}", &filename);
                return;
            };

            let prs = dekejit::assembler::parser::Parser::new(inp_content);

            let sections = match prs.parse_sections() {
                Ok(s) => s,
                Err(p_err) => {
                    println!("Parser error: {:?}", p_err);
                    return;
                }
            };

            let Some(bin) = dekejit::assembler::to_binary(sections) else {
                println!("Unspecified error while converting file to binary. Must fix.");
                return;
            };

            info!("{:?}", bin);

            let out_bin = dekejit::loader::unloader::make_binary(&bin);

            info!("{:?}", out_bin);

            let out_bin = transmute_to_vecu8_as_is(out_bin);

            info!("{:?}", out_bin);

            match std::fs::write(output.clone(), out_bin) {
                Ok(_) => {}
                Err(_) => {
                    println!("could not write file {}", output);
                }
            };
        }
        Some(View { filename, format }) => {
            info!("Trying to read {}", filename);

            let Ok(content) = std::fs::read_to_string(&filename) else {
                println!("File {} does not exist or cannot be read", &filename);
                return;
            };

            let p = parser::Parser::new(content);

            let s = p.parse_sections().unwrap();

            println!(
                "{}",
                format_code(dekejit::pretty_printers::CodeWrapper::Asm(s), format).unwrap()
            );

            // let Ok(content) = std::fs::read(&filename) else {
            //     println!("File {} does not exist or cannot be read.", &filename);
            //     return;
            // };
            //
            //
            // let bytes = dekejit::transmute_to_vecu16_as_is(content.to_vec());
            //
            // info!("{:?}", bytes);
            //
            // info!("Begin parsing file {}", &filename);
            // let sections = match read_binary(&bytes) {
            //     Ok(k) => k,
            //     Err(p) => {
            //         println!("Parsing error: {:?}", p);
            //         return;
            //     }
            // };
            //
            // println!("{:?}", sections);
        }
        Some(Debug) => {}
        None => {}
    }

    // let parser = parser::Parser::new(code);
    //
    // let r = parser.parse_sections().unwrap();
    //
    // // println!("Parsed sections: {:?}", r);
    //
    // let code = to_binary(r).unwrap();

    // let mut k = make_string("Hello world!");
    //
    // let mut code: Vec<u16> = vec![
    //     0b0111000100000011, // addi ra 3
    //     0b1110000100000011, // ecall ra 3
    //     0b1111000000000000, // HALT.
    // ];
    //
    // code.append(&mut k);
    //
    // let mut env = IOBuffer::default();
    // //
    // let mut cpu = CPU::new(&mut env);
    // //
    // // for c in &code[..] {
    // //     // println!("{:#018b}", c);
    // // }
    // //
    // match cpu.run_code_raw(&code) {
    //     Ok(_) => {
    //         println!("Result: {}", env.output)
    //     }
    //     Err(e) => println!("Err: {:?}", e),
    // };
}