/*
 * Author:          Patrick-Christopher Mattulat
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2022-08-05
 * Changed:         2022-08-07
 *
 * */

#include <gtest/gtest.h>
#include <ls-math/ls_math_vector.hpp>
#include <cmath>

using namespace ls::math::vector;
using namespace ls::math::core::type;

namespace
{
  class Vector2Test : public ::testing::Test
  {
    protected:

      Vector2Test() = default;
      ~Vector2Test() override = default;

      void SetUp() override
      {}

      void TearDown() override
      {}
  };

  TEST_F(Vector2Test, operator_addition)
  {
    Vector2 c = Vector2(3, 4) + Vector2(5, 3);

    ASSERT_FLOAT_EQ(8, c.getX());
    ASSERT_FLOAT_EQ(7, c.getY());
  }

  TEST_F(Vector2Test, operator_substraction)
  {
    Vector2 c = Vector2(3, 4) - Vector2(5, 3);

    ASSERT_FLOAT_EQ(-2, c.getX());
    ASSERT_FLOAT_EQ(1, c.getY());
  }

  TEST_F(Vector2Test, operator_scalar)
  {
    vector_scalar scalar = Vector2(3, 4) * Vector2(5, 3);
    ASSERT_FLOAT_EQ(27, scalar);
  }

  TEST_F(Vector2Test, operator_multiplicator)
  {
    Vector2 c = Vector2(3, 4) * 1.5f;

    ASSERT_FLOAT_EQ(4.5f, c.getX());
    ASSERT_FLOAT_EQ(6.0f, c.getY());
  }

  TEST_F(Vector2Test, operator_divisor)
  {
    Vector2 c = Vector2(150.0f, -25.0f);
    Vector2 n = c / 152.4f;

    // round by two decimals

    double powValue = pow(10.0f, (double)2);
    double roundedX = round(n.getX() * powValue) / powValue;
    double roundedY = round(n.getY() * powValue) / powValue;

    // evaluate result

    ASSERT_FLOAT_EQ(0.98f, roundedX);
    ASSERT_FLOAT_EQ(-0.16f, roundedY);
  }

  TEST_F(Vector2Test, operator_equals)
  {
    ASSERT_TRUE(Vector2(3, 4) == Vector2(3, 4));
  }

  TEST_F(Vector2Test, operator_equals_not_equals)
  {
    ASSERT_FALSE(Vector2(3, 8) == Vector2(3, 4));
  }

  TEST_F(Vector2Test, operator_not_equals)
  {
    ASSERT_TRUE(Vector2(3, 5) != Vector2(3, 4));
  }

  TEST_F(Vector2Test, operator_not_equals_equals)
  {
    ASSERT_FALSE(Vector2(3, 4) != Vector2(3, 4));
  }

  TEST_F(Vector2Test, add)
  {
    Vector2 c = Vector2::add(Vector2(3, 4), Vector2(5, 3));

    ASSERT_FLOAT_EQ(8, c.getX());
    ASSERT_FLOAT_EQ(7, c.getY());
  }

  TEST_F(Vector2Test, dot)
  {
    vector_scalar scalar = ls::math::vector::Vector2::dot(Vector2(3, 4), Vector2(5, 3));
    ASSERT_FLOAT_EQ(27, scalar);
  }

  TEST_F(Vector2Test, getLength)
  {
    Vector2 a{6, 8};
    ASSERT_FLOAT_EQ(10, a.getLength());
  }

  TEST_F(Vector2Test, getX)
  {
    Vector2 a{3, 4};
    ASSERT_FLOAT_EQ(3, a.getX());
  }

  TEST_F(Vector2Test, getY)
  {
    Vector2 a{3, 4};
    ASSERT_FLOAT_EQ(4, a.getY());
  }

  TEST_F(Vector2Test, normalize)
  {
    Vector2 a{150.0f, -25.0f};
    Vector2 n = a.normalize();

    // round by two decimals

    double roundedX = round(n.getX() * 1000.0f) / 1000.0f;
    double roundedY = round(n.getY() * 1000.0f) / 1000.0f;

    // evaluate results

    ASSERT_FLOAT_EQ(0.986f, roundedX);
    ASSERT_FLOAT_EQ(-0.164f, roundedY);
    ASSERT_FLOAT_EQ(1.0f, n.getLength());
  }

  TEST_F(Vector2Test, setX)
  {
    Vector2 a{3, 4};
    a.setX(14);

    ASSERT_FLOAT_EQ(14, a.getX());
  }

  TEST_F(Vector2Test, setY)
  {
    Vector2 a{3, 4};
    a.setY(8);

    ASSERT_FLOAT_EQ(8, a.getY());
  }

  TEST_F(Vector2Test, subtract)
  {
    Vector2 c = ls::math::vector::Vector2::subtract(Vector2(3, 4), Vector2(5, 3));

    ASSERT_FLOAT_EQ(-2, c.getX());
    ASSERT_FLOAT_EQ(1, c.getY());
  }
}