use chumsky::{input::Stream, prelude::*};

const DEBUG_COMPILE: bool = true;
const DEBUG_RUN: bool = true;

mod memory_sandbox;

mod spans;

mod lexer;
use crate::lexer::lexer;

mod parser;
use crate::parser::parser;

mod validator;

mod compiler;
use crate::compiler::Chunk;

mod value;

mod vm;
use vm::Vm;

pub fn run(src: &'static str) {
    let (tokens, lex_errs) = lexer().parse(src).into_output_errors();
    if !lex_errs.is_empty() {
        println!("{:?}", lex_errs);
        return;
    }

    let tokens = tokens.unwrap();

    let (parse_result, parse_errors) = parser()
        .parse(Stream::from_iter(tokens).map((0..src.len()).into(), |(t, s)| (t, s)))
        .into_output_errors();
    if !parse_errors.is_empty() {
        println!("{:?}", parse_errors);
        return;
    }

    let parsed = parse_result.unwrap();

    let mut chunk = Chunk::new(&parsed, "test", src);
    chunk.compile();
    if DEBUG_COMPILE {
        chunk.disassemble();
        println!("\n\n")
    }

    if DEBUG_RUN {
        println!("=== vm run: test ===");
    }

    let mut vm = Vm::new(&chunk);
    let result = vm.interpret();
    let output = match result {
        Ok(val) => val.show(&chunk),
        Err(panic) => format!("{:?}", panic),
    };
    println!("{output}");
}

pub fn main() {
    let src = "
let foo = 42
when {
    foo -> :two
    false -> :four
    :else -> :thing
}
    ";
    run(src);
}