use super::{angle::Angle, numeric::Float};

pub fn animate<T, F>(low: T, high: T, value: T, f: F) -> T
where
    T: Float,
    F: FnOnce(T) -> T,
{
    low + f(value) * (high - low)
}

pub fn zero<T: Float>(_: T) -> T {
    T::zero()
}

pub fn one<T: Float>(_: T) -> T {
    T::one()
}

pub fn step<T: Float + Ord>(value: T) -> T {
    if value < T::new(0.5) {
        T::zero()
    } else {
        T::one()
    }
}

pub fn linear<T: Float>(value: T) -> T {
    value
}

pub fn invert<T: Float>(value: T) -> T {
    T::one() - value
}

pub fn sinus<T: Float>(value: T) -> T {
    Angle::Deg(T::new(360.0) * value)
        .into_rad()
        .into_inner()
        .sin()
}

pub fn cosinus<T: Float>(value: T) -> T {
    Angle::Deg(T::new(360.0) * value)
        .into_rad()
        .into_inner()
        .cos()
}

pub fn ease_in_quadric<T: Float>(value: T) -> T {
    value * value
}

pub fn ease_in_cubic<T: Float>(value: T) -> T {
    value * value * value
}

pub fn ease_in_quartic<T: Float>(value: T) -> T {
    value * value * value * value
}

pub fn ease_in_quintic<T: Float>(value: T) -> T {
    value * value * value * value * value
}

pub fn ease_in_sinusoidal<T: Float>(value: T) -> T {
    Angle::Deg(T::new(90.0) * value + T::one())
        .into_rad()
        .into_inner()
        .cos()
        .neg()
}

pub fn ease_in_circular<T: Float + Ord>(value: T) -> T {
    if value > T::one() {
        T::one()
    } else {
        T::one() - (T::one() - value * value)
    }
}

pub fn ease_in_back_cubic<T: Float>(value: T) -> T {
    T::new(4.0) * value * value * value - T::new(3.0) * value * value
}

pub fn ease_in_back_quadric<T: Float>(value: T) -> T {
    T::new(2.0) * value * value * value * value + T::new(2.0) * value * value * value
        - T::new(3.0) * value * value
}

pub fn ease_in_elastic_small<T: Float>(value: T) -> T {
    T::new(33.0) * value * value * value * value * value
        - T::new(59.0) * value * value * value * value
        + T::new(32.0) * value * value * value
        - T::new(5.0) * value * value
}

pub fn ease_in_elastic_big<T: Float>(value: T) -> T {
    T::new(56.0) * value * value * value * value * value
        - T::new(105.0) * value * value * value * value
        + T::new(60.0) * value * value * value
        - T::new(10.0) * value * value
}

pub fn ease_out_quadric<T: Float>(value: T) -> T {
    -value * (value - T::new(2.0))
}

pub fn ease_out_cubic<T: Float>(value: T) -> T {
    let value = value - T::one();

    value * value * value + T::one()
}

pub fn ease_out_quartic<T: Float>(value: T) -> T {
    let value = value - T::one();

    -value * value * value * value + T::one()
}

pub fn ease_out_quintic<T: Float>(value: T) -> T {
    let value = value - T::one();

    value * value * value * value * value + T::one()
}

pub fn ease_out_sinusoidal<T: Float>(value: T) -> T {
    Angle::Deg(T::new(90.0) * value)
        .into_rad()
        .into_inner()
        .sin()
}

pub fn ease_out_circular<T: Float + Ord>(value: T) -> T {
    if value < T::zero() {
        T::zero()
    } else {
        let value = value - T::one();

        (T::one() - value * value).sqrt()
    }
}

pub fn ease_out_back_cubic<T: Float>(value: T) -> T {
    T::new(4.0) * value * value * value - T::new(9.0) * value * value + T::new(6.0) * value
}

pub fn ease_out_back_quadric<T: Float>(value: T) -> T {
    -T::new(2.0) * value * value * value * value + T::new(10.0) * value * value * value
        - T::new(15.0) * value * value
        + T::new(8.0) * value
}

pub fn ease_out_elastic_small<T: Float>(value: T) -> T {
    T::new(33.0) * value * value * value * value * value
        - T::new(106.0) * value * value * value * value
        + T::new(126.0) * value * value * value
        - T::new(67.0) * value * value
        + T::new(15.0) * value
}

pub fn ease_out_elastic_big<T: Float>(value: T) -> T {
    T::new(56.0) * value * value * value * value * value
        - T::new(175.0) * value * value * value * value
        + T::new(200.0) * value * value * value
        - T::new(100.0) * value * value
        + T::new(20.0) * value
}

pub fn ease_in_out_quadric<T: Float + Ord>(value: T) -> T {
    ease_in_out(value, ease_in_quadric, ease_out_quadric)
}

pub fn ease_in_out_cubic<T: Float + Ord>(value: T) -> T {
    ease_in_out(value, ease_in_cubic, ease_out_cubic)
}

pub fn ease_in_out_quartic<T: Float + Ord>(value: T) -> T {
    ease_in_out(value, ease_in_quartic, ease_out_quartic)
}

pub fn ease_in_out_quintic<T: Float + Ord>(value: T) -> T {
    ease_in_out(value, ease_in_quintic, ease_out_quintic)
}

pub fn ease_in_out_sinusodial<T: Float>(value: T) -> T {
    -T::new(0.5)
        * (Angle::Deg(T::new(180.0) * value)
            .into_rad()
            .into_inner()
            .cos()
            - T::one())
}

pub fn ease_in_out_circular<T: Float + Ord>(value: T) -> T {
    ease_in_out(value, ease_in_circular, ease_out_circular)
}

pub fn ease_in_out_back_cubic<T: Float + Ord>(value: T) -> T {
    ease_in_out(value, ease_in_back_cubic, ease_out_back_cubic)
}

pub fn ease_in_out_back_quadtric<T: Float + Ord>(value: T) -> T {
    ease_in_out(value, ease_in_back_quadric, ease_out_back_quadric)
}

pub fn ease_in_out_elasic_small<T: Float + Ord>(value: T) -> T {
    ease_in_out(value, ease_in_elastic_small, ease_out_elastic_small)
}

pub fn ease_in_out_elasic_big<T: Float + Ord>(value: T) -> T {
    ease_in_out(value, ease_in_elastic_big, ease_out_elastic_big)
}

pub fn ease_in_out<T, F1, F2>(value: T, f1: F1, f2: F2) -> T
where
    T: Float + Ord,
    F1: FnOnce(T) -> T,
    F2: FnOnce(T) -> T,
{
    if value < T::new(0.5) {
        T::new(0.5) * f1(T::new(2.0) * value)
    } else {
        T::new(0.5) * f2(T::new(2.0) * (value - T::new(0.5))) + T::new(0.5)
    }
}