#include "shell_test.h"

#include <stdbool.h>
#include <stdio.h>

#include "files.h"
#include "graphs.h"
#include "nfa.h"
#include "nfa_determi.h"
#include "nfa_tocode.h"
#include "parse_regexp.h"
#include "parser.h"
#include "shell_languages.h"
#include "shell_tools.h"
#include "type_boolarray.h"
#include "type_dequeue.h"

// Cette fonction est appelée par le shell sur la commande "test".
// Vous pouvez y mettre le code que vous voulez tester.

#define TEST_DEQUEUE true
#define TEST_BOOLARRAY false
#define NB_TESTS_OCCUR 1000

static void printf_dequeue(dequeue *dq, char *function, char *var,
                           int i_function, int i_result) {
    if (function != NULL)
        printf("%s(", function);
    else
        printf("%s\n", var);
    if (function != NULL && i_function >= 0) printf("%d, ", i_function);
    if (function != NULL) printf("%s)", var);
    if (function != NULL && i_result >= 0)
        printf(" = %d\n", i_result);
    else if (function != NULL)
        printf("\n");
    print_dequeue(dq);
    printf("isempty_dequeue(%s) = %d\n", var, isempty_dequeue(dq));
    printf("size_dequeue(%s) = %d\n", var, size_dequeue(dq));
    printf("\n");
}

static void printf_boolarray(barray *ba, char *function, char *var,
                             int i_function, int i_result) {
    if (function != NULL)
        printf("%s(", function);
    else
        printf("%s\n", var);
    if (function != NULL && i_function >= 0) printf("%d, ", i_function);
    if (function != NULL) printf("%s)", var);
    if (function != NULL && i_result >= 0)
        printf(" = %d\n", i_result);
    else if (function != NULL)
        printf("\n");
    printf("Boolarray : ");
    for (uint i = 0; i < getsize_barray(ba); i++) {
        printf("%d ", getval_barray(ba, i));
    }
    printf("\n");
    printf("getsize_barray(%s) = %d\n", var, getsize_barray(ba));
    printf("\n");
}

void test(void) {
    // regexp *myexp;

    // Cette première affectation ne fonctionnera que si vous avez implémenté
    // les fonctions du module regexp.h.
    // myexp = parse_string_regexp("(a+bb)*");

    // L'affichage de l'expression régulière est fait par la fonction reg_print,
    // définie dans printing.c et déjà fournie. Vous pouvez la décommenter pour
    // afficher l'expression régulière, après avoir implémenté les fonctions
    // nécessaires dans regexp.c.
    // reg_print(myexp);

    // Autre exemple, avec une construction directe de NFA.
    // nfa* A = create_sing_epsilon();
    // nfa_view(A);

    // Tests de dequeue
    if (TEST_DEQUEUE) {
        dequeue *dq = create_dequeue();
        printf_dequeue(dq, NULL, "dq", 0, -1);
        for (uint i = 11; i <= 20; i++) {
            rigins_dequeue(i, dq);
            // printf_dequeue(dq, "rigins_dequeue", "dq", i, -1);
        }
        for (uint i = 10; i > 0; i--) {
            lefins_dequeue(i, dq);
            // printf_dequeue(dq, "leftins_dequeue", "dq", i, -1);
        }
        printf("--------------------\n");
        printf(
            "Test rigins_dequeue et leftins_dequeue\n");  // Test rigins_dequeue
                                                          // et leftins_dequeue
        printf("--------------------\n");
        for (uint i = 0; i < size_dequeue(dq); i++) {
            assert(lefread_dequeue(dq, i) == i + 1);
            printf("assert(lefread_dequeue(dq, %d) == %d) check\n", i, i + 1);
        }
        for (uint i = 0; i < 20; i++) {
            if (i % 2 == 0) {
                uint tmp[i / 2];
                for (uint j = 0; j < i / 2; j++) {
                    // printf_dequeue(dq, "lefread_dequeue", "dq", -1,
                    //                lefread_dequeue(dq, 0));
                    tmp[j] = lefpull_dequeue(dq);
                    // printf_dequeue(dq, "lefpull_dequeue",
                    // "dq", -1, -1);
                }
                for (uint j = 0; j < i / 2; j++) {
                    lefins_dequeue(tmp[i / 2 - j - 1], dq);
                    // printf_dequeue(dq, "lefins_dequeue", "dq", tmp[j], -1);
                }
            } else {
                uint tmp[i / 2];
                for (uint j = 0; j < i / 2; j++) {
                    // printf_dequeue(dq, "rigread_dequeue", "dq", -1,
                    // rigread_dequeue(dq, 0));
                    tmp[j] = rigpull_dequeue(dq);
                    // printf_dequeue(dq, "rigpull_dequeue", "dq", -1, -1);
                }
                for (uint j = 0; j < i / 2; j++) {
                    rigins_dequeue(tmp[i / 2 - j - 1], dq);
                    // printf_dequeue(dq, "rigins_dequeue", "dq", tmp[j], -1);
                }
            }
        }
        printf("--------------------\n");
        printf(
            "Test lefpull_dequeue et rigpull_dequeue\n");  // Test
                                                           // lefpull_dequeue et
                                                           // rigpull_dequeue
        printf("--------------------\n");
        for (uint i = 0; i < size_dequeue(dq); i++) {
            assert(lefread_dequeue(dq, i) == i + 1);
            printf("assert(lefread_dequeue(dq, %d) == %d) check\n", i, i + 1);
        }
        printf("--------------------\n");
        printf(
            "Test makeempty_dequeue et copy_dequeue_right in array [1, 20]\n");  // Test makeempty_dequeue et copy_dequeue_right
        printf("--------------------\n");
        dequeue *dq2 = create_dequeue();
        for (uint i = 0; i < 10; i++) {
            makeempty_dequeue(dq2);
            // printf_dequeue(dq2, "makeempty_dequeue", "dq2", -1, -1);
            copy_dequeue_right(dq2, dq, i);
            // printf_dequeue(dq2, "copy_dequeue_right", "dq2", i, -1);
            printf("----------");
            printf(" Test +%d ", i);
            printf("----------\n");
            for (uint j = 0; j < size_dequeue(dq2); j++) {
                assert(lefread_dequeue(dq2, j) == lefread_dequeue(dq, j) + i);
                printf("assert(lefread_dequeue(dq2, %d) == %d) check\n", j,
                       lefread_dequeue(dq, j) + i);
            }
        }
        printf("--------------------\n");
        printf("Test mem_dequeue in array [1, 20]\n");  // Test mem_dequeue
        printf("--------------------\n");
        for (uint i = 0; i < 20; i++) {
            uint value = rand() % 100;
            // printf_dequeue(dq, "mem_dequeue", "dq2", value,
            //                mem_dequeue(value, dq));
            assert(mem_dequeue(value, dq) == (value > 0 && value <= 20));
            printf("assert(mem_dequeue(%d, dq) == %d) check\n", value,
                   (value > 0 && value <= 20));
        }
        if (dq == NULL) delete_dequeue(dq2);
        for (uint k = 0; k < NB_TESTS_OCCUR; k++) {
            dq2 = create_dequeue();
            for (uint i = 0; i < 20; i++) {
                lefins_dequeue(rand() % 100, dq2);
            }
            // printf_dequeue(dq2, "random", "dq2", -1, -1);
            sort_dequeue_norepeat(dq2);
            // printf_dequeue(dq2, "sort_dequeue_norepeat", "dq2", -1, -1);
            printf("--------------------\n");
            printf(
                "Test sort_dequeue_norepeat\n");  // Test sort_dequeue_norepeat
            printf("--------------------\n");
            for (uint i = 0; i < size_dequeue(dq2) - 1; i++) {
                assert(lefread_dequeue(dq2, i) < lefread_dequeue(dq2, i + 1));
                printf(
                    "%u - assert(lefread_dequeue(dq2, %d) < "
                    "lefread_dequeue(dq2, "
                    "%d)) "
                    "check\n",
                    k, i, i + 1);
            }
            // for (uint i = 0; i < 20; i++) {
            //     printf_dequeue(dq2, "mem_dequeue_sorted", "dq2", i,
            //                    mem_dequeue_sorted(i, dq2));
            // }
            printf("--------------------\n");
            printf("Test mem_dequeue_sorted\n");  // Test mem_dequeue_sorted
            printf("--------------------\n");
            for (uint i = 0; i < 20; i++) {
                assert(mem_dequeue_sorted(i, dq2) == mem_dequeue(i, dq2));
                printf("assert(mem_dequeue_sorted(%d, dq2) == %d) check\n", i,
                       mem_dequeue(i, dq2));
            }
            if (dq2 == NULL) delete_dequeue(dq2);
        }
        printf("--------------------\n");
        printf("Test merge_sorted_dequeue\n");  // Test merge_sorted_dequeue
        printf("--------------------\n");
        for (uint k = 0; k < NB_TESTS_OCCUR; k++) {
            dq = create_dequeue();
            dq2 = create_dequeue();
            dequeue *dq3 = create_dequeue();
            for (uint i = 0; i < 10; i++) {
                lefins_dequeue(rand() % 100, dq);
                lefins_dequeue(rand() % 100, dq2);
            }
            sort_dequeue_norepeat(dq);
            sort_dequeue_norepeat(dq2);
            copy_dequeue_right(dq3, dq, 0);
            merge_sorted_dequeue(dq3, dq2);
            for (uint i = 0; i < size_dequeue(dq3) - 1; i++) {
                assert(lefread_dequeue(dq3, i) < lefread_dequeue(dq3, i + 1));
                printf(
                    "%u - assert(lefread_dequeue(dq2, %d) < "
                    "lefread_dequeue(dq2, "
                    "%d)) "
                    "check\n",
                    k, i, i + 1);
            }
            for (uint i = 0; i < size_dequeue(dq3); i++) {
                assert(mem_dequeue_sorted(lefread_dequeue(dq3, i), dq) ||
                       mem_dequeue_sorted(lefread_dequeue(dq3, i), dq2));
                printf(
                    "%u - assert(mem_dequeue_sorted(%d, dq) || "
                    "mem_dequeue_sorted(%d, dq2)) check\n",
                    k, lefread_dequeue(dq3, i), lefread_dequeue(dq3, i));
            }
            for (uint i = 0; i < size_dequeue(dq); i++) {
                assert(mem_dequeue_sorted(lefread_dequeue(dq, i), dq3));
                printf(
                    "%u - assert(mem_dequeue_sorted(leftread_dequeue(dq, %d), "
                    "dq3)) check\n",
                    k, i);
            }
            for (uint i = 0; i < size_dequeue(dq2); i++) {
                assert(mem_dequeue_sorted(lefread_dequeue(dq2, i), dq3));
                printf(
                    "%u - assert(mem_dequeue_sorted(leftread_dequeue(dq2, %d), "
                    "dq3)) check\n",
                    k, i);
            }
            if (dq == NULL) delete_dequeue(dq);
            if (dq2 == NULL) delete_dequeue(dq2);
            if (dq3 == NULL) delete_dequeue(dq3);
        }
        printf("--------------------\n");
        printf(
            "Test make_inter_sorted_dequeue\n");  // Test
                                                  // make_inter_sorted_dequeue
        printf("--------------------\n");
        for (uint k = 0; k < NB_TESTS_OCCUR; k++) {
            dq = create_dequeue();
            dq2 = create_dequeue();
            for (uint i = 0; i < 20; i++) {
                lefins_dequeue(rand() % 100, dq);
                lefins_dequeue(rand() % 100, dq2);
            }
            sort_dequeue_norepeat(dq);
            sort_dequeue_norepeat(dq2);
            dequeue *dq3 = make_inter_sorted_dequeue(dq, dq2);
            for (uint i = 0; i < size_dequeue(dq3); i++) {
                assert(mem_dequeue_sorted(lefread_dequeue(dq3, i), dq) &&
                       mem_dequeue_sorted(lefread_dequeue(dq3, i), dq2));
                printf(
                    "%u - assert(mem_dequeue_sorted(%d, dq) && "
                    "mem_dequeue_sorted(%d, dq2)) check\n",
                    k, lefread_dequeue(dq3, i), lefread_dequeue(dq3, i));
            }
            if (dq == NULL) delete_dequeue(dq);
            if (dq2 == NULL) delete_dequeue(dq2);
            if (dq3 == NULL) delete_dequeue(dq3);
        }
        printf("--------------------\n");
        printf("Test intersec_dequeue\n");  // Test
                                            // intersec_dequeue
        printf("--------------------\n");
        for (uint k = 0; k < NB_TESTS_OCCUR; k++) {
            dq = create_dequeue();
            dq2 = create_dequeue();
            for (uint i = 0; i < 10; i++) {
                lefins_dequeue(rand() % 100, dq);
                lefins_dequeue(rand() % 100, dq2);
            }
            sort_dequeue_norepeat(dq);
            sort_dequeue_norepeat(dq2);
            bool result = intersec_dequeue(dq, dq2);
            dequeue *dq3 = make_inter_sorted_dequeue(dq, dq2);
            assert(result == (size_dequeue(dq3) > 0));
            printf(
                "%u - size_dequeue(make_inter_sorted_dequeue(dq, dq2)) check\n",
                k);
            if (dq == NULL) delete_dequeue(dq);
            if (dq2 == NULL) delete_dequeue(dq2);
        }
        for (uint k = 0; k < NB_TESTS_OCCUR; k++) {
            dq = create_dequeue();
            for (uint i = 0; i < 10; i++) {
                lefins_dequeue(rand() % 100, dq);
            }
            sort_dequeue_norepeat(dq);
            uint val = rand() % 100;
            insert_dequeue(dq, val);
            for (uint i = 0; i < size_dequeue(dq) - 1; i++) {
                assert(lefread_dequeue(dq, i) < lefread_dequeue(dq, i + 1));
                printf(
                    "%u - assert(lefread_dequeue(dq2, %d) < "
                    "lefread_dequeue(dq2, "
                    "%d)) "
                    "check\n",
                    k, i, i + 1);
            }
            assert(mem_dequeue_sorted(val, dq));
            printf("%u - assert(mem_dequeue_sorted(%d, dq)) check\n", k, val);
            if (dq == NULL) delete_dequeue(dq);
        }
        printf("--------------------\n");
        printf("Plus de %d tests effectués avec succès\n", NB_TESTS_OCCUR * 5);
    }
    // Tests de boolarray
    if (TEST_BOOLARRAY) {
        barray *ba = create_barray(10);
        printf_boolarray(ba, NULL, "ba", 0, -1);
        for (uint i = 0; i < 10; i++) {
            if (i % 2 == 0) {
                settrue_barray(ba, i);
                printf_boolarray(ba, "settrue_barray", "ba", i, -1);
            } else {
                setfalse_barray(ba, i);
                printf_boolarray(ba, "setfalse_barray", "ba", i, -1);
            }
        }
        delete_barray(ba);
        ba = create_barray(10);
        for (uint i = 0; i < 10; i++) {
            bool x = rand() % 2;
            if (x) {
                settrue_barray(ba, i);
                printf_boolarray(ba, "settrue_barray", "ba", i, -1);
            } else {
                setfalse_barray(ba, i);
                printf_boolarray(ba, "setfalse_barray", "ba", i, -1);
            }
        }
        barray *ba2 = create_barray(10);
        for (uint i = 0; i < 10; i++) {
            bool x = rand() % 2;
            if (x) {
                settrue_barray(ba2, i);
            } else {
                setfalse_barray(ba2, i);
            }
        }
        printf_boolarray(ba2, NULL, "ba2", -1, -1);
        barray *ba3 = or_barray(ba, ba2);
        printf_boolarray(ba3, "or_barray", "ba3", -1, -1);
        delete_barray(ba3);
        ba3 = and_barray(ba, ba2);
        printf_boolarray(ba3, "and_barray", "ba3", -1, -1);
        delete_barray(ba3);
        delete_barray(ba2);
        printf_boolarray(ba, NULL, "ba", -1, -1);
        ba2 = copy_barray(ba);
        printf_boolarray(ba2, "copy_barray", "ba", -1, -1);
        delete_barray(ba);
    }
}