use std::{collections::HashSet, fs::File, io::Read, path::PathBuf, process::exit};

use schala_lang::{Schala, SchalaConfig};
use schala_repl::{ComputationRequest, ProgrammingLanguageInterface, Repl};

//TODO specify multiple langs, and have a way to switch between them
fn main() {
    let args: Vec<String> = std::env::args().collect();
    let matches = command_line_options().parse(&args[1..]).unwrap_or_else(|e| {
        eprintln!("Error parsing options: {}", e);
        exit(1);
    });

    if matches.opt_present("help") {
        println!("{}", command_line_options().usage("Schala metainterpreter"));
        exit(0);
    }

    if matches.free.is_empty() {
        let state = Schala::new();
        let mut repl = Repl::new(state);
        let config = SchalaConfig { repl: true };
        repl.run_repl(config);
    } else {
        let paths: Vec<PathBuf> = matches.free.iter().map(PathBuf::from).collect();
        //TODO handle more than one file
        let filename = &paths[0];
        let extension = filename.extension().and_then(|e| e.to_str()).unwrap_or_else(|| {
            eprintln!("Source file `{}` has no extension.", filename.display());
            exit(1);
        });

        //TODO this proably should be a macro for every supported language
        if extension == Schala::source_file_suffix() {
            let config = SchalaConfig { repl: false };

            run_noninteractive(paths, Schala::new(), config);
        } else {
            eprintln!("Extension .{} not recognized", extension);
            exit(1);
        }
    }
}

pub fn run_noninteractive<L: ProgrammingLanguageInterface>(
    filenames: Vec<PathBuf>,
    mut language: L,
    config: L::Config,
) {
    // for now, ony do something with the first filename

    let filename = &filenames[0];
    let mut source_file = File::open(filename).unwrap();
    let mut buffer = String::new();
    source_file.read_to_string(&mut buffer).unwrap();

    let request = ComputationRequest { source: &buffer, config, debug_requests: HashSet::new() };

    let response = language.run_computation(request);
    match response.main_output {
        Ok(s) => println!("{}", s),
        Err(s) => eprintln!("{}", s),
    };
}

fn command_line_options() -> getopts::Options {
    let mut options = getopts::Options::new();
    options.optflag("h", "help", "Show help text");
    //options.optflag("w", "webapp", "Start up web interpreter");
    options
}