#![cfg(test)]

use std::env;
use std::path::{Path, PathBuf};
use std::process::Command;
use std::fs::File;
use std::collections::HashMap;

use serde_json;
use super::test;
use parity_wasm_interp::{
    Error as InterpreterError, Externals, FuncInstance, FuncRef,
    GlobalInstance, GlobalRef, ImportResolver, ImportsBuilder,
    MemoryInstance, MemoryRef, ModuleImportResolver, ModuleInstance,
    ModuleRef, RuntimeValue, TableInstance, TableRef, ValueType,
    load_from_buffer, LoadedModule, Signature, MemoryDescriptor, TableDescriptor, GlobalDescriptor,
};

#[derive(Debug)]
enum Error {
    Load(String),
    Interpreter(InterpreterError),
}

impl From<InterpreterError> for Error {
	fn from(e: InterpreterError) -> Error {
		Error::Interpreter(e)
	}
}

struct SpecModule {
    table: TableRef,
    memory: MemoryRef,
    global_i32: GlobalRef,
    global_i64: GlobalRef,
    global_f32: GlobalRef,
    global_f64: GlobalRef,
}

impl SpecModule {
    fn new() -> Self {
        SpecModule {
            table: TableInstance::alloc(10, Some(20)).unwrap(),
            memory: MemoryInstance::alloc(1, Some(2)).unwrap(),
            global_i32: GlobalInstance::alloc(RuntimeValue::I32(666), false),
            global_i64: GlobalInstance::alloc(RuntimeValue::I64(666), false),
            global_f32: GlobalInstance::alloc(RuntimeValue::F32(666.0), false),
            global_f64: GlobalInstance::alloc(RuntimeValue::F64(666.0), false),
        }
    }
}

const PRINT_FUNC_INDEX: usize = 0;

impl Externals for SpecModule {
    fn invoke_index(
        &mut self,
        index: usize,
        args: &[RuntimeValue],
    ) -> Result<Option<RuntimeValue>, InterpreterError> {
        match index {
            PRINT_FUNC_INDEX => {
                println!("print: {:?}", args);
                Ok(None)
            }
            _ => panic!("SpecModule doesn't provide function at index {}", index),
        }
    }
}

impl ModuleImportResolver for SpecModule {
    fn resolve_func(
        &self,
        field_name: &str,
        func_type: &Signature,
    ) -> Result<FuncRef, InterpreterError> {
        if field_name == "print" {
            if func_type.return_type().is_some() {
                return Err(InterpreterError::Instantiation(
                    "Function `print` have unit return type".into(),
                ));
            }

            let func = FuncInstance::alloc_host(func_type.clone(), PRINT_FUNC_INDEX);
            return Ok(func);
        }

        Err(InterpreterError::Instantiation(
            format!("Unknown host func import {}", field_name),
        ))
    }

    fn resolve_global(
        &self,
        field_name: &str,
        global_type: &GlobalDescriptor,
    ) -> Result<GlobalRef, InterpreterError> {
        if field_name == "global" {
            return match global_type.value_type() {
                ValueType::I32 => Ok(self.global_i32.clone()),
                ValueType::I64 => Ok(self.global_i64.clone()),
                ValueType::F32 => Ok(self.global_f32.clone()),
                ValueType::F64 => Ok(self.global_f64.clone()),
            };
        }

        Err(InterpreterError::Instantiation(
            format!("Unknown host global import {}", field_name),
        ))
    }

    fn resolve_memory(
        &self,
        field_name: &str,
        _memory_type: &MemoryDescriptor,
    ) -> Result<MemoryRef, InterpreterError> {
        if field_name == "memory" {
            return Ok(self.memory.clone());
        }

        Err(InterpreterError::Instantiation(
            format!("Unknown host memory import {}", field_name),
        ))
    }

    fn resolve_table(
        &self,
        field_name: &str,
        _table_type: &TableDescriptor,
    ) -> Result<TableRef, InterpreterError> {
        if field_name == "table" {
            return Ok(self.table.clone());
        }

        Err(InterpreterError::Instantiation(
            format!("Unknown host table import {}", field_name),
        ))
    }
}

struct SpecDriver {
    spec_module: SpecModule,
    instances: HashMap<String, ModuleRef>,
}

impl SpecDriver {
    fn new() -> SpecDriver {
        SpecDriver {
            spec_module: SpecModule::new(),
            instances: HashMap::new(),
        }
    }

    fn spec_module(&mut self) -> &mut SpecModule {
        &mut self.spec_module
    }

    fn add_module(&mut self, name: String, module: ModuleRef) {
        self.instances.insert(name, module);
    }

    fn module(&self, name: &str) -> Result<ModuleRef, InterpreterError> {
        self.instances.get(name).cloned().ok_or_else(|| {
            InterpreterError::Instantiation(format!("Module not registered {}", name))
        })
    }
}

impl ImportResolver for SpecDriver {
    fn resolve_func(
        &self,
        module_name: &str,
        field_name: &str,
        func_type: &Signature,
    ) -> Result<FuncRef, InterpreterError> {
        if module_name == "spectest" {
            self.spec_module.resolve_func(field_name, func_type)
        } else {
            self.module(module_name)?
                .resolve_func(field_name, func_type)
        }
    }

    fn resolve_global(
        &self,
        module_name: &str,
        field_name: &str,
        global_type: &GlobalDescriptor,
    ) -> Result<GlobalRef, InterpreterError> {
        if module_name == "spectest" {
            self.spec_module.resolve_global(field_name, global_type)
        } else {
            self.module(module_name)?
                .resolve_global(field_name, global_type)
        }
    }

    fn resolve_memory(
        &self,
        module_name: &str,
        field_name: &str,
        memory_type: &MemoryDescriptor,
    ) -> Result<MemoryRef, InterpreterError> {
        if module_name == "spectest" {
            self.spec_module.resolve_memory(field_name, memory_type)
        } else {
            self.module(module_name)?
                .resolve_memory(field_name, memory_type)
        }
    }

    fn resolve_table(
        &self,
        module_name: &str,
        field_name: &str,
        table_type: &TableDescriptor,
    ) -> Result<TableRef, InterpreterError> {
        if module_name == "spectest" {
            self.spec_module.resolve_table(field_name, table_type)
        } else {
            self.module(module_name)?
                .resolve_table(field_name, table_type)
        }
    }
}

fn try_load_module(base_dir: &Path, module_path: &str) -> Result<LoadedModule, Error> {
    use std::io::prelude::*;

    let mut wasm_path = PathBuf::from(base_dir.clone());
    wasm_path.push(module_path);
	let mut file = File::open(wasm_path).unwrap();
	let mut buf = Vec::new();
	file.read_to_end(&mut buf).unwrap();
	load_from_buffer(buf).map_err(|e| Error::Load(e.to_string()))
}

fn try_load(
    base_dir: &Path,
    module_path: &str,
    spec_driver: &mut SpecDriver,
) -> Result<(), Error> {
    let module = try_load_module(base_dir, module_path)?;
    let instance = ModuleInstance::new(&module, &ImportsBuilder::default())?;
    instance.run_start(spec_driver.spec_module())?;
    Ok(())
}

fn load_module(
    base_dir: &Path,
    path: &str,
    name: &Option<String>,
    spec_driver: &mut SpecDriver,
) -> ModuleRef {
    let module =
        try_load_module(base_dir, path).expect(&format!("Wasm file {} failed to load", path));
    let instance = ModuleInstance::new(&module, spec_driver)
        .expect("Instantiation failed")
        .run_start(spec_driver.spec_module())
        .expect("Run start failed");

    let module_name = name.as_ref()
        .map(|s| s.as_ref())
        .unwrap_or("wasm_test")
        .trim_left_matches('$');
    spec_driver.add_module(module_name.to_owned(), instance.clone());

    instance
}

fn runtime_value(test_val: &test::RuntimeValue) -> RuntimeValue {
    match test_val.value_type.as_ref() {
        "i32" => {
            let unsigned: u32 = test_val.value.parse().expect("Literal parse error");
            RuntimeValue::I32(unsigned as i32)
        }
        "i64" => {
            let unsigned: u64 = test_val.value.parse().expect("Literal parse error");
            RuntimeValue::I64(unsigned as i64)
        }
        "f32" => {
            let unsigned: u32 = test_val.value.parse().expect("Literal parse error");
            RuntimeValue::decode_f32(unsigned)
        }
        "f64" => {
            let unsigned: u64 = test_val.value.parse().expect("Literal parse error");
            RuntimeValue::decode_f64(unsigned)
        }
        _ => panic!("Unknwon runtime value type"),
    }
}

fn runtime_values(test_vals: &[test::RuntimeValue]) -> Vec<RuntimeValue> {
    test_vals
        .iter()
        .map(runtime_value)
        .collect::<Vec<RuntimeValue>>()
}

fn run_action(
    program: &mut SpecDriver,
    action: &test::Action,
) -> Result<Option<RuntimeValue>, InterpreterError> {
    match *action {
        test::Action::Invoke {
            ref module,
            ref field,
            ref args,
        } => {
            let module = module.clone().unwrap_or("wasm_test".into());
            let module = module.trim_left_matches('$');
            let module = program.module(&module).expect(&format!(
                "Expected program to have loaded module {}",
                module
            ));
            module.invoke_export(
                &jstring_to_rstring(field),
                &runtime_values(args),
                program.spec_module(),
            )
        }
        test::Action::Get {
            ref module,
            ref field,
            ..
        } => {
            let module = module.clone().unwrap_or("wasm_test".into());
            let module = module.trim_left_matches('$');
            let module = program.module(&module).expect(&format!(
                "Expected program to have loaded module {}",
                module
            ));
            let field = jstring_to_rstring(&field);

            let global = module
                .export_by_name(&field)
                .ok_or_else(|| {
                    InterpreterError::Global(format!("Expected to have export with name {}", field))
                })?
                .as_global()
                .ok_or_else(|| {
                    InterpreterError::Global(format!("Expected export {} to be a global", field))
                })?;
            Ok(Some(global.get()))
        }
    }
}

pub struct FixtureParams {
    failing: bool,
    json: String,
}

pub fn run_wast2wasm(name: &str) -> FixtureParams {
    let outdir = env::var("OUT_DIR").unwrap();

    let mut wast2wasm_path = PathBuf::from(outdir.clone());
    wast2wasm_path.push("bin");
    wast2wasm_path.push("wast2wasm");

    let mut json_spec_path = PathBuf::from(outdir.clone());
    json_spec_path.push(&format!("{}.json", name));

    let wast2wasm_output = Command::new(wast2wasm_path)
        .arg("--spec")
        .arg("-o")
        .arg(&json_spec_path)
        .arg(&format!("./wabt/third_party/testsuite/{}.wast", name))
        .output()
        .expect("Failed to execute process");

    FixtureParams {
        json: json_spec_path.to_str().unwrap().to_owned(),
        failing: {
            if !wast2wasm_output.status.success() {
                println!("wasm2wast error code: {}", wast2wasm_output.status);
                println!(
                    "wasm2wast stdout: {}",
                    String::from_utf8_lossy(&wast2wasm_output.stdout)
                );
                println!(
                    "wasm2wast stderr: {}",
                    String::from_utf8_lossy(&wast2wasm_output.stderr)
                );
                true
            } else {
                false
            }
        },
    }
}

pub fn failing_spec(name: &str) {
    let fixture = run_wast2wasm(name);
    if !fixture.failing {
        panic!("wasm2wast expected to fail, but terminated normally");
    }
}

pub fn spec(name: &str) {
    let tmpdir = env::var("OUT_DIR").unwrap();

    let fixture = run_wast2wasm(name);
    if fixture.failing {
        panic!("wasm2wast terminated abnormally, expected to success");
    }

    let mut f =
        File::open(&fixture.json).expect(&format!("Failed to load json file {}", &fixture.json));
    let spec: test::Spec =
        serde_json::from_reader(&mut f).expect("Failed to deserialize JSON file");

    let mut spec_driver = SpecDriver::new();
    let mut last_module = None;
    for command in &spec.commands {
        println!("command {:?}", command);
        match command {
            &test::Command::Module {
                ref name,
                ref filename,
                ..
            } => {
                last_module = Some(load_module(tmpdir.as_ref(), &filename, &name, &mut spec_driver));
            }
            &test::Command::AssertReturn {
                line,
                ref action,
                ref expected,
            } => {
                let result = run_action(&mut spec_driver, action);
                match result {
                    Ok(result) => {
                        let spec_expected = runtime_values(expected);
                        let actual_result = result.into_iter().collect::<Vec<RuntimeValue>>();
                        for (actual_result, spec_expected) in
                            actual_result.iter().zip(spec_expected.iter())
                        {
                            assert_eq!(actual_result.value_type(), spec_expected.value_type());
                            // f32::NAN != f32::NAN
                            match spec_expected {
                                &RuntimeValue::F32(val) if val.is_nan() => match actual_result {
                                    &RuntimeValue::F32(val) => assert!(val.is_nan()),
                                    _ => unreachable!(), // checked above that types are same
                                },
                                &RuntimeValue::F64(val) if val.is_nan() => match actual_result {
                                    &RuntimeValue::F64(val) => assert!(val.is_nan()),
                                    _ => unreachable!(), // checked above that types are same
                                },
                                spec_expected @ _ => assert_eq!(actual_result, spec_expected),
                            }
                        }
                        println!("assert_return at line {} - success", line);
                    }
                    Err(e) => {
                        panic!("Expected action to return value, got error: {:?}", e);
                    }
                }
            }
            &test::Command::AssertReturnCanonicalNan { line, ref action } |
            &test::Command::AssertReturnArithmeticNan { line, ref action } => {
                let result = run_action(&mut spec_driver, action);
                match result {
                    Ok(result) => {
                        for actual_result in result.into_iter().collect::<Vec<RuntimeValue>>() {
                            match actual_result {
                                RuntimeValue::F32(val) => if !val.is_nan() {
                                    panic!("Expected nan value, got {:?}", val)
                                },
                                RuntimeValue::F64(val) => if !val.is_nan() {
                                    panic!("Expected nan value, got {:?}", val)
                                },
                                val @ _ => {
                                    panic!("Expected action to return float value, got {:?}", val)
                                }
                            }
                        }
                        println!("assert_return_nan at line {} - success", line);
                    }
                    Err(e) => {
                        panic!("Expected action to return value, got error: {:?}", e);
                    }
                }
            }
            &test::Command::AssertExhaustion {
                line, ref action, ..
            } => {
                let result = run_action(&mut spec_driver, action);
                match result {
                    Ok(result) => panic!("Expected exhaustion, got result: {:?}", result),
                    Err(e) => println!("assert_exhaustion at line {} - success ({:?})", line, e),
                }
            }
            &test::Command::AssertTrap {
                line, ref action, ..
            } => {
                let result = run_action(&mut spec_driver, action);
                match result {
                    Ok(result) => {
                        panic!(
                            "Expected action to result in a trap, got result: {:?}",
                            result
                        );
                    }
                    Err(e) => {
                        println!("assert_trap at line {} - success ({:?})", line, e);
                    }
                }
            }
            &test::Command::AssertInvalid {
                line, ref filename, ..
            } |
            &test::Command::AssertMalformed {
                line, ref filename, ..
            } |
            &test::Command::AssertUnlinkable {
                line, ref filename, ..
            } => {
                let module_load = try_load(tmpdir.as_ref(), filename, &mut spec_driver);
                match module_load {
                    Ok(_) => panic!("Expected invalid module definition, got some module!"),
                    Err(e) => println!("assert_invalid at line {} - success ({:?})", line, e),
                }
            }
            &test::Command::AssertUninstantiable {
                line, ref filename, ..
            } => match try_load(tmpdir.as_ref(), &filename, &mut spec_driver) {
                Ok(_) => panic!("Expected error running start function at line {}", line),
                Err(e) => println!("assert_uninstantiable - success ({:?})", e),
            },
            &test::Command::Register {
                ref name,
                ref as_name,
                ..
            } => {
                match name {
                    &Some(ref name) => assert_eq!(name.trim_left_matches('$'), as_name), // we have already registered this module without $ prefix
                    &None => spec_driver.add_module(
                        as_name.clone(),
                        last_module
                            .take()
                            .expect("Last module must be set for this command"),
                    ),
                }
            }
            &test::Command::Action { line, ref action } => {
                match run_action(&mut spec_driver, action) {
                    Ok(_) => {}
                    Err(e) => panic!("Failed to invoke action at line {}: {:?}", line, e),
                }
            }
        }
    }
}

// Convert json string to correct rust UTF8 string.
// The reason is that, for example, rust character "\u{FEEF}" (3-byte UTF8 BOM) is represented as "\u00ef\u00bb\u00bf" in spec json.
// It is incorrect. Correct BOM representation in json is "\uFEFF" => we need to do a double utf8-parse here.
// This conversion is incorrect in general case (casting char to u8)!!!
fn jstring_to_rstring(jstring: &str) -> String {
    let jstring_chars: Vec<u8> = jstring.chars().map(|c| c as u8).collect();
    let rstring = String::from_utf8(jstring_chars).unwrap();
    rstring
}