#include "fesa/math/vector.h"

#include <gtest/gtest.h>

#include <cmath>
#include <stdexcept>
#include <utility>

namespace fesa {
namespace {

TEST(DenseMath, VectorOwnsAndChecksContiguousStorage) {
  Vector empty{0};
  EXPECT_EQ(empty.Size(), 0U);
  EXPECT_DOUBLE_EQ(empty.Norm(), 0.0);
  EXPECT_NO_THROW(empty.Scale(3.0));
  EXPECT_NO_THROW(empty.Axpy(-2.0, Vector{0}));
  EXPECT_THROW(static_cast<void>(empty[0]), std::out_of_range);

  Vector original{3};
  original[0] = 1.0;
  original[1] = -2.0;
  original[2] = 3.0;

  EXPECT_EQ(original.Data() + 1, &original[1]);
  EXPECT_EQ(original.Data() + 2, &original[2]);
  const Vector& const_original = original;
  EXPECT_EQ(const_original.Data() + 2, &const_original[2]);

  Vector copied{original};
  EXPECT_NE(copied.Data(), original.Data());
  copied[0] = 99.0;
  EXPECT_DOUBLE_EQ(original[0], 1.0);

  Vector copy_assigned{0};
  copy_assigned = original;
  EXPECT_NE(copy_assigned.Data(), original.Data());
  copy_assigned[1] = 17.0;
  EXPECT_DOUBLE_EQ(original[1], -2.0);

  Vector moved{std::move(copied)};
  EXPECT_EQ(copied.Size(), 0U);
  EXPECT_EQ(moved.Size(), 3U);
  EXPECT_DOUBLE_EQ(moved[0], 99.0);
  EXPECT_NO_THROW(copied.Scale(4.0));

  Vector move_assigned{1, -1.0};
  move_assigned = std::move(copy_assigned);
  EXPECT_EQ(copy_assigned.Size(), 0U);
  EXPECT_EQ(move_assigned.Size(), 3U);
  EXPECT_DOUBLE_EQ(move_assigned[1], 17.0);

  Vector rhs{3};
  rhs[0] = 4.0;
  rhs[1] = 5.0;
  rhs[2] = -6.0;
  EXPECT_DOUBLE_EQ(original.Dot(rhs), -24.0);
  EXPECT_NEAR(original.Norm(), std::sqrt(14.0), 1.0e-15);

  Vector scaled{original};
  scaled.Scale(-0.5);
  EXPECT_DOUBLE_EQ(scaled[0], -0.5);
  EXPECT_DOUBLE_EQ(scaled[1], 1.0);
  EXPECT_DOUBLE_EQ(scaled[2], -1.5);

  Vector accumulated{3};
  accumulated[0] = 1.0;
  accumulated[1] = 2.0;
  accumulated[2] = 3.0;
  Vector increment{3};
  increment[0] = 4.0;
  increment[1] = -1.0;
  increment[2] = 0.5;
  accumulated.Axpy(2.0, increment);
  EXPECT_DOUBLE_EQ(accumulated[0], 9.0);
  EXPECT_DOUBLE_EQ(accumulated[1], 0.0);
  EXPECT_DOUBLE_EQ(accumulated[2], 4.0);

  EXPECT_THROW(static_cast<void>(original[3]), std::out_of_range);
  EXPECT_THROW(static_cast<void>(const_original[3]), std::out_of_range);
  EXPECT_THROW(static_cast<void>(original.Dot(Vector{2})),
               std::invalid_argument);
  EXPECT_THROW(original.Axpy(1.0, Vector{2}), std::invalid_argument);
}

}  // namespace
}  // namespace fesa