///! Sequences and other 'stock' math functions

///! Calculate a number in the fibonacci sequence,
///! using a lookup table for better worst-case performance.
///
/// Can calculate up to 186 using native unsigned 128 bit integers.
pub fn fibonacci(n: usize) -> Option<u128> {
    let mut table: Vec<u128> = vec![];

    _fibonacci(n, &mut table)
}

/// Actual calculating function for `fibonacci`
#[inline]
fn _fibonacci(n: usize, table: &mut Vec<u128>) -> Option<u128> {
    match table.get(n) {
        Some(x) => Some(*x),
        None => {
            let a = _fibonacci(n - 1, table)?;
            let b = _fibonacci(n - 2, table)?;

            // Check for overflow when adding
            let attempt = a.checked_add(b);

            if let Some(current) = attempt {
                table.insert(n, current);
            }

            attempt
        }
    }
}

///! Calculate the value of a factorial,
///! using a lookup table for better worst-case performance.
///
/// Can calculate up to 34! using native unsigned 128 bit integers.
/// If the result overflows, an error message will be displayed.
pub fn factorial(n: usize) -> Option<u128> {
    let mut table: Vec<u128> = vec![0, 1, 1, 2, 3, 5];

    _factorial(n, &mut table)
}

/// Actual Calculation function for factoral
#[inline]
fn _factorial (n: usize, table: &mut Vec<u128>) -> Option<u128> {
    match table.get(n) {
        // Vec<T>.get returns a Option with a reference to the value,
        // so deref and wrap in Some() for proper return type
        Some(x) => Some(*x),
        None => {
            // The ? suffix passes along the Option value
            // to be handled later
            // See: https://doc.rust-lang.org/reference/expressions/operator-expr.html#the-question-mark-operator
            let prev = _factorial(n - 1, table)?;

            // Do an overflow-checked multiply
            let attempt = (n as u128).checked_mul(prev);

            // If there isn't an overflow, add the result
            // to the calculation table
            if let Some(current) = attempt {
                table.insert(n, current);
            }

            attempt // Some(x) if no overflow
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_factorial() {
        let res = factorial(34);
        assert!(res.is_some());

        let res = factorial(35);
        assert!(res.is_none());
    }

    #[test]
    fn test_fibonacci() {
        let res = fibonacci(186);
        assert!(res.is_some());

        let res = fibonacci(187);
        assert!(res.is_none());
    }
}