#![warn(missing_docs)]

//! Crate for math Funcs
/// Contains context
pub mod ctx;
/// Utils for printing functions
pub mod display;
mod operations;

mod macros;
/// Operations betwen unctions
mod ops;
mod parser;
pub(crate) mod simp;
mod traits;
use ctx::Ctx;

/// Representation of a Func
#[derive(Clone, PartialEq, Eq, Debug)]
pub(crate) enum Func {
    X,
    Y,
    Z,
    E,
    PI,
    Num(i32),
    Param(String),
    Add(Vec<Self>),
    Mul(Vec<Self>, Vec<Self>),
    Pow(Box<Self>, Box<Self>),
    Special { kind: FuncType, argument: Box<Self> },
}

#[derive(Debug, PartialEq)]
/// Representation of a Func with 1 variable
pub struct F1D(Func, Ctx);
#[derive(Debug, PartialEq)]
/// Representation of a Func with 2 variables
pub struct F2D(Func, Ctx);
#[derive(PartialEq, Debug)]
/// Representation of a Func with 3 variables
pub struct F3D(Func, Ctx);

#[derive(Clone, Eq, PartialEq, Debug)]
/// Types of special built-in Funcs
pub(crate) enum FuncType {
    Sin,
    Cos,
    Tan,
    Cot,
    Sec,
    Csc,
    ASin,
    ACos,
    ATan,
    Sinh,
    Cosh,
    Tanh,
    Coth,
    Sech,
    Csch,
    ASinh,
    ACosh,
    ATanh,
    Abs,
    /// Natural logarithm
    Ln,
}

#[derive(Clone, PartialEq, Debug)]
pub(crate) enum Op {
    Add,
    Sub,
    Mul,
    Div,
    Pow,
    Comp,
}

impl Op {
    fn priority(&self) -> u8 {
        match self {
            Op::Add => 4,
            Op::Sub => 4,
            Op::Mul => 3,
            Op::Div => 3,
            Op::Pow => 2,
            Op::Comp => 1,
        }
    }
}

/// Func to approximate f64 to the nth decimal place
pub fn approx(num: f64, digits: u32) -> f64 {
    let y = 10i32.pow(digits) as f64;
    (num * y).round() / y
}

impl std::iter::Sum for Func {
    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
        iter.fold(Func::Num(0), |acc, func| acc + func)
    }
}

impl std::iter::Product for Func {
    fn product<I: Iterator<Item = Self>>(iter: I) -> Self {
        iter.fold(Func::Num(1), |acc, func| acc * func)
    }
}