#include "minunit.h"
#include "../vec2.h"
#include <math.h>

static vec2 four_two;
static vec2 minus_three_nine;
static vec2 e_x;
static vec2 e_y;
static double alpha = 0.0;


void test_setup(void) {
    four_two = vec2_create(4.0, 2.0);
    minus_three_nine = vec2_create(-3.0, 9.0);

    e_x =  vec2_create(1.0, 0.0);
    e_y =  vec2_create(0.0, 1.0);

    alpha = 1.5;
}

void test_teardown(void) {
	/* Nothing */
}

MU_TEST(test_vec2_create) {
	mu_assert_double_eq(four_two.x, 4.0);
	mu_assert_double_eq(four_two.y, 2.0);
    mu_assert(vec2_is_approx_equal(four_two, vec2_create(4.0, 2.0), MINUNIT_EPSILON), "four_two should be (4.0, 2.0).");

	mu_assert_double_eq(minus_three_nine.x, -3.0);
	mu_assert_double_eq(minus_three_nine.y,  9.0);

	mu_assert_double_eq(e_x.x, 1.0);
	mu_assert_double_eq(e_x.y, 0.0);

	mu_assert_double_eq(e_y.x, 0.0);
	mu_assert_double_eq(e_y.y, 1.0);
}

MU_TEST(test_vec2_add) {
    mu_assert(
        vec2_is_approx_equal(
            vec2_add(four_two, minus_three_nine), 
            vec2_create(1.0, 11.0), MINUNIT_EPSILON), 
        "(4,2)+(-3,9)=(1, 11)."
    );
    mu_assert(
        vec2_is_approx_equal(
            vec2_add(four_two, minus_three_nine), 
            vec2_add(minus_three_nine, four_two), MINUNIT_EPSILON), 
        "Addition is commutative."
    );
}

MU_TEST(test_vec2_sub) {
    mu_assert(
        vec2_is_approx_equal(
            vec2_sub(four_two, minus_three_nine), 
            vec2_create(7.0, -7.0), MINUNIT_EPSILON), 
        "(4,2)-(-3,9)=(7, -7)."
    );

    mu_assert(
        vec2_is_approx_equal(
            vec2_sub(four_two, minus_three_nine), 
            vec2_add(four_two, vec2_mul(-1.0, minus_three_nine)), MINUNIT_EPSILON), 
        "(4,2) - (-3,9) = (4,2) + (-1) * (-3,9)."
    );
}

MU_TEST(test_vec2_mul) {
    mu_assert(
        vec2_is_approx_equal(
            vec2_mul(alpha, minus_three_nine), 
            vec2_create(-4.5, 13.5), MINUNIT_EPSILON), 
        "1.5 * (-3,9)=(-4.5, 13.5)."
    );

    mu_assert(
        vec2_is_approx_equal(
            vec2_add(vec2_mul(4.0, e_x), vec2_mul(2.0, e_y)), 
            four_two, MINUNIT_EPSILON), 
        "4 * (1,0) + 2 * (0,1) = (4,2)."
    );
}

MU_TEST(test_vec2_dot) {
    mu_assert_double_eq(
        vec2_dot(four_two, minus_three_nine), 
        6.0
    );

    mu_assert_double_eq(
        vec2_dot(e_x, e_y), 
        0.0
    );

    mu_assert_double_eq(
        vec2_dot(four_two, e_x), 
        4.0
    );

    mu_assert_double_eq(
        vec2_dot(four_two, e_y), 
        2.0
    );
}

MU_TEST(test_vec2_norm) {
    mu_assert_double_eq(
        vec2_norm(e_x), 
        1.0
    );

    mu_assert_double_eq(
        vec2_norm(e_y), 
        1.0
    );

    mu_assert_double_eq(
        vec2_norm(four_two), 
        sqrt(20.0)
    );
}

MU_TEST_SUITE(test_suite) {
	MU_SUITE_CONFIGURE(&test_setup, &test_teardown);

	MU_RUN_TEST(test_vec2_create);

	MU_RUN_TEST(test_vec2_add);
	MU_RUN_TEST(test_vec2_sub);
	MU_RUN_TEST(test_vec2_mul);
	MU_RUN_TEST(test_vec2_dot);
	MU_RUN_TEST(test_vec2_norm);
}

int main() {
	MU_RUN_SUITE(test_suite);
	MU_REPORT();
	return MU_EXIT_CODE;
}