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 Spherical import *

class PolarTest(unittest.TestCase):
    def test_FromVector2(self):
        v: Vector2 = Vector2(0, 1)
        p: Polar = Polar.FromVector2(v)

        assert(p.distance == 1)
        assert(p.direction.InDegrees() == 0)

        v = Vector2(1, 0)
        p = Polar.FromVector2(v)

        assert(p.distance, 1)
        assert(p.direction.InDegrees(), 90)

        v = Vector2(-1, 1)
        p = Polar.FromVector2(v)

        assert(p.distance == math.sqrt(2))
        assert(p.direction.InDegrees() == -45)

    def test_Equality(self):
        v1: Polar = Polar.Degrees(4, 5)

        v2: Polar = Polar.Degrees(1, 2)
        assert(v1 != v2)

        v2 = Polar.Degrees(4, 5)
        assert(v1 == v2)

    def test_Magnitude(self):
        v: Polar = Polar.Degrees(2, 30)
        r: float = 0

        r = v.Magnitude()
        assert(r == 2)

        v = Polar.Degrees(-2, -30)
        r = v.Magnitude()
        assert(r == 2)

        v = Polar.Degrees(0, 0)
        r = v.Magnitude()
        assert(r == 0)

    def test_Normalize(self):
        v1: Polar = Polar.Degrees(2, 90)
        r: Polar = Polar.zero

        r = v1.Normalized()
        assert(r == Polar.Degrees(1, 90))

        v1 = Polar.Degrees(2, -90)
        r = v1.Normalized()
        assert(r == Polar.Degrees(1, -90))

        v1 = Polar.Degrees(0, 0)
        r = v1.Normalized()
        assert(r == Polar.Degrees(0, 0))

    def test_Negate(self):
        v1: Polar = Polar.Degrees(2, 45)
        r: Polar = Polar.zero

        r = -v1
        assert(r == Polar.Degrees(2, -135))

        v1 = Polar.Degrees(2, -45)
        r = -v1
        assert(r == Polar.Degrees(2, 135))

        v1 = Polar.Degrees(2, 0)
        r = -v1
        assert(r == Polar.Degrees(2, 180))

        v1 = Polar.Degrees(0, 0)
        r = -v1
        assert(r == Polar.Degrees(0, 0))

    def test_Subtract(self):
        r: Polar = Polar.zero
        v1: Polar = Polar.Degrees(4, 45)

        v2: Polar = Polar.zero
        r = v1 - v2
        assert(r == v1)

        r = v1
        r -= v2
        assert(r == v1)

        v2: Polar = Polar.Degrees(1, 45)
        r = v1 - v2
        assert(r == Polar.Degrees(3, 45))

        v2: Polar = Polar.Degrees(1, -135)
        r = v1 - v2
        assert(r == Polar.Degrees(5, 45))

    def test_Addition(self):
        r = Polar.zero

        v1 = Polar.Degrees(4, 45)
        v2 = Polar.zero
        r = v1 + v2
        assert(r == v1)

        r = v1
        r += v2
        assert(r == v1)

        v2 = Polar.Degrees(1, 45)
        r = v1 + v2
        assert(r == Polar.Degrees(5, 45))

        v2 = Polar.Degrees(1, -135)
        r = v1 + v2
        assert(r == Polar.Degrees(3, 45))

    def test_Multiply(self):
        r: Polar = Polar.zero

        v1: Polar = Polar.Degrees(4, 45)
        r = v1 * 2
        assert(r == Polar.Degrees(8, 45))

        r = v1 * -2
        assert(r == Polar.Degrees(8, -135))

        r = v1 * 0
        assert(r == Polar.Degrees(0, 0))

    def test_Divide(self):
        r: Polar.zero

        v1 = Polar.Degrees(4, 45)
        r = v1 / 2
        assert(r == Polar.Degrees(2, 45))

        r = v1 / -2
        assert(r == Polar.Degrees(2, -135))

    def test_Distance(self):
        r: float = 0

        v1 = Polar.Degrees(4, 45)
        v2 = Polar.Degrees(1, -135)
        r = Polar.Distance(v1, v2)
        assert(r == 5)

        v2 = Polar.Degrees(-1, -135)
        r = Polar.Distance(v1, v2)
        assert(r == 3)

        v2 = Polar.Degrees(0, 0)
        r = Polar.Distance(v1, v2)
        assert(r == 4)

    def test_Angle(self):
        r = Angle.zero

        v1 = Polar.Degrees(4, 45)
        v2 = Polar.Degrees(1, -45)

        r = Polar.Angle(v1, v2)
        assert(r.InDegrees() == 90)

        v2 = Polar.Degrees(1, 135)
        r = Polar.Angle(v1, v2)
        assert(r.InDegrees() == 90)

        v2 = Polar.Degrees(1, 45)
        r = Polar.Angle(v1, v2)
        assert(r.InDegrees() == 0)

    def test_SignedAngle(self):
        r = Angle.zero

        v1 = Polar.Degrees(4, 45)
        v2 = Polar.Degrees(1, -45)

        r = Polar.SignedAngle(v1, v2)
        assert(r.InDegrees() == -90)

        v2 = Polar.Degrees(1, 135)
        r = Polar.SignedAngle(v1, v2)
        assert(r.InDegrees() == 90)

        v2 = Polar.Degrees(1, 45)
        r = Polar.SignedAngle(v1, v2)
        assert(r.InDegrees() == 0)

    def test_Lerp(self):
        r = Polar.zero

        v1 = Polar.Degrees(5, 45)
        v2 = Polar.Degrees(1, -45)

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

        r = Polar.Lerp(v1, v2, 0.5)
        assert(r == Polar.Degrees(3, 0))

        r = Polar.Lerp(v1, v2, -1)
        assert(r == Polar.Degrees(9, 135))

        r = Polar.Lerp(v1, v2, 2)
        assert(r == Polar.Degrees(-3, -135))

class SphericalTest(unittest.TestCase):
    def test_FromVector3(self):
        v: Vector3 = Vector3(0, 0, 1)
        p: Spherical = Spherical.FromVector3(v)

        assert(p.distance == 1)
        assert(p.direction.horizontal.InDegrees() == 0)
        assert(p.direction.vertical.InDegrees() == 0)

        v = Vector3(1, 0, 0)
        p = Spherical.FromVector3(v)

        assert(p.distance, 1)
        assert(p.direction.horizontal.InDegrees(), 90)
        assert(p.direction.vertical.InDegrees(), 0)

        v = Vector3(0, 1, 0)
        p = Spherical.FromVector3(v)

        assert(p.distance, 1)
        assert(p.direction.horizontal.InDegrees(), 0)
        assert(p.direction.vertical.InDegrees(), 90)

        v = Vector3(-1, 0, 1)
        p = Spherical.FromVector3(v)

        assert(p.distance == math.sqrt(2))
        assert(p.direction.horizontal.InDegrees() == -45)
        assert(p.direction.vertical.InDegrees() == 0)

    def test_Equality(self):
        v1: Spherical = Spherical.Degrees(4, 5, 6)

        v2: Spherical = Spherical.Degrees(1, 2, 3)
        assert(v1 != v2)

        v2 = Spherical.Degrees(4, 5, 6)
        assert(v1 == v2)

    def test_Magnitude(self):
        v: Spherical = Spherical.Degrees(2, 30, 0)
        r: float = 0

        r = v.Magnitude()
        assert(r == 2)

        v = Spherical.Degrees(-2, -30, 0)
        r = v.Magnitude()
        assert(r == 2)

        v = Spherical.Degrees(0, 0, 0)
        r = v.Magnitude()
        assert(r == 0)

    def test_Normalize(self):
        v1: Spherical = Spherical.Degrees(2, 90, 0)
        r: Spherical = Spherical.zero

        r = v1.Normalized()
        assert(r == Spherical.Degrees(1, 90, 0))

        v1 = Spherical.Degrees(2, -90, 0)
        r = v1.Normalized()
        assert(r == Spherical.Degrees(1, -90, 0))

        v1 = Spherical.Degrees(0, 0, 0)
        r = v1.Normalized()
        assert(r == Spherical.Degrees(0, 0, 0))

    def test_Negate(self):
        v1: Spherical = Spherical.Degrees(2, 45, 0)
        r: Spherical = Spherical.zero

        r = -v1
        assert(r == Spherical.Degrees(2, -135, 0))

        v1 = Spherical.Degrees(2, -45, 0)
        r = -v1
        assert(r == Spherical.Degrees(2, 135, 0))

        v1 = Spherical.Degrees(0, 0, 0)
        r = -v1
        assert(r == Spherical.Degrees(0, 180, 0))

    def test_Subtract(self):
        r: Spherical = Spherical.zero

        v1: Spherical = Spherical.Degrees(4, 45, 0)
        v2: Spherical = Spherical.zero
        r = v1 - v2
        assert(r == v1)

        r = v1
        r -= v2
        assert(r == v1)

        v2 = Spherical.Degrees(1, 45, 0)
        r = v1 - v2
        assert(r == Spherical(3, 45, 0))

        v2 = Spherical.Degrees(1, -135, 0)
        r = v1 - v2
        assert(r == Spherical.Degrees(5, 45, 0))

    def test_Addition(self):
        v1 = Spherical(1, Direction.Degrees(45, 0))
        v2 = Spherical.zero
        r = Spherical.zero

        r = v1 + v2
        assert(r.distance == v1.distance)

        r = v1
        r += v2
        assert(r.distance == v1.distance)

        v2 = Spherical(1, Direction.Degrees(-45, 0))
        r = v1 + v2
        assert(r.distance == math.sqrt(2))
        assert(r.direction.horizontal.InDegrees() == 0)
        assert(r.direction.vertical.InDegrees() == 0)

        v2 = Spherical(1, Direction.Degrees(0, 90))
        r = v1 + v2
        assert(r.distance == math.sqrt(2))
        assert(r.direction.horizontal.InDegrees() == 45)
        assert(r.direction.vertical.InDegrees() == 45)

    def test_Multiply(self):
        r = Spherical.zero

        v1 = Spherical.Degrees(4, 45, 0)
        r = v1 * 3
        assert(r == Spherical.Degrees(12, 45, 0))

        r = v1 * -3
        assert(r == Spherical.Degrees(12, -135, 0))

        r = v1 * 0
        assert(r == Spherical.Degrees(0, 0, 0))

    def test_Divide(self):
        r: Spherical.zero

        v1 = Spherical.Degrees(4, 45, 0)
        r = v1 / 2
        assert(r == Spherical.Degrees(2, 45, 0))

        r = v1 / -2
        assert(r == Spherical.Degrees(2, -135, 0))

    def test_Distance(self):
        r: float = 0

        v1 = Spherical.Degrees(4, 45, 0)
        v2 = Spherical.Degrees(1, -135, 0)
        r = Spherical.Distance(v1, v2)
        assert(r == 5)

        v2 = Spherical.Degrees(-1, -135, 0)
        r = Spherical.Distance(v1, v2)
        assert(r == 3)

        v2 = Spherical.Degrees(0, 0, 0)
        r = Spherical.Distance(v1, v2)
        assert(r == 4)

    def test_Angle(self):
        r = Angle.zero

        v1 = Spherical.Degrees(4, 45, 0)
        v2 = Spherical.Degrees(1, -45, 0)

        r = Spherical.Angle(v1, v2)
        assert(r.InDegrees() == 90)

        v2 = Spherical.Degrees(1, 135, 0)
        r = Spherical.Angle(v1, v2)
        assert(r.InDegrees() == 90)

        v2 = Spherical.Degrees(1, 45, 0)
        r = Spherical.Angle(v1, v2)
        assert(r.InDegrees() == 0)

    def test_SignedAngle(self):
        r = Angle.zero

        v1 = Spherical.Degrees(4, 45, 0)
        v2 = Spherical.Degrees(1, -45, 0)

        r = Spherical.SignedAngle(v1, v2, Direction.up)
        assert(r.InDegrees() == -90)

        v2 = Spherical.Degrees(1, 135, 0)
        r = Spherical.SignedAngle(v1, v2, Direction.up)
        assert(r.InDegrees() == 90)

        v2 = Spherical.Degrees(1, 45, 0)
        r = Spherical.SignedAngle(v1, v2, Direction.up)
        assert(r.InDegrees() == 0)

    def test_Lerp(self):
        r = Spherical.zero

        v1 = Spherical.Degrees(5, 45, 0)
        v2 = Spherical.Degrees(1, -45, 0)

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

        r = Spherical.Lerp(v1, v2, 0.5)
        assert(r == Spherical.Degrees(3, 0, 0))

        r = Spherical.Lerp(v1, v2, -1)
        assert(r == Spherical.Degrees(9, 135, 0))

        r = Spherical.Lerp(v1, v2, 2)
        assert(r == Spherical.Degrees(-3, -135, 0))