import unittest
import sys
from pathlib import Path
# Add the project root to sys.path
sys.path.append(str(Path(__file__).resolve().parent.parent))
                
from Vector import *

class Vector2Test(unittest.TestCase):
    def test_Equality(self):
        v1: Vector2 = Vector2(4, 5)

        v2: Vector2 = Vector2(1, 2)
        assert(v1 != v2)

        v2 = Vector2(4, 5)
        assert(v1 == v2)

    def test_SqrMagnitude(self):
        v: Vector2 = Vector2(1, 2)
        m: float = 0;

        m = v.SqrMagnitude()
        assert(m == 5)

        v = Vector2(-1, -2)
        m = v.SqrMagnitude()
        assert(m == 5)

        v = Vector2(0, 0)
        m = v.SqrMagnitude()
        assert(m == 0)

    def test_Magnitude(self):
        v: Vector2 = Vector2(1, 2)
        m: float = 0;

        m = v.Magnitude()
        assert(m == 2.23606797749979)

        v = Vector2(-1, -2)
        m = v.Magnitude()
        assert(m == 2.23606797749979)

        v = Vector2(0, 0)
        m = v.Magnitude()
        assert(m == 0)

    def test_Normalize(self):
        v1: Vector2 = Vector2(0, 2)
        v: Vector2 = Vector2.zero

        v = v1.Normalized()
        assert(v == Vector2(0, 1))

        v1 = Vector2(0, -2)
        v = v1.Normalized()
        assert(v == Vector2(0, -1))

        v1 = Vector2(0, 0)
        v = v1.Normalized()
        assert(v == Vector2(0, 0))

    def test_Negate(self):
        v1: Vector2 = Vector2(4, 5)
        r: Vector2 = Vector2.zero

        r = -v1
        assert(r == Vector2(-4, -5))

        v1 = Vector2(-4, -5)
        r = -v1
        assert(r == Vector2(4, 5))

        v1 = Vector2(0, 0)
        r = -v1
        assert(r == Vector2(0, 0))

    def test_Subtract(self):
        v1: Vector2 = Vector2(4, 5)
        v2: Vector2 = Vector2(1, 2)
        r: Vector2 = Vector2.zero


        r = v1 - v2
        assert(v1 - v2 == Vector2(3, 3))

        v2 = Vector2(-1, -2)
        r = v1 - v2
        assert(r == Vector2(5, 7))

        v2 = Vector2(4, 5)
        r = v1 - v2
        assert(r == Vector2(0, 0))

        v2 = Vector2(0, 0)
        r = v1 - v2
        assert(r == Vector2(4, 5))

    def test_Addition(self):
        v1: Vector2 = Vector2(4, 5)
        v2: Vector2 = Vector2(1, 2)
        r: Vector2 = Vector2.zero

        r = v1 + v2
        assert(r == Vector2(5, 7))

        v2 = Vector2(-1, -2)
        r = v1 + v2
        assert(r == Vector2(3, 3))

        v2 = Vector2(0, 0)
        r = v1 + v2
        assert(r == Vector2(4, 5))

    def test_Scale(self):
        v1: Vector2 = Vector2(4, 5)
        v2: Vector2 = Vector2(1, 2)
        r: Vector2 = Vector2.zero

        r = v1.Scale(v2)
        assert(r == Vector2(4, 10))

        v2 = Vector2(-1, -2)
        r = v1.Scale(v2)
        assert(r == Vector2(-4, -10))

        v2 = Vector2(0, 0)
        r = v1.Scale(v2)
        assert(r == Vector2(0, 0))

    def test_Multiply(self):
        v1: Vector2 = Vector2(4, 5)
        f: float = 3
        r: Vector2 = Vector2.zero

        r = v1 * f
        assert(r == Vector2(12, 15))

        f = -3
        r = v1 * f
        assert(r == Vector2(-12, -15))

        f = 0
        r = v1 * f
        assert(r == Vector2(0, 0))

    def test_Divide(self):
        v1: Vector2 = Vector2(4, 5)
        f: float = 2
        v: Vector2 = Vector2.zero

        v = v1 / f
        assert(v == Vector2(2, 2.5))

        f = -2
        v = v1 / f
        assert(v == Vector2(-2, -2.5))

    def test_Distance(self):
        v1: Vector2 = Vector2(4, 5)
        v2: Vector2 = Vector2(1, 2)
        r: float = 0

        r = Vector2.Distance(v1, v2)
        assert(r == 4.242640687119285)

        v2 = Vector2(-1, -2)
        r = Vector2.Distance(v1, v2)
        assert(r == 8.602325267042627)

        v2 = Vector2(0, 0)
        r = Vector2.Distance(v1, v2)
        assert(r == 6.4031242374328485)

    def test_Dot(self):
        v1: Vector2 = Vector2(4, 5)
        v2: Vector2 = Vector2(1, 2)
        r: float = 0

        r = Vector2.Dot(v1, v2)
        assert(r == 14)

        v2 = Vector2(-1, -2)
        r = Vector2.Dot(v1, v2)
        assert(r, -14)

        v2 = Vector2(0, 0)
        r = Vector2.Dot(v1, v2)
        assert(r, 0)

    def test_Angle(self):
        v1: Vector2 = Vector2(4, 5)
        v2: Vector2 = Vector2(1, 2)
        r: Angle = Angle.Degrees(0)

        r = Vector2.Angle(v1, v2)
        assert(r.InDegrees() == 12.094757077012119)

        v2 = Vector2(-1, -2)
        r = Vector2.Angle(v1, v2)
        assert(r.InDegrees() == 167.9052429229879)

        v2 = Vector2(0, 0)
        r = Vector2.Angle(v1, v2)
        assert(r.InDegrees() == 0)

    def test_SignedAngle(self):
        v1: Vector2 = Vector2(4, 5)
        v2: Vector2 = Vector2(1, 2)
        r: float = 0

        r = Vector2.SignedAngle(v1, v2)
        assert(r.InDegrees() == -12.094757077012098)

        v2 = Vector2(-1, -2)
        r = Vector2.SignedAngle(v1, v2)
        assert(r.InDegrees() == 167.90524292298792)

        v2 = Vector2(0, 0);
        r = Vector2.SignedAngle(v1, v2)
        assert(r.InDegrees() == 0)

        v1 = Vector2(0, 1)
        v2 = Vector2(1, 0)
        r = Vector2.SignedAngle(v1, v2)
        assert(r.InDegrees(), 90)

        v1 = Vector2(0, 1)
        v2 = Vector2(0, -1)
        r = Vector2.SignedAngle(v1, v2)
        assert(r.InDegrees(), 180)

    def test_Lerp(self):
        v1: Vector2 = Vector2(4, 5)
        v2: Vector2 = Vector2(1, 2)
        r: Vector2 = Vector2.zero

        r = Vector2.Lerp(v1, v2, 0)
        assert(Vector2.Distance(r, v1), 0)

        r = Vector2.Lerp(v1, v2, 1)
        assert(Vector2.Distance(r, v2), 0)

        r = Vector2.Lerp(v1, v2, 0.5)
        assert(Vector2.Distance(r, Vector2(2.5, 3.5)), 0)

        r = Vector2.Lerp(v1, v2, -1)
        assert(Vector2.Distance(r, Vector2(7.0, 8.0)), 0)

        r = Vector2.Lerp(v1, v2, 2)
        assert(Vector2.Distance(r, Vector2(-2.0, -1.0)), 0)

class Vector3Test(unittest.TestCase):
    def test_Equality(self):
        v1: Vector3 = Vector3(4, 5, 6)
        v2: Vector3 = Vector3(1, 2, 3)
        r: bool = False

        r = v1 == v2
        assert(r == False)

        v2 = Vector3(4, 5, 6);
        r = v1 == v2;
        assert(r == True)

    def test_SqrMagnitude(self):
        v: Vector3 = Vector3(1, 2, 3)
        m: float = 0;

        m = v.SqrMagnitude()
        assert(m == 14)

        v = Vector3(-1, -2, -3)
        m = v.SqrMagnitude()
        assert(m == 14)

        v = Vector3(0, 0, 0)
        m = v.SqrMagnitude()
        assert(m == 0)

    def test_Magnitude(self):
        v: Vector3 = Vector3(1, 2, 3)
        m: float = 0;

        m = v.Magnitude()
        assert(m == 3.7416573867739413)

        v = Vector3(-1, -2, -3)
        m = v.Magnitude()
        assert(m == 3.7416573867739413)

        v = Vector3(0, 0, 0)
        m = v.Magnitude()
        assert(m == 0)

    def test_Normalize(self):
        r: bool = False

        v1: Vector3 = Vector3(0, 2, 0)
        v: Vector3 = Vector3.zero

        v = v1.Normalized()
        assert(v == Vector3(0, 1, 0))

        v1 = Vector3(0, -2, 0)
        v = v1.Normalized()
        assert(v == Vector3(0, -1, 0))

        v1 = Vector3(0, 0, 0)
        v = v1.Normalized()
        assert(v == Vector3(0, 0, 0))

    def test_Negate(self):
        v1: Vector3 = Vector3(4, 5, 6)
        v: Vector3 = Vector3.zero

        v = -v1
        assert(v == Vector3(-4, -5, -6))

        v1 = Vector3(-4, -5, -6)
        v = -v1
        assert(v == Vector3(4, 5, 6))

        v1 = Vector3(0, 0, 0)
        v = -v1
        assert(v == Vector3(0, 0, 0))

    def test_Subtract(self):
        v1: Vector3 = Vector3(4, 5, 6)
        v2: Vector3 = Vector3(1, 2, 3)
        v3: Vector3 = Vector3.zero

        v = v1 - v2
        assert(v == Vector3(3, 3, 3))

        v2 = Vector3(-1, -2, -3)
        v = v1 - v2
        assert(v == Vector3(5, 7, 9))

        v2 = Vector3(4, 5, 6)
        v = v1 - v2
        assert(v == Vector3(0, 0, 0))

        v2 = Vector3(0, 0, 0)
        v = v1 - v2
        assert(v == Vector3(4, 5, 6))

    def test_Addition(self):
        v1: Vector3 = Vector3(4, 5, 6)
        v2: Vector3 = Vector3(1, 2, 3)
        v: Vector3 = Vector3.zero

        v = v1 + v2
        assert(v == Vector3(5, 7, 9))

        v2 = Vector3(-1, -2, -3)
        v = v1 + v2
        assert(v == Vector3(3, 3, 3))

        v2 = Vector3(0, 0, 0)
        v = v1 + v2
        assert(v == Vector3(4, 5, 6))

    def test_Scale(self):
        v1: Vector3 = Vector3(4, 5, 6)
        v2: Vector3 = Vector3(1, 2, 3)
        v: Vector3 = Vector3.zero

        v = v1.Scale(v2)
        assert(v == Vector3(4, 10, 18))

        v2 = Vector3(-1, -2, -3)
        v = v1.Scale(v2)
        assert(v == Vector3(-4, -10, -18))

        v2 = Vector3(0, 0, 0)
        v = v1.Scale(v2)
        assert(v == Vector3(0, 0, 0))

    def test_Multiply(self):
        v1: Vector3 = Vector3(4, 5, 6)
        f: float = 3
        v: Vector3 = Vector3.zero

        v = v1 * f
        assert(v == Vector3(12, 15, 18))

        f = -3
        v = v1 * f
        assert(v == Vector3(-12, -15, -18))

        f = 0
        v = v1 * f
        assert(v == Vector3(0, 0, 0))

    def test_Divide(self):
        v1: Vector3 = Vector3(4, 5, 6)
        f: float = 2
        v: Vector3 = Vector3.zero

        v = v1 / f
        assert(v == Vector3(2, 2.5, 3))

        f = -2
        v = v1 / f
        assert(v == Vector3(-2, -2.5, -3))

    def test_Distance(self):
        v1: Vector3 = Vector3(4, 5, 6);
        v2: Vector3 = Vector3(1, 2, 3);
        f: float = 0

        f = Vector3.Distance(v1, v2);
        assert(f == 5.196152422706632)

        v2 = Vector3(-1, -2, -3);
        f = Vector3.Distance(v1, v2);
        assert(f == 12.449899597988733)

        v2 = Vector3(0, 0, 0);
        f = Vector3.Distance(v1, v2);
        assert(f == 8.774964387392123)

    def test_Dot(self):
        v1: Vector3 = Vector3(4, 5, 6)
        v2: Vector3 = Vector3(1, 2, 3)
        f: float = 0

        f = Vector3.Dot(v1, v2)
        assert(f == 32)

        v2 = Vector3(-1, -2, -3)
        f = Vector3.Dot(v1, v2)
        assert(f, -32)

        v2 = Vector3(0, 0, 0)
        f = Vector3.Dot(v1, v2)
        assert(f, 0)

    def test_Cross(self):
        v1: Vector3 = Vector3(4, 5, 6)
        v2: Vector3 = Vector3(1, 2, 3)
        v: Vector3 = Vector3.zero

        v = Vector3.Cross(v1, v2)
        assert(v == Vector3(3, -6, 3))

        v2 = Vector3(-1, -2, -3)
        v = Vector3.Cross(v1, v2)
        assert(v == Vector3(-3, 6, -3))

        v2 = Vector3(0, 0, 0)
        v = Vector3.Cross(v1, v2)
        assert(v == Vector3(0, 0, 0))

    def test_Project(self):
        v1: Vector3 = Vector3(4, 5, 6)
        v2: Vector3 = Vector3(1, 2, 3)
        v: Vector3 = Vector3.zero

        v = v1.Project(v2)
        assert(v == Vector3(2.2857142857142856, 4.571428571428571, 6.857142857142857))

        v2 = Vector3(-1, -2, -3)
        v = v1.Project(v2)
        assert(v == Vector3(2.2857142857142856, 4.571428571428571, 6.857142857142857))

        v2 = Vector3(0, 0, 0)
        v = v1.Project(v2)
        assert(v == Vector3(0, 0, 0))

    def test_ProjectOnPlane(self):
        v1: Vector3 = Vector3(4, 5, 6)
        v2: Vector3 = Vector3(1, 2, 3)
        v: Vector3 = Vector3.zero

        v = v1.ProjectOnPlane(v2)
        assert(v == Vector3(1.7142857142857144, 0.4285714285714288, -0.8571428571428568))

        v2 = Vector3(-1, -2, -3)
        v = v1.ProjectOnPlane(v2)
        assert(v == Vector3(1.7142857142857144, 0.4285714285714288, -0.8571428571428568))

        v2 = Vector3(0, 0, 0)
        v = v1.ProjectOnPlane(v2)
        assert(v == Vector3(4, 5, 6))

    def test_Angle(self):
        v1: Vector3 = Vector3(4, 5, 6)
        v2: Vector3 = Vector3(1, 2, 3)
        f: Angle = Angle.Degrees(0)

        f = Vector3.Angle(v1, v2)
        assert(f.InDegrees() == 12.933154491899135)

        v2 = Vector3(-1, -2, -3)
        f = Vector3.Angle(v1, v2)
        assert(f.InDegrees() == 167.06684550810087)

        v2 = Vector3(0, 0, 0)
        f = Vector3.Angle(v1, v2)
        assert(f.InDegrees() == 0)

    def test_SignedAngle(self):
        v1: Vector3 = Vector3(4, 5, 6)
        v2: Vector3 = Vector3(1, 2, 3)
        v3: Vector3 = Vector3(7, 8, -9)
        f: Angle = Angle.Degrees(0);
        r: bool = False

        f = Vector3.SignedAngle(v1, v2, v3)
        assert(f.InDegrees() == -12.933154491899135)

        v2 = Vector3(-1, -2, -3)
        f = Vector3.SignedAngle(v1, v2, v3)
        assert(f.InDegrees(), 167.06684550810087)

        v2 = Vector3(0, 0, 0)
        f = Vector3.SignedAngle(v1, v2, v3)
        assert(f.InDegrees(), 0)

        v2 = Vector3(1, 2, 3)

        v3 = Vector3(-7, -8, 9)
        f = Vector3.SignedAngle(v1, v2, v3)
        assert(f.InDegrees(), 12.933154491899135)

        v3 = Vector3(0, 0, 0)
        f = Vector3.SignedAngle(v1, v2, v3)
        assert(f.InDegrees(), 0)

    def test_Lerp(self):
        v1: Vector3 = Vector3(4, 5, 6)
        v2: Vector3 = Vector3(1, 2, 3)
        r: Vector3 = Vector3(0, 0, 0)

        r = Vector3.Lerp(v1, v2, 0)
        assert(Vector3.Distance(r, v1), 0)

        r = Vector3.Lerp(v1, v2, 1)
        assert(Vector3.Distance(r, v2), 0)

        r = Vector3.Lerp(v1, v2, 0.5)
        assert(Vector3.Distance(r, Vector3(2.5, 3.5, 4.5)), 0)

        r = Vector3.Lerp(v1, v2, -1)
        assert(Vector3.Distance(r, Vector3(7.0, 8.0, 9.0)), 0)

        r = Vector3.Lerp(v1, v2, 2)
        assert(Vector3.Distance(r, Vector3(-2.0, -1.0, 0.0)), 0)