#include "graph.h"
#include <stdio.h>
#include <time.h>
#include <stdlib.h>

void benchmark_gemm() {
    const ulong vertex_count = 100;
    ulong adjacency_matrix1[vertex_count][vertex_count];
    ulong adjacency_matrix2[vertex_count][vertex_count];
    ulong dot_product[vertex_count][vertex_count];

    double elapsed_time = 0.0;
    const ulong iterations = 10;
    clock_t start_time;

    for (ulong i = 0; i < iterations; i++) {
        random_adjacency(vertex_count, adjacency_matrix1);
        random_adjacency(vertex_count, adjacency_matrix2);

        start_time = clock();

        gemm_basic(vertex_count, vertex_count, adjacency_matrix1,
                   vertex_count, vertex_count, adjacency_matrix2,
                   dot_product);

        elapsed_time += (double)(clock() - start_time) / CLOCKS_PER_SEC;
    }

    printf("%lu iterations of gemm_basic took roughly %f seconds\n", iterations, elapsed_time);
    printf("An iteration of gemm_basic took on average roughly %f seconds\n", elapsed_time/iterations);
}

void benchmark_find_components() {
    const ulong vertex_count = 100;
    ulong adjacency_matrix[vertex_count][vertex_count];
    ulong components[vertex_count][vertex_count];
    ulong path_matrix[vertex_count][vertex_count];

    double elapsed_time = 0.0;
    const ulong iterations = 100;
    clock_t start_time;

    for (ulong i = 0; i < iterations; i++) {
        random_adjacency(vertex_count, adjacency_matrix);

        start_time = clock();

        calculate_path_matrix(vertex_count, adjacency_matrix, path_matrix);
        find_components_basic(vertex_count, path_matrix, components);

        elapsed_time += (double)(clock() - start_time) / CLOCKS_PER_SEC;
    }

    printf("%lu iterations of find_components_basic took roughly %f seconds\n", iterations, elapsed_time);
    printf("An iteration of find_components_basic took on average roughly %f seconds\n", elapsed_time/iterations);

    elapsed_time = 0.0;

    for (ulong i = 0; i < iterations; i++) {
        random_adjacency(vertex_count, adjacency_matrix);

        start_time = clock();

        find_components_dfs(vertex_count, adjacency_matrix, components);

        elapsed_time += (double)(clock() - start_time) / CLOCKS_PER_SEC;
    }

    printf("%lu iterations of find_components_dfs took roughly %f seconds\n", iterations, elapsed_time);
    printf("An iteration of find_components_dfs took on average roughly %f seconds\n", elapsed_time/iterations);
}

void test_with_basic() {
    const ulong vertex_count = 24;
    ulong adjacency_matrix[vertex_count][vertex_count];
    ulong distance_matrix[vertex_count][vertex_count];
    ulong path_matrix[vertex_count][vertex_count];
    ulong eccentricities[vertex_count];
    ulong radius, diameter, centre[vertex_count];
    ulong components[vertex_count][vertex_count];
    ulong bridges[vertex_count][2];
    ulong articulations[vertex_count];

    if (read_csv("csv/24n.csv", vertex_count, vertex_count, adjacency_matrix) == 1) {
        return;
    }

    calculate_distance_matrix(vertex_count, adjacency_matrix, distance_matrix);
    get_eccentricities(vertex_count, distance_matrix, eccentricities);
    radius = get_radius(vertex_count, eccentricities);
    diameter = get_diameter(vertex_count, eccentricities);
    get_centre(vertex_count, eccentricities, radius, centre);
    calculate_path_matrix(vertex_count, adjacency_matrix, path_matrix);
    find_components_basic(vertex_count, path_matrix, components);
    find_bridges_basic(vertex_count, adjacency_matrix, components, bridges);
    find_articulations_basic(vertex_count, adjacency_matrix, components, articulations);

    puts("adjacency_matrix:");
    print_matrix(vertex_count, vertex_count, adjacency_matrix);

    puts("\ndistance_matrix:");
    print_matrix(vertex_count, vertex_count, distance_matrix);

    puts("\neccentricities:");
    for (ulong index = 0; index < vertex_count; index++) {
        printf("\tVertex %lu: %lu\n", index + 1,  eccentricities[index]);
    }

    printf("\nradius: %lu", radius);
    printf("\ndiameter: %lu", diameter);
    puts("\ncentre:");
    for (ulong index = 0; index < vertex_count; index++) {
        if (centre[index] == 1) {
            printf("\tVertex %lu\n", index + 1);
        }
    }

    puts("\npath_matrix:");
    print_matrix(vertex_count, vertex_count, path_matrix);

    puts("\ncomponents:");
    for (ulong row_index = 0; row_index < vertex_count; row_index++) {
        int empty = 1;

        for (ulong column_index = 0; column_index < vertex_count; column_index++) {
            if (components[row_index][column_index] != 0) {
                empty = 0;
            }
        }

        if (empty) {
            continue;
        }

        printf("\tComponent %lu: {", row_index + 1);
        for (ulong column_index = 0; column_index < vertex_count; column_index++) {
            if (components[row_index][column_index] != 0) {
                printf("%lu, ", components[row_index][column_index]);
            }
        }
        puts("}");
    }

    puts("\nbridges:");
    for (ulong index = 0; index < vertex_count; index++) {
        if (bridges[index][0] != 0) {
            printf("\tBridge %lu: {%lu, %lu}\n", index + 1, bridges[index][0], bridges[index][1]);
        }
    }

    puts("\narticulations:");
    for (ulong index = 0; index < vertex_count; index++) {
        if (articulations[index] != 0) {
            printf("\tVertex %lu\n", articulations[index]);
        }
    }
}

void test_with_dfs() {
    const ulong vertex_count = 24;
    ulong adjacency_matrix[vertex_count][vertex_count];
    ulong distance_matrix[vertex_count][vertex_count];
    ulong eccentricities[vertex_count];
    ulong radius, diameter;
    ulong centre[vertex_count];
    ulong components[vertex_count][vertex_count];
    ulong bridges[vertex_count][2];
    ulong articulations[vertex_count];

    if (read_csv("csv/24n.csv", vertex_count, vertex_count, adjacency_matrix) == 1) {
        return;
    }

    /*
    const ulong vertex_count = 1500;
    ulong (*adjacency_matrix)[vertex_count] = malloc(vertex_count * vertex_count * sizeof(ulong));
    ulong (*distance_matrix)[vertex_count] = malloc(vertex_count * vertex_count * sizeof(ulong));
    ulong *eccentricities = malloc(vertex_count * sizeof(ulong));
    ulong radius, diameter;
    ulong *centre = malloc(vertex_count * sizeof(ulong));
    ulong (*components)[vertex_count] = malloc(vertex_count * vertex_count * sizeof(ulong));
    ulong (*bridges)[vertex_count] = malloc(vertex_count * 2 * sizeof(ulong));
    ulong *articulations = malloc(vertex_count * sizeof(ulong));

    random_adjacency(vertex_count, adjacency_matrix);
    */

    calculate_distance_matrix(vertex_count, adjacency_matrix, distance_matrix);
    get_eccentricities(vertex_count, distance_matrix, eccentricities);
    radius = get_radius(vertex_count, eccentricities);
    diameter = get_diameter(vertex_count, eccentricities);
    get_centre(vertex_count, eccentricities, radius, centre);
    find_components_dfs(vertex_count, adjacency_matrix, components);
    find_bridges_dfs_v2(vertex_count, adjacency_matrix, components, bridges);
    find_articulations_dfs_v2(vertex_count, adjacency_matrix, components, articulations);

    puts("\nadjacency_matrix:");
    print_matrix(vertex_count, vertex_count, adjacency_matrix);

    puts("\ndistance_matrix:");
    print_matrix(vertex_count, vertex_count, distance_matrix);

    puts("\neccentricities:");
    for (ulong index = 0; index < vertex_count; index++) {
        printf("\tVertex %lu: %lu\n", index + 1,  eccentricities[index]);
    }

    printf("\nradius: %lu", radius);
    printf("\ndiameter: %lu", diameter);
    puts("\ncentre:");
    for (ulong index = 0; index < vertex_count; index++) {
        if (centre[index] == 1) {
            printf("\tVertex %lu\n", index + 1);
        }
    }

    puts("\ncomponents:");
    for (ulong row_index = 0; row_index < vertex_count; row_index++) {
        int empty = 1;

        for (ulong column_index = 0; column_index < vertex_count; column_index++) {
            if (components[row_index][column_index] != 0) {
                empty = 0;
            }
        }

        if (empty) {
            continue;
        }

        printf("\tComponent %lu: {", row_index + 1);
        for (ulong column_index = 0; column_index < vertex_count; column_index++) {
            if (components[row_index][column_index] != 0) {
                printf("%lu, ", column_index + 1);
            }
        }
        puts("}");
    }

    ulong bridge_number = 1;
    puts("\nbridges:");
    for (ulong index = 0; index < vertex_count; index++) {
        if (bridges[index][0] != 0) {
            printf("\tBridge %lu: {%lu, %lu}\n", bridge_number, bridges[index][0], bridges[index][1]);
            bridge_number++;
        }
    }

    puts("\narticulations:");
    for (ulong index = 0; index < vertex_count; index++) {
        if (articulations[index] != 0) {
            printf("\tVertex %lu\n", articulations[index]);
        }
    }

    // free(adjacency_matrix);
    // free(distance_matrix);
    // free(eccentricities);
    // free(centre);
    // free(components);
    // free(bridges);
    // free(articulations);
}

void test_with_structs() {
    ulong row_length = 5, column_length = 5;

    Matrix *adjacency_matrix1 = create_matrix(row_length, column_length);
    Matrix *adjacency_matrix2 = create_matrix(row_length, column_length);
    Matrix *dot_product = create_matrix(row_length, column_length);

    random_adjacency_struct(adjacency_matrix1);
    print_matrix_struct(adjacency_matrix1);
    putchar('\n');

    random_adjacency_struct(adjacency_matrix2);
    print_matrix_struct(adjacency_matrix2);
    putchar('\n');

    gemm_basic_structs(adjacency_matrix1, adjacency_matrix2,dot_product);
    print_matrix_struct(dot_product);

    free_matrix(adjacency_matrix1);
    free_matrix(adjacency_matrix2);
    free_matrix(dot_product);
}

int main(void) {
    // benchmark_gemm();
    // benchmark_find_components();
    // test_with_basic();
    // test_with_dfs();
    test_with_structs();
}