use std::fs;
use std::path::PathBuf;
use std::process;
use std::time;
use std::env;

use mist_parser::error;
use crate::modules;

pub fn transpile() PathBuf {
    let start = time::Instant::now();

    let root = env::current_dir().expect("Unable to find project root");

    let src = root.join("src");
    let out = root.join(".mist/src");

    let master = modules::master_package(src.join("main.mist"));

    master.transpile(&out);

    let elapsed = start.elapsed();
    
    println!(
        "\x1b[32m\nTranspile successful\x1b[0m in \x1b[34m{:.2?}\x1b[0m",
        elapsed
    );

    root
}

impl modules::Module {
    fn transpile(*self, parent_dir *PathBuf) String {
        if (!self.path.is_dir() && self.path.extension().and_then(fn(v) -> v.to_str()) != Some("mist")) {
            let file_name = self.path.file_name()
                .and_then(fn(s) -> s.to_str())
                .expect("Failed to get file name");

            fs::copy(&self.path, parent_dir.join(&file_name)).expect("Failed to copy SideFile");

            return String::new();
        }

        let dir = self.output_dir(&parent_dir);
        let output_file = self.output_path(&parent_dir);

        let _ = fs::create_dir_all(&dir);

        let mut output = String::new();

        for (child : &self.children) {
            output.push_str(&child.transpile(&dir));
        }

        if (self.path.is_dir()) {
            if (output.len() == 0) {
                return String::new();
            }

            let res = fs::write(&output_file, output);

            if (res.is_err()) {
                eprintln!(
                    "error: failed to write output {}\n  {}",
                    output_file.display(),
                    res.unwrap_err(),
                );

                process::exit(1);
            }
        } else {
            transpile_file(&self.path, &output_file, &output);
        }

        format!("pub mod {};\n", self.name)
    }
}

fn transpile_file(path *PathBuf, output_file *PathBuf, mod_decl *str) {
    let source = match (fs::read_to_string(path)) {
        Ok[s] => s;
        Err[e] => {
            eprintln!("error: failed to read file {}\n  {}", path.display(), e);

            process::exit(1);
        }
    };

    let mut gc = mist_codegen::RustCodegen::new();

    let output = gc.generate(match (mist_parser::parse(&source)) {
        Ok[ast] => ast;
        Err[e] => {
            match (e) {
                error::ParseError::Ast[e] => {
                    let start_pos = e.span.start_pos().line_col();

                    let span = e.span.as_str();

                    eprintln!(
                        "\n{}:{}:{}\n \x1b[31mError\x1b[0m: {}\n\t{}{}\t{}",
                        path.as_os_str().display(),
                        start_pos.0,
                        start_pos.1,
                        e.error_message,
                        span,
                        if span.ends_with("\n") { "" } else { "\n" },
                        "^".repeat(span.trim().len()),
                    );

                    process::exit(1);
                }

                error::ParseError::PreAst[e] => {
                    eprintln!("error: parse failed in {}\n{}", path.display(), e);

                    process::exit(1);
                }
            }
        }
    });

    let res = fs::write(&output_file, format!("{mod_decl}{output}"));

    if (res.is_err()) {
        eprintln!(
            "error: failed to write output {}\n  {}",
            output_file.display(),
            res.unwrap_err(),
        );

        process::exit(1);
    }
}