using Vector;
namespace Test.Vector;
public class TestsVector2I {
    [SetUp]
    public void Setup() {
    }

    [Test]
    public void TestVector2I_Constructors() {
        // Arrange & Act
        var v1 = new Vector2I();
        var v2 = new Vector2I(1, 2);
        var v3 = new Vector2I(v2);

        // Assert
        Assert.Multiple(() => {
            Assert.That(v1.X, Is.EqualTo(0));
            Assert.That(v1.Y, Is.EqualTo(0));
            Assert.That(v2.X, Is.EqualTo(1));
            Assert.That(v2.Y, Is.EqualTo(2));
            Assert.That(v3.X, Is.EqualTo(1));
            Assert.That(v3.Y, Is.EqualTo(2));
        });
    }

    [Test]
    public void TestVector2I_Operators() {
        // Arrange
        var v1 = new Vector2I(1, 2);
        var v2 = new Vector2I(3, 4);

        // Act
        var v3 = v1 + v2;
        var v4 = v1 - v2;
        var v5 = v1 * v2;

        // Assert
        Assert.Multiple(() => {
            Assert.That(v3, Is.EqualTo(new Vector2I(4, 6)));
            Assert.That(v4, Is.EqualTo(new Vector2I(-2, -2)));
            Assert.That(v5, Is.EqualTo(new Vector2I(3, 8)));
        });
    }

    [Test]
    public void TestVector2I_DotProduct() {
        // Arrange
        var v1 = new Vector2I(1, 2);
        var v2 = new Vector2I(3, 4);

        // Act
        var dotProduct = v1.Dot(v2);

        // Assert
        Assert.That(dotProduct, Is.EqualTo(11));
    }

    [Test]
    public void TestVector2I_ParameterModification() {
        // Arrange
        var v1 = new Vector2I(1, 2);
        var v2 = new Vector2I(3, 4);

        // Act
        var v3 = v1 + v2;
        var v4 = v1 - v2;
        var v5 = v1 * v2;

        // Assert
        Assert.Multiple(() => {
            Assert.That(v1, Is.EqualTo(new Vector2I(1, 2)), "v1 should not be modified");
            Assert.That(v2, Is.EqualTo(new Vector2I(3, 4)), "v2 should not be modified");
        });
    }

    [Test]
    public void TestVector2I_Equality() {
        // Arrange
        var v1 = new Vector2I(1, 2);
        var v2 = new Vector2I(1, 2);
        var v3 = new Vector2I(3, 4);

        // Act & Assert
        Assert.Multiple(() => {
            Assert.That(v1, Is.EqualTo(v2));
            Assert.That(v1, Is.Not.EqualTo(v3));
        });
    }

    [Test]
    public void TestVector2I_HashCode() {
        // Arrange
        var v1 = new Vector2I(1, 2);
        var v2 = new Vector2I(1, 2);
        var v3 = new Vector2I(3, 4);

        // Act & Assert
        Assert.Multiple(() => {
            Assert.That(v1.GetHashCode(), Is.EqualTo(v2.GetHashCode()));
            Assert.That(v1.GetHashCode(), Is.Not.EqualTo(v3.GetHashCode()));
        });
    }

    [Test]
    public void TestVector2I_BoundaryValues() {
        // Arrange
        var v1 = new Vector2I(0, 0);
        var v2 = new Vector2I(-1, -2);
        var v3 = new Vector2I(int.MaxValue, int.MaxValue);
        var v4 = new Vector2I(int.MinValue, int.MinValue);

        // Act
        var v5 = v1 + v2;
        var v6 = v1 - v2;
        var v7 = v1 * v2;
        var v8 = v3 + v4;
        var v9 = v3 - v4;
        var v10 = v3 * v4;

        // Assert
        Assert.Multiple(() => {
            Assert.That(v5, Is.EqualTo(new Vector2I(-1, -2)));
            Assert.That(v6, Is.EqualTo(new Vector2I(1, 2)));
            Assert.That(v7, Is.EqualTo(new Vector2I(0, 0)));

            Assert.That(v8, Is.EqualTo(new Vector2I(-1, -1)));
            // Assert.That(v9, Is.EqualTo(new Vector2I(2 * int.MaxValue - 1, 2 * int.MaxValue - 1)));
            // Assert.That(v10, Is.EqualTo(new Vector2I(int.MaxValue * int.MinValue, int.MaxValue * int.MinValue)));
        });
    }
}

public class TestsTrans2DI {
    [SetUp]
    public void Setup() {
    }

    [Test]
    public void Test1() {
        Assert.Pass();
    }

    [Test]
    public void TestVector2I_Constructors() {
        // Arrange & Act
        var v1 = new Vector2I();
        var v2 = new Vector2I(1, 2);
        var v3 = new Vector2I(v2);

        // Assert
        Assert.That(v1.X, Is.EqualTo(0));
        Assert.That(v1.Y, Is.EqualTo(0));
        Assert.That(v2.X, Is.EqualTo(1));
        Assert.That(v2.Y, Is.EqualTo(2));
        Assert.That(v3.X, Is.EqualTo(1));
        Assert.That(v3.Y, Is.EqualTo(2));
    }

    [Test]
    public void TestVector2I_Operators() {
        // Arrange
        var v1 = new Vector2I(1, 2);
        var v2 = new Vector2I(3, 4);

        // Act
        var v3 = v1 + v2;
        var v4 = v1 - v2;
        var v5 = v1 * v2;

        // Assert
        Assert.That(v3, Is.EqualTo(new Vector2I(4, 6)));
        Assert.That(v4, Is.EqualTo(new Vector2I(-2, -2)));
        Assert.That(v5, Is.EqualTo(new Vector2I(3, 8)));
    }

    [Test]
    public void TestTrans2DI_Constructors() {
        // Arrange & Act
        var t1 = new Trans2DI();
        var t2 = new Trans2DI(new Vector2I(1, 0), new Vector2I(0, 1), new Vector2I(0, 0));
        var t3 = new Trans2DI(t2);
        var t4 = new Trans2DI(1, 0, 0, 1, 0, 0);

        // Assert
        Assert.That(t1.XAxis, Is.EqualTo(new Vector2I(1, 0)));
        Assert.That(t1.YAxis, Is.EqualTo(new Vector2I(0, 1)));
        Assert.That(t1.Origin, Is.EqualTo(new Vector2I(0, 0)));

        Assert.That(t2.XAxis, Is.EqualTo(new Vector2I(1, 0)));
        Assert.That(t2.YAxis, Is.EqualTo(new Vector2I(0, 1)));
        Assert.That(t2.Origin, Is.EqualTo(new Vector2I(0, 0)));

        Assert.That(t3.XAxis, Is.EqualTo(new Vector2I(1, 0)));
        Assert.That(t3.YAxis, Is.EqualTo(new Vector2I(0, 1)));
        Assert.That(t3.Origin, Is.EqualTo(new Vector2I(0, 0)));

        Assert.That(t4.XAxis, Is.EqualTo(new Vector2I(1, 0)));
        Assert.That(t4.YAxis, Is.EqualTo(new Vector2I(0, 1)));
        Assert.That(t4.Origin, Is.EqualTo(new Vector2I(0, 0)));
    }

    [Test]
    public void TestTrans2DI_Operators() {
        // Arrange
        var t1 = new Trans2DI(new Vector2I(1, 0), new Vector2I(0, 1), new Vector2I(1, 2));
        var v1 = new Vector2I(3, 4);

        // Act
        var v2 = t1 * v1;
        var v3 = v1 * t1;

        // Assert
        Assert.That(v2, Is.EqualTo(new Vector2I(4, 6)));
        Assert.That(v3, Is.EqualTo(new Vector2I(2, 2)));
    }

    [Test]
    public void TestTrans2DI_BoundaryValues() {
        // Arrange
        var t1 = new Trans2DI(new Vector2I(int.MaxValue, 0), new Vector2I(0, int.MaxValue), new Vector2I(0, 0));
        var t2 = new Trans2DI(new Vector2I(int.MinValue, 0), new Vector2I(0, int.MinValue), new Vector2I(0, 0));
        var v1 = new Vector2I(1, 1);

        // Act
        var v2 = t1 * v1;
        var v3 = t2 * v1;

        // Assert
        Assert.That(v2, Is.EqualTo(new Vector2I(int.MaxValue, int.MaxValue)));
        Assert.That(v3, Is.EqualTo(new Vector2I(int.MinValue, int.MinValue)));
    }

    [Test]
    public void TestTrans2DI_SpecialValues() {
        // Arrange
        var t1 = new Trans2DI(new Vector2I(0, 0), new Vector2I(0, 0), new Vector2I(0, 0));
        var t2 = new Trans2DI(new Vector2I(1, 0), new Vector2I(0, 1), new Vector2I(0, 0));
        var v1 = new Vector2I(1, 1);

        // Act
        var v2 = t1 * v1;
        var v3 = t2 * v1;

        // Assert
        Assert.That(v2, Is.EqualTo(new Vector2I(0, 0)));
        Assert.That(v3, Is.EqualTo(new Vector2I(1, 1)));
    }

    [Test]
    public void TestTrans2DI_Multiplication() {
        // Arrange
        var t1 = new Trans2DI(new Vector2I(1, 0), new Vector2I(0, 1), new Vector2I(1, 2));
        var t2 = new Trans2DI(new Vector2I(2, 0), new Vector2I(0, 2), new Vector2I(3, 4));

        // Act
        var t3 = t1 * t2;

        // Assert
        Assert.That(t3.XAxis, Is.EqualTo(new Vector2I(2, 0)));
        Assert.That(t3.YAxis, Is.EqualTo(new Vector2I(0, 2)));
        Assert.That(t3.Origin, Is.EqualTo(new Vector2I(5, 8)));
    }
}