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

#include "unit/tests.hpp"
#include <array>
#include <functional>

template<typename MatrixType> struct MatrixDescriptor
{
  std::size_t rows, cols;
  std::function<void(MatrixType&, std::size_t, std::size_t)> init_fn;
};

template<typename MatrixType, std::size_t N>
void test_matrix_sizes(
  rotgen::Index rows,
  rotgen::Index cols,
  std::function<void(MatrixType&, std::size_t, std::size_t)> const& init_fn,
  std::array<std::pair<int, int>, N> const& resize_dimensions)
{
  MatrixType matrix(rows, cols);

  for (rotgen::Index r = 0; r < rows; ++r)
    for (rotgen::Index c = 0; c < cols; ++c) init_fn(matrix, r, c);

  TTS_EQUAL(rotgen::size(matrix), rows * cols);

  for (std::size_t i = 0; i < N; ++i)
  {
    int r = resize_dimensions[i].first;
    int c = resize_dimensions[i].second;

    rotgen::resize(matrix, r, c);

    TTS_EQUAL(rotgen::rows(matrix), r);
    TTS_EQUAL(rotgen::cols(matrix), c);
    TTS_EQUAL(rotgen::size(matrix), r * c);
  }

  rotgen::conservativeResize(matrix, rows, cols);
  TTS_EQUAL(rotgen::size(matrix), rows * cols);

  int i = 1;
  for (rotgen::Index r = 0; r < rows; ++r)
    for (rotgen::Index c = 0; c < cols; ++c) matrix(r, c) = i++;

  rotgen::conservativeResize(matrix, rows + 3, cols + 2);
  TTS_EQUAL(rotgen::size(matrix), (rows + 3) * (cols + 2));

  i = 1;
  for (rotgen::Index r = 0; r < rows; ++r)
    for (rotgen::Index c = 0; c < cols; ++c) TTS_EQUAL(matrix(r, c), i++);
}

TTS_CASE("Matrix size-related operations")
{
  std::vector<MatrixDescriptor<rotgen::matrix<double>>> test_matrices = {
    {3, 3, [](auto& m, std::size_t r, std::size_t c) { m(r, c) = r + c; }},
    {2, 3, [](auto& m, std::size_t r, std::size_t c) { m(r, c) = 0.0; }},
    {2, 7,
     [](auto& m, std::size_t r, std::size_t c) {
       m(r, c) = -r * r * r - c * c - 1.23;
     }},
    {17, 3,
     [](auto& m, std::size_t r, std::size_t c) { m(r, c) = r * c + 0.98; }},
    {1, 1, [](auto& m, std::size_t r, std::size_t c) { m(r, c) = 42.0; }},
    {10, 11,
     [](auto& m, std::size_t r, std::size_t c) { m(r, c) = std::tan(r + c); }},
    {1, 5,
     [](auto& m, std::size_t r, std::size_t c) {
       m(r, c) = -1.5 * r + 2.56 * c + 3.33;
     }},
    {7, 1,
     [](auto& m, std::size_t r, std::size_t c) {
       m(r, c) = (r == c ? 1.0 : 0.0);
     }},
    {0, 0,
     [](auto& m, std::size_t r, std::size_t c) {
       m(r, c) = (r == c ? 1.0 : 0.0);
     }},
  };

  for (auto const& [rows, cols, init_fn] : test_matrices)
    test_matrix_sizes<rotgen::matrix<double>>(rows, cols, init_fn,
                                              std::array{
                                                std::pair{1, 2},
                                                std::pair{11, 17},
                                                std::pair{4, 5},
                                                std::pair{9, 1},
                                                std::pair{3, 8},
                                                std::pair{22, 0},
                                              });
};