#include <limits.h>
#include <riscv_vector.h>
#include <softrvv.h>
#include <springbok.h>
#include <stdio.h>
#include <stdlib.h>

#include <bit>
#include <tuple>

#include "pw_unit_test/framework.h"
#include "test_v_helpers.h"

namespace vadd_vv_test {
namespace {

using namespace test_v_helpers;

uint8_t test_vector_1[MAXVL_BYTES];
uint8_t reference_vector_1[MAXVL_BYTES];

class VaddVxTest : public ::testing::Test {
 protected:
  void SetUp() override { zero_vector_registers(); }
  void TearDown() override { zero_vector_registers(); }
};

// Below is a demo Test for convenient debugging
// Currently disabled, so remove "DISABLED_" prefix to enable this test
TEST_F(VaddVxTest, DISABLED_vadd_vv_demo) {
  for (int i = 0; i < AVL_COUNT; i++) {
    int32_t avl = AVLS[i];
    int vlmax;
    int vl;
    std::tie(vlmax, vl) = vector_test_setup<int8_t>(
        VLMUL::LMUL_M1, avl, test_vector_1, reference_vector_1);
    if (avl > vlmax) {
      continue;
    }
    int8_t *ptr_vec_1 = reinterpret_cast<int8_t *>(test_vector_1);
    int8_t *ptr_ref_vec_1 = reinterpret_cast<int8_t *>(reference_vector_1);

    // set up values to test up to index of the AVL
    for (int idx = 0; idx < vl; idx++) {
      // restrict values to valid int8_t range
      ptr_vec_1[idx] = idx % (INT8_MAX) + (INT8_MIN);
      reference_vector_1[idx] = ptr_vec_1[idx];
    }
    __asm__ volatile("vle8.v v8, (%0)" : : "r"(ptr_vec_1));
    __asm__ volatile("vadd.vv v8, v8, v8");
    softrvv::vadd_vv<int8_t>(ptr_ref_vec_1, ptr_ref_vec_1, ptr_ref_vec_1, avl);
    __asm__ volatile("vse8.v v8, (%0)" : : "r"(ptr_vec_1));
    assert_vec_elem_eq<int8_t>(vlmax, test_vector_1, reference_vector_1);
  }
}

#define DEFINE_TEST_VADD_VV(_SEW_, _LMUL_)                                \
  TEST_F(VaddVxTest, vadd_vv##_SEW_##m##_LMUL_) {                         \
    for (int i = 0; i < AVL_COUNT; i++) {                                 \
      int32_t avl = AVLS[i];                                              \
      int vlmax;                                                          \
      int vl;                                                             \
      std::tie(vlmax, vl) = vector_test_setup<int##_SEW_##_t>(            \
          VLMUL::LMUL_M##_LMUL_, avl, test_vector_1, reference_vector_1); \
      if (avl > vlmax) {                                                  \
        continue;                                                         \
      }                                                                   \
      int##_SEW_##_t *ptr_vec_1 =                                         \
          reinterpret_cast<int##_SEW_##_t *>(test_vector_1);              \
      int##_SEW_##_t *ptr_ref_vec_1 =                                     \
          reinterpret_cast<int##_SEW_##_t *>(reference_vector_1);         \
                                                                          \
      for (long long idx = 0; idx < vl; idx++) {                          \
        ptr_vec_1[idx] = idx % INT##_SEW_##_MAX + INT##_SEW_##_MIN;       \
        ptr_ref_vec_1[idx] = ptr_vec_1[idx];                              \
      }                                                                   \
                                                                          \
      __asm__ volatile("vle" #_SEW_ ".v v8, (%0)" : : "r"(ptr_vec_1));    \
      __asm__ volatile("vadd.vv v8, v8, v8");                             \
      softrvv::vadd_vv<int##_SEW_##_t>(ptr_ref_vec_1, ptr_ref_vec_1,      \
                                       ptr_ref_vec_1, avl);               \
      __asm__ volatile("vse" #_SEW_ ".v v8, (%0)" : : "r"(ptr_vec_1));    \
      assert_vec_elem_eq<int##_SEW_##_t>(vlmax, test_vector_1,            \
                                         reference_vector_1);             \
    }                                                                     \
  }  // namespace

// TODO(gkielian): modify macro to permit more than one test per sew/lmul pair
DEFINE_TEST_VADD_VV(8, 1)
DEFINE_TEST_VADD_VV(8, 2)
DEFINE_TEST_VADD_VV(8, 4)
DEFINE_TEST_VADD_VV(8, 8)

DEFINE_TEST_VADD_VV(16, 1)
DEFINE_TEST_VADD_VV(16, 2)
DEFINE_TEST_VADD_VV(16, 4)
DEFINE_TEST_VADD_VV(16, 8)

DEFINE_TEST_VADD_VV(32, 1)
DEFINE_TEST_VADD_VV(32, 2)
DEFINE_TEST_VADD_VV(32, 4)
DEFINE_TEST_VADD_VV(32, 8)

}  // namespace
}  // namespace vadd_vv_test