path: root/src/lisp/eval.rs

use crate::{
    app::AppState,
    keybind::Keybind,
    lisp::{
        error::{EvalError, LispError},
        expr::{Arity, Ident, LispExpr, LispFunction},
        Environment,
    },
    type_match,
};

use std::{convert::TryInto, str::FromStr};

use log::{error, info};

pub type Context = Vec<String>;

pub struct Evaluator<'ctx, 'global> {
    pub app: &'global mut AppState<'ctx>,
    pub context: Context,
}

impl<'ctx, 'global> Evaluator<'ctx, 'global> {
    pub fn new(app: &'global mut AppState<'ctx>) -> Self {
        Self {
            app,
            context: Vec::new(),
        }
    }
}

impl<'ctx, 'global> Evaluator<'ctx, 'global>
where
    'ctx: 'global,
{
    pub fn eval(&mut self, expr: &LispExpr) -> Result<LispExpr, LispError> {
        match expr {
            LispExpr::Unit => Ok(expr.clone()),
            LispExpr::StringLit(_) => Ok(expr.clone()),
            LispExpr::Char(_) => Ok(expr.clone()),
            LispExpr::Number(_) => Ok(expr.clone()),
            LispExpr::BoolLit(_) => Ok(expr.clone()),
            LispExpr::Ident(ref id) => lookup(&self.app.lisp_env, id),
            LispExpr::Quote(item, _) => Ok(apply_quote(&item.as_ref())),
            LispExpr::List(li) => {
                let func_expr = &li[0];
                match func_expr {
                    LispExpr::Ident(s) => match s.as_ref() {
                        "define" => self.define_var(&li[1..]),
                        "set!" => self.set_var(&li[1..]),
                        "lambda" => create_lambda(&li[1..]),
                        "if" => self.eval_if(&li[1..]),
                        "cond" => self.eval_cond(&li[1..]),
                        "for" => self.eval_for(&li[1..]),
                        "quote" => Ok(apply_quote(&li[1])),
                        "let" => self.eval_let(&li[1..]),
                        "bind-key" => self.eval_bind_key(&li[1..]),
                        _ => {
                            let mut new_ls = vec![self.eval(&func_expr)?];
                            new_ls.extend(li[1..].to_vec());
                            self.eval(&(LispExpr::List(new_ls)))
                        }
                    },
                    LispExpr::PrimitiveFunc(f) => {
                        let mut args = Vec::new();
                        // context.push(f.name.to_string());
                        for item in li[1..].iter() {
                            args.push(self.eval(item)?);
                        }
                        f.call(&args, &mut self.app)
                    }
                    LispExpr::Function(f) => {
                        let mut args = Vec::new();
                        for item in li[1..].iter() {
                            let i = self.eval(item)?;
                            args.push(i);
                        }
                        if f.params.len() != args.len() {
                            info!("too many or too little number of args");
                            Err(EvalError::ArgumentCount(Arity::Exact(f.params.len())).into())
                        } else {
                            let nested_env: Environment =
                                f.params.clone().into_iter().zip(args).collect();
                            self.app.lisp_env.push(nested_env);
                            let result = self.eval(&f.body);
                            self.app.lisp_env.pop();
                            result
                        }
                    }
                    LispExpr::List(_) => {
                        info!("list as funciton");
                        let func_expr = self.eval(&func_expr)?;
                        let mut new_ls = vec![func_expr];
                        new_ls.extend(li[1..].to_vec());
                        self.eval(&(LispExpr::List(new_ls)))
                    }
                    _ => Err(EvalError::BadForm.into()),
                }
            }
            _ => Err(EvalError::BadForm.into()),
        }
    }

    pub fn define_var(&mut self, args: &[LispExpr]) -> Result<LispExpr, LispError> {
        (Arity::Exact(2)).check(args)?;
        match args {
            [LispExpr::Ident(id), expr] => {
                let value = self.eval(&expr)?;
                let local_env = &mut self.app.lisp_env.last_mut();
                if let Some(env) = local_env {
                    env.insert(id.into(), value);
                } else {
                    error!("Unable to create global definition");
                    return Err(EvalError::BadForm.into());
                }
                Ok(LispExpr::Unit)
            }
            [LispExpr::List(shorthand), body] => {
                // (define (func arg) <body>) shorthand
                let id = shorthand[0].unwrap_ident();
                let params = if shorthand.len() > 1 {
                    &shorthand[1..]
                } else {
                    &[]
                }
                .to_vec()
                .into_iter()
                .map(|arg| arg.try_into())
                .collect::<Result<Vec<Ident>, LispError>>()?;
                let value = LispExpr::Function(LispFunction {
                    params,
                    body: Box::new(body.clone()),
                });

                let local_env = &mut self.app.lisp_env.last_mut();
                if let Some(env) = local_env {
                    env.insert(id, value);
                } else {
                    error!("Unable to create global definition");
                    return Err(EvalError::BadForm.into());
                }
                Ok(LispExpr::Unit)
            }
            _ => {
                error!("Invalid usage of `define`");
                Err(EvalError::BadForm.into())
            }
        }
    }

    pub fn set_var(&mut self, args: &[LispExpr]) -> Result<LispExpr, LispError> {
        (Arity::Exact(2)).check(args)?;
        match args {
            [LispExpr::Ident(id), expr] => {
                let value = self.eval(&expr)?;
                let loc = lookup_mut(&mut self.app.lisp_env, id)?;
                *loc = value;
                Ok(LispExpr::Unit)
            }
            _ => {
                error!("Invalid usage of `set!`");
                Err(EvalError::BadForm.into())
            }
        }
    }

    pub fn eval_if(&mut self, args: &[LispExpr]) -> Result<LispExpr, LispError> {
        (Arity::Exact(3)).check(args)?;
        match args {
            [predicate, then, else_] => {
                let predicate = self.eval(&predicate)?;
                if matches!(predicate, LispExpr::BoolLit(false)) {
                    self.eval(&else_)
                } else {
                    self.eval(&then)
                }
            }
            _ => {
                panic!("panicked at `if` expression")
            }
        }
    }

    pub fn eval_cond(&mut self, args: &[LispExpr]) -> Result<LispExpr, LispError> {
        Arity::Atleast(1).check(args)?;
        let valid_cond_stmt = |expr: &LispExpr| matches!(expr, LispExpr::List(v) if v.len() == 2);
        for cond_stmt in args {
            if valid_cond_stmt(cond_stmt) {
                match &cond_stmt.unwrap_list()[..] {
                    [predicate, then] => {
                        if self.eval(&predicate)?.cast_bool() {
                            return self.eval(&then);
                        }
                    }
                    _ => return Err(EvalError::BadForm.into()),
                }
            } else {
                error!("bad `cond` form");
                return Err(EvalError::BadForm.into());
            }
        }
        Ok(LispExpr::Unit)
    }

    pub fn eval_for(&mut self, args: &[LispExpr]) -> Result<LispExpr, LispError> {
        Arity::Exact(2).check(args)?;
        let valid_binding_stmt = |expr: &LispExpr| {
            matches!(
                expr,
                LispExpr::List(v)
                if v.len() == 2
                && matches!(v[0], LispExpr::Ident(_)))
        };

        let nested_env = Environment::new();
        self.app.lisp_env.push(nested_env);
        match args {
            [binding, body] => {
                if valid_binding_stmt(binding) {
                    let binding = binding.unwrap_list();
                    let binding_name = binding[0].unwrap_ident();
                    let binding_ls = self.eval(&binding[1])?;
                    if matches!(binding_ls, LispExpr::List(_)) {
                        let binding_ls = binding_ls.unwrap_list();
                        let mut result = vec![];
                        for bind_val in binding_ls.iter() {
                            let value = self.eval(&bind_val)?;
                            if let Some(env) = self.app.lisp_env.last_mut() {
                                env.insert(binding_name.clone(), value);
                            }
                            result.push(self.eval(body)?);
                        }
                        self.app.lisp_env.pop();
                        Ok(LispExpr::List(result))
                    } else {
                        error!("invalid binding form");
                        Err(EvalError::BadForm.into())
                    }
                } else {
                    error!("invalid binding form");
                    Err(EvalError::BadForm.into())
                }
            }
            _ => {
                error!("invalid for loop args");
                Err(EvalError::BadForm.into())
            }
        }
    }

    pub fn eval_let(&mut self, args: &[LispExpr]) -> Result<LispExpr, LispError> {
        Arity::Exact(2).check(args)?;
        let valid_binding_stmt =
            |expr: &LispExpr| matches!(expr, LispExpr::List(v) if v.len() == 2);
        let nested_env = Environment::new();
        self.app.lisp_env.push(nested_env);
        match args {
            [LispExpr::List(bindings), body] => {
                for binding_stmt in bindings {
                    if valid_binding_stmt(binding_stmt) {
                        match &binding_stmt.unwrap_list()[..] {
                            [LispExpr::Ident(id), bind_val] => {
                                let value = self.eval(&bind_val)?;
                                if let Some(env) = self.app.lisp_env.last_mut() {
                                    env.insert(id.into(), value);
                                }
                            }
                            _ => {
                                error!("bad let binding form");
                                return Err(EvalError::BadForm.into());
                            }
                        }
                    } else {
                        error!("bad `let` form");
                        return Err(EvalError::BadForm.into());
                    }
                }
                let result = self.eval(&body);
                self.app.lisp_env.pop();
                result
            }
            _ => {
                error!("bad `let` form");
                Err(EvalError::BadForm.into())
            }
        }
    }

    pub fn eval_bind_key(&mut self, args: &[LispExpr]) -> Result<LispExpr, LispError> {
        Arity::Exact(2).check(args)?;
        match args {
            [LispExpr::StringLit(s), body] => {
                let bind = Keybind::from_str(&s).map_err(EvalError::KeybindError)?;
                self.app.keybinds.insert(bind, body.clone());
                Ok(LispExpr::Unit)
            }
            _ => Err(EvalError::BadForm.into()),
        }
    }
}

pub fn apply_quote(arg: &LispExpr) -> LispExpr {
    match arg {
        i @ LispExpr::Unit
        | i @ LispExpr::StringLit(_)
        | i @ LispExpr::Char(_)
        | i @ LispExpr::Number(_)
        | i @ LispExpr::BoolLit(_) => i.clone(),
        LispExpr::Quote(expr, depth) => LispExpr::Quote(Box::clone(expr), depth + 1),
        LispExpr::List(ls) => LispExpr::List(ls.iter().map(|a| apply_quote(a)).collect::<Vec<_>>()),
        _ => arg.clone(),
    }
}

pub fn create_lambda(cdr: &[LispExpr]) -> Result<LispExpr, LispError> {
    Arity::Exact(2).check(cdr)?;
    match cdr {
        [LispExpr::List(params), body] if type_match!(params, (..) => LispExpr::Ident(_)) => {
            Ok(LispExpr::Function(LispFunction {
                params: params.iter().map(|p| p.unwrap_ident()).collect::<Vec<_>>(),
                body: Box::new(body.clone()),
            }))
        }
        _ => {
            error!("Invalid usage of `lambda`");
            Err(EvalError::BadForm.into())
        }
    }
}

pub fn lookup(env_list: &[Environment], key: &str) -> Result<LispExpr, LispError> {
    Ok(env_list
        .iter()
        .rev()
        .find_map(|local_env| local_env.get(key).cloned())
        .ok_or(EvalError::UnboundVariable(key.into()))?)
}

pub fn lookup_mut<'a, 'b>(
    env_list: &'a mut [Environment],
    key: &'b str,
) -> Result<&'a mut LispExpr, LispError> {
    Ok(env_list
        .iter_mut()
        .rev()
        .find_map(|local_env| local_env.get_mut(key))
        .ok_or(EvalError::UnboundVariable(key.into()))?)
}

pub fn completions<'a>(env_list: &'a [Environment], prefix: &str) -> Vec<&'a str> {
    fn helper<'h>(env_list: &'h [Environment], prefix: &str, completions: &mut Vec<Vec<&'h str>>) {
        if !env_list.is_empty() {
            let nearest_env = env_list.last().unwrap();
            completions.push(
                nearest_env
                    .keys()
                    .filter(|k| k.starts_with(prefix))
                    .map(|s| &s[prefix.len()..])
                    .collect::<Vec<_>>(),
            );
            helper(&env_list[..env_list.len() - 1], prefix, completions);
        }
    }
    let mut completions = Vec::new();
    helper(env_list, prefix, &mut completions);
    completions.into_iter().flatten().collect()
}

#[cfg(test)]
mod tests {
    use super::*;

    use crate::lisp::{expr::LispExpr, lex::Lexer, number::LispNumber, parse::Parser};

    fn run(code: &str, app: &mut AppState) -> LispExpr {
        let mut parser = Parser::new(Lexer::new(code));
        let mut evaluator = Evaluator {
            app,
            context: Vec::new(),
        };
        evaluator
            .eval(&parser.parse_single_expr().unwrap())
            .unwrap()
    }

    #[test]
    fn eval_all() {
        let sdl_context = sdl2::init().unwrap();
        let ttf_context = sdl2::ttf::init().unwrap();
        let mut app = AppState::init(100, 100, &sdl_context, &ttf_context, None, None).unwrap();
        eval_arithmetic(&mut app);
        eval_logical(&mut app);
        eval_looping(&mut app);
        eval_quote(&mut app);
        eval_std_tests(&mut app);
    }

    fn eval_arithmetic(app: &mut AppState) {
        assert_eq!(
            run("(+ 1 2 3)", app),
            LispExpr::Number(LispNumber::Integer(6))
        );
        assert_eq!(
            run("(+ 1.1 2.2 3.3)", app),
            LispExpr::Number(LispNumber::Float(6.6))
        );
        assert_eq!(
            run("(* 1 2 3 4 5)", app),
            LispExpr::Number(LispNumber::Integer(120))
        );
        assert_eq!(run("(< 1 2)", app), LispExpr::BoolLit(true));
        assert_eq!(run("(> 6 5 4 3 2 1)", app), LispExpr::BoolLit(true));
        assert_eq!(run("(< 1 2 3 4 5 6)", app), LispExpr::BoolLit(true));
        assert_eq!(run("(>= 5 5 4 3 2 1)", app), LispExpr::BoolLit(true));
        assert_eq!(run("(<= 2 2 3 4 5 6)", app), LispExpr::BoolLit(true));
    }

    fn eval_quote(app: &mut AppState) {
        assert!(run("(quote a)", app).cast_bool());
        assert!(run("(eq? 'a 'a)", app).cast_bool());
        assert!(run("(eq? '(1 2 3) '(1 2 3))", app).cast_bool());
        assert!(run("(eq? '(1 '(1 2 3)) '(1 '(1 2 3)))", app).cast_bool(),);
        assert!(run("(eq? '#t '#t)", app).cast_bool());

        assert!(run("(eq? 1 '1)", app).cast_bool());
        assert_eq!(
            run("'(1 2 3)", app),
            LispExpr::List(
                vec![1, 2, 3]
                    .into_iter()
                    .map(LispNumber::Integer)
                    .map(LispExpr::Number)
                    .collect()
            ),
        );
        assert_eq!(
            run("(caar (cdr '(1 (4 5))))", app),
            LispExpr::Number(LispNumber::Integer(4))
        );
        assert_eq!(run("''1", app), LispExpr::Number(LispNumber::Integer(1)));
    }

    fn eval_logical(app: &mut AppState) {
        assert!(run("(and #t #t)", app).cast_bool());
        assert!(run("(or #f #t)", app).cast_bool());
        assert!(!run("(not #t)", app).cast_bool());
        assert_eq!(run("(not #f)", app), run("(not (not #t))", app));
    }

    fn eval_looping(app: &mut AppState) {
        assert_eq!(
            run("(for (i '(1 2 3)) (+ i 2))", app),
            run("(map (lambda (x) (+ x 2)) '(1 2 3))", app)
        );
    }

    fn eval_std_tests(app: &mut AppState) {
        crate::utils::load_script("src/lisp/test.lisp", app).unwrap();
    }
}