#include <softrvv.h>
#include <springbok.h>
#include <stdio.h>

#include <tuple>

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

namespace vfadd_vv_test
{
namespace
{
using namespace test_v_helpers;

float src_vector_1[MAXVL_BYTES];
float src_vector_2[MAXVL_BYTES];
float dest_vector[MAXVL_BYTES];
float ref_dest_vector[MAXVL_BYTES];

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

TEST_F(VfaddTest, vfadd_vv32m1) {
  for (int i = 0; i < AVL_COUNT; i++) {
    int32_t avl = AVLS[i];
    int vlmax;
    int vl;

    /* For non narrowing instructions all vectors have same type*/
    std::tie(vlmax, vl) = vector_test_setup<int32_t>(
        VLMUL::LMUL_M1, avl,
        {dest_vector, ref_dest_vector, src_vector_1, src_vector_2});

    if (avl > vlmax) {
      continue;
    }

    float *ptr_vec_1 = reinterpret_cast<float *>(src_vector_1);
    float *ptr_vec_2 = reinterpret_cast<float *>(src_vector_2);
    float *ptr_dest_vec = reinterpret_cast<float *>(dest_vector);
    float *ptr_ref_dest_vec = reinterpret_cast<float *>(ref_dest_vector);

    // set up values to test up to index of the AVL
    fill_random_vector<float>(ptr_vec_1, avl);
    fill_random_vector<float>(ptr_vec_2, avl);

    // Generate reference vector
    softrvv::vfadd_vv(ptr_ref_dest_vec, ptr_vec_2, ptr_vec_1, avl);
    // Load vector registers
    __asm__ volatile("vle32.v v8, (%0)" : : "r"(ptr_vec_1));
    __asm__ volatile("vle32.v v16, (%0)" : : "r"(ptr_vec_2));

    // Run target instruction
    __asm__ volatile("vfadd.vv v24, v16, v8");

    // Store result vector register
    __asm__ volatile("vse32.v v24, (%0)" : : "r"(ptr_dest_vec));
    // Check vector elements
    assert_vec_elem_eq<float>(vlmax, dest_vector, ref_dest_vector);
  }
}
}  // namespace
}  // namespace vfadd_vv_test