use super::{Value, VariableType};

#[derive(Debug, Clone)]
pub struct FunctionSignature {
    pub name: String,
    pub parameters: Vec<VariableType>,
}

impl FunctionSignature {
    pub fn new<T: Into<String>>(name: T, params: Vec<VariableType>) -> FunctionSignature {
        FunctionSignature {
            name: name.into(),
            parameters: params,
        }
    }
}

impl PartialEq for FunctionSignature {
    fn eq(&self, other: &FunctionSignature) -> bool {
        if self.name == other.name && self.parameters.len() == other.parameters.len() {
            let mut found_difference = false;
            for (idx, t) in self.parameters.iter().enumerate() {
                if other.parameters[idx] != *t {
                    found_difference = true;
                }
            }
            !found_difference
        } else {
            false
        }
    }
}

impl From<BuiltinFunctionDef> for FunctionSignature {
    fn from(from: BuiltinFunctionDef) -> FunctionSignature {
        from.signature
    }
}

pub enum FunctionDef {
    Builtin(BuiltinFunctionDef),
}

impl FunctionDef {
    fn get_signature(&self) -> &FunctionSignature {
        match self {
            FunctionDef::Builtin(func) => &func.signature,
        }
    }
}

impl PartialEq for FunctionDef {
    fn eq(&self, other: &FunctionDef) -> bool {
        self.get_signature() == other.get_signature()
    }
}

impl PartialEq<FunctionSignature> for FunctionDef {
    fn eq(&self, other: &FunctionSignature) -> bool {
        self.get_signature() == other
    }
}

pub struct BuiltinFunctionDef {
    pub signature: FunctionSignature,
    pub function: Box<dyn Fn(Vec<Value>)>,
}

impl BuiltinFunctionDef {
    pub fn new<T: Into<String>>(
        name: T,
        parameters: Vec<VariableType>,
        func: Box<dyn Fn(Vec<Value>)>,
    ) -> BuiltinFunctionDef {
        BuiltinFunctionDef {
            signature: FunctionSignature {
                name: name.into(),
                parameters,
            },
            function: func,
        }
    }
}

pub struct BuiltinFunctions(pub Vec<BuiltinFunctionDef>);

impl BuiltinFunctions {
    pub fn signatures(&self) -> Vec<FunctionSignature> {
        let mut signatures = Vec::new();
        for func in &self.0 {
            signatures.push(func.signature.clone());
        }
        signatures
    }
}

impl From<BuiltinFunctions> for Vec<BuiltinFunctionDef> {
    fn from(builtin: BuiltinFunctions) -> Self {
        builtin.0
    }
}