use std::sync::{Arc, LazyLock};

use crate::interpreter::{self, Interpreter, Value, wrap_in_quote};

mod lists;
mod numbers;
mod pairlists;

pub use lists::*;
pub use numbers::*;
pub use pairlists::*;

pub static T: LazyLock<Arc<Value>> = LazyLock::new(|| Arc::new(Value::Identifier("T".into())));
pub static F: LazyLock<Arc<Value>> = LazyLock::new(|| Arc::new(Value::Identifier("F".into())));
pub static NIL: LazyLock<Arc<Value>> = LazyLock::new(|| Arc::new(Value::Identifier("NIL".into())));

fn delsh_bool(value: bool) -> Arc<Value> {
	match value {
		true => T.clone(),
		false => NIL.clone(),
	}
}

pub fn quote(_interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
	args[0].clone()
}

pub fn eval(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
	let form = interpreter.eval(args[0].clone());
	let variables = args
		.get(1)
		.map(|value| interpreter.eval(value.clone()).list().expect("a pair list"));

	interpreter.push_frame();

	if let Some(variables) = variables {
		for variable in variables {
			let Some((name, value)) = variable.pair() else {
				continue;
			};
			let Some(name) = name.string() else {
				continue;
			};
			interpreter.set_atom(name.clone(), value.clone());
		}
	}

	let result = interpreter.eval(form);

	interpreter.pop_frame();
	result
}

pub fn apply(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
	let function = interpreter.eval(args[0].clone());
	let arguments = interpreter
		.eval(args[1].clone())
		.list()
		.expect("a list of arguments")
		.into_iter()
		.map(wrap_in_quote)
		.collect::<Box<_>>();
	let variables = args.get(2).map(|value| {
		interpreter
			.eval(value.clone())
			.list()
			.expect("a list of variables")
	});

	interpreter.push_frame();

	if let Some(variables) = variables {
		for variable in variables {
			let Some((name, value)) = variable.pair() else {
				continue;
			};
			let Some(name) = name.string() else {
				continue;
			};
			interpreter.set_atom(name.clone(), value.clone());
		}
	}

	let result = interpreter.run_function(&function, &arguments);

	interpreter.pop_frame();
	result
}

pub fn define(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
	let definitions = args[0].list().expect("a list of definitions");
	for definition in definitions {
		let pair = definition.list().expect("a name-value pair");
		let Some(name) = pair[0].string() else {
			continue;
		};

		let value = interpreter.eval(pair[1].clone());
		interpreter.set_atom(name.clone(), value);
	}

	NIL.clone()
}

pub fn set(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
	let lhs = args[0]
		.identifier()
		.expect("an identifier on the left side");
	let rhs = interpreter.eval(args[1].clone());
	interpreter.set_atom(lhs.clone(), rhs.clone());

	rhs
}

pub fn lambda(_interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
	Arc::new(Value::DelshFn {
		args: args[0]
			.list()
			.expect("a list of argument names")
			.into_iter()
			.filter_map(|value| value.identifier().cloned())
			.collect(),
		command: args[1].clone(),
	})
}

pub fn defun(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
	let Value::Identifier(function_name) = &*args[0] else {
		return NIL.clone();
	};

	let function = Value::DelshFn {
		args: args[1]
			.list()
			.expect("a list of parameter names")
			.into_iter()
			.filter_map(|value| value.identifier().cloned())
			.collect(),
		command: args[2].clone(),
	};

	let function = Arc::new(function);
	interpreter.set_atom(function_name.clone(), function.clone());
	function
}

pub fn do_function(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
	let Some(last_arg) = args.last() else {
		return NIL.clone();
	};

	for arg in &args[..args.len() - 1] {
		interpreter.eval(arg.clone());
	}

	interpreter.eval(last_arg.clone())
}

pub fn if_function(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
	let condition = interpreter.eval(args[0].clone());
	let if_block = args[1].clone();
	let else_block = args[2].clone();

	if condition != *NIL {
		interpreter.eval(if_block)
	} else {
		interpreter.eval(else_block)
	}
}

pub fn cond_function(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
	for case in args {
		let case = case.list().expect("a list of cases");
		let condition = interpreter.eval(case[0].clone());
		if condition != *NIL {
			let mut result = NIL.clone();
			for command in &case[1..] {
				result = interpreter.eval(command.clone());
			}
			return result;
		}
	}

	NIL.clone()
}

pub fn while_function(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
	let condition = args[0].clone();
	let while_block = args[1].clone();

	while interpreter.eval(condition.clone()) != NIL.clone() {
		interpreter.eval(while_block.clone());
	}

	NIL.clone()
}

pub fn loop_function(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
	let expression = args[0].clone();

	loop {
		interpreter.eval(expression.clone());
	}
}

pub fn cons(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
	Arc::new(Value::Pair(
		interpreter.eval(args[0].clone()),
		interpreter.eval(args[1].clone()),
	))
}

pub fn ff(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
	fn ff_inner(arg: Arc<Value>) -> Arc<Value> {
		if let Value::Pair(a, _b) = &*arg {
			ff_inner(a.clone())
		} else {
			arg
		}
	}

	ff_inner(interpreter.eval(args[0].clone()))
}

pub fn subst(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
	fn subst_inner(replacement: Arc<Value>, pattern: Arc<Value>, full: Arc<Value>) -> Arc<Value> {
		if full == pattern {
			return replacement;
		}

		if let Value::Pair(a, b) = &*full {
			return Arc::new(Value::Pair(
				subst_inner(replacement.clone(), pattern.clone(), a.clone()),
				subst_inner(replacement, pattern, b.clone()),
			));
		}

		full
	}

	let arg1 = interpreter.eval(args[0].clone());
	let arg2 = interpreter.eval(args[1].clone());
	let arg3 = interpreter.eval(args[2].clone());

	subst_inner(arg1, arg2, arg3)
}

pub fn is_atom(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
	match &*interpreter.eval(args[0].clone()) {
		Value::Identifier(_) => T.clone(),
		Value::Number(_) => T.clone(),
		Value::String(_) => T.clone(),
		Value::RustFn(_) => T.clone(),
		Value::DelshFn { .. } => T.clone(),
		Value::Pair(..) => NIL.clone(),
	}
}

pub fn is_nil(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
	let x = interpreter.eval(args[0].clone());

	delsh_bool(x == *NIL)
}

pub fn maplist(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
	let list = interpreter.eval(args[0].clone()).list().expect("a list");
	let mapper = interpreter.eval(args[1].clone());

	let mapped = list
		.into_iter()
		.map(|i| interpreter.run_function(&mapper, &[i]))
		.collect::<Box<_>>();
	interpreter::vec_to_value(&mapped)
}

pub fn and(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
	for arg in args {
		let arg = interpreter.eval(arg.clone());
		if arg != *NIL {
			return arg;
		}
	}

	NIL.clone()
}

pub fn or(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
	for arg in args {
		let arg = interpreter.eval(arg.clone());
		if arg == *NIL {
			return arg;
		}
	}

	NIL.clone()
}

pub fn not(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
	is_nil(interpreter, args)
}