//! Interprets an AST as a program

use env::Environment;
use error::{Error, IResult};
use interpret::Interpret;
use temp_type_impl::ConValue;

/// Callable types can be called from within a Conlang program
pub trait Callable: std::fmt::Debug {
    /// Calls this [Callable] in the provided [Environment], with [ConValue] args  \
    /// The Callable is responsible for checking the argument count and validating types
    fn call(&self, interpreter: &mut Environment, args: &[ConValue]) -> IResult<ConValue>;
    /// Returns the common name of this identifier.
    fn name(&self) -> &str;
}

/// [BuiltIn]s are [Callable]s with bespoke definitions
pub trait BuiltIn: std::fmt::Debug + Callable {}

pub mod temp_type_impl {
    //! Temporary implementations of Conlang values
    //!
    //! The most permanent fix is a temporary one.
    use super::{
        error::{Error, IResult},
        function::Function,
        BuiltIn, Callable, Environment,
    };
    use std::ops::*;
    /// A Conlang value
    ///
    /// This is a hack to work around the fact that Conlang doesn't
    /// have a functioning type system yet :(
    #[derive(Clone, Debug, Default)]
    pub enum ConValue {
        /// The empty/unit `()` type
        #[default]
        Empty,
        /// An integer
        Int(i128),
        /// A boolean
        Bool(bool),
        /// A unicode character
        Char(char),
        /// A string
        String(String),
        /// An Array
        Array(Vec<ConValue>),
        /// A tuple
        Tuple(Vec<ConValue>),
        /// An exclusive range
        RangeExc(i128, i128),
        /// An inclusive range
        RangeInc(i128, i128),
        /// A callable thing
        Function(Function),
        /// A built-in function
        BuiltIn(&'static dyn BuiltIn),
    }
    impl ConValue {
        /// Gets whether the current value is true or false
        pub fn truthy(&self) -> IResult<bool> {
            match self {
                ConValue::Bool(v) => Ok(*v),
                _ => Err(Error::TypeError)?,
            }
        }
        pub fn range_exc(self, other: Self) -> IResult<Self> {
            let (Self::Int(a), Self::Int(b)) = (self, other) else {
                Err(Error::TypeError)?
            };
            Ok(Self::RangeExc(a, b.saturating_sub(1)))
        }
        pub fn range_inc(self, other: Self) -> IResult<Self> {
            let (Self::Int(a), Self::Int(b)) = (self, other) else {
                Err(Error::TypeError)?
            };
            Ok(Self::RangeInc(a, b))
        }
        pub fn index(&self, index: &Self) -> IResult<ConValue> {
            let Self::Int(index) = index else {
                Err(Error::TypeError)?
            };
            let Self::Array(arr) = self else {
                Err(Error::TypeError)?
            };
            arr.get(*index as usize)
                .cloned()
                .ok_or(Error::OobIndex(*index as usize, arr.len()))
        }
        cmp! {
            lt: false, <;
            lt_eq: true, <=;
            eq: true, ==;
            neq: false, !=;
            gt_eq: true, >=;
            gt: false, >;
        }
        assign! {
            add_assign: +;
            bitand_assign: &;
            bitor_assign: |;
            bitxor_assign: ^;
            div_assign: /;
            mul_assign: *;
            rem_assign: %;
            shl_assign: <<;
            shr_assign: >>;
            sub_assign: -;
        }
    }

    impl Callable for ConValue {
        fn name(&self) -> &str {
            match self {
                ConValue::Function(func) => func.name(),
                ConValue::BuiltIn(func) => func.name(),
                _ => "",
            }
        }
        fn call(&self, interpreter: &mut Environment, args: &[ConValue]) -> IResult<ConValue> {
            match self {
                Self::Function(func) => func.call(interpreter, args),
                Self::BuiltIn(func) => func.call(interpreter, args),
                _ => Err(Error::NotCallable(self.clone())),
            }
        }
    }
    /// Templates comparison functions for [ConValue]
    macro cmp ($($fn:ident: $empty:literal, $op:tt);*$(;)?) {$(
        /// TODO: Remove when functions are implemented:
        ///       Desugar into function calls
        pub fn $fn(&self, other: &Self) -> IResult<Self> {
            match (self, other) {
                (Self::Empty, Self::Empty) => Ok(Self::Bool($empty)),
                (Self::Int(a), Self::Int(b)) => Ok(Self::Bool(a $op b)),
                (Self::Bool(a), Self::Bool(b)) => Ok(Self::Bool(a $op b)),
                (Self::Char(a), Self::Char(b)) => Ok(Self::Bool(a $op b)),
                (Self::String(a), Self::String(b)) => Ok(Self::Bool(a $op b)),
                _ => Err(Error::TypeError)
            }
        }
    )*}
    macro assign($( $fn: ident: $op: tt );*$(;)?) {$(
        pub fn $fn(&mut self, other: Self) -> IResult<()> {
            *self = (std::mem::take(self) $op other)?;
            Ok(())
        }
    )*}
    /// Implements [From] for an enum with 1-tuple variants
    macro from ($($T:ty => $v:expr),*$(,)?) {
        $(impl From<$T> for ConValue {
            fn from(value: $T) -> Self { $v(value.into()) }
        })*
    }
    from! {
        i128 => ConValue::Int,
        bool => ConValue::Bool,
        char => ConValue::Char,
        &str => ConValue::String,
        String => ConValue::String,
        Function => ConValue::Function,
        Vec<ConValue> => ConValue::Tuple,
    }
    impl From<()> for ConValue {
        fn from(_: ()) -> Self {
            Self::Empty
        }
    }
    impl From<&[ConValue]> for ConValue {
        fn from(value: &[ConValue]) -> Self {
            match value.len() {
                0 => Self::Empty,
                1 => value[0].clone(),
                _ => Self::Tuple(value.into()),
            }
        }
    }

    /// Implements binary [std::ops] traits for [ConValue]
    ///
    /// TODO: Desugar operators into function calls
    macro ops($($trait:ty: $fn:ident = [$($match:tt)*])*) {
        $(impl $trait for ConValue {
            type Output = IResult<Self>;
            /// TODO: Desugar operators into function calls
            fn $fn(self, rhs: Self) -> Self::Output {Ok(match (self, rhs) {$($match)*})}
        })*
    }
    ops! {
        Add: add = [
            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a + b),
            (ConValue::String(a), ConValue::String(b)) => ConValue::String(a + &b),
            _ => Err(Error::TypeError)?
            ]
        BitAnd: bitand = [
            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a & b),
            (ConValue::Bool(a), ConValue::Bool(b)) => ConValue::Bool(a & b),
            _ => Err(Error::TypeError)?
        ]
        BitOr: bitor = [
            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a | b),
            (ConValue::Bool(a), ConValue::Bool(b)) => ConValue::Bool(a | b),
            _ => Err(Error::TypeError)?
        ]
        BitXor: bitxor = [
            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a ^ b),
            (ConValue::Bool(a), ConValue::Bool(b)) => ConValue::Bool(a ^ b),
            _ => Err(Error::TypeError)?
        ]
        Div: div = [
            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a / b),
            _ => Err(Error::TypeError)?
        ]
        Mul: mul = [
            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a * b),
            _ => Err(Error::TypeError)?
        ]
        Rem: rem = [
            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a % b),
            _ => Err(Error::TypeError)?
        ]
        Shl: shl = [
            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a << b),
            _ => Err(Error::TypeError)?
        ]
        Shr: shr = [
            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a >> b),
            _ => Err(Error::TypeError)?
        ]
        Sub: sub = [
            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a - b),
            _ => Err(Error::TypeError)?
        ]
    }
    impl Neg for ConValue {
        type Output = IResult<Self>;
        fn neg(self) -> Self::Output {
            Ok(match self {
                ConValue::Empty => ConValue::Empty,
                ConValue::Int(v) => ConValue::Int(-v),
                _ => Err(Error::TypeError)?,
            })
        }
    }
    impl Not for ConValue {
        type Output = IResult<Self>;
        fn not(self) -> Self::Output {
            Ok(match self {
                ConValue::Empty => ConValue::Empty,
                ConValue::Int(v) => ConValue::Int(!v),
                ConValue::Bool(v) => ConValue::Bool(!v),
                _ => Err(Error::TypeError)?,
            })
        }
    }
    impl std::fmt::Display for ConValue {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            match self {
                ConValue::Empty => "Empty".fmt(f),
                ConValue::Int(v) => v.fmt(f),
                ConValue::Bool(v) => v.fmt(f),
                ConValue::Char(v) => v.fmt(f),
                ConValue::String(v) => v.fmt(f),
                ConValue::Array(array) => {
                    '['.fmt(f)?;
                    for (idx, element) in array.iter().enumerate() {
                        if idx > 0 {
                            ", ".fmt(f)?
                        }
                        element.fmt(f)?
                    }
                    ']'.fmt(f)
                }
                ConValue::RangeExc(a, b) => write!(f, "{a}..{}", b + 1),
                ConValue::RangeInc(a, b) => write!(f, "{a}..={b}"),
                ConValue::Tuple(tuple) => {
                    '('.fmt(f)?;
                    for (idx, element) in tuple.iter().enumerate() {
                        if idx > 0 {
                            ", ".fmt(f)?
                        }
                        element.fmt(f)?
                    }
                    ')'.fmt(f)
                }
                ConValue::Function(func) => {
                    write!(f, "fn {}", func.name())
                }
                ConValue::BuiltIn(func) => {
                    write!(f, "internal fn {}", func.name())
                }
            }
        }
    }
}

pub mod interpret {
    use super::*;
    use crate::ast::*;
    /// A work-in-progress tree walk interpreter for Conlang
    pub trait Interpret {
        /// Interprets this thing in the given [`Environment`].
        ///
        /// Everything returns a value!™
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue>;
    }

    impl Interpret for File {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            for item in &self.items {
                item.interpret(env)?;
            }
            Ok(ConValue::Empty)
        }
    }
    impl Interpret for Item {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            match &self.kind {
                ItemKind::Const(item) => item.interpret(env),
                ItemKind::Static(item) => item.interpret(env),
                ItemKind::Module(item) => item.interpret(env),
                ItemKind::Function(item) => item.interpret(env),
                ItemKind::Struct(item) => item.interpret(env),
                ItemKind::Enum(item) => item.interpret(env),
                ItemKind::Impl(item) => item.interpret(env),
            }
        }
    }
    impl Interpret for Const {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            todo!("interpret const in {env}")
        }
    }
    impl Interpret for Static {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            todo!("interpret static in {env}")
        }
    }
    impl Interpret for Module {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            // TODO: Enter this module's namespace
            match &self.kind {
                ModuleKind::Inline(file) => file.interpret(env),
                ModuleKind::Outline => todo!("Load and parse external files"),
            }
        }
    }
    impl Interpret for Function {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            // register the function in the current environment
            env.insert_fn(self);
            Ok(ConValue::Empty)
        }
    }
    impl Interpret for Struct {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            todo!("Interpret structs in {env}")
        }
    }
    impl Interpret for Enum {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            todo!("Interpret enums in {env}")
        }
    }
    impl Interpret for Impl {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            todo!("Enter a struct's namespace and insert function definitions into it in {env}");
        }
    }
    impl Interpret for Stmt {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            let Self { extents: _, kind, semi } = self;
            let out = match kind {
                StmtKind::Empty => ConValue::Empty,
                StmtKind::Local(stmt) => stmt.interpret(env)?,
                StmtKind::Item(stmt) => stmt.interpret(env)?,
                StmtKind::Expr(stmt) => stmt.interpret(env)?,
            };
            Ok(match semi {
                Semi::Terminated => ConValue::Empty,
                Semi::Unterminated => out,
            })
        }
    }
    impl Interpret for Let {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            let Let { mutable: _, name: Identifier(name), init } = self;
            if let Some(init) = init {
                let init = init.interpret(env)?;
                env.insert(name, Some(init));
            } else {
                env.insert(name, None);
            }
            Ok(ConValue::Empty)
        }
    }
    impl Interpret for Expr {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            let Self { extents: _, kind } = self;
            match kind {
                ExprKind::Assign(v) => v.interpret(env),
                ExprKind::Binary(v) => v.interpret(env),
                ExprKind::Unary(v) => v.interpret(env),
                ExprKind::Member(v) => v.interpret(env),
                ExprKind::Call(v) => v.interpret(env),
                ExprKind::Index(v) => v.interpret(env),
                ExprKind::Path(v) => v.interpret(env),
                ExprKind::Literal(v) => v.interpret(env),
                ExprKind::Array(v) => v.interpret(env),
                ExprKind::ArrayRep(v) => v.interpret(env),
                ExprKind::AddrOf(v) => v.interpret(env),
                ExprKind::Block(v) => v.interpret(env),
                ExprKind::Empty => Ok(ConValue::Empty),
                ExprKind::Group(v) => v.interpret(env),
                ExprKind::Tuple(v) => v.interpret(env),
                ExprKind::While(v) => v.interpret(env),
                ExprKind::If(v) => v.interpret(env),
                ExprKind::For(v) => v.interpret(env),
                ExprKind::Break(v) => v.interpret(env),
                ExprKind::Return(v) => v.interpret(env),
                ExprKind::Continue(v) => v.interpret(env),
            }
        }
    }
    impl Interpret for Assign {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            let Assign { head, op, tail } = self;
            // Resolve the head pattern
            let head = match &head.kind {
                ExprKind::Path(Path { parts, .. }) if parts.len() == 1 => {
                    match parts.last().expect("parts should not be empty") {
                        PathPart::SuperKw => Err(Error::NotAssignable(head.extents.head))?,
                        PathPart::SelfKw => todo!("Assignment to `self`"),
                        PathPart::Ident(Identifier(s)) => s,
                    }
                }
                ExprKind::Member(_) => todo!("Member access assignment"),
                ExprKind::Call(_) => todo!("Assignment to the result of a function call?"),
                ExprKind::Index(_) => todo!("Assignment to an index operation"),
                ExprKind::Path(_) => todo!("Path expression resolution (IMPORTANT)"),
                ExprKind::Empty | ExprKind::Group(_) | ExprKind::Tuple(_) => {
                    todo!("Pattern Destructuring?")
                }
                _ => Err(Error::NotAssignable(head.extents.head))?,
            };
            // Get the initializer and the tail
            let init = tail.interpret(env)?;
            let target = env.get_mut(head)?;

            if let AssignKind::Plain = op {
                use std::mem::discriminant as variant;
                // runtime typecheck
                match target {
                    Some(value) if variant(value) == variant(&init) => {
                        *value = init;
                    }
                    value @ None => *value = Some(init),
                    _ => Err(Error::TypeError)?,
                }
                return Ok(ConValue::Empty);
            }
            let Some(target) = target else {
                return Err(Error::NotInitialized(head.into()));
            };

            match op {
                AssignKind::Add => target.add_assign(init)?,
                AssignKind::Sub => target.sub_assign(init)?,
                AssignKind::Mul => target.mul_assign(init)?,
                AssignKind::Div => target.div_assign(init)?,
                AssignKind::Rem => target.rem_assign(init)?,
                AssignKind::And => target.bitand_assign(init)?,
                AssignKind::Or => target.bitor_assign(init)?,
                AssignKind::Xor => target.bitxor_assign(init)?,
                AssignKind::Shl => target.shl_assign(init)?,
                AssignKind::Shr => target.shr_assign(init)?,
                _ => (),
            }
            Ok(ConValue::Empty)
        }
    }
    impl Interpret for Binary {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            let Binary { head, tail } = self;
            let mut head = head.interpret(env)?;
            for (op, tail) in tail {
                head = match op {
                    BinaryKind::LogAnd => {
                        if head.truthy()? {
                            tail.interpret(env)
                        } else {
                            return Ok(head); // Short circuiting
                        }
                    }
                    BinaryKind::LogOr => {
                        if !head.truthy()? {
                            tail.interpret(env)
                        } else {
                            return Ok(head); // Short circuiting
                        }
                    }
                    BinaryKind::LogXor => {
                        // TODO: It should be possible to assemble better error information from
                        // this
                        let (lhs, rhs) = (head.truthy()?, tail.interpret(env)?.truthy()?);
                        Ok(ConValue::Bool(lhs ^ rhs))
                    }
                    // TODO: For all overloadable operators, transmute into function call
                    BinaryKind::Mul => head * tail.interpret(env)?,
                    BinaryKind::Div => head / tail.interpret(env)?,
                    BinaryKind::Rem => head % tail.interpret(env)?,
                    BinaryKind::Add => head + tail.interpret(env)?,
                    BinaryKind::Sub => head - tail.interpret(env)?,
                    BinaryKind::Shl => head << tail.interpret(env)?,
                    BinaryKind::Shr => head >> tail.interpret(env)?,
                    BinaryKind::BitAnd => head & tail.interpret(env)?,
                    BinaryKind::BitOr => head | tail.interpret(env)?,
                    BinaryKind::BitXor => head ^ tail.interpret(env)?,
                    BinaryKind::RangeExc => head.range_exc(tail.interpret(env)?),
                    BinaryKind::RangeInc => head.range_inc(tail.interpret(env)?),
                    BinaryKind::Lt => head.lt(&tail.interpret(env)?),
                    BinaryKind::LtEq => head.lt_eq(&tail.interpret(env)?),
                    BinaryKind::Equal => head.eq(&tail.interpret(env)?),
                    BinaryKind::NotEq => head.neq(&tail.interpret(env)?),
                    BinaryKind::GtEq => head.gt_eq(&tail.interpret(env)?),
                    BinaryKind::Gt => head.gt(&tail.interpret(env)?),
                    BinaryKind::Dot => todo!("search within a type's namespace!"),
                }?;
            }
            Ok(head)
        }
    }
    impl Interpret for Unary {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            let Unary { tail, ops } = self;
            let mut operand = tail.interpret(env)?;

            for op in ops.iter().rev() {
                operand = match op {
                    UnaryKind::Deref => todo!("Deref operator"),
                    UnaryKind::Neg => (-operand)?,
                    UnaryKind::Not => (!operand)?,
                    UnaryKind::At => unimplemented!("At operator"),
                    UnaryKind::Hash => {
                        println!("{operand}");
                        operand
                    }
                    UnaryKind::Tilde => unimplemented!("Tilde operator"),
                };
            }
            Ok(operand)
        }
    }
    impl Interpret for Member {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            todo!("Interpret member accesses in {env}")
        }
    }
    impl Interpret for Call {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            let Self { callee, args } = self;
            // evaluate the callee
            let mut callee = callee.interpret(env)?;
            for args in args {
                let ConValue::Tuple(args) = args.interpret(env)? else {
                    Err(Error::TypeError)?
                };
                callee = callee.call(env, &args)?;
            }
            Ok(callee)
        }
    }
    impl Interpret for Index {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            let Self { head, indices } = self;
            let mut head = head.interpret(env)?;
            for indices in indices {
                let Indices { exprs } = indices;
                for index in exprs {
                    head = head.index(&index.interpret(env)?)?;
                }
            }
            Ok(head)
        }
    }
    impl Interpret for Path {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            let Self { absolute: _, parts } = self;

            if parts.len() == 1 {
                match parts.last().expect("parts should not be empty") {
                    PathPart::SuperKw | PathPart::SelfKw => todo!("Path navigation"),
                    PathPart::Ident(Identifier(s)) => env.get(s).cloned(),
                }
            } else {
                todo!("Path navigation!")
            }
        }
    }
    impl Interpret for Literal {
        fn interpret(&self, _env: &mut Environment) -> IResult<ConValue> {
            Ok(match self {
                Literal::String(value) => ConValue::from(value.as_str()),
                Literal::Char(value) => ConValue::Char(*value),
                Literal::Bool(value) => ConValue::Bool(*value),
                // Literal::Float(value) => todo!("Float values in interpreter: {value:?}"),
                Literal::Int(value) => ConValue::Int(*value as _),
            })
        }
    }
    impl Interpret for Array {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            let Self { values } = self;
            let mut out = vec![];
            for expr in values {
                out.push(expr.interpret(env)?)
            }
            Ok(ConValue::Array(out))
        }
    }
    impl Interpret for ArrayRep {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            let Self { value, repeat } = self;
            let repeat = match repeat.interpret(env)? {
                ConValue::Int(v) => v,
                _ => Err(Error::TypeError)?,
            };
            let value = value.interpret(env)?;
            Ok(ConValue::Array(vec![value; repeat as usize]))
        }
    }
    impl Interpret for AddrOf {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            todo!("Implement AddrOf in {env}")
        }
    }
    impl Interpret for Block {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            let Self { stmts } = self;
            let mut env = env.frame("block");
            let mut out = ConValue::Empty;
            for stmt in stmts {
                let Stmt { kind, semi, .. } = stmt;
                out = match (kind, semi) {
                    (StmtKind::Expr(_), Semi::Unterminated) => stmt.interpret(&mut env)?,
                    (StmtKind::Expr(_), _) => {
                        stmt.interpret(&mut env)?;
                        ConValue::Empty
                    }
                    _ => {
                        stmt.interpret(&mut env)?;
                        continue;
                    }
                }
            }
            Ok(out)
        }
    }
    impl Interpret for Group {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            let Self { expr } = self;
            expr.interpret(env)
        }
    }
    impl Interpret for Tuple {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            let Self { exprs } = self;
            Ok(ConValue::Tuple(exprs.iter().try_fold(
                vec![],
                |mut out, element| {
                    out.push(element.interpret(env)?);
                    Ok(out)
                },
            )?))
        }
    }
    impl Interpret for While {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            let Self { cond, pass, fail } = self;
            while cond.interpret(env)?.truthy()? {
                match pass.interpret(env) {
                    Err(Error::Break(value)) => return Ok(value),
                    Err(Error::Continue) => continue,
                    e => e?,
                };
            }
            fail.interpret(env)
        }
    }
    impl Interpret for If {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            let Self { cond, pass, fail } = self;
            if cond.interpret(env)?.truthy()? {
                pass.interpret(env)
            } else {
                fail.interpret(env)
            }
        }
    }
    impl Interpret for For {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            let Self { bind: Identifier(name), cond, pass, fail } = self;
            // TODO: A better iterator model
            let bounds = match cond.interpret(env)? {
                ConValue::RangeExc(a, b) => a..=b,
                ConValue::RangeInc(a, b) => a..=b,
                _ => Err(Error::TypeError)?,
            };
            {
                let mut env = env.frame("loop variable");
                for loop_var in bounds {
                    env.insert(name, Some(loop_var.into()));
                    match pass.interpret(&mut env) {
                        Err(Error::Break(value)) => return Ok(value),
                        Err(Error::Continue) => continue,
                        result => result?,
                    };
                }
            }
            fail.interpret(env)
        }
    }
    impl Interpret for Else {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            let Self { body } = self;
            match body {
                Some(body) => body.interpret(env),
                None => Ok(ConValue::Empty),
            }
        }
    }
    impl Interpret for Continue {
        fn interpret(&self, _env: &mut Environment) -> IResult<ConValue> {
            Err(Error::Continue)
        }
    }
    impl Interpret for Return {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            let Self { body } = self;
            Err(Error::Return(
                body.as_ref()
                    .map(|body| body.interpret(env))
                    .unwrap_or(Ok(ConValue::Empty))?,
            ))
        }
    }
    impl Interpret for Break {
        fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
            let Self { body } = self;
            Err(Error::Return(
                body.as_ref()
                    .map(|body| body.interpret(env))
                    .unwrap_or(Ok(ConValue::Empty))?,
            ))
        }
    }
}

pub mod function {
    //! Represents a block of code which lives inside the Interpreter
    use super::{Callable, ConValue, Environment, Error, IResult, Interpret};
    use crate::ast::{Function as FnDecl, Identifier, Param};
    /// Represents a block of code which persists inside the Interpreter
    #[derive(Clone, Debug)]
    pub struct Function {
        /// Stores the contents of the function declaration
        decl: Box<FnDecl>,
        // /// Stores the enclosing scope of the function
        // env: Box<Environment>,
    }

    impl Function {
        pub fn new(decl: &FnDecl) -> Self {
            Self { decl: decl.clone().into() }
        }
    }

    impl Callable for Function {
        fn name(&self) -> &str {
            let FnDecl { name: Identifier(ref name), .. } = *self.decl;
            name
        }
        fn call(&self, env: &mut Environment, args: &[ConValue]) -> IResult<ConValue> {
            let FnDecl { name: Identifier(name), args: declargs, body, rety: _ } = &*self.decl;
            // Check arg mapping
            if args.len() != declargs.len() {
                return Err(Error::ArgNumber { want: declargs.len(), got: args.len() });
            }
            let Some(body) = body else {
                return Err(Error::NotDefined(name.into()));
            };
            // TODO: completely refactor data storage
            let mut frame = env.frame("fn args");
            for (Param { mutability: _, name: Identifier(name), ty: _ }, value) in
                declargs.iter().zip(args)
            {
                frame.insert(name, Some(value.clone()));
            }
            match body.interpret(&mut frame) {
                Err(Error::Return(value)) => Ok(value),
                Err(Error::Break(value)) => Err(Error::BadBreak(value)),
                result => result,
            }
        }
    }
}

pub mod builtin {
    //! Implementations of built-in functions
    mod builtin_imports {
        pub use crate::interpreter::{
            env::Environment, error::IResult, temp_type_impl::ConValue, BuiltIn, Callable,
        };
    }
    use super::BuiltIn;
    /// Builtins to load when a new interpreter is created
    pub const DEFAULT_BUILTINS: &[&dyn BuiltIn] = &[&print::Print, &dbg::Dbg, &dump::Dump];

    mod print {
        //! Implements the unstable `print(...)` builtin
        use super::builtin_imports::*;
        /// Implements the `print(...)` builtin
        #[derive(Clone, Debug)]
        pub struct Print;
        impl BuiltIn for Print {}
        #[rustfmt::skip]
        impl Callable for Print {
            fn name(&self) -> &'static str { "print" }
            fn call(&self, _inter: &mut Environment, args: &[ConValue]) -> IResult<ConValue> {
                for arg in args {
                    print!("{arg}")
                }
                println!();
                Ok(ConValue::Empty)
            }
        }
    }
    mod dbg {
        //! Implements the unstable `dbg(...)` builtin
        use super::builtin_imports::*;
        #[derive(Clone, Debug)]
        pub struct Dbg;
        impl BuiltIn for Dbg {}
        #[rustfmt::skip]
        impl Callable for Dbg {
            fn name(&self) -> &str { "dbg" }
            fn call(&self, _inter: &mut Environment, args: &[ConValue]) -> IResult<ConValue> {
                println!("{args:?}");
                Ok(args.into())
            }
        }
    }
    mod dump {
        use super::builtin_imports::*;
        #[derive(Clone, Debug)]
        pub struct Dump;
        impl BuiltIn for Dump {}
        impl Callable for Dump {
            fn call(&self, env: &mut Environment, _args: &[ConValue]) -> IResult<ConValue> {
                println!("{}", *env);
                Ok(ConValue::Empty)
            }

            fn name(&self) -> &str {
                "dump"
            }
        }
    }
}

pub mod env {
    //! Lexical and non-lexical scoping for variables
    use super::{
        builtin::DEFAULT_BUILTINS,
        error::{Error, IResult},
        function::Function,
        temp_type_impl::ConValue,
        Callable, Interpret,
    };
    use crate::ast::{Function as FnDecl, Identifier};
    use std::{
        collections::HashMap,
        fmt::Display,
        ops::{Deref, DerefMut},
    };

    /// Implements a nested lexical scope
    #[derive(Clone, Debug)]
    pub struct Environment {
        frames: Vec<(HashMap<String, Option<ConValue>>, &'static str)>,
    }

    impl Display for Environment {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            for (frame, name) in self.frames.iter().rev() {
                writeln!(f, "--- {name} ---")?;
                for (var, val) in frame {
                    write!(f, "- {var}: ")?;
                    match val {
                        Some(value) => writeln!(f, "{value}"),
                        None => writeln!(f, "<undefined>"),
                    }?
                }
            }
            Ok(())
        }
    }
    impl Default for Environment {
        fn default() -> Self {
            let mut builtins = HashMap::new();
            for &builtin in DEFAULT_BUILTINS {
                builtins.insert(builtin.name().into(), Some(ConValue::BuiltIn(builtin)));
            }
            // FIXME: Temporary until modules are implemented
            Self { frames: vec![(builtins, "builtins"), (HashMap::new(), "globals")] }
        }
    }

    impl Environment {
        pub fn new() -> Self {
            Self::default()
        }
        /// Creates an [Environment] with no [builtins](super::builtin)
        pub fn no_builtins(name: &'static str) -> Self {
            Self { frames: vec![(Default::default(), name)] }
        }

        pub fn eval(&mut self, node: &impl Interpret) -> IResult<ConValue> {
            node.interpret(self)
        }

        /// Calls a function inside the interpreter's scope,
        /// and returns the result
        pub fn call(&mut self, name: &str, args: &[ConValue]) -> IResult<ConValue> {
            // FIXME: Clone to satisfy the borrow checker
            let function = self.get(name)?.clone();
            function.call(self, args)
        }
        /// Enters a nested scope, returning a [`Frame`] stack-guard.
        ///
        /// [`Frame`] implements Deref/DerefMut for [`Environment`].
        pub fn frame(&mut self, name: &'static str) -> Frame {
            Frame::new(self, name)
        }
        /// Resolves a variable mutably.
        ///
        /// Returns a mutable reference to the variable's record, if it exists.
        pub fn get_mut(&mut self, id: &str) -> IResult<&mut Option<ConValue>> {
            for (frame, _) in self.frames.iter_mut().rev() {
                if let Some(var) = frame.get_mut(id) {
                    return Ok(var);
                }
            }
            Err(Error::NotDefined(id.into()))
        }
        /// Resolves a variable immutably.
        ///
        /// Returns a reference to the variable's contents, if it is defined and initialized.
        pub fn get(&self, id: &str) -> IResult<&ConValue> {
            for (frame, _) in self.frames.iter().rev() {
                match frame.get(id) {
                    Some(Some(var)) => return Ok(var),
                    Some(None) => return Err(Error::NotInitialized(id.into())),
                    _ => (),
                }
            }
            Err(Error::NotDefined(id.into()))
        }
        /// Inserts a new [ConValue] into this [Environment]
        pub fn insert(&mut self, id: &str, value: Option<ConValue>) {
            if let Some((frame, _)) = self.frames.last_mut() {
                frame.insert(id.into(), value);
            }
        }
        /// A convenience function for registering a [FnDecl] as a [Function]
        pub fn insert_fn(&mut self, decl: &FnDecl) {
            let FnDecl { name: Identifier(name), .. } = decl;
            let (name, function) = (name.clone(), Some(Function::new(decl).into()));
            if let Some((frame, _)) = self.frames.last_mut() {
                frame.insert(name, function);
            }
        }
    }

    /// Functions which aid in the implementation of [`Frame`]
    impl Environment {
        /// Enters a scope, creating a new namespace for variables
        fn enter(&mut self, name: &'static str) -> &mut Self {
            self.frames.push((Default::default(), name));
            self
        }

        /// Exits the scope, destroying all local variables and
        /// returning the outer scope, if there is one
        fn exit(&mut self) -> &mut Self {
            if self.frames.len() > 2 {
                self.frames.pop();
            }
            self
        }
    }

    /// Represents a stack frame
    #[derive(Debug)]
    pub struct Frame<'scope> {
        scope: &'scope mut Environment,
    }
    impl<'scope> Frame<'scope> {
        fn new(scope: &'scope mut Environment, name: &'static str) -> Self {
            Self { scope: scope.enter(name) }
        }
    }
    impl<'scope> Deref for Frame<'scope> {
        type Target = Environment;
        fn deref(&self) -> &Self::Target {
            self.scope
        }
    }
    impl<'scope> DerefMut for Frame<'scope> {
        fn deref_mut(&mut self) -> &mut Self::Target {
            self.scope
        }
    }
    impl<'scope> Drop for Frame<'scope> {
        fn drop(&mut self) {
            self.scope.exit();
        }
    }
}

pub mod error {
    //! The [Error] type represents any error thrown by the [Environment](super::Environment)

    use super::temp_type_impl::ConValue;
    use crate::common::Loc;

    pub type IResult<T> = Result<T, Error>;

    /// Represents any error thrown by the [Environment](super::Environment)
    #[derive(Clone, Debug)]
    pub enum Error {
        /// Propagate a Return value
        Return(ConValue),
        /// Propagate a Break value
        Break(ConValue),
        /// Break propagated across function bounds
        BadBreak(ConValue),
        /// Continue to the next iteration of a loop
        Continue,
        /// Underflowed the stack
        StackUnderflow,
        /// Exited the last scope
        ScopeExit,
        /// Type incompatibility
        // TODO: store the type information in this error
        TypeError,
        /// In clause of For loop didn't yield a Range
        NotIterable,
        /// A value at this [location](struct@Loc) can't be indexed
        NotIndexable(Loc),
        /// An array index went out of bounds
        OobIndex(usize, usize),
        /// An expression at this [location](struct@Loc)ation is not assignable
        NotAssignable(Loc),
        /// A name was not defined in scope before being used
        NotDefined(String),
        /// A name was defined but not initialized
        NotInitialized(String),
        /// A value was called, but is not callable
        NotCallable(ConValue),
        /// A function was called with the wrong number of arguments
        ArgNumber { want: usize, got: usize },
    }

    impl std::error::Error for Error {}
    impl std::fmt::Display for Error {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            match self {
                Error::Return(value) => write!(f, "return {value}"),
                Error::Break(value) => write!(f, "break {value}"),
                Error::BadBreak(value) => write!(f, "rogue break: {value}"),
                Error::Continue => "continue".fmt(f),
                Error::StackUnderflow => "Stack underflow".fmt(f),
                Error::ScopeExit => "Exited the last scope. This is a logic bug.".fmt(f),
                Error::TypeError => "Incompatible types".fmt(f),
                Error::NotIterable => "`in` clause of `for` loop did not yield an iterable".fmt(f),
                Error::NotIndexable(location) => {
                    write!(f, "{location} expression cannot be indexed")
                }
                Error::OobIndex(idx, len) => {
                    write!(f, "Index out of bounds: index was {idx}. but len is {len}")
                }
                Error::NotAssignable(location) => {
                    write!(f, "{location} expression is not assignable")
                }
                Error::NotDefined(value) => {
                    write!(f, "{value} not bound. Did you mean `let {value};`?")
                }
                Error::NotInitialized(value) => {
                    write!(f, "{value} bound, but not initialized")
                }
                Error::NotCallable(value) => {
                    write!(f, "{value} is not callable.")
                }
                Error::ArgNumber { want, got } => {
                    write!(f, "Expected {want} arguments, got {got}")
                }
            }
        }
    }
}

#[cfg(test)]
mod tests;