use std::env;
use std::io;
use std::io::Write;
use std::path::Path;

mod cexpr;
mod sexpr;

use cexpr::CExpr;

fn repl(_verbose: bool) {
    let stdin = io::stdin();
    let mut stdout = io::stdout();

    loop {
        let raw_input = &mut String::new();
        stdout.write(b"\ncasual> ").unwrap();
        stdout.flush().unwrap();
        stdin.read_line(raw_input).unwrap();
        let raw_input = raw_input; // mutable to immutable reference
        if raw_input.len() == 0 {
            // end-of-line, aka Ctrl-D. Blank line will still have newline char
            stdout.write(b"\nCiao!\n").unwrap();
            return;
        }
        let expr = match CExpr::from_str(&raw_input) {
            Ok(expr) => expr,
            Err(e) => {
                println!("error: {}", e);
                continue;
            }
        };
        println!("{}", expr);
    }
}

fn usage() {
    println!("usage:\tcasual [-h] [-v] [--no-repl] [<files>]");
    println!("");
    println!("Files will be loaded in order, then drop to REPL (unless \"--no-repl\" is passed).");
    println!(
        "Verbose flag (\"-v\") will result in lexed tokens and parsed AST \
        being dumped to stdout (when on REPL)."
    );
}

fn main() {
    let mut verbose: bool = false;
    let mut no_repl: bool = false;

    let mut file_list = Vec::<String>::new();

    for arg in env::args().skip(1) {
        match &*arg {
            "-v" | "--verbose" => {
                verbose = true;
            }
            "--no-repl" => {
                no_repl = true;
            }
            "-h" | "--help" => {
                usage();
                return;
            }
            _ if arg.starts_with("-") => {
                println!("Unknown option: {}", arg);
                println!("");
                usage();
                return;
            }
            _ => {
                file_list.push(arg.clone());
            }
        }
    }

    for fname in file_list {
        let fpath = Path::new(&fname);
        if !fpath.is_file() {
            println!("File not found (or not file): {}", fname);
            return;
        }
        println!("Loading {}...", fname);
        match sexpr::sexpr_parse_file(&fpath) {
            Err(e) => {
                println!("Error loading file: {}\n    {}", fname, e);
                return;
            }
            Ok(_) => (),
        }
    }

    if !no_repl {
        repl(verbose);
    }
}