// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "gtest/gtest.h"

#include "flutter/impeller/geometry/matrix.h"

#include "flutter/impeller/geometry/geometry_asserts.h"
#include "impeller/geometry/constants.h"

namespace impeller {
namespace testing {

TEST(MatrixTest, Multiply) {
  Matrix x(0.0, 0.0, 0.0, 1.0,  //
           1.0, 0.0, 0.0, 1.0,  //
           0.0, 1.0, 0.0, 1.0,  //
           1.0, 1.0, 0.0, 1.0);
  Matrix translate = Matrix::MakeTranslation({10, 20, 0});
  Matrix result = translate * x;
  EXPECT_TRUE(MatrixNear(result, Matrix(10.0, 20.0, 0.0, 1.0,  //
                                        11.0, 20.0, 0.0, 1.0,  //
                                        10.0, 21.0, 0.0, 1.0,  //
                                        11.0, 21.0, 0.0, 1.0)));
}

TEST(MatrixTest, Equals) {
  Matrix x;
  Matrix y = x;
  EXPECT_TRUE(x.Equals(y));
}

TEST(MatrixTest, NotEquals) {
  Matrix x;
  Matrix y = x.Translate({1, 0, 0});
  EXPECT_FALSE(x.Equals(y));
}

TEST(MatrixTest, HasPerspective2D) {
  EXPECT_FALSE(Matrix().HasPerspective2D());

  auto test = [](int index, bool expect) {
    Matrix matrix;
    EXPECT_FALSE(matrix.HasPerspective2D());
    matrix.m[index] = 0.5f;
    EXPECT_EQ(matrix.HasPerspective2D(), expect) << "index: " << index;
  };

  // clang-format off
  test( 0, false);  test( 1, false);  test( 2, false);  test( 3, true);
  test( 4, false);  test( 5, false);  test( 6, false);  test( 7, true);
  test( 8, false);  test( 9, false);  test(10, false);  test(11, false);
  test(12, false);  test(13, false);  test(14, false);  test(15, true);
  // clang-format on
}

TEST(MatrixTest, HasPerspective) {
  EXPECT_FALSE(Matrix().HasPerspective());

  auto test = [](int index, bool expect) {
    Matrix matrix;
    EXPECT_FALSE(matrix.HasPerspective());
    matrix.m[index] = 0.5f;
    EXPECT_EQ(matrix.HasPerspective(), expect) << "index: " << index;
  };

  // clang-format off
  test( 0, false);  test( 1, false);  test( 2, false);  test( 3, true);
  test( 4, false);  test( 5, false);  test( 6, false);  test( 7, true);
  test( 8, false);  test( 9, false);  test(10, false);  test(11, true);
  test(12, false);  test(13, false);  test(14, false);  test(15, true);
  // clang-format on
}

TEST(MatrixTest, HasTranslation) {
  EXPECT_TRUE(Matrix::MakeTranslation({100, 100, 0}).HasTranslation());
  EXPECT_TRUE(Matrix::MakeTranslation({0, 100, 0}).HasTranslation());
  EXPECT_TRUE(Matrix::MakeTranslation({100, 0, 0}).HasTranslation());
  EXPECT_FALSE(Matrix().HasTranslation());
}

TEST(MatrixTest, IsTranslationOnly) {
  EXPECT_TRUE(Matrix::MakeTranslation({100, 100, 0}).IsTranslationOnly());
  EXPECT_TRUE(Matrix::MakeTranslation({100, 100, 0}).IsTranslationScaleOnly());
  EXPECT_TRUE(Matrix::MakeTranslation({0, 100, 0}).IsTranslationOnly());
  EXPECT_TRUE(Matrix::MakeTranslation({0, 100, 0}).IsTranslationScaleOnly());
  EXPECT_TRUE(Matrix::MakeTranslation({100, 0, 0}).IsTranslationOnly());
  EXPECT_TRUE(Matrix::MakeTranslation({100, 0, 0}).IsTranslationScaleOnly());
  EXPECT_TRUE(Matrix().IsTranslationOnly());
  EXPECT_TRUE(Matrix().IsTranslationScaleOnly());
}

TEST(MatrixTest, IsTranslationScaleOnly) {
  EXPECT_FALSE(Matrix::MakeScale({100, 100, 1}).IsTranslationOnly());
  EXPECT_TRUE(Matrix::MakeScale({100, 100, 1}).IsTranslationScaleOnly());
  EXPECT_FALSE(Matrix::MakeScale({1, 100, 1}).IsTranslationOnly());
  EXPECT_TRUE(Matrix::MakeScale({1, 100, 1}).IsTranslationScaleOnly());
  EXPECT_FALSE(Matrix::MakeScale({100, 1, 1}).IsTranslationOnly());
  EXPECT_TRUE(Matrix::MakeScale({100, 1, 1}).IsTranslationScaleOnly());
  EXPECT_TRUE(Matrix().IsTranslationOnly());
  EXPECT_TRUE(Matrix().IsTranslationScaleOnly());
}

TEST(MatrixTest, IsInvertibleGetDeterminant) {
  EXPECT_TRUE(Matrix().IsInvertible());
  EXPECT_NE(Matrix().GetDeterminant(), 0.0f);

  EXPECT_TRUE(Matrix::MakeTranslation({100, 100, 0}).IsInvertible());
  EXPECT_NE(Matrix::MakeTranslation({100, 100, 0}).GetDeterminant(), 0.0f);

  EXPECT_TRUE(Matrix::MakeScale({100, 100, 1}).IsInvertible());
  EXPECT_NE(Matrix::MakeScale({100, 100, 1}).GetDeterminant(), 0.0f);

  EXPECT_TRUE(Matrix::MakeRotationX(Degrees(30)).IsInvertible());
  EXPECT_NE(Matrix::MakeRotationX(Degrees(30)).GetDeterminant(), 0.0f);

  EXPECT_TRUE(Matrix::MakeRotationY(Degrees(30)).IsInvertible());
  EXPECT_NE(Matrix::MakeRotationY(Degrees(30)).GetDeterminant(), 0.0f);

  EXPECT_TRUE(Matrix::MakeRotationZ(Degrees(30)).IsInvertible());
  EXPECT_NE(Matrix::MakeRotationZ(Degrees(30)).GetDeterminant(), 0.0f);

  EXPECT_FALSE(Matrix::MakeScale({0, 1, 1}).IsInvertible());
  EXPECT_EQ(Matrix::MakeScale({0, 1, 1}).GetDeterminant(), 0.0f);
  EXPECT_FALSE(Matrix::MakeScale({1, 0, 1}).IsInvertible());
  EXPECT_EQ(Matrix::MakeScale({1, 0, 1}).GetDeterminant(), 0.0f);
  EXPECT_FALSE(Matrix::MakeScale({1, 1, 0}).IsInvertible());
  EXPECT_EQ(Matrix::MakeScale({1, 1, 0}).GetDeterminant(), 0.0f);
}

TEST(MatrixTest, IsFinite) {
  EXPECT_TRUE(Matrix().IsFinite());

  EXPECT_TRUE(Matrix::MakeTranslation({100, 100, 0}).IsFinite());
  EXPECT_TRUE(Matrix::MakeScale({100, 100, 1}).IsFinite());

  EXPECT_TRUE(Matrix::MakeRotationX(Degrees(30)).IsFinite());
  EXPECT_TRUE(Matrix::MakeRotationY(Degrees(30)).IsFinite());
  EXPECT_TRUE(Matrix::MakeRotationZ(Degrees(30)).IsFinite());

  EXPECT_TRUE(Matrix::MakeScale({0, 1, 1}).IsFinite());
  EXPECT_TRUE(Matrix::MakeScale({1, 0, 1}).IsFinite());
  EXPECT_TRUE(Matrix::MakeScale({1, 1, 0}).IsFinite());

  for (int i = 0; i < 16; i++) {
    {
      Matrix matrix;
      ASSERT_TRUE(matrix.IsFinite());
      matrix.m[i] = std::numeric_limits<Scalar>::infinity();
      ASSERT_FALSE(matrix.IsFinite());
    }

    {
      Matrix matrix;
      ASSERT_TRUE(matrix.IsFinite());
      matrix.m[i] = -std::numeric_limits<Scalar>::infinity();
      ASSERT_FALSE(matrix.IsFinite());
    }

    {
      Matrix matrix;
      ASSERT_TRUE(matrix.IsFinite());
      matrix.m[i] = -std::numeric_limits<Scalar>::quiet_NaN();
      ASSERT_FALSE(matrix.IsFinite());
    }
  }
}

TEST(MatrixTest, IsAligned2D) {
  EXPECT_TRUE(Matrix().IsAligned2D());
  EXPECT_TRUE(Matrix::MakeScale({1.0f, 1.0f, 2.0f}).IsAligned2D());

  auto test = [](int index, bool expect) {
    Matrix matrix;
    EXPECT_TRUE(matrix.IsAligned2D());
    matrix.m[index] = 0.5f;
    EXPECT_EQ(matrix.IsAligned2D(), expect) << "index: " << index;
  };

  // clang-format off
  test( 0, true);   test( 1, false);  test( 2, true);   test( 3, false);
  test( 4, false);  test( 5, true);   test( 6, true);   test( 7, false);
  test( 8, true);   test( 9, true);   test(10, true);   test(11, true);
  test(12, true);   test(13, true);   test(14, true);   test(15, false);
  // clang-format on

  // True for quadrant rotations from -250 to +250 full circles
  for (int i = -1000; i < 1000; i++) {
    Degrees d = Degrees(i * 90);
    Matrix matrix = Matrix::MakeRotationZ(Degrees(d));
    EXPECT_TRUE(matrix.IsAligned2D()) << "degrees: " << d.degrees;
  }

  // False for half degree rotations from -999.5 to +1000.5 degrees
  for (int i = -1000; i < 1000; i++) {
    Degrees d = Degrees(i + 0.5f);
    Matrix matrix = Matrix::MakeRotationZ(Degrees(d));
    EXPECT_FALSE(matrix.IsAligned2D()) << "degrees: " << d.degrees;
  }
}

TEST(MatrixTest, IsAligned) {
  EXPECT_TRUE(Matrix().IsAligned());
  EXPECT_TRUE(Matrix::MakeScale({1.0f, 1.0f, 2.0f}).IsAligned());

  // Begin Legacy tests transferred over from geometry_unittests.cc
  {
    auto m = Matrix::MakeTranslation({1, 2, 3});
    bool result = m.IsAligned();
    ASSERT_TRUE(result);
  }

  {
    auto m = Matrix::MakeRotationZ(Degrees{123});
    bool result = m.IsAligned();
    ASSERT_FALSE(result);
  }
  // End Legacy tests transferred over from geometry_unittests.cc

  auto test = [](int index, bool expect) {
    Matrix matrix;
    EXPECT_TRUE(matrix.IsAligned());
    matrix.m[index] = 0.5f;
    EXPECT_EQ(matrix.IsAligned(), expect) << "index: " << index;
  };

  // clang-format off
  test( 0, true);   test( 1, false);  test( 2, false);  test( 3, false);
  test( 4, false);  test( 5, true);   test( 6, false);  test( 7, false);
  test( 8, false);  test( 9, false);  test(10, true);   test(11, false);
  test(12, true);   test(13, true);   test(14, true);   test(15, false);
  // clang-format on

  // True for quadrant rotations from -250 to +250 full circles
  for (int i = -1000; i < 1000; i++) {
    Degrees d = Degrees(i * 90);
    Matrix matrix = Matrix::MakeRotationZ(Degrees(d));
    EXPECT_TRUE(matrix.IsAligned()) << "degrees: " << d.degrees;
  }

  // False for half degree rotations from -999.5 to +1000.5 degrees
  for (int i = -1000; i < 1000; i++) {
    Degrees d = Degrees(i + 0.5f);
    Matrix matrix = Matrix::MakeRotationZ(Degrees(d));
    EXPECT_FALSE(matrix.IsAligned()) << "degrees: " << d.degrees;
  }
}

TEST(MatrixTest, TransformHomogenous) {
  Matrix matrix = Matrix::MakeColumn(
      // clang-format off
       2.0f,  3.0f,  5.0f,  7.0f,
      11.0f, 13.0f, 17.0f, 19.0f,
      23.0f, 29.0f, 31.0f, 37.0f,
      41.0f, 43.0f, 47.0f, 53.0f
      // clang-format on
  );
  EXPECT_EQ(matrix.TransformHomogenous({1.0f, -1.0f}),
            Vector3(32.0f, 33.0f, 41.0f));
}

TEST(MatrixTest, GetMaxBasisXYNegativeScale) {
  Matrix m = Matrix::MakeScale({-2, 1, 1});

  EXPECT_EQ(m.GetMaxBasisLengthXY(), 2);

  m = Matrix::MakeScale({1, -3, 1});

  EXPECT_EQ(m.GetMaxBasisLengthXY(), 3);
}

// Verifies a translate scale matrix doesn't need to compute sqrt(pow(scale, 2))
TEST(MatrixTest, GetMaxBasisXYWithLargeAndSmallScalingFactor) {
  Matrix m = Matrix::MakeScale({2.625e+20, 2.625e+20, 1});
  EXPECT_NEAR(m.GetMaxBasisLengthXY(), 2.625e+20, 1e+20);

  m = Matrix::MakeScale({2.625e-20, 2.625e-20, 1});
  EXPECT_NEAR(m.GetMaxBasisLengthXY(), 2.625e-20, 1e-20);
}

TEST(MatrixTest, GetMaxBasisXYWithLargeAndSmallScalingFactorNonScaleTranslate) {
  Matrix m = Matrix::MakeScale({2.625e+20, 2.625e+20, 1});
  m.e[0][1] = 2;

  EXPECT_TRUE(std::isinf(m.GetMaxBasisLengthXY()));
}

TEST(MatrixTest, TranslateWithPerspective) {
  Matrix m = Matrix::MakeRow(1.0, 0.0, 0.0, 10.0,  //
                             0.0, 1.0, 0.0, 20.0,  //
                             0.0, 0.0, 1.0, 0.0,   //
                             0.0, 2.0, 0.0, 30.0);
  Matrix result = m.Translate({100, 200});
  EXPECT_TRUE(MatrixNear(result, Matrix::MakeRow(1.0, 0.0, 0.0, 110.0,  //
                                                 0.0, 1.0, 0.0, 220.0,  //
                                                 0.0, 0.0, 1.0, 0.0,    //
                                                 0.0, 2.0, 0.0, 430.0)));
}

TEST(MatrixTest, MakeScaleTranslate) {
  EXPECT_TRUE(MatrixNear(
      Matrix::MakeTranslateScale({1, 1, 1.0 / 1024}, {10, 10, 1.0 / 1024}),
      Matrix::MakeTranslation({10, 10, 1.0 / 1024}) *
          Matrix::MakeScale({1, 1, 1.0 / 1024})));

  EXPECT_TRUE(MatrixNear(
      Matrix::MakeTranslateScale({2, 2, 2}, {10, 10, 0}),
      Matrix::MakeTranslation({10, 10, 0}) * Matrix::MakeScale({2, 2, 2})));

  EXPECT_TRUE(MatrixNear(
      Matrix::MakeTranslateScale({0, 0, 0}, {0, 0, 0}),
      Matrix::MakeTranslation({0, 0, 0}) * Matrix::MakeScale({0, 0, 0})));
}

TEST(MatrixTest, To3x3) {
  Matrix x(1.0, 0.0, 4.0, 0.0,    //
           0.0, 1.0, 4.0, 0.0,    //
           6.0, 5.0, 111.0, 7.0,  //
           0.0, 0.0, 9.0, 1.0);

  EXPECT_TRUE(MatrixNear(x.To3x3(), Matrix()));
}

TEST(MatrixTest, MinMaxScales2D) {
  // The GetScales2D() method is allowed to return the scales in any
  // order so we need to take special care in verifying the return
  // value to test them in either order.
  auto check_pair = [](const Matrix& matrix, Scalar scale1, Scalar scale2) {
    auto pair = matrix.GetScales2D();
    EXPECT_TRUE(pair.has_value())
        << "Scales: " << scale1 << ", " << scale2 << ", " << matrix;
    if (ScalarNearlyEqual(pair->first, scale1)) {
      EXPECT_FLOAT_EQ(pair->first, scale1) << matrix;
      EXPECT_FLOAT_EQ(pair->second, scale2) << matrix;
    } else {
      EXPECT_FLOAT_EQ(pair->first, scale2) << matrix;
      EXPECT_FLOAT_EQ(pair->second, scale1) << matrix;
    }
  };

  for (int i = 1; i < 10; i++) {
    Scalar xScale = static_cast<Scalar>(i);
    for (int j = 1; j < 10; j++) {
      Scalar yScale = static_cast<Scalar>(j);
      Scalar minScale = std::min(xScale, yScale);
      Scalar maxScale = std::max(xScale, yScale);

      {
        // Simple scale
        Matrix matrix = Matrix::MakeScale({xScale, yScale, 1.0f});
        EXPECT_TRUE(matrix.GetMinScale2D().has_value());
        EXPECT_TRUE(matrix.GetMaxScale2D().has_value());
        EXPECT_FLOAT_EQ(matrix.GetMinScale2D().value_or(-1.0f), minScale);
        EXPECT_FLOAT_EQ(matrix.GetMaxScale2D().value_or(-1.0f), maxScale);
        check_pair(matrix, xScale, yScale);
      }

      {
        // Simple scale with Z scale
        Matrix matrix = Matrix::MakeScale({xScale, yScale, 5.0f});
        EXPECT_TRUE(matrix.GetMinScale2D().has_value());
        EXPECT_TRUE(matrix.GetMaxScale2D().has_value());
        EXPECT_FLOAT_EQ(matrix.GetMinScale2D().value_or(-1.0f), minScale);
        EXPECT_FLOAT_EQ(matrix.GetMaxScale2D().value_or(-1.0f), maxScale);
        check_pair(matrix, xScale, yScale);
      }

      {
        // Simple scale + translate
        Matrix matrix = Matrix::MakeTranslateScale({xScale, yScale, 1.0f},
                                                   {10.0f, 15.0f, 2.0f});
        EXPECT_TRUE(matrix.GetMinScale2D().has_value());
        EXPECT_TRUE(matrix.GetMaxScale2D().has_value());
        EXPECT_FLOAT_EQ(matrix.GetMinScale2D().value_or(-1.0f), minScale);
        EXPECT_FLOAT_EQ(matrix.GetMaxScale2D().value_or(-1.0f), maxScale);
        check_pair(matrix, xScale, yScale);
      }

      for (int d = 45; d < 360; d += 45) {
        {
          // Rotation * Scale
          Matrix matrix = Matrix::MakeScale({xScale, yScale, 1.0f}) *
                          Matrix::MakeRotationZ(Degrees(d));
          EXPECT_TRUE(matrix.GetMinScale2D().has_value());
          EXPECT_TRUE(matrix.GetMaxScale2D().has_value());
          EXPECT_FLOAT_EQ(matrix.GetMinScale2D().value_or(-1.0f), minScale);
          EXPECT_FLOAT_EQ(matrix.GetMaxScale2D().value_or(-1.0f), maxScale);
          check_pair(matrix, xScale, yScale);
        }

        {
          // Scale * Rotation
          Matrix matrix = Matrix::MakeRotationZ(Degrees(d)) *
                          Matrix::MakeScale({xScale, yScale, 1.0f});
          EXPECT_TRUE(matrix.GetMinScale2D().has_value());
          EXPECT_TRUE(matrix.GetMaxScale2D().has_value());
          EXPECT_FLOAT_EQ(matrix.GetMinScale2D().value_or(-1.0f), minScale);
          EXPECT_FLOAT_EQ(matrix.GetMaxScale2D().value_or(-1.0f), maxScale);
          check_pair(matrix, xScale, yScale);
        }
      }

      {
        // Scale + PerspectiveX (returns invalid values)
        Matrix matrix = Matrix::MakeScale({xScale, yScale, 1.0f});
        matrix.m[3] = 0.1;
        EXPECT_FALSE(matrix.GetMinScale2D().has_value());
        EXPECT_FALSE(matrix.GetMaxScale2D().has_value());
        EXPECT_FALSE(matrix.GetScales2D().has_value());
      }

      {
        // Scale + PerspectiveY (returns invalid values)
        Matrix matrix = Matrix::MakeScale({xScale, yScale, 1.0f});
        matrix.m[7] = 0.1;
        EXPECT_FALSE(matrix.GetMinScale2D().has_value());
        EXPECT_FALSE(matrix.GetMaxScale2D().has_value());
        EXPECT_FALSE(matrix.GetScales2D().has_value());
      }

      {
        // Scale + PerspectiveZ (Z ignored; returns actual scales)
        Matrix matrix = Matrix::MakeScale({xScale, yScale, 1.0f});
        matrix.m[11] = 0.1;
        EXPECT_TRUE(matrix.GetMinScale2D().has_value());
        EXPECT_TRUE(matrix.GetMaxScale2D().has_value());
        EXPECT_FLOAT_EQ(matrix.GetMinScale2D().value_or(-1.0f), minScale);
        EXPECT_FLOAT_EQ(matrix.GetMaxScale2D().value_or(-1.0f), maxScale);
        check_pair(matrix, xScale, yScale);
      }

      {
        // Scale + PerspectiveW (returns invalid values)
        Matrix matrix = Matrix::MakeScale({xScale, yScale, 1.0f});
        matrix.m[15] = 0.1;
        EXPECT_FALSE(matrix.GetMinScale2D().has_value());
        EXPECT_FALSE(matrix.GetMaxScale2D().has_value());
        EXPECT_FALSE(matrix.GetScales2D().has_value());
      }
    }
  }
}

}  // namespace testing
}  // namespace impeller