use crate::function::Function;
use crate::operation::Operation;
use crate::complex::Complex;
use std::collections::HashMap;

#[derive(Default)]
pub struct Context {
    ops: Vec<Operation>,
    vars: HashMap<String, Complex>,
    funcs: HashMap<String, Box<dyn Function>>,
}

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

    pub fn with_operations(mut self, ops: Vec<Operation>) -> Self {
        self.ops = ops;
        self
    }

    pub fn with_variables(mut self, vars: HashMap<String, Complex>) -> Self {
        self.vars = vars;
        self
    }

    pub fn with_functions(mut self, funcs: HashMap<String, Box<dyn Function>>) -> Self {
        self.funcs = funcs;
        self
    }

    pub fn operations(&self) -> &Vec<Operation> {
        &self.ops
    }

    pub fn variable_mut(&mut self, name: &str) -> Option<&mut Complex> {
        self.vars.get_mut(name)
    }

    pub fn function_mut(&mut self, name: &str) -> Option<&mut Box<dyn Function>> {
        self.funcs.get_mut(name)
    }

    pub fn variable(&self, name: &str) -> Option<&Complex> {
        self.vars.get(name)
    }

    #[allow(clippy::borrowed_box)]
    pub fn function(&self, name: &str) -> Option<&Box<dyn Function>> {
        self.funcs.get(name)
    }
}

#[macro_export]
macro_rules! variables {
    {$($x:expr => $y:expr), *} => {
        {
            let mut h : HashMap<String, Complex> = HashMap::new();
            $(
                h.insert($x.to_string(), $y);
            )*
            h
        }
    };
}