//! CLI tool to use the functions provided by crates [wasm2cretonne](../wasm2cretonne/index.html)
//! and [wasmstandalone](../wasmstandalone/index.html).
//!
//! Reads Wasm binary files (one Wasm module per file), translates the functions' code to Cretonne
//! IL. Can also executes the `start` function of the module by laying out the memories, globals
//! and tables, then emitting the translated code with hardcoded addresses to memory.

use cretonne_wasm::{translate_module, FunctionTranslation, DummyRuntime, WasmRuntime};
use std::path::PathBuf;
use cretonne::loop_analysis::LoopAnalysis;
use cretonne::flowgraph::ControlFlowGraph;
use cretonne::dominator_tree::DominatorTree;
use cretonne::Context;
use cretonne::result::CtonError;
use cretonne::ir;
use cretonne::ir::entities::AnyEntity;
use cretonne::isa::TargetIsa;
use cretonne::verifier;
use std::fs::File;
use std::error::Error;
use std::io;
use std::io::BufReader;
use std::io::prelude::*;
use std::path::Path;
use std::process::Command;
use tempdir::TempDir;
use term;

macro_rules! vprintln {
    ($x: expr, $($tts:tt)*) => {
        if $x {
            println!($($tts)*);
        }
    }
}

macro_rules! vprint {
    ($x: expr, $($tts:tt)*) => {
        if $x {
            print!($($tts)*);
        }
    }
}

fn read_wasm_file(path: PathBuf) -> Result<Vec<u8>, io::Error> {
    let mut buf: Vec<u8> = Vec::new();
    let file = File::open(path)?;
    let mut buf_reader = BufReader::new(file);
    buf_reader.read_to_end(&mut buf)?;
    Ok(buf)
}


pub fn run(
    files: Vec<String>,
    flag_verbose: bool,
    flag_optimize: bool,
    flag_check: bool,
) -> Result<(), String> {
    for filename in files.iter() {
        let path = Path::new(&filename);
        let name = String::from(path.as_os_str().to_string_lossy());
        match handle_module(
            flag_verbose,
            flag_optimize,
            flag_check,
            path.to_path_buf(),
            name,
        ) {
            Ok(()) => {}
            Err(message) => return Err(message),
        }
    }
    Ok(())
}

fn handle_module(
    flag_verbose: bool,
    flag_optimize: bool,
    flag_check: bool,
    path: PathBuf,
    name: String,
) -> Result<(), String> {
    let mut terminal = term::stdout().unwrap();
    terminal.fg(term::color::YELLOW).unwrap();
    vprint!(flag_verbose, "Handling: ");
    terminal.reset().unwrap();
    vprintln!(flag_verbose, "\"{}\"", name);
    terminal.fg(term::color::MAGENTA).unwrap();
    vprint!(flag_verbose, "Translating...");
    terminal.reset().unwrap();
    let data = match path.extension() {
        None => {
            return Err(String::from("the file extension is not wasm or wast"));
        }
        Some(ext) => {
            match ext.to_str() {
                Some("wasm") => {
                    match read_wasm_file(path.clone()) {
                        Ok(data) => data,
                        Err(err) => {
                            return Err(String::from(err.description()));
                        }
                    }
                }
                Some("wast") => {
                    let tmp_dir = TempDir::new("wasm2cretonne").unwrap();
                    let file_path = tmp_dir.path().join("module.wasm");
                    File::create(file_path.clone()).unwrap();
                    Command::new("wast2wasm")
                        .arg(path.clone())
                        .arg("-o")
                        .arg(file_path.to_str().unwrap())
                        .output()
                        .or_else(|e| if let io::ErrorKind::NotFound = e.kind() {
                            return Err(String::from("wast2wasm not found"));
                        } else {
                            return Err(String::from(e.description()));
                        })
                        .unwrap();
                    match read_wasm_file(file_path) {
                        Ok(data) => data,
                        Err(err) => {
                            return Err(String::from(err.description()));
                        }
                    }
                }
                None | Some(&_) => {
                    return Err(String::from("the file extension is not wasm or wast"));
                }
            }
        }
    };
    let mut dummy_runtime = DummyRuntime::new();
    let translation = {
        let runtime: &mut WasmRuntime = &mut dummy_runtime;
        match translate_module(&data, runtime) {
            Ok(x) => x,
            Err(string) => {
                return Err(string);
            }
        }
    };
    terminal.fg(term::color::GREEN).unwrap();
    vprintln!(flag_verbose, " ok");
    terminal.reset().unwrap();
    if flag_check {
        terminal.fg(term::color::MAGENTA).unwrap();
        vprint!(flag_verbose, "Checking...   ");
        terminal.reset().unwrap();
        for func in translation.functions.iter() {
            let il = match *func {
                FunctionTranslation::Import() => continue,
                FunctionTranslation::Code { ref il, .. } => il.clone(),
            };
            match verifier::verify_function(&il, None) {
                Ok(()) => (),
                Err(err) => return Err(pretty_verifier_error(&il, None, err)),
            }
        }
        terminal.fg(term::color::GREEN).unwrap();
        vprintln!(flag_verbose, " ok");
        terminal.reset().unwrap();
    }
    if flag_optimize {
        terminal.fg(term::color::MAGENTA).unwrap();
        vprint!(flag_verbose, "Optimizing... ");
        terminal.reset().unwrap();
        for func in translation.functions.iter() {
            let mut il = match *func {
                FunctionTranslation::Import() => continue,
                FunctionTranslation::Code { ref il, .. } => il.clone(),
            };
            let mut loop_analysis = LoopAnalysis::new();
            let mut cfg = ControlFlowGraph::new();
            cfg.compute(&il);
            let mut domtree = DominatorTree::new();
            domtree.compute(&mut il, &cfg);
            loop_analysis.compute(&mut il, &mut cfg, &mut domtree);
            let mut context = Context::new();
            context.func = il;
            context.cfg = cfg;
            context.domtree = domtree;
            context.loop_analysis = loop_analysis;
            match verifier::verify_context(&context.func, &context.cfg, &context.domtree, None) {
                Ok(()) => (),
                Err(err) => {
                    return Err(pretty_verifier_error(&context.func, None, err));
                }
            };
            match context.licm() {
                Ok(())=> (),
                Err(error) => {
                    match error {
                        CtonError::Verifier(err) => {
                            return Err(pretty_verifier_error(&context.func, None, err));
                        }
                        CtonError::ImplLimitExceeded |
                        CtonError::CodeTooLarge => return Err(String::from(error.description())),
                    }
                }
            };
            match context.simple_gvn() {
                Ok(())=> (),
                Err(error) => {
                    match error {
                        CtonError::Verifier(err) => {
                            return Err(pretty_verifier_error(&context.func, None, err));
                        }
                        CtonError::ImplLimitExceeded |
                        CtonError::CodeTooLarge => return Err(String::from(error.description())),
                    }
                }
            };
            match verifier::verify_context(&context.func, &context.cfg, &context.domtree, None) {
                Ok(()) => (),
                Err(err) => return Err(pretty_verifier_error(&context.func, None, err)),
            }
        }
        terminal.fg(term::color::GREEN).unwrap();
        vprintln!(flag_verbose, " ok");
        terminal.reset().unwrap();
    }
    Ok(())
}

/// Pretty-print a verifier error.
pub fn pretty_verifier_error(
    func: &ir::Function,
    isa: Option<&TargetIsa>,
    err: verifier::Error,
) -> String {
    let msg = err.to_string();
    let str1 = match err.location {
        AnyEntity::Inst(inst) => {
            format!(
                "{}\n{}: {}\n\n",
                msg,
                inst,
                func.dfg.display_inst(inst, isa)
            )
        }
        _ => String::from(format!("{}\n", msg)),
    };
    format!("{}{}", str1, func.display(isa))
}