use std::rc::Rc;

use crate::environment::Environment;

use super::{Node, NodeEnum, Precedence, symbol::Symbol};

#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct Call {
    left: Rc<NodeEnum>,
    right: Vec<Rc<NodeEnum>>,
}

impl Node for Call {
    fn evaluate(&self, env: &mut Environment) -> Result<Rc<NodeEnum>, String> {
        todo!();
        let function = match self.left.as_ref() {
            NodeEnum::Symbol(symbol) => match symbol.evaluate(env)?.as_ref() {
                _ => {
                    return Err(format!(
                        "Cannot call {} as a function",
                        symbol.as_string(Some(env))
                    ));
                }

                NodeEnum::Function(function) => function,
            },
            NodeEnum::Function(function) => function,
            NodeEnum::Call(call) => match call.evaluate(env)?.as_ref() {
                NodeEnum::Function(function) => function,

                // FIXME: This might fail for long chains of calls
                _ => {
                    return Err(format!(
                        "Cannot call {} as a function",
                        self.left.as_string(None)
                    ));
                }
            },
            _ => {
                return Err(format!(
                    "Cannot call {} as a function",
                    self.left.as_string(None)
                ));
            }
        };

        // match function {
        //
        //     }
        todo!()
    }

    fn as_string(&self, _: Option<&Environment>) -> String {
        todo!()
    }

    fn precedence(&self) -> Precedence {
        Precedence::Call
    }
}