use builtins::initialise_globals;
use codespan_reporting::{
    files::SimpleFiles,
    term::{
        self,
        termcolor::{ColorChoice, StandardStream},
    },
};
use syntax::parse_syntax;

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

mod builtins;
mod lexer;
mod syntax;
mod type_repr;

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)
    }

    let valid_add_input_pipe = "1 | add 2";
    let valid_add_input_pipe_id = files.add("valid_add_input_pipe", valid_add_input_pipe);
    let syntax = dbg!(check(
        parse_syntax(valid_add_input_pipe, valid_add_input_pipe_id).unwrap(),
        valid_add_input_pipe,
        valid_add_input_pipe_id,
    )
    .unwrap());

    let valid_add_input_args = "add 1 2";
    let valid_add_input_args_id = files.add("valid_add_input_args", valid_add_input_args);
    let syntax = dbg!(check(
        parse_syntax(valid_add_input_args, valid_add_input_args_id).unwrap(),
        valid_add_input_args,
        valid_add_input_args_id,
    )
    .unwrap());

    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();
    }
}