import math { close, is_nan, radians, tolerance, veryclose }
import math.vec

fn test_vec2_int() {
    mut v1 := vec.vec2(0, 0)
    mut v2 := vec.vec2(0, 0)
    assert v1 == v2
    v1.one()
    v2.one()
    assert v1.x == 1
    assert v1.y == 1
    assert v1 == v2

    v3 := v1 + v2
    assert typeof(v3).name == 'vec.Vec2[int]'
    assert v3.x == 2
    assert v3.y == 2
}

fn test_vec2_f32() {
    mut v1 := vec.vec2(f32(0), 0)
    mut v2 := vec.vec2(f32(0), 0)
    assert v1 == v2
    v1.one()
    v2.one()
    assert v1.x == 1
    assert v1.y == 1
    assert v1 == v2

    v3 := v1 + v2
    assert typeof(v3).name == 'vec.Vec2[f32]'
    assert v3.x == 2
    assert v3.y == 2
}

fn test_vec2_f64() {
    mut v1 := vec.vec2(0.0, 0)
    mut v2 := vec.vec2(0.0, 0)
    assert v1 == v2
    v1.one()
    v2.one()
    assert v1.x == 1
    assert v1.y == 1
    assert v1 == v2

    v3 := v1 + v2
    assert typeof(v3).name == 'vec.Vec2[f64]'
    assert v3.x == 2
    assert v3.y == 2
}

fn test_vec2_f64_utils_1() {
    mut v1 := vec.vec2(2.0, 3.0)
    mut v2 := vec.vec2(1.0, 4.0)

    mut zv := vec.vec2(5.0, 5.0)
    zv.zero()

    v3 := v1 + v2
    assert v3.x == 3
    assert v3.y == 7

    assert v1.dot(v2) == 14
    assert v1.cross(v2) == 5

    v1l := vec.vec2(40.0, 9.0)
    assert v1l.magnitude() == 41

    mut ctv1 := vec.vec2(0.000001, 0.000001)
    ctv1.clean_tolerance(0.00001)
    assert ctv1 == zv
}

fn test_vec2_f64_utils_2() {
    mut v1 := vec.vec2(4.0, 4.0)
    assert veryclose(v1.unit().magnitude(), 1)
    v2 := v1.mul_scalar(0.5)
    assert v2.x == 2
    assert v2.y == 2
    assert veryclose(v2.unit().magnitude(), 1)

    invv2 := v2.inv()
    assert invv2.x == 0.5
    assert invv2.y == 0.5
}

fn fcorrect_angles() []f64 {
    return [
        math.pi * 1.0 / 4.0,
        math.pi * 2.0 / 4.0,
        math.pi * 3.0 / 4.0,
        math.pi,
        math.pi * 5.0 / 4.0 - 2 * math.pi,
        math.pi * 6.0 / 4.0 - 2 * math.pi,
        math.pi * 7.0 / 4.0 - 2 * math.pi,
    ]
}

fn fsurround() []vec.Vec2[f64] {
    return [
        vec.vec2(1.0, 1.0),
        vec.vec2(0.0, 1.0),
        vec.vec2(-1.0, 1.0),
        vec.vec2(-1.0, 0.0),
        vec.vec2(-1.0, -1.0),
        vec.vec2(0.0, -1.0),
        vec.vec2(1.0, -1.0),
    ]
}

fn test_vec2_angle_between() {
    surround := fsurround()
    correct_angles := fcorrect_angles()
    v1 := vec.vec2(1.0, 0.0)
    for i in 0 .. 7 {
        assert v1.angle_between(surround[i]) == correct_angles[i]
        // check the angle between non-normalised, scaled vectors too:
        assert v1.mul_scalar(5.0).angle_between(surround[i].mul_scalar(2.0)) == correct_angles[i]
        offset := f64(i) + 123.123456
        assert v1.mul_scalar(offset).angle_between(surround[i].mul_scalar(offset)) == correct_angles[i]
        // check f32 version:
        v1_f32 := vec.vec2(f32(v1.x), f32(v1.y))
        v2_f32 := vec.vec2(f32(surround[i].x), f32(surround[i].y))
        assert v1_f32.angle_between(v2_f32) == f32(correct_angles[i])
        // check int version:
        v1_int := vec.vec2(int(v1.x), int(v1.y))
        v2_int := vec.vec2(int(surround[i].x), int(surround[i].y))
        assert v1_int.angle_between(v2_int) == int(correct_angles[i])
    }
}

fn test_vec2_angle_towards() {
    surround := fsurround()
    correct_angles := fcorrect_angles()
    // basic case, let p0 be the coordinate origin point:
    p0 := vec.vec2(0.0, 0.0)
    for i in 0 .. 7 {
        assert p0.angle_towards(surround[i]) == correct_angles[i]
        assert (surround[i] - p0).angle() == p0.angle_towards(surround[i])
        // check f32 version:
        p0_f32 := vec.vec2(f32(0), f32(0))
        s_f32 := vec.vec2(f32(surround[i].x), f32(surround[i].y))
        assert p0_f32.angle_towards(s_f32) == f32(correct_angles[i])
        // check int version:
        p0_int := vec.vec2(int(0), int(0))
        s_int := vec.vec2(int(surround[i].x), int(surround[i].y))
        assert p0_int.angle_towards(s_int) == int(correct_angles[i])
        // check invariants, when the 2 points are moved and translated:
        for x := -0.5; x <= 0.5; x += 0.1 {
            for y := -0.5; y <= 0.5; y += 0.1 {
                p1 := vec.vec2(x, y)
                p2 := p1.add(surround[i])
                assert veryclose(p1.angle_towards(p2), correct_angles[i]), 'i: ${i}, p1: ${p1} | p2: ${p2}'
                offset := f64(i) + 123.123456
                p1_o := p1.add_scalar(offset)
                p2_o := p2.add_scalar(offset)
                assert (p2_o - p1_o).angle() == p1_o.angle_towards(p2_o)
                assert close(p1_o.angle_towards(p2_o), correct_angles[i]), 'i: ${i}, p1_o: ${p1_o} | p2_o: ${p2_o}'
            }
        }
    }
}

fn test_vec2_rotate_around_cw() {
    origin := vec.vec2(0.0, 0.0)
    mut v := vec.vec2(0.0, 1.0)
    v = v.rotate_around_cw(origin, radians(90))
    assert close(v.x, 1.0)
    assert close(v.y, 0.0)
    v = v.rotate_around_cw(origin, radians(90))
    assert close(v.x, 0.0)
    assert close(v.y, -1.0)
    v = v.rotate_around_cw(origin, radians(90))
    assert close(v.x, -1.0)
    assert close(v.y, 0.0)
    v = v.rotate_around_cw(origin, radians(90))
    assert close(v.x, 0.0)
    assert close(v.y, 1.0)
}

fn test_vec2_rotate_around_ccw() {
    origin := vec.vec2(0.0, 0.0)
    mut v := vec.vec2(0.0, 1.0)
    v = v.rotate_around_ccw(origin, radians(90))
    assert close(v.x, -1.0)
    assert close(v.y, 0.0)
    v = v.rotate_around_ccw(origin, radians(90))
    assert close(v.x, 0.0)
    assert close(v.y, -1.0)
    v = v.rotate_around_ccw(origin, radians(90))
    assert close(v.x, 1.0)
    assert close(v.y, 0.0)
    v = v.rotate_around_ccw(origin, radians(90))
    assert close(v.x, 0.0)
    assert close(v.y, 1.0)
}

fn test_vec2_rotate_around_cw_2() {
    origin := vec.vec2(1.0, 1.0)
    mut v := vec.vec2(1.0, 2.0)
    v = v.rotate_around_cw(origin, radians(90))
    assert close(v.x, 2.0)
    assert close(v.y, 1.0)
    v = v.rotate_around_cw(origin, radians(90))
    assert close(v.x, 1.0)
    assert close(v.y, 0.0)
    v = v.rotate_around_cw(origin, radians(90))
    assert close(v.x, 0.0)
    assert close(v.y, 1.0)
    v = v.rotate_around_cw(origin, radians(90))
    assert close(v.x, 1.0)
    assert close(v.y, 2.0)
}

fn test_vec2_rotate_around_ccw_2() {
    origin := vec.vec2(-1.0, 1.0)
    mut v := vec.vec2(-1.0, -1.0)
    v = v.rotate_around_ccw(origin, radians(90))
    assert close(v.x, 1.0)
    assert close(v.y, 1.0)
    v = v.rotate_around_ccw(origin, radians(90))
    assert close(v.x, -1.0)
    assert close(v.y, 3.0)
    v = v.rotate_around_ccw(origin, radians(90))
    assert close(v.x, -3.0)
    assert close(v.y, 1.0)
    v = v.rotate_around_ccw(origin, radians(90))
    assert close(v.x, -1.0)
    assert close(v.y, -1.0)
}

// Test for Vec2 projection
//
fn test_vec2_project_onto_basic() {
    v := vec.vec2(5.0, 6.0) // magnitude ~7.81 vector
    u := vec.vec2(3.0, 4.0) // magnitude 5 vector
    // hand-computed:
    // v·u = 5*3 + 6*4 = 39
    // |u|^2 = 3^2 + 4^2 = 25
    // scale = 39/25 = 1.56
    // proj = scale * u = (1.56*3, 1.56*4) = (4.68, 6.24)
    proj := v.project(u)
    assert tolerance(proj.x, 4.68, vec.vec_epsilon)
    assert tolerance(proj.y, 6.24, vec.vec_epsilon)
}

// Test for Vec2 projection onto zero vector
// project v into the null vector
fn test_vec2_project_onto_zero() {
    v := vec.vec2(5.0, 6.0)
    u := vec.vec2(0.0, 0.0)
    proj := v.project(u)
    // must be nan
    assert is_nan(proj.x)
    assert is_nan(proj.y)
}

// Test for Vec2 projection of zero vector
// project a null vector
fn test_vec2_project_zero_vector() {
    v := vec.vec2(0.0, 0.0)
    u := vec.vec2(3.0, 4.0)
    proj := v.project(u)
    assert proj.x == 0.0
    assert proj.y == 0.0
}

// Test for Vec2 projection onto itself
//
fn test_vec2_project_onto_self() {
    u := vec.vec2(3.0, 4.0)
    proj := u.project(u)
    assert veryclose(proj.x, u.x)
    assert veryclose(proj.y, u.y)
}

// Test for Vec2 projection onto orthogonal vector
//
fn test_vec2_project_onto_orthogonal() {
    v := vec.vec2(0.0, 1.0)
    u := vec.vec2(1.0, 0.0)
    proj := u.project(v)
    // more sensitive to floating point errors so i think close is better here
    assert close(proj.x, 0.0)
    assert close(proj.y, 0.0)
}

// Test for Vec2 projection with negative components
//
fn test_vec2_project_negative_components() {
    v := vec.vec2(5.0, -6.0)
    u := vec.vec2(-3.0, 4.0)
    // hand-computed:
    // v·u = 5*-3 + -6*4 = -15 - 24 = -39
    // |u|^2 = -3^2 + 4^2 = 9 + 16 = 25
    // scale = -39/25 = -1.56
    // proj = scale * u = (-1.56*-3, -1.56*4) = (4.68, -6.24)
    proj := v.project(u)
    assert tolerance(proj.x, 4.68, vec.vec_epsilon)
    assert tolerance(proj.y, -6.24, vec.vec_epsilon)
}

// Test for perpendicularity
// 'u' and 'v' are already perpendicular so it must return v
fn test_vec2_perpendicularity_angle() {
    u := vec.vec2(1.0, 0.0)
    v := vec.vec2(0.0, 3.0)

    per := v.perpendicular(u)
    assert tolerance(per.x, v.x, vec.vec_epsilon)
    assert tolerance(per.y, v.y, vec.vec_epsilon)
}

// 'u' and 'v' are collinear so it must return the null vector
fn test_vec2_collinear() {
    u := vec.vec2(1.0, 0.0)
    v := vec.vec2(3.0, 0.0)

    per := v.perpendicular(u)
    assert tolerance(per.x, 0.0, vec.vec_epsilon)
    assert tolerance(per.y, 0.0, vec.vec_epsilon)
}