use std::{
	collections::{HashMap, HashSet},
	fmt::Debug,
	sync::Arc,
};

use rust_decimal::Decimal;

use crate::{
	ast::{self, Expression, List},
	builtins::NIL,
};

type NativeFunction = fn(&mut Interpreter, &[Arc<Value>]) -> Arc<Value>;

#[derive(Debug, Default)]
pub struct Interpreter {
	stack: Vec<HashMap<Arc<str>, Arc<Value>>>,
}

#[derive(Clone, PartialEq, Eq, Hash)]
pub enum Value {
	Identifier(Arc<str>),
	Number(Decimal),
	String(Arc<str>),
	Pair(Arc<Value>, Arc<Value>),
	RustFn(NativeFunction),
	DelshFn {
		args: Arc<[Arc<str>]>,
		command: Arc<Value>,
	},
}

impl Debug for Value {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		fn fmt_pair(
			f: &mut std::fmt::Formatter<'_>,
			a: Arc<Value>,
			b: Arc<Value>,
		) -> std::fmt::Result {
			a.fmt(f)?;

			if let Value::Pair(a, b) = &*b {
				f.write_str(" ")?;
				fmt_pair(f, a.clone(), b.clone())
			} else if b == NIL.clone() {
				f.write_str(")")
			} else {
				f.write_str(" . ")?;
				b.fmt(f)?;
				f.write_str(")")
			}
		}

		match self {
			Value::Identifier(identifier) => f.write_str(identifier),
			Value::Number(number) => write!(f, "{number}"),
			Value::String(string) => write!(f, "\"{string}\""),
			Value::Pair(a, b) => {
				f.write_str("(")?;
				fmt_pair(f, a.clone(), b.clone())
			}
			Value::RustFn(_) => f.write_str("builtin function"),
			Value::DelshFn { .. } => f.write_str("function"),
		}
	}
}

impl Value {
	pub fn identifier(&self) -> Option<&Arc<str>> {
		if let Value::Identifier(identifier) = self {
			Some(identifier)
		} else {
			None
		}
	}

	pub fn number(&self) -> Option<&Decimal> {
		if let Value::Number(number) = self {
			Some(number)
		} else {
			None
		}
	}

	pub fn string(&self) -> Option<&Arc<str>> {
		if let Value::String(string) = self {
			Some(string)
		} else {
			None
		}
	}

	pub fn pair(&self) -> Option<(&Arc<Value>, &Arc<Value>)> {
		if let Value::Pair(a, b) = self {
			Some((a, b))
		} else {
			None
		}
	}

	pub fn list(&self) -> Option<Vec<Arc<Value>>> {
		let mut list = self;
		let mut builder = Vec::new();
		loop {
			if let Value::Pair(head, rest) = &list {
				builder.push(head.clone());
				list = rest;
			} else if list == &**NIL {
				return Some(builder);
			} else {
				return None;
			}
		}
	}

	pub fn set(&self) -> Option<HashSet<Arc<Value>>> {
		let mut head = self;
		let mut builder = HashSet::new();
		loop {
			if let Value::Pair(car, cdr) = &head {
				builder.insert(car.clone());
				head = cdr;
			} else if head == &**NIL {
				return Some(builder);
			} else {
				return None;
			}
		}
	}

	pub fn rust_fn(&self) -> Option<&NativeFunction> {
		if let Value::RustFn(func) = self {
			Some(func)
		} else {
			None
		}
	}

	pub fn is_function(&self) -> bool {
		matches!(self, Value::RustFn(_) | Value::DelshFn { .. })
	}
}

pub fn wrap_in_quote(value: Arc<Value>) -> Arc<Value> {
	Arc::new(Value::Pair(
		Arc::new(Value::Identifier("QUOTE".into())),
		Arc::new(Value::Pair(value, NIL.clone())),
	))
}

pub fn vec_to_value(list: &[Arc<Value>]) -> Arc<Value> {
	if list.is_empty() {
		NIL.clone()
	} else if list.len() == 1 {
		Arc::new(Value::Pair(list[0].clone(), NIL.clone()))
	} else {
		Arc::new(Value::Pair(list[0].clone(), vec_to_value(&list[1..])))
	}
}

impl Interpreter {
	pub fn new() -> Self {
		Self {
			stack: vec![HashMap::new()],
		}
	}

	fn current_stack_frame_mut(&mut self) -> &mut HashMap<Arc<str>, Arc<Value>> {
		self.stack
			.last_mut()
			.expect("there should always be at least one stack frame")
	}

	pub fn push_frame(&mut self) {
		self.stack.push(HashMap::new());
	}

	pub fn pop_frame(&mut self) {
		if self.stack.len() == 1 {
			return;
		}

		self.stack.pop();
	}

	pub fn get_atom(&self, name: &str) -> Option<Arc<Value>> {
		for frame in self.stack.iter().rev() {
			if let Some(value) = frame.get(name) {
				return Some(value.clone());
			}
		}

		None
	}

	pub fn set_atom(&mut self, name: Arc<str>, value: Arc<Value>) {
		self.current_stack_frame_mut()
			.insert(name.to_uppercase().into(), value);
	}

	pub fn run_function(&mut self, function: &Value, arguments: &[Arc<Value>]) -> Arc<Value> {
		match function {
			Value::RustFn(func) => func(self, arguments),
			Value::DelshFn { args, command } => {
				self.push_frame();
				for (name, value) in args.iter().zip(arguments) {
					let value = self.eval(value.clone());
					self.set_atom(name.clone(), value);
				}

				let return_value = self.eval(command.clone());
				self.pop_frame();
				return_value
			}
			_ => panic!("expected a function"),
		}
	}

	pub fn eval(&mut self, value: Arc<Value>) -> Arc<Value> {
		match &*value {
			Value::Identifier(identifier) => {
				self.get_atom(identifier).expect("a defined atom").clone()
			}
			Value::Pair(function, arguments) => {
				let function = self.eval(function.clone());
				let arguments = arguments.list().expect("arguments to be a list");
				self.run_function(&function, &arguments)
			}
			_ => value,
		}
	}

	fn ast_list_to_value(&mut self, list: &List) -> Arc<Value> {
		let contains_dot = list.items.iter().any(|item| item.dot().is_some());
		let mut head = (!contains_dot).then(|| NIL.clone());
		for item in list.items.iter().rev() {
			let Some(item) = item.expression() else {
				continue;
			};
			let Some(head) = head.as_mut() else {
				head = Some(self.ast_expression_value(item));
				continue;
			};

			*head = Arc::new(Value::Pair(self.ast_expression_value(item), head.clone()));
		}

		head.unwrap_or_else(|| NIL.clone())
	}

	pub fn ast_expression_value(&mut self, expr: &Expression) -> Arc<Value> {
		let suffix_value = match &expr.suffix {
			ast::ExpressionSuffix::Nothing => NIL.clone(),
			ast::ExpressionSuffix::Number { value, .. } => Arc::new(Value::Number(*value)),
			ast::ExpressionSuffix::String { value, .. } => Arc::new(Value::String(value.clone())),
			ast::ExpressionSuffix::Identifier { name, .. } => {
				Arc::new(Value::Identifier(name.clone()))
			}
			ast::ExpressionSuffix::List(list) => self.ast_list_to_value(list),
		};

		if expr.is_quoted() {
			wrap_in_quote(suffix_value)
		} else {
			suffix_value
		}
	}

	pub fn run_ast_command(&mut self, command: &ast::Command) -> Arc<Value> {
		match command {
			ast::Command::Statement(statement) => {
				let function_name = &statement.function_name;
				let function = self
					.get_atom(function_name)
					.expect("expected a defined value")
					.clone();
				let arguments = statement
					.args
					.iter()
					.map(|arg| self.ast_expression_value(arg))
					.collect::<Box<_>>();

				self.run_function(&function, &arguments)
			}
			ast::Command::Expression(expression) => {
				let value = self.ast_expression_value(expression);
				self.eval(value)
			}
			ast::Command::PanicMode(_) => NIL.clone(),
		}
	}
}