#ifndef _MATRIX_TEMPLATES_H_
#define _MATRIX_TEMPLATES_H_

/*--------------------------------------------------------------------------------*/
/* Includes */
/*--------------------------------------------------------------------------------*/
#include "test_templates.h"

/*--------------------------------------------------------------------------------*/
/* Group Specific Templates */
/*--------------------------------------------------------------------------------*/

/**
 *  Compare the outputs from the function under test and the reference
 *  function.
 */
#define MATRIX_COMPARE_INTERFACE(output_type, output_content_type)  \
    TEST_ASSERT_BUFFERS_EQUAL(                                      \
        ((output_type *) &matrix_output_ref)->pData,                \
        ((output_type *) &matrix_output_fut)->pData,                \
        ((output_type *) &matrix_output_fut)->numRows *             \
        ((output_type *) &matrix_output_ref)->numCols *             \
        sizeof(output_content_type))

/**
 * Comparison SNR thresholds for the data types used in matrix_tests.
 */
#define MATRIX_SNR_THRESHOLD 120

/**
 *  Compare the outputs from the function under test and the reference
 *  function using SNR.
 */
#define MATRIX_SNR_COMPARE_INTERFACE(output_type, output_content_type)  \
    do                                                                  \
    {                                                                   \
        TEST_CONVERT_AND_ASSERT_SNR(                                    \
            (float32_t *)matrix_output_f32_ref,                         \
            ((output_type *) &matrix_output_ref)->pData,                \
            (float32_t *)matrix_output_f32_fut,                         \
            ((output_type *) &matrix_output_ref)->pData,                \
            ((output_type *) &matrix_output_fut)->numRows *             \
            ((output_type *) &matrix_output_ref)->numCols,              \
            output_content_type,                                        \
            MATRIX_SNR_THRESHOLD                                        \
            );                                                          \
    } while (0)

/**
 *  Compare the outputs from the function under test and the reference
 *  function using SNR. This is special for float64_t
 */
#define MATRIX_DBL_SNR_COMPARE_INTERFACE(output_type)                   \
    do                                                                  \
    {                                                                   \
        TEST_ASSERT_DBL_SNR(                                            \
            (float64_t *)matrix_output_f32_ref,                         \
            (float64_t *)matrix_output_f32_fut,                         \
            ((output_type *) &matrix_output_fut)->numRows *             \
            ((output_type *) &matrix_output_ref)->numCols,              \
            MATRIX_SNR_THRESHOLD                                        \
            );                                                          \
    } while (0)

/*--------------------------------------------------------------------------------*/
/* Input Interfaces */
/*--------------------------------------------------------------------------------*/
/*
 *  General:
 *  Input interfaces provide inputs to functions inside test templates.  They
 *  ONLY provide the inputs.  The output variables should be hard coded.
 *
 *  The input interfaces must have the following format:
 *
 *  ARM_xxx_INPUT_INTERFACE() or
 *  REF_xxx_INPUT_INTERFACE()
 *
 *  The xxx must be lowercase, and is intended to be the indentifying substring
 *  in the function's name.  Acceptable values are 'sub' or 'add' from the
 *  functions arm_add_q31.
 */

#define ARM_mat_add_INPUT_INTERFACE(input_a_ptr, input_b_ptr)    \
    PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_fut)

#define REF_mat_add_INPUT_INTERFACE(input_a_ptr, input_b_ptr)    \
    PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_ref)

#define ARM_mat_cmplx_mult_INPUT_INTERFACE(input_a_ptr, input_b_ptr)    \
    PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_fut)

#define REF_mat_cmplx_mult_INPUT_INTERFACE(input_a_ptr, input_b_ptr)    \
    PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_ref)

#define ARM_mat_inverse_INPUT_INTERFACE(input_ptr)  \
    PAREN(input_ptr, (void *) &matrix_output_fut)

#define REF_mat_inverse_INPUT_INTERFACE(input_ptr)  \
    PAREN(input_ptr, (void *) &matrix_output_ref)

#define ARM_mat_mult_INPUT_INTERFACE(input_a_ptr, input_b_ptr)      \
    PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_fut)

#define REF_mat_mult_INPUT_INTERFACE(input_a_ptr, input_b_ptr)      \
    PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_ref)

#define ARM_mat_mult_fast_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \
    PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_fut)

#define REF_mat_mult_fast_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \
    PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_ref)

#define ARM_mat_sub_INPUT_INTERFACE(input_a_ptr, input_b_ptr)    \
    PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_fut)

#define REF_mat_sub_INPUT_INTERFACE(input_a_ptr, input_b_ptr)    \
    PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_ref)

#define ARM_mat_trans_INPUT_INTERFACE(input_ptr)    \
    PAREN(input_ptr, (void *) &matrix_output_fut)

#define REF_mat_trans_INPUT_INTERFACE(input_ptr)    \
    PAREN(input_ptr, (void *) &matrix_output_ref)

/*--------------------------------------------------------------------------------*/
/* Dimension Validation Interfaces */
/*--------------------------------------------------------------------------------*/

#define MATRIX_TEST_VALID_ADDITIVE_DIMENSIONS(input_type,   \
                                              matrix_a_ptr, \
                                              matrix_b_ptr) \
    ((((input_type) (matrix_a_ptr))->numRows ==             \
      ((input_type) (matrix_b_ptr))->numRows) &&            \
     (((input_type) (matrix_a_ptr))->numCols ==             \
      ((input_type) (matrix_b_ptr))->numCols))

#define MATRIX_TEST_VALID_MULTIPLICATIVE_DIMENSIONS(input_type,     \
                                                    matrix_a_ptr,   \
                                                    matrix_b_ptr)   \
    (((input_type) (matrix_a_ptr))->numCols ==                      \
     ((input_type) (matrix_b_ptr))->numRows)

#define MATRIX_TEST_VALID_SQUARE_DIMENSIONS(input_type, \
                                            matrix_ptr) \
    (((input_type)(matrix_ptr))->numRows ==             \
     ((input_type)(matrix_ptr))->numCols)

#define MATRIX_TEST_VALID_DIMENSIONS_ALWAYS(input_type, \
                                            matrix_ptr) \
    (1 == 1)                                            \

/*--------------------------------------------------------------------------------*/
/* Output Configuration Interfaces */
/*--------------------------------------------------------------------------------*/
/* The matrix tests assume the output matrix is always the correct size.  These
 * interfaces size the properly size the output matrices according to the input
 * matrices and the operation at hand.*/

#define MATRIX_TEST_CONFIG_ADDITIVE_OUTPUT(input_type,      \
                                           matrix_a_ptr,    \
                                           matrix_b_ptr)    \
    do                                                      \
    {                                                       \
        ((input_type) &matrix_output_fut)->numRows =        \
            ((input_type)(matrix_a_ptr))->numRows;          \
        ((input_type) &matrix_output_fut)->numCols =        \
            ((input_type)(matrix_a_ptr))->numCols;          \
        ((input_type) &matrix_output_ref)->numRows =        \
            ((input_type)(matrix_a_ptr))->numRows;          \
        ((input_type) &matrix_output_ref)->numCols =        \
            ((input_type)(matrix_a_ptr))->numCols;          \
    } while (0)

#define MATRIX_TEST_CONFIG_MULTIPLICATIVE_OUTPUT(input_type,    \
                                                 matrix_a_ptr,  \
                                                 matrix_b_ptr)  \
    do                                                          \
    {                                                           \
        ((input_type) &matrix_output_fut)->numRows =            \
            ((input_type)(matrix_a_ptr))->numRows;              \
        ((input_type) &matrix_output_fut)->numCols =            \
            ((input_type)(matrix_b_ptr))->numCols;              \
        ((input_type) &matrix_output_ref)->numRows =            \
            ((input_type)(matrix_a_ptr))->numRows;              \
        ((input_type) &matrix_output_ref)->numCols =            \
            ((input_type)(matrix_b_ptr))->numCols;              \
    } while (0)

#define MATRIX_TEST_CONFIG_SAMESIZE_OUTPUT(input_type,  \
                                           matrix_ptr)  \
    do                                                  \
    {                                                   \
        ((input_type) &matrix_output_fut)->numRows =    \
            ((input_type)(matrix_ptr))->numRows;        \
        ((input_type) &matrix_output_fut)->numCols =    \
            ((input_type)(matrix_ptr))->numCols;        \
        ((input_type) &matrix_output_ref)->numRows =    \
            ((input_type)(matrix_ptr))->numRows;        \
        ((input_type) &matrix_output_ref)->numCols =    \
            ((input_type)(matrix_ptr))->numCols;        \
    } while (0)

#define MATRIX_TEST_CONFIG_TRANSPOSE_OUTPUT(input_type,     \
                                            matrix_ptr)     \
        do                                                  \
        {                                                   \
            ((input_type) &matrix_output_fut)->numRows =    \
                ((input_type)(matrix_ptr))->numCols;        \
            ((input_type) &matrix_output_fut)->numCols =    \
                ((input_type)(matrix_ptr))->numRows;        \
            ((input_type) &matrix_output_ref)->numRows =    \
                ((input_type)(matrix_ptr))->numCols;        \
            ((input_type) &matrix_output_ref)->numCols =    \
                ((input_type)(matrix_ptr))->numRows;        \
        } while (0)

/*--------------------------------------------------------------------------------*/
/* TEST Templates */
/*--------------------------------------------------------------------------------*/

#define MATRIX_TEST_TEMPLATE_ELT1(arr_desc_inputs,                      \
                                  input_type,                           \
                                  output_type, output_content_type,     \
                                  fut, fut_arg_interface,               \
                                  ref, ref_arg_interface,               \
                                  output_config_interface,              \
                                  dim_validation_interface,             \
                                  compare_interface)                    \
    do                                                                  \
    {                                                                   \
        TEMPLATE_DO_ARR_DESC(                                           \
            input_idx, input_type, input, arr_desc_inputs               \
            ,                                                           \
            JTEST_DUMP_STRF("Matrix Dimensions: %dx%d\n",               \
                         (int)input->numRows,                           \
                         (int)input->numCols);                          \
                                                                        \
            if (dim_validation_interface(input_type,                     \
                                        input)) {                       \
                output_config_interface(input_type,                     \
                                        input);                         \
                TEST_CALL_FUT_AND_REF(                                  \
                    fut, fut_arg_interface(input),                      \
                    ref, ref_arg_interface(input));                     \
                compare_interface(output_type,                          \
                                  output_content_type);                 \
            } else {                                                    \
                arm_status matrix_test_retval;                          \
                TEST_CALL_FUT(                                          \
                    matrix_test_retval = fut,                           \
                    fut_arg_interface(input));                          \
                                                                        \
                /* If dimensions are known bad, the fut should */       \
                /* detect it. */                                        \
                if ( matrix_test_retval != ARM_MATH_SIZE_MISMATCH) {     \
                    return JTEST_TEST_FAILED;                           \
                }                                                       \
            });                                                         \
        return JTEST_TEST_PASSED;                                       \
    } while (0)


#define MATRIX_TEST_TEMPLATE_ELT2(arr_desc_inputs_a,                    \
                                  arr_desc_inputs_b,                    \
                                  input_type,                           \
                                  output_type, output_content_type,     \
                                  fut, fut_arg_interface,               \
                                  ref, ref_arg_interface,               \
                                  output_config_interface,              \
                                  dim_validation_interface,             \
                                  compare_interface)                    \
    do                                                                  \
    {                                                                   \
        TEMPLATE_DO_ARR_DESC(                                           \
            input_a_idx, input_type, input_a, arr_desc_inputs_a         \
            ,                                                           \
            input_type input_b = ARR_DESC_ELT(                          \
                input_type, input_a_idx,                                \
                &(arr_desc_inputs_b));                                  \
                                                                        \
            JTEST_DUMP_STRF("Matrix Dimensions: A %dx%d  B %dx%d\n",    \
                     (int)input_a->numRows,                             \
                     (int)input_a->numCols,                             \
                     (int)input_b->numRows,                             \
                     (int)input_b->numCols);                            \
                                                                        \
            if (dim_validation_interface(input_type,                     \
                                        input_a,                        \
                                        input_b)) {                     \
                                                                        \
                output_config_interface(input_type,                     \
                                        input_a,                        \
                                        input_b);                       \
                                                                        \
                TEST_CALL_FUT_AND_REF(                                  \
                    fut, fut_arg_interface(input_a, input_b),           \
                    ref, ref_arg_interface(input_a, input_b));          \
                                                                        \
                compare_interface(output_type, output_content_type);    \
                                                                        \
            } else {                                                    \
                arm_status matrix_test_retval;                          \
                TEST_CALL_FUT(                                          \
                    matrix_test_retval = fut, fut_arg_interface(input_a, input_b)); \
                                                                        \
                /* If dimensions are known bad, the fut should */       \
                /* detect it. */                                        \
                if ( matrix_test_retval != ARM_MATH_SIZE_MISMATCH) {     \
                    return JTEST_TEST_FAILED;                           \
                }                                                       \
            });                                                         \
        return JTEST_TEST_PASSED;                                       \
    } while (0)

/**
 *  Specialization of #MATRIX_TEST_TEMPLATE_ELT2() for matrix tests.
 *
 *  @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
 *  REF_xxx_INPUT_INTERFACEs.
 */
#define MATRIX_DEFINE_TEST_TEMPLATE_ELT2(fn_name, suffix,           \
                                         output_config_interface,   \
                                         dim_validation_interface,  \
                                         comparison_interface)      \
        JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test,          \
                          arm_##fn_name##_##suffix)                 \
        {                                                           \
            MATRIX_TEST_TEMPLATE_ELT2(                              \
                matrix_##suffix##_a_inputs,                         \
                matrix_##suffix##_b_inputs,                         \
                arm_matrix_instance_##suffix * ,                    \
                arm_matrix_instance_##suffix,                       \
                TYPE_FROM_ABBREV(suffix),                           \
                arm_##fn_name##_##suffix,                           \
                ARM_##fn_name##_INPUT_INTERFACE,                    \
                ref_##fn_name##_##suffix,                           \
                REF_##fn_name##_INPUT_INTERFACE,                    \
                output_config_interface,                            \
                dim_validation_interface,                           \
                comparison_interface);                              \
        }                                                           \

/**
 *  Specialization of #MATRIX_TEST_TEMPLATE_ELT1() for matrix tests.
 *
 *  @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
 *  REF_xxx_INPUT_INTERFACEs.
 */
#define MATRIX_DEFINE_TEST_TEMPLATE_ELT1(fn_name, suffix,           \
                                         output_config_interface,   \
                                         dim_validation_interface)  \
        JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test,          \
                          arm_##fn_name##_##suffix)                 \
        {                                                           \
            MATRIX_TEST_TEMPLATE_ELT1(                              \
                matrix_##suffix##_a_inputs,                         \
                arm_matrix_instance_##suffix * ,                    \
                arm_matrix_instance_##suffix,                       \
                TYPE_FROM_ABBREV(suffix),                           \
                arm_##fn_name##_##suffix,                           \
                ARM_##fn_name##_INPUT_INTERFACE,                    \
                ref_##fn_name##_##suffix,                           \
                REF_##fn_name##_INPUT_INTERFACE,                    \
                output_config_interface,                            \
                dim_validation_interface,                           \
                MATRIX_COMPARE_INTERFACE);                          \
        }                                                           \


#endif /* _MATRIX_TEMPLATES_H_ */