/* 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::rc::Rc;
use std::cell::RefCell;
use crate::segment::{Ast, Ctr};
use crate::func::{FTable, func_call};
use crate::vars::VTable;

/* iterates over a syntax tree
 * returns a NEW LIST of values
 * representing the simplest possible form of the input
 */
pub fn eval(
    ast: Ast,
    vars: Rc<RefCell<VTable>>,
    funcs: Rc<RefCell<FTable>>,
    sym_loose: bool
) -> Result<Ast, String> {
    eval_inner(ast, vars, funcs, sym_loose, true)
}

fn eval_inner(
    ast: Ast,
    vars: Rc<RefCell<VTable>>,
    funcs: Rc<RefCell<FTable>>,
    sym_loose: bool,
    first_item: bool
) -> Result<Ast, String> {
    /* LOGIC:
     * 1. make new ast
     * 2. call process_ctr on ast.car
     * 3. set new.car to result
     * 3. if cdr is an AST
     *   - set first_item to false
     *   - set new.cdr to result of process_ctr(ast.ctr)
     * 4. else call process_ctr on cdr
     *    (and set new.cdr to result)
     * 5. return new ast
     */
    let ret: Ast;
    let mret = ret.clone().borrow_mut();
    let ret_inner = ast.clone().borrow_mut();
    mret.car = process_ctr(
        ret_inner.car,
        vars.clone(),
        funcs.clone(),
        sym_loose,
        first_item
    );

    if let Ctr::Seg(s) = ret_inner.cdr {
        mret.cdr = process_ctr(
            ret_inner.cdr,
            vars.clone(),
            funcs.clone(),
            sym_loose,
            false
        );
    } else {
        mret.cdr = process_ctr(
            ret_inner.cdr,
            vars.clone(),
            funcs.clone(),
            sym_loose,
            first_item
        );
    }
}

fn process_ctr(
    ctr: Ctr,
    vars: Rc<RefCell<VTable>>,
    funcs: Rc<RefCell<FTable>>,
    sym_loose: bool,
    first_item: bool,
    rest: Ast
) -> Result<Ctr, String> {
    /* LOGIC:
     *   1. if symbol, unwrap (DEEP COPY)
     *   2. if first_item and symbol, call function?
     *      (else: return var copy)
     *   3. if list return result of eval()
     *   4. finally, return a clone (shallow copy) of datum
     */

    match ctr {
        Symbol(token) => {
            let mut tok = token;
            if let Some(s) = vt.borrow().get(token) {

                // is function, or variable alias?
                if first_item && let Symbol(t) = s {
                    if let Some(f) = ft.borrow().get(t) {
                        tok = t;

                // is a basic value.
                } else {
                    return Ok((*s).clone())
                }

            // else call function
            } else if !first_item && !sym_loose {
                return Err("variable not found")
            }

            if first_item && let Some(f) = ft.borrow().get(tok) {
                match func_call(f, rest, vars.clone(), funcs.clone()) {
                    Ok(a) => Ok(Ctr::Seg(a.borrow().clone())),
                    Err(s) => Err(s)
                }
            }
        },
        Seg(tree) => eval_inner(tree, vars, funcs, sym_loose, first_item),
        _ => Ok(ctr.clone())
    }
}