pub mod ast;
mod atoms;
mod grammar;
#[cfg(test)]
mod test_suite;

use crate::error::{ForgeError, ForgeErrorKind, ForgeResult};
use crate::print_forge_error;
pub use atoms::TokenSlice;

pub fn slice<'a>(toks: &'a [crate::lexer::ScriptToken]) -> TokenSlice<'a> {
	TokenSlice(toks)
}

pub fn parse_expression(expr: &str) -> ForgeResult<ast::Expression> {
	let tokens = crate::lexer::script_to_tokens(expr)?;
	let result = match grammar::expression(&TokenSlice(tokens.as_slice())) {
		Ok(expr) => Ok(expr),
		Err(parse_error) => {
			let bad_token = &tokens[parse_error.location];
			Err(ForgeError {
				kind: ForgeErrorKind::UnexpectedToken {
					found: bad_token.clone(),
					expected: parse_error.expected,
				},
			})
		}
	};

	result.map_err(|e| {
		print_forge_error(expr, &e);
		e
	})
}

pub fn parse_program(prog: &str) -> ForgeResult<ast::Program> {
	let tokens = crate::lexer::script_to_tokens(prog)?;
	let result = match grammar::program(&TokenSlice(tokens.as_slice())) {
		Ok(prog) => Ok(prog.clone()),
		Err(parse_error) => {
			let bad_token = &tokens[parse_error.location];
			Err(ForgeError {
				kind: ForgeErrorKind::UnexpectedToken {
					found: bad_token.clone(),
					expected: parse_error.expected,
				},
			})
		}
	};

	result.map_err(|e| {
		print_forge_error(prog, &e);
		e
	})
}