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

#include "unit/tests.hpp"
#include <Eigen/Core>

template<typename RType, typename EType> void check_size_properties()
{
  TTS_CONSTEXPR_EQUAL(RType::RowsAtCompileTime, EType::RowsAtCompileTime)
    << tts::typename_<RType> << " vs " << tts::typename_<EType> << "\n";
  TTS_CONSTEXPR_EQUAL(RType::ColsAtCompileTime, EType::ColsAtCompileTime)
    << tts::typename_<RType> << " vs " << tts::typename_<EType> << "\n";
  TTS_CONSTEXPR_EQUAL(RType::MaxRowsAtCompileTime, EType::MaxRowsAtCompileTime)
    << tts::typename_<RType> << " vs " << tts::typename_<EType> << "\n";
  TTS_CONSTEXPR_EQUAL(RType::MaxColsAtCompileTime, EType::MaxColsAtCompileTime)
    << tts::typename_<RType> << " vs " << tts::typename_<EType> << "\n";
  TTS_CONSTEXPR_EQUAL(RType::IsVectorAtCompileTime,
                      EType::IsVectorAtCompileTime)
    << tts::typename_<RType> << " vs " << tts::typename_<EType> << "\n";
  TTS_CONSTEXPR_EQUAL(RType::InnerStrideAtCompileTime,
                      EType::InnerStrideAtCompileTime)
    << tts::typename_<RType> << " vs " << tts::typename_<EType> << "\n";
  TTS_CONSTEXPR_EQUAL(RType::OuterStrideAtCompileTime,
                      EType::OuterStrideAtCompileTime)
    << tts::typename_<RType> << " vs " << tts::typename_<EType> << "\n";
}

TTS_CASE("Compile-Time informations conformance w/r to Eigen - matrix")
{
  using namespace rotgen;
  using namespace Eigen;

  check_size_properties<matrixXf, MatrixXf>();
  check_size_properties<matrix<float, -1, -1, 0, 3, 3>,
                        Matrix<float, -1, -1, 0, 3, 3>>();
  check_size_properties<matrix<float, 4, 9>, Matrix<float, 4, 9>>();
  check_size_properties<vector4f, Vector4f>();
  check_size_properties<matrix<float, 1, -1>, Matrix<float, 1, -1>>();
  check_size_properties<row_vector4f, RowVector4f>();
  check_size_properties<matrix<float, -1, 1>, Matrix<float, -1, 1>>();

  // RowMajor / ColMajor
  {
    TTS_CONSTEXPR_EQUAL(matrixXf::IsRowMajor, MatrixXf::IsRowMajor);
    TTS_CONSTEXPR_EQUAL((matrix<float, -1, -1, rotgen::RowMajor>::IsRowMajor),
                        (Matrix<float, -1, -1, Eigen::RowMajor>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL((matrix<float, -1, 7, rotgen::RowMajor>::IsRowMajor),
                        (Matrix<float, -1, 7, Eigen::RowMajor>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL((matrix<float, 7, -1, rotgen::RowMajor>::IsRowMajor),
                        (Matrix<float, 7, -1, Eigen::RowMajor>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL((matrix<float, 9, 1>::IsRowMajor),
                        (Matrix<float, 9, 1>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL(row_vectorXf::IsRowMajor, RowVectorXf::IsRowMajor);
    TTS_CONSTEXPR_EQUAL((matrix<float, 1, 9>::IsRowMajor),
                        (Matrix<float, 1, 9>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL(vectorXf::IsRowMajor, VectorXf::IsRowMajor);
  }
};

TTS_CASE("Compile-Time informations conformance w/r to Eigen - map")
{
  using namespace rotgen;
  using namespace Eigen;

  check_size_properties<map<matrixXf>, Map<MatrixXf>>();
  check_size_properties<map<matrix<float, -1, -1, 0, 3, 3>>,
                        Map<Matrix<float, -1, -1, 0, 3, 3>>>();
  check_size_properties<map<matrix<float, -1, -1, 0, 3, 3>>,
                        Map<Matrix<float, -1, -1, 0, 3, 3>>>();
  check_size_properties<map<matrix<float, 4, 9>>, Map<Matrix<float, 4, 9>>>();
  check_size_properties<map<vector4f>, Map<Vector4f>>();
  check_size_properties<map<matrix<float, 1, -1>>, Map<Matrix<float, 1, -1>>>();
  check_size_properties<map<row_vector4f>, Map<RowVector4f>>();
  check_size_properties<map<matrix<float, -1, 1>>, Map<Matrix<float, -1, 1>>>();

  // Row/Col Major
  {
    TTS_CONSTEXPR_EQUAL((map<matrixXf>::IsRowMajor),
                        (Map<MatrixXf>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL(
      (map<matrix<float, -1, -1, rotgen::RowMajor>>::IsRowMajor),
      (Map<Matrix<float, -1, -1, Eigen::RowMajor>>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL(
      (map<matrix<float, -1, -1, rotgen::ColMajor>>::IsRowMajor),
      (Map<Matrix<float, -1, -1, Eigen::ColMajor>>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL((map<vectorXf>::IsRowMajor),
                        (Map<VectorXf>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL((map<row_vectorXf>::IsRowMajor),
                        (Map<RowVectorXf>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL(
      (map<matrix<float, -1, 5, rotgen::RowMajor>>::IsRowMajor),
      (Map<Matrix<float, -1, 5, Eigen::RowMajor>>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL(
      (map<matrix<float, -1, 7, rotgen::ColMajor>>::IsRowMajor),
      (Map<Matrix<float, -1, 7, Eigen::ColMajor>>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL(
      (map<matrix<float, 5, -1, rotgen::RowMajor>>::IsRowMajor),
      (Map<Matrix<float, 5, -1, Eigen::RowMajor>>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL(
      (map<matrix<float, 7, -1, rotgen::ColMajor>>::IsRowMajor),
      (Map<Matrix<float, 7, -1, Eigen::ColMajor>>::IsRowMajor));
  }
};

TTS_CASE("Compile-Time informations conformance w/r to Eigen - block")
{
  using namespace rotgen;
  using namespace Eigen;

  check_size_properties<block<matrixXf>, Block<MatrixXf>>();
  check_size_properties<block<matrix<float, 2, 4>>,
                        Block<Matrix<float, 2, 4>>>();
  check_size_properties<block<matrixXf, 3, 6>, Block<MatrixXf, 3, 6>>();
  check_size_properties<block<matrix<float, 8, 8>, 3, 6>,
                        Block<Matrix<float, 8, 8>, 3, 6>>();
  check_size_properties<block<matrixXf, 1, 6>, Block<MatrixXf, 1, 6>>();
  check_size_properties<block<matrix<float, 8, 8>, 1, 6>,
                        Block<Matrix<float, 8, 8>, 1, 6>>();
  check_size_properties<block<matrixXf, 7, 1>, Block<MatrixXf, 7, 1>>();
  check_size_properties<block<matrix<float, 8, 8>, 7, 1>,
                        Block<Matrix<float, 8, 8>, 7, 1>>();

  check_size_properties<block<map<matrixXf>>, Block<Map<MatrixXf>>>();
  check_size_properties<block<map<matrix<float, 2, 4>>>,
                        Block<Map<Matrix<float, 2, 4>>>>();
  check_size_properties<block<map<matrixXf>, 3, 6>,
                        Block<Map<MatrixXf>, 3, 6>>();
  check_size_properties<block<map<matrix<float, 8, 8>>, 3, 6>,
                        Block<Map<Matrix<float, 8, 8>>, 3, 6>>();
  check_size_properties<block<map<matrixXf>, 1, 6>,
                        Block<Map<MatrixXf>, 1, 6>>();
  check_size_properties<block<map<matrix<float, 8, 8>>, 1, 6>,
                        Block<Map<Matrix<float, 8, 8>>, 1, 6>>();
  check_size_properties<block<map<matrixXf>, 7, 1>,
                        Block<Map<MatrixXf>, 7, 1>>();
  check_size_properties<block<map<matrix<float, 8, 8>>, 7, 1>,
                        Block<Map<Matrix<float, 8, 8>>, 7, 1>>();

  // Row/Col Major
  {
    TTS_CONSTEXPR_EQUAL((block<matrixXf>::IsRowMajor),
                        (Block<MatrixXf>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL((block<matrixXf, 1, 8>::IsRowMajor),
                        (Block<MatrixXf, 1, 8>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL((block<matrixXf, 8, 1>::IsRowMajor),
                        (Block<MatrixXf, 8, 1>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL(
      (block<matrix<float, -1, -1, rotgen::RowMajor>>::IsRowMajor),
      (Block<Matrix<float, -1, -1, Eigen::RowMajor>>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL(
      (block<matrix<float, -1, -1, rotgen::ColMajor>>::IsRowMajor),
      (Block<Matrix<float, -1, -1, Eigen::ColMajor>>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL((block<vectorXf>::IsRowMajor),
                        (Block<VectorXf>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL((block<row_vectorXf>::IsRowMajor),
                        (Block<RowVectorXf>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL((block<vectorXf, 1, 8>::IsRowMajor),
                        (Block<VectorXf, 1, 8>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL((block<row_vectorXf, 8, 1>::IsRowMajor),
                        (Block<RowVectorXf, 8, 1>::IsRowMajor));
  }
};

TTS_CASE("Compile-Time informations conformance w/r to Eigen - ref")
{
  using namespace rotgen;
  using namespace Eigen;

  check_size_properties<ref<matrixXf>, Ref<MatrixXf>>();
  check_size_properties<ref<matrix<float, -1, -1, 0, 3, 3>>,
                        Ref<Matrix<float, -1, -1, 0, 3, 3>>>();
  check_size_properties<ref<matrix<float, 4, 9>>, Ref<Matrix<float, 4, 9>>>();
  check_size_properties<ref<vector4f>, Ref<Vector4f>>();
  check_size_properties<ref<matrix<float, 1, -1>>, Ref<Matrix<float, 1, -1>>>();
  check_size_properties<ref<row_vector4f>, Ref<RowVector4f>>();
  check_size_properties<ref<matrix<float, -1, 1>>, Ref<Matrix<float, -1, 1>>>();

  // Row/Col Major
  {
    TTS_CONSTEXPR_EQUAL((ref<matrixXf>::IsRowMajor),
                        (Ref<MatrixXf>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL(
      (ref<matrix<float, -1, -1, rotgen::RowMajor>>::IsRowMajor),
      (Ref<Matrix<float, -1, -1, Eigen::RowMajor>>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL(
      (ref<matrix<float, -1, -1, rotgen::ColMajor>>::IsRowMajor),
      (Ref<Matrix<float, -1, -1, Eigen::ColMajor>>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL((ref<vectorXf>::IsRowMajor),
                        (Ref<VectorXf>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL((ref<row_vectorXf>::IsRowMajor),
                        (Ref<RowVectorXf>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL(
      (ref<matrix<float, -1, 5, rotgen::RowMajor>>::IsRowMajor),
      (Ref<Matrix<float, -1, 5, Eigen::RowMajor>>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL(
      (ref<matrix<float, -1, 7, rotgen::ColMajor>>::IsRowMajor),
      (Ref<Matrix<float, -1, 7, Eigen::ColMajor>>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL(
      (ref<matrix<float, 5, -1, rotgen::RowMajor>>::IsRowMajor),
      (Ref<Matrix<float, 5, -1, Eigen::RowMajor>>::IsRowMajor));
    TTS_CONSTEXPR_EQUAL(
      (ref<matrix<float, 7, -1, rotgen::ColMajor>>::IsRowMajor),
      (Ref<Matrix<float, 7, -1, Eigen::ColMajor>>::IsRowMajor));
  }
};