extern crate modelthing;
extern crate rustc_serialize;
extern crate clap;
extern crate modelica_parser;

use modelthing::transpile_scheme::TranspileScheme;
use modelthing::transpile_js::TranspileJS;
use modelthing::modelica_model::ModelicaModelExt;
use clap::{App, SubCommand};
use std::io::Read;
use std::fs::File;
use std::path::Path;
use std::time::Instant;
use std::process::exit;


fn parse_modelica_files(paths: Vec<String>) {
    for input in &paths {
        let mut s = String::new();
        if let Err(err) = File::open(input).and_then(|mut f| f.read_to_string(&mut s)) {
            println!("Input `{}`: I/O Error {}",
                     input, err);
            continue;
        }

        let time_stamp = Instant::now();
        let result = modelica_parser::parse_model(&s);
        let elapsed = time_stamp.elapsed();
        let elapsed = elapsed.as_secs() as f64 + elapsed.subsec_nanos() as f64 / 1000_000_000.0;

        match result {
            Ok(_) => println!("Input `{}` ({}s): OK", input, elapsed),
            Err(err) => println!("Input `{}` ({}sec): ERROR\n{}", input, elapsed, modelica_parser::pp_parseerror(&s, err)),
        }
    }
}

fn main() {

    let matches = App::new("mt-tool")
        .version(env!("CARGO_PKG_VERSION"))
        .subcommand(SubCommand::with_name("parse")
            .about("checks that file contains a valid modelica model")
            .arg_from_usage("<FILE>... 'file to parse from'"))
        .subcommand(SubCommand::with_name("list")
            .about("dumps all the known models in database"))
        .subcommand(SubCommand::with_name("load")
            .about("checks that directory contains valid model and metadata")
            .arg_from_usage("<DIR> 'model to load'"))
        .subcommand(SubCommand::with_name("transpile_js")
            .about("converts modelica to javascript function")
            .arg_from_usage("<DIR> 'model to load'"))
        .subcommand(SubCommand::with_name("transpile_scheme")
            .about("converts modelica to scheme function")
            .arg_from_usage("<DIR> 'model to load'"))
        .subcommand(SubCommand::with_name("solve_for")
            .about("")
            .arg_from_usage("<DIR> 'model to load'")
            .arg_from_usage("--dep <VAR>... 'dependent variable'")
            .arg_from_usage("--indep <VAR>... 'independent variable'"))
        .get_matches();

    
    match matches.subcommand() {
        ("parse", Some(subm)) => {
            parse_modelica_files(subm.values_of_lossy("FILE").unwrap());
        },
        ("solve_for", Some(subm)) => {
            let dir = Path::new(subm.value_of("DIR").unwrap());
            let indep = subm.values_of_lossy("indep").unwrap();
            let dep = subm.values_of_lossy("dep").unwrap();
            let me = modelthing::load_model_entry(dir).unwrap();
            println!("{:?}", me.ast.solve_for(indep, dep));
        },
        ("transpile_scheme", Some(subm)) => {
            let dir = Path::new(subm.value_of("DIR").unwrap());
            let me = modelthing::load_model_entry(dir).unwrap();
            println!("{}", me.ast.repr_scheme().unwrap());
        },
        ("transpile_js", Some(subm)) => {
            let dir = Path::new(subm.value_of("DIR").unwrap());
            let me = modelthing::load_model_entry(dir).unwrap();
            println!("{}", me.ast.repr_js().unwrap());
        },
        ("list", Some(subm)) => {
            let dir = Path::new(subm.value_of("DIR").unwrap_or("examples"));
            for m in modelthing::search_models(dir) {
                println!("{}", m)
            }
        },
        ("load", Some(subm)) => {
            let dir = Path::new(subm.value_of("DIR").unwrap());
            let me = modelthing::load_model_entry(dir).unwrap();
            println!("{:?}", me);
        },
        _ => {
            println!("Missing or unimplemented command!");
            println!("{}", matches.usage());
            exit(-1);
        },
    }
}