use std::{fs::File, io::Read, collections::LinkedList, process::exit};

use logos::Logos;
use parser::{program::Program, Parsable, WrappedLexer};

mod token;
mod parser;
mod ir;

fn main() -> std::io::Result<()> {
    let mut input_file = File::open("sample-initial.amo")?;
	let mut input = String::with_capacity(4096);
	input_file.read_to_string(&mut input)?;

	let lexer = token::Token::lexer(&input);
	let mut wrapped_lexer = WrappedLexer::new(lexer);
	let program = match Program::parse(&mut wrapped_lexer) {
		Err(e) => {
			let location = e.location;
			eprintln!("Parse error at {location:?}!");
			eprintln!("Expected one of:");
			for token in e.expected {
				eprintln!(" - {token:?}");
			}
			exit(1);
		}
		Ok(p) => p
	};

	println!("Parse successful!!");
	for decl in &program.0 {
		println!("{decl:?}\n");
	}

	println!("Building IR...");
	match program.gen_ir() {
		Ok(program) =>
			println!(
				"IR built successfully!\n{}",
				program.into_iter()
					.map(|decl| format!("\n\n{decl}"))
					.collect::<String>(),
			),
		Err(e) =>
			println!("Oh noes! {e:?}"),
	}
	Ok(())
}

pub fn cons<T>(mut v: Vec<T>, e: T) -> Vec<T> {
	v.push(e);
	v
}

pub fn cons_ll<T>(mut v: LinkedList<T>, e: T) -> LinkedList<T> {
	v.push_back(e);
	v
}

pub fn join<T>(mut a: LinkedList<T>, mut b: LinkedList<T>) -> LinkedList<T> {
	a.append(&mut b);
	a
}

pub fn join_vec<T>(mut a: Vec<T>, mut b: Vec<T>) -> Vec<T> {
	a.append(&mut b);
	a
}