use std::{collections::HashMap, marker::PhantomData};

use crate::{
    env::Env,
    statement::Statement,
    value::{FromValue, Value},
};

mod function_impl;

#[derive(Debug, Clone, Copy)]
enum FunctionType {
    Native,
    Interpreter,
}

#[derive(Default)]
pub struct FunctionMap(HashMap<String, (Box<dyn Function>, FunctionType)>);

impl FunctionMap {
    pub fn new() -> Self {
        Default::default()
    }

    pub fn insert_native<S, P, F>(&mut self, name: S, f: F)
    where
        S: ToString,
        P: 'static,
        F: 'static + NativeFunction<P>,
    {
        self.0.insert(
            name.to_string(),
            (Box::new(f.into_function()), FunctionType::Native),
        );
    }

    pub fn insert_interpreter(&mut self, name: &str, params: Vec<String>, body: Vec<Statement>) {
        self.0.insert(
            name.to_string(),
            (
                Box::new(InterpreterFunction::new(params, body)),
                FunctionType::Interpreter,
            ),
        );
    }

    pub fn call(&self, name: &str, env: &Env, args: &[Value]) -> Result<Value, String> {
        let (f, t) = self
            .0
            .get(name)
            .ok_or_else(|| format!("Function {} not found", name))?;
        println!("Calling {:?} function {}", t, name);

        f.execute(env, self, args)
    }
}

pub trait NativeFunction<P>: Sized {
    fn native_execute(&self, env: &Env, args: &[Value]) -> Result<Value, String>;

    fn into_function(self) -> IntoFunction<Self, P> {
        IntoFunction::new(self)
    }
}

pub struct IntoFunction<F, P> {
    func: F,
    _phantom: PhantomData<P>,
}

impl<F, P> IntoFunction<F, P> {
    fn new(func: F) -> Self {
        IntoFunction {
            func,
            _phantom: PhantomData,
        }
    }
}

impl<F: NativeFunction<P>, P> Function for IntoFunction<F, P> {
    fn execute(&self, env: &Env, _: &FunctionMap, args: &[Value]) -> Result<Value, String> {
        self.func.native_execute(env, args)
    }
}

pub struct InterpreterFunction {
    parameters: Vec<String>,
    body: Vec<Statement>,
}

impl InterpreterFunction {
    pub fn new(parameters: Vec<String>, body: Vec<Statement>) -> Self {
        InterpreterFunction { parameters, body }
    }
}

impl Function for InterpreterFunction {
    fn execute(&self, env: &Env, map: &FunctionMap, args: &[Value]) -> Result<Value, String> {
        let sub_env = Env::new_with_parent(env);
        for (name, value) in self.parameters.iter().zip(args) {
            sub_env.set(name, value.clone());
        }
        for stmt in self.body.iter() {
            stmt.eval(&sub_env, map);
        }
        Ok(Value::Nothing)
    }
}

pub trait Function {
    fn execute(&self, env: &Env, map: &FunctionMap, args: &[Value]) -> Result<Value, String>;
}