use builtins::initialise_globals;
use codespan_reporting::files::SimpleFiles;
use codespan_reporting::term;
use codespan_reporting::term::termcolor::ColorChoice;
use codespan_reporting::term::termcolor::StandardStream;
use syntax::parse_syntax;

use crate::syntax::check::check;

mod builtins;
mod hir;
mod lexer;
mod syntax;

fn main() {
    let mut files = SimpleFiles::new();
    let mut out_errs = Vec::new();

    let global_ns = initialise_globals();
    let int = global_ns.get_type_by_name("integer").unwrap();
    let numeric = global_ns.get_trait_by_name("Numeric").unwrap();
    assert!(int.has_trait(&numeric));

    let invalid_toks = "meow | gay $ error!\\";
    let invalid_toks_id = files.add("invalid_toks", invalid_toks);
    if let Err(err) = parse_syntax(invalid_toks, invalid_toks_id) {
        out_errs.push(err)
    }

    let invalid_no_streamer = "| invert | save \"./image_processed.jpg\"";
    let invalid_no_streamer_id = files.add("invalid_no_streamer", invalid_no_streamer);
    if let Err(mut errs) = check(
        parse_syntax(invalid_no_streamer, invalid_no_streamer_id).unwrap(),
        invalid_no_streamer,
        invalid_no_streamer_id,
    ) {
        out_errs.append(&mut errs)
    }

    let invalid_missing_filters = "meow | | test | awa |   | nya";
    let invalid_missing_filters_id = files.add("invalid_missing_filters", invalid_missing_filters);
    if let Err(mut errs) = check(
        parse_syntax(invalid_missing_filters, invalid_missing_filters_id).unwrap(),
        invalid_missing_filters,
        invalid_missing_filters_id,
    ) {
        out_errs.append(&mut errs)
    }

    let invalid_no_sink = "meow | invert | ";
    let invalid_no_sink_id = files.add("invalid_no_sink", invalid_no_sink);
    if let Err(mut errs) = check(
        parse_syntax(invalid_no_sink, invalid_no_sink_id).unwrap(),
        invalid_no_sink,
        invalid_no_sink_id,
    ) {
        out_errs.append(&mut errs)
    }

    // invalid
    let writer = StandardStream::stderr(ColorChoice::Always);
    let config = term::Config::default();

    for err in out_errs {
        let writer = &mut writer.lock();
        term::emit(writer, &config, &files, &err.to_diagnostic()).unwrap();
    }
}