mod environment;
mod interpreter;
mod lexer;
mod parser;
mod primitives;

use std::env;
use std::fs;
use std::io;
use std::io::prelude::*;
use std::path::Path;

fn repl() {
    let mut env = environment::get_global_environment();
    loop {
        let mut input = String::new();
        print!(" ]=> ");
        io::stdout().flush().ok().expect("Could not flush stdout");
        match io::stdin().read_line(&mut input) {
            Ok(_) => {
                let tokens = lexer::read(&input);
                let datum = parser::parse(tokens);
                let result = interpreter::interpret(&datum, &mut env);
                println!("{:?}", result);
            }
            Err(error) => println!("error: {}", error),
        }
    }
}

fn interpret_code(scm_code: &str) {
    let tokens = lexer::read(scm_code);
    let datum = parser::parse(tokens);
    let mut env = environment::get_global_environment();
    let result = interpreter::interpret(&datum, &mut env);
    println!("{:?}", result);
}

fn interpret_file(filename: &Path) {
    match fs::read_to_string(filename) {
        Ok(scm_code) => {
            let tokens = lexer::read(scm_code.as_str());
            let datum = parser::parse(tokens);
            let mut env = environment::get_global_environment();
            let _result = interpreter::interpret(&datum, &mut env);
            // println!("{:?}", result);
        }
        Err(error) => println!("error: {} {:?}", error, filename),
    }
}

fn main() {
    let args: Vec<String> = env::args().collect();
    let scm_code = "";

    if args.len() == 2 {
        let arg_path = Path::new(&args[1]);
        interpret_file(arg_path);
    } else if scm_code.len() > 0 {
        interpret_code(scm_code);
    } else {
        repl();
    }
}