/* relish: versatile lisp shell
 * Copyright (C) 2021 Aidan Hahn
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

use std::boxed::Box;
use std::collections::HashMap;
use crate::cell::{Ctr, Cell, Type};
use crate::vars::{VTable};
use crate::eval::eval;

// Standardized function signature for stdlib functions
pub type Operation = fn(Box<Cell>, Box<VTable>, Box<FTable>) -> Box<Cell>;
pub type FTable = HashMap<String, Function>;

/* Function Args
 * If Lazy, is an integer denoting number of args
 * If Strict, is a list of Ctrs (with no wrapped values) denoting arg type.
 */
pub enum Args {
    // signed: -1 denotes infinite args
    Lazy(i128),
    Strict(Vec<Type>)
}

// function which does not need args checked
pub struct Function {
    pub function: Operation,
    pub name: String,
    pub times_called: u128,
    pub args: Args,

    // dont fail on undefined symbol (passed to eval)
    pub loose_syms: bool,

    // dont evaluate args at all. leave that to the function
    pub eval_lazy: bool
}

/* call_function
 * routine is called by eval when a function call is detected
 * full list of cells considered to be a function call is passed in
 * (that means that args contains the function symbol in 0 index)
 */
pub fn call_function(
    args: Box<Cell>,
    func: Function,
    vars: Box<VTable>,
    funcs: Box<FTable>
) -> Result<Box<Cell>, String> {
    let mut n_args = args;
    if !func.eval_lazy {
        match eval(args, vars, funcs, func.loose_syms) {
            Ok(box_cell) => n_args = box_cell,
            Err(s) => return Err(
                format!(
                    "error evaluating args to {}: {}",
                    func.name,
                    s
                )
            )
        }
    }

    let mut passes = false;
    match func.args {
        Args::Lazy(num) => {
            if num < 0 {
                passes = true
            }

            if !(num == (args.len() - 1)) {
                return Err(format!("expected {} args in call to {}", num, func.name))
            }
        },

        Args::Strict(arg_types) => {
            let idx: usize = 0;
            passes = args.circuit(|c: Ctr| {
                if idx >= arg_types.len() {
                    return false;
                }

                if let c = Ctr::None {
                    return false;
                }

                let ret = arg_types[idx] == c.to_type();
                if ret {
                    idx += 1;
                }
                return ret;
            });

            if passes && idx < (arg_types.len() - 1) {
                Err(format!(
                    "{} too little arguments in call to {}",
                    arg_types.len() - (idx + 1),
                    func.name
                ));
            }

            if !passes {
                if idx < (arg_types.len() - 1) {
                    Err(format!(
                        "argument {} in call to {} is of wrong type (expected {})",
                        idx + 1,
                        func.name,
                        arg_types[idx].to_str()
                    ));
                }

                if idx == (arg_types.len() - 1) {
                    Err(format!(
                        "too many arguments in call to {}",
                        func.name
                    ));
                }
            }
        }
    }

    func.times_called += 1;
    return Ok((func.function)(args, vars, funcs));
}