//==================================================================================================
/*
  ROTGEN - Runtime Overlay for Eigen
  Copyright : CODE RECKONS
  SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#include <rotgen/rotgen.hpp>

#include "unit/tests.hpp"

template<int size = rotgen::Dynamic,
         typename Scalar = float,
         int maxSize = size>
using column = rotgen::matrix<Scalar, size, 1, rotgen::ColMajor, maxSize, 1>;

template<int size = rotgen::Dynamic, typename Scalar = float>
using column_ref = rotgen::ref<column<size, Scalar>>;

template<int size = rotgen::Dynamic, typename Scalar = float>
using const_column_ref = rotgen::ref<column<size, Scalar> const>;

template<int N> void process(column_ref<N> v)
{
  v(0) = rotgen::sum(v);
}

auto process(column_ref<> v)
{
  auto sz = v.size();
  switch (sz)
  {
  case 1:
    process<1>(v);
    break;
  case 2:
    process<2>(v);
    break;
  case 3:
    process<3>(v);
    break;
  default:
    break;
  }

  return sz;
}

TTS_CASE("Reference of reference check")
{
  auto v1 = rotgen::setOnes<rotgen::matrix<float, 1, 1>>();
  auto v2 = rotgen::setRandom<rotgen::matrix<float, 2, 1>>();
  auto v3 = rotgen::setConstant<rotgen::matrix<float, 3, 1>>(6.66);

  auto sum1 = v1(0);
  auto sum2 = v2(0) + v2(1);
  auto sum3 = v3(0) + v3(1) + v3(2);

  TTS_EQUAL(process(v1), 1);
  TTS_EQUAL(process(v2), 2);
  TTS_EQUAL(process(v3), 3);

  TTS_EQUAL(v1[0], sum1);
  TTS_EQUAL(v2[0], sum2);
  TTS_EQUAL(v3[0], sum3);
};

int f(rotgen::ref<rotgen::matrix<float, 1, 3, rotgen::RowMajor>>)
{
  return +2;
}

template<int N>
int g(rotgen::ref<rotgen::matrix<float, -1, N, rotgen::ColMajor>>)
{
  return +1;
}

template<int N>
int g(rotgen::ref<rotgen::matrix<float, -1, N, rotgen::RowMajor>>)
requires(N > 1)
{
  return -1;
}

TTS_CASE("Reference overload on storage order check")
{
  using col3 = rotgen::matrix<float, -1, 3, rotgen::ColMajor>;
  using row3 = rotgen::matrix<float, -1, 3, rotgen::RowMajor>;

  rotgen::matrixXf mat_dyn(1, 3);
  col3 mat_col(1, 3);
  row3 mat_row(1, 3);

  TTS_EQUAL(f(mat_dyn), +2);
  TTS_EQUAL(g<3>(mat_dyn), +1);
  TTS_EQUAL(g<3>(mat_col), +1);
  TTS_EQUAL(g<3>(mat_row), -1);

  TTS_EQUAL(f(rotgen::map<rotgen::matrixXf, 1>(mat_dyn.data(), 1, 3)), +2);
  TTS_EQUAL(g<3>(rotgen::map<rotgen::matrixXf, 1>(mat_dyn.data(), 1, 3)), +1);
  TTS_EQUAL(g<3>(rotgen::map<col3, 1>(mat_dyn.data(), 1, 3)), +1);
  TTS_EQUAL(g<3>(rotgen::map<row3, 1>(mat_dyn.data(), 1, 3)), -1);

  TTS_EQUAL(f(rotgen::map<rotgen::matrixXf, 1, rotgen::outer_stride<>>(
              mat_dyn.data(), 1, 3, rotgen::outer_stride<>{1})),
            +2);
  TTS_EQUAL(g<3>(rotgen::map<rotgen::matrixXf, 1, rotgen::outer_stride<>>(
              mat_dyn.data(), 1, 3, rotgen::outer_stride<>{1})),
            +1);
  TTS_EQUAL(g<3>(rotgen::map<col3, 1, rotgen::outer_stride<>>(
              mat_dyn.data(), 1, 3, rotgen::outer_stride<>{1})),
            +1);
  TTS_EQUAL(g<3>(rotgen::map<row3, 1, rotgen::outer_stride<>>(
              mat_dyn.data(), 1, 3, rotgen::outer_stride<>{1})),
            -1);

  TTS_EQUAL(f(rotgen::extract(mat_dyn, 0, 0, 1, 3)), +2);
  TTS_EQUAL(g<3>(rotgen::extract(mat_dyn, 0, 0, 1, 3)), +1);
  TTS_EQUAL(g<3>(rotgen::extract(mat_col, 0, 0, 1, 3)), +1);
  TTS_EQUAL(g<3>(rotgen::extract(mat_row, 0, 0, 1, 3)), -1);
};