#include <stdio.h>
#include <stdlib.h>
#include <basic-geometry.h>
#include "affine3.h"

#ifdef _WIN64
#include <windows.h>
#else
#include <time.h>
#endif // _WINDOWS_

BGC_FP32_Affine3* _create_bgc_affine3_list(int affine_amount)
{
    BGC_FP32_Affine3* affines = malloc(affine_amount * sizeof(BGC_FP32_Affine3));

    if (affines == 0) {
        return 0;
    }

    for (int i = 0; i < affine_amount; i++) {
        bgc_fp32_affine3_reset(&affines[i]);
    }

    return affines;
}

float get_random_value_fp32()
{
    return rand() * (2.0f / RAND_MAX) - 1.0f;
}

BGC_FP32_Affine3* _create_bgc_affine3_random_list(int affine_amount)
{
    BGC_FP32_Affine3* affines = malloc(affine_amount * sizeof(BGC_FP32_Affine3));

    if (affines == 0) {
        return 0;
    }

    BGC_FP32_Position3 position;

    for (int i = 0; i < affine_amount; i++) {
        bgc_fp32_versor_make(
            &position.turn,
            get_random_value_fp32(),
            get_random_value_fp32(),
            get_random_value_fp32(),
            get_random_value_fp32()
        );

        position.shift.x1 = get_random_value_fp32();
        position.shift.x2 = get_random_value_fp32();
        position.shift.x3 = get_random_value_fp32();

        bgc_fp32_position3_get_outward_affine(&affines[i], &position);
    }

    return affines;
}

BGC_FP32_Vector3* _create_bgc_vector3_list(int amount)
{
    return malloc(amount * sizeof(BGC_FP32_Vector3));
}

BGC_FP32_Vector3* _create_bgc_vector3_random_list(int amount)
{
    BGC_FP32_Vector3* vectors = _create_bgc_vector3_list(amount);

    if (vectors == 0) {
        return 0;
    }

    for (int i = 0; i < amount; i++) {
        vectors[i].x1 = get_random_value_fp32();
        vectors[i].x2 = get_random_value_fp32();
        vectors[i].x3 = get_random_value_fp32();
    }

    return vectors;
}

float test_bgc_affine3_performance(int affine_amount, int vector_per_affine)
{
    BGC_FP32_Affine3* affines;
    BGC_FP32_Vector3* source_vectors;
    BGC_FP32_Vector3* result_vectors;

    int vector_index = 0;
    float time = -1.0f;

#ifdef _WIN64
    ULONGLONG start, end;

    start = GetTickCount64();

    srand((unsigned int)(start & 0xfffffff));
#else
    struct timespec start, end;
    clock_gettime(0, &start);
    srand((unsigned int)(start.tv_nsec & 0xfffffff));
#endif // _WIN64

    affines = _create_bgc_affine3_random_list(affine_amount);

    if (affines == 0) {
        return time;
    }

    source_vectors = _create_bgc_vector3_random_list(affine_amount * vector_per_affine);

    if (source_vectors == 0) {
        free(affines);
        return time;
    }

    result_vectors = _create_bgc_vector3_list(affine_amount * vector_per_affine);

    if (result_vectors == 0) {
        free(source_vectors);
        free(affines);
        return time;
    }

#ifdef _WIN64
    start = GetTickCount64();
#else
    clock_gettime(CLOCK_REALTIME, &start);
#endif // _WIN64

    for (int i = 0; i < affine_amount; i++)
    {
        for (int j = 0; j < vector_per_affine; j++) {
            bgc_fp32_affine3_transform_point(&result_vectors[vector_index], &affines[i], &source_vectors[vector_index]);
            vector_index++;
        }
    }

#ifdef _WIN64
    end = GetTickCount64();

    time = (end - start) * 0.001f;
#else
    clock_gettime(CLOCK_REALTIME, &end);

    time = (float)(end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) * 0.000000001f;
#endif // _WIN64

    printf("Result vector [0] = (%f, %f, %f)\n", result_vectors[0].x1, result_vectors[0].x2, result_vectors[0].x3);

    free(result_vectors);
    free(source_vectors);
    free(affines);

    return time;
}