/** @file testlib.hpp
 *
 *  @author Cory Alexander Balaton (coryab)
 *  @author Janita Ovidie Sandtrøen Willumsen (janitaws)
 *
 *  @version 1.0
 *
 *  @brief A small test library.
 *
 *  @details This a small testing library that is tailored for the needs of the
 *  project. Anything that is in the details namespace should not be used 
 *  directly, or else it might cause undefined behavior if not used correctly.
 *
 *  @bug No known bugs
 * */
#ifndef __TESTLIB__
#define __TESTLIB__

#include "utils.hpp"

#include <armadillo>
#include <string>
#include <type_traits>

/** @def ASSERT(expr)
 *  @brief A prettier assertion function.
 *
 *  This macro calls the m_assert function which is a more informative
 *  assertion function than the regular assert function from cassert.
 * */
#define ASSERT(expr, msg)                                                      \
    details::m_assert(expr, #expr, __METHOD_NAME__, __FILE__, __LINE__, msg)

namespace details {
/** @brief Test an expression, confirm that test is ok, or abort execution.
 *
 *  @details This function takes in an expression and prints an OK message if
 *  it's true, or it prints a fail message and aborts execution if it fails.
 *
 *  @param expr The expression to be evaluated
 *  @param expr_str The stringified version of the expression
 *  @param func The function name of the caller
 *  @param file The file of the caller
 *  @param line The line number where this function is called from
 *  @param msg The message to be displayed
 * */
void m_assert(bool expr, std::string expr_str, std::string func,
              std::string file, int line, std::string msg);
} // namespace details

namespace testlib {
/** @brief Test if two armadillo matrices/vectors are close to each other.
 *
 *  @details This function takes in 2 matrices/vectors and checks if they are
 *  approximately equal to each other given a tolerance.
 *
 *  @param a Matrix/vector a
 *  @param b Matrix/vector b
 *  @param tol The tolerance
 *
 *  @return bool
 * */
template <class T,
          class = typename std::enable_if<std::is_arithmetic<T>::value>::type>
static bool close_to(arma::Mat<T> &a, arma::Mat<T> &b, double tol = 1e-8)
{
    if (a.n_elem != b.n_elem) {
        return false;
    }

    for (size_t i = 0; i < a.n_elem; i++) {
        if (!close_to(a(i), b(i))) {
            return false;
        }
    }
    return true;
}

/** @brief Test if two numbers are close to each other.
 *
 *  @details This function takes in 2 matrices/vectors and checks if they are
 *  approximately equal to each other given a tolerance.
 *
 *  @param a Matrix/vector a
 *  @param b Matrix/vector b
 *  @param tol The tolerance
 *
 *  @return bool
 * */
template <class T,
          class = typename std::enable_if<std::is_arithmetic<T>::value>::type>
static bool close_to(T a, T b, double tol = 1e-8)
{
    return std::fabs(a - b) < tol;
}

/** @brief Test if two armadillo matrices/vectors are equal.
 *
 *  @details This function takes in 2 matrices/vectors and checks if they are
 *  equal to each other. This should only be used for integral types.
 *
 *  @param a Matrix/vector a
 *  @param b Matrix/vector b
 *
 *  @return bool
 * */
template <class T,
          class = typename std::enable_if<std::is_integral<T>::value>::type>
static bool is_equal(arma::Mat<T> &a, arma::Mat<T> &b)
{
    for (size_t i = 0; i < a.n_elem; i++) {
        if (!(a(i) == b(i))) {
            return false;
        }
    }
    return true;
}

/** @brief Test that all elements fulfill the condition.
 *
 *  @param expr The boolean expression to apply to each element
 *  @param M The matrix/vector to iterate over
 *
 *  @return bool
 * */
template <class T,
          class = typename std::enable_if<std::is_arithmetic<T>::value>::type>
static bool assert_each(std::function<bool(T)> expr, arma::Mat<T> &M)
{
    for (size_t i = 0; i < M.n_elem; i++) {
        if (!expr(M(i))) {
            return false;
        }
    }
    return true;
}
} // namespace testlib
#endif
