/**
 * \file function.c
 * Ce fichier contient toute les fonction utile pour le jeu. Sauf pour
 * l'affichage.
 *
 */

#include "../include/function.h"
#include "../include/display.h"

#include <SDL2/SDL_events.h>
#include <SDL2/SDL_keycode.h>
#include <SDL2/SDL_render.h>
#include <SDL2/SDL_scancode.h>
#include <SDL2/SDL_timer.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

/**
 * \brief Cette fonction permet de creer une liste 2D carre
 * \param N La valeur N est le nombre d'élément dans le tableau.
 * \return Le pointeur du tableau 2D carre de char (1 octet).
 */
char **creatArea2D (const int x, const int y)
{
    char **tab2d;
    tab2d = calloc (x, sizeof (char *));
    if (tab2d == NULL)
    {
        return NULL;
    }

    bool fail = false;
    int i;
    for (i = 0; i < x && !fail; ++i)
    {
        tab2d[i] = calloc (y, sizeof (char));
        if (tab2d[i] == NULL)
        {
            fail = true;
        }
    }

    if (fail)
    {
        int j;
        for (j = 0; j < i; ++j)
        {
            free (tab2d[j]);
        }
        free (tab2d);
        return NULL;
    }
    return tab2d;
}

/**
 * \brief Cette fontion permet de liberer l'espace tu tableau 2D de char.
 * \param tab Le tableau 2D.
 * \param N Le nombre d'éléments.
 * \return Void.
 */
void free2D (char **tab, int x)
{
    int i;
    for (i = 0; i < x; ++i)
    {
        free (tab[i]);
    }
    free (tab);
    return;
}

/**
 * \brief La fontction permet de savoir si le joueur peut ce deplacer dans une
 * direction.
 * \param valueOfNCase La valeur de la case dans la direction que le joueur
 * veut aller.
 * \param valueOfNPlusOneCase La valeur de la case dans la direction que le
 * joueur veut aller mais une fois de plus.
 * \return 0 Si c'est un mur devant le joueur, 1 si c'est vide devant le
 * joueur, 2 si c'est une boite mais qu'on peux la pousser ,3 si le joueur
 * pousse une boite sur un point d'interer, 4 si le joueur bouge sur un point
 * d'interer, 5 si le joueur peux pousser une boite mais le joueur se place sur
 * un point d'interer et 6 si le joeuur pousse une boite sur un point d'interer
 * et que le joueu est aussi sur un point d'interer.
 */
char canIGoDirection (char valueOfNCase, char valueOfNPlusOneCase)
{
    if (valueOfNCase != WALL)
    {
        if ((valueOfNCase == BOX && valueOfNPlusOneCase == EMPTY)
            || (valueOfNCase == BOX && valueOfNPlusOneCase == TARGET))
        {
            if (valueOfNPlusOneCase == TARGET)
            {
                // Box on target
                return 3;
            }
            // move the box
            return 2;
        }
        if ((valueOfNCase == BOX_ON_TARGET && valueOfNPlusOneCase == EMPTY)
            || (valueOfNCase == BOX_ON_TARGET
                && valueOfNPlusOneCase == TARGET))
        {
            if (valueOfNPlusOneCase == TARGET)
            {
                // Box on target and player on target too
                return 6;
            }
            // move the box but player on a target
            return 5;
        }
        if (valueOfNCase == BUTTON)
        {
            return 7;
        }
        if (valueOfNCase == TARGET)
        {
            // move player on target
            return 4;
        }

        if (valueOfNCase == EMPTY)
        {
            // move player
            return 1;
        }
    }

    return 0;
}

/**
 * \brief Cette fonction effectue les deplacements du joueur et des boites en
 * fonction de la situation.
 * \param tab Le tableau 2D du plateau de jeu.
 * \param playerpos La position actuel du joueur.
 * \param direction La direction que le joueur veut effectuer.
 * \param score_user Toutes les données nécessaire pour calculer le score fini
 * du joueur.
 * \return Void
 *
 */
void move (char **tab, vect *playerPos, vect direction, score *score_user)
{
    short int valueOfNCase
        = tab[playerPos->x + direction.x][playerPos->y + direction.y];

    vect add = plusVect (*playerPos, direction);
    add = plusVect (add, direction);
    short int valueOfNPlusOneCase;

    if (add.x < 0 || add.y < 0)
    {
        valueOfNPlusOneCase = WALL;
    }
    else
    {
        valueOfNPlusOneCase = tab[add.x][add.y];
    }

    short int returnValue
        = canIGoDirection (valueOfNCase, valueOfNPlusOneCase);
    short int playerState = tab[playerPos->x][playerPos->y];

    if (returnValue != 0)
        score_user->move_player++;

    switch (returnValue)
    {
    case 0:

        break;
    case 1:
        // move player
        tab[playerPos->x + direction.x][playerPos->y + direction.y] = PLAYER;
        break;
    case 2:
        // move player and the box

        tab[playerPos->x + direction.x][playerPos->y + direction.y] = PLAYER;
        tab[playerPos->x + direction.x * 2][playerPos->y + direction.y * 2]
            = BOX;
        score_user->move_box++;
        break;
    case 3:
        // move player and the box is well-placed

        tab[playerPos->x + direction.x][playerPos->y + direction.y] = PLAYER;
        tab[playerPos->x + direction.x * 2][playerPos->y + direction.y * 2]
            = BOX_ON_TARGET;
        score_user->move_box++;
        break;
    case 4:
        // move player on a target

        tab[playerPos->x + direction.x][playerPos->y + direction.y]
            = PLAYER_ON_TARGET;
        break;
    case 5:
        // move box and player on a target

        tab[playerPos->x + direction.x * 2][playerPos->y + direction.y * 2]
            = BOX;
        tab[playerPos->x + direction.x][playerPos->y + direction.y]
            = PLAYER_ON_TARGET;
        score_user->move_box++;
        break;
    case 6:
        // move player on a target and box on a target

        tab[playerPos->x + direction.x * 2][playerPos->y + direction.y * 2]
            = BOX_ON_TARGET;
        tab[playerPos->x + direction.x][playerPos->y + direction.y]
            = PLAYER_ON_TARGET;
        score_user->move_box++;
        break;
    case 7:
        tab[playerPos->x + direction.x][playerPos->y + direction.y]
            = PLAYER_ON_BUTTON;
        break;
    default:
        printf ("Commande inconnue !\n");
    }

    if (returnValue != 0)
    {
        if (playerState == PLAYER_ON_TARGET)
        {
            tab[playerPos->x][playerPos->y] = TARGET;
        }
        else if (playerState == PLAYER_ON_BUTTON)
        {
            tab[playerPos->x][playerPos->y] = BUTTON;
        }
        else
        {
            tab[playerPos->x][playerPos->y] = EMPTY;
        }
        playerPos->x = playerPos->x + direction.x;
        playerPos->y = playerPos->y + direction.y;
    }
}

/**
 *
 * \brief La fonction permet de faire la boucle de jeu et le menu.
 * \param tab2d Le tableau 2d carre.
 * \param N LE nombre d'element de tab2d.
 * \param playerPos La position de depart du joueur.
 * \param targets Le tableau de toutes les positions des points d'interer de la
 * maps.
 * \param int nbr_targets Le nombre de point d'interer.
 * \param display_user Tout les information SDL pour afficher le jeu.
 * \param score_user Toute les données nécessaire pour calculer le score fini
 * du joueur.
 *\param menu True si c'est la loop du menu.
 * \return L'indice de la map si c'est un menu, sinon renvoie -1
 */
int inGameLoop (char **tab2d, vect *dim_tab, vect *playerPos, vect *targets,
                int nbr_targets, dis *display_user, score *score_user,
                bool menu)
{
    int fov = -1;
    int indice_button = -1;

    vect size_menu
        = { display_user->size_menu - 10, display_user->size_window / 3 - 10 };
    vect coor_time
        = { 10, display_user->size_window - display_user->size_menu + 10 };
    vect coor_move_player
        = { display_user->size_window / 3 + 10,
            display_user->size_window - display_user->size_menu + 10 };
    vect coor_move_box
        = { (display_user->size_window / 3) * 2 + 10,
            display_user->size_window - display_user->size_menu + 10 };

    if (menu)
        fov = 5;
    else
    {
        displayTextSDL (display_user, "MP : 0", coor_move_player, size_menu,
                        50);
        displayTextSDL (display_user, "MB : 0", coor_move_box, size_menu, 50);
    }

    time_t time_start = time (NULL);
    time_t current_time = time (NULL);
    time_t delay = 0;
    vect direction = { 0, 0 };

    char input;
    bool finish = false;
    SDL_Event event;
    screenDisplayGameSDL (tab2d, *dim_tab, display_user, playerPos, fov);
    while (!finish)
    {
        while (SDL_PollEvent (&event))
        {
            if (event.type == SDL_KEYDOWN)
            {
                input = event.key.keysym.scancode;
                switch (input)
                {
                case SDL_SCANCODE_ESCAPE:
                    if(menu) return 0;
                    return -1;
                    finish = true;
                    break;
                case SDL_SCANCODE_D:
                    direction.y = 1;
                    direction.x = 0;
                    break;
                case SDL_SCANCODE_A:
                    direction.y = -1;
                    direction.x = 0;
                    break;
                case SDL_SCANCODE_W:
                    direction.x = -1;
                    direction.y = 0;
                    break;
                case SDL_SCANCODE_S:
                    direction.x = 1;
                    direction.y = 0;
                    break;
                case SDL_SCANCODE_RETURN:
                    if (tab2d[playerPos->x][playerPos->y] == PLAYER_ON_BUTTON)
                        return indice_button;
                    break;
                default:
                    direction.x = 0;
                    direction.y = 0;
                }
                move (tab2d, playerPos, direction, score_user);
                screenDisplayGameSDL (tab2d, *dim_tab, display_user, playerPos,
                                      fov);
                if (!menu)
                {

                    char nbr_p[20];
                    snprintf (nbr_p, 20, "MP : %d", score_user->move_player);
                    char nbr_b[20];
                    snprintf (nbr_b, 20, "MB : %d", score_user->move_box);

                    displayTextSDL (display_user, nbr_p, coor_move_player,
                                    size_menu, 50);
                    displayTextSDL (display_user, nbr_b, coor_move_box,
                                    size_menu, 50);
                    if (isWin (tab2d, targets, nbr_targets))
                    {
                        puts ("Win!");
                        finish = true;
                    }
                    if (islose (tab2d, dim_tab->x))
                    {
                        puts ("lose!");
                        finish = true;
                    }
                }
                else if (tab2d[playerPos->x][playerPos->y] == PLAYER_ON_BUTTON)
                {
                    vect size_txt = { display_user->size_menu,
                                      display_user->size_window };
                    char txt_empty[100]
                        = "                                                   "
                          "                      ";
                    displayTextSDL (display_user, txt_empty, coor_time,
                                    size_txt, 100);
                    char txt_button[50] = "";
                    indice_button = playerPos->y / 5;
                    if (indice_button <= 3)
                    {
                        snprintf (txt_button, 50,
                                  "Voulez-vous faire le niveau Original %d ?",
                                  indice_button);
                    }
                    else if (indice_button == dim_tab->y / 5)
                    {
                        snprintf (txt_button, 50,
                                  "Voulez-vous faire une map Custom (%d)?",
                                  indice_button - 3);
                    }
                    else
                    {
                        snprintf (txt_button, 50,
                                  "Voulez-vous faire le niveau Custom %d ?",
                                  indice_button - 3);
                    }
                    displayTextSDL (display_user, txt_button, coor_time,
                                    size_txt, 50);
                }
                else
                {
                    vect size_txt = { display_user->size_menu,
                                      display_user->size_window };
                    char txt_empty[100]
                        = "Echap pour quitter                                   ";
                    displayTextSDL (display_user, txt_empty, coor_time,
                                    size_txt, 80);
                }
            }
        }
        current_time = time (NULL);
        if (current_time > delay)
        {
            delay = current_time;
            char *char_time = timeToText (time (NULL) - time_start);
            if (!menu)
                displayTextSDL (display_user, char_time, coor_time, size_menu,
                                50);
            free (char_time);
        }

        SDL_Delay (16);
    }
    return -1;
}

/**
 * \brief Cette fonction verrifie si la partie est gagnante.
 * \param tab2d Le tableau 2D du jeu.
 * \param targets Le tableau de toute les positions des points d'interer.
 * \param nbr_targets Le nombre de points d'interer.
 * \return True si le joueur a remplis tout les points d'interer, false si ce
 * n'est pas le cas .
 */
bool isWin (char **tab2d, vect *targets, int nbr_targets)
{
    int i;
    for (i = 0; i < nbr_targets; ++i)
    {
        int x = targets[i].x;
        int y = targets[i].y;
        if (tab2d[x][y] != BOX_ON_TARGET)
        {
            return false;
        }
    }
    return true;
}

/**
 * \brief La fonction renvois si la partie est perdante.
 * \param tab2d Le tableau 2d carre du plateau de jeu.
 * \param N Le nombre d'éléments dans le tab2d.
 * \return True si c'est perdu, false si c'est pas perdu a cette instant.
 *
 */
bool islose (char **tab2d, const int N)
{
    int x = 0, y = 0;
    for (x = 0; x < N; ++x)
    {
        for (y = 0; y < N; ++y)
        {
            bool isblock = false;
            if (tab2d[x][y] == BOX)
            {
                vect box;
                box.x = x;
                box.y = y;
                isblock = blockBox (tab2d, box);
            }

            if (isblock)
            {
                return true;
            }
        }
    }
    return false;
}

/**
 * \brief La fonction fait une addition de vecteur, (x1+x2, y1+y2).
 * \param one Premier vecteur.
 * \param two Deuzieme vecteur.
 * \return vect Un vecteur de l'addition de one et two.
 */
vect plusVect (vect one, vect two)
{
    vect result;
    result.x = one.x + two.x;
    result.y = one.y + two.y;
    return result;
}

/**
 * \brief Renvois la longeur Manhattan
 */
int lengthVect (vect vector) { return abs (vector.x) + abs (vector.y); }

/**
 * \brief La fonction permet de savoir si une boite est dans une situation ou
 * le joueur ne poura pas la debloqué.
 * \param tab2d Le tableau 2D carre du plateau de jeu.
 * \param box_coor Les corrdonnée de la boite que la fonction test.
 * \return True si la la boite est bloquer, sinon false.
 */
bool blockBox (char **tab2d, vect box_coor)
{
    int nbr_touch = 0;
    vect card[4] = { { 0, -1 }, { 1, 0 }, { 0, 1 }, { -1, 0 } };
    int indice_card[4] = { 0 };
    int id_box = -1;
    int i;
    for (i = 0; i < 4; ++i)
    {
        vect test = plusVect (box_coor, card[i]);
        char val = tab2d[test.x][test.y];
        if (val == BOX || val == WALL || val == BOX_ON_TARGET)
        {
            nbr_touch++;
            if (val == BOX || val == BOX_ON_TARGET)
            {
                id_box = nbr_touch - 1;
            }
            indice_card[nbr_touch - 1] = i;
        }
    }
    if (nbr_touch == 0)
        return false;

    if (nbr_touch >= 3)
    {
        if (id_box != -1)
        {
            vect other1 = card[indice_card[(id_box + 1) % 3]];
            vect other2 = card[indice_card[(id_box + 2) % 3]];
            vect test_add_other = plusVect (other1, other2);
            vect coor_box = plusVect (card[indice_card[id_box]], box_coor);
            vect other_plus_box1 = plusVect (other1, coor_box);
            vect other_plus_box2 = plusVect (other2, coor_box);
            int val1 = tab2d[other_plus_box1.x][other_plus_box1.y];
            int val2 = tab2d[other_plus_box2.x][other_plus_box2.y];

            if (test_add_other.x == 0 && test_add_other.y == 0)
            {

                if ((val1 == WALL || val1 == BOX || val1 == BOX_ON_TARGET)
                    || (val2 == WALL || val2 == BOX || val2 == BOX_ON_TARGET))
                {
                    return true;
                }
                return false;
            }
        }
        return true;
    }

    if (nbr_touch == 2)
    {
        int id1 = indice_card[0];
        int id2 = indice_card[1];
        vect add = plusVect (card[id1], card[id2]);
        if (lengthVect (add) == 2)
        {
            if (id_box == -1)
                return true;
            vect test = plusVect (card[indice_card[id_box]],
                                  card[indice_card[(id_box + 1) % 2]]);
            test = plusVect (test, box_coor);
            if (tab2d[test.x][test.y] == WALL)
                return true;
        }
        return false;
    }

    vect normal = card[indice_card[0]];
    vect director1 = card[(indice_card[0] + 1) % 4];
    vect director2 = card[(indice_card[0] + 1) % 4];
    vect dir_test[2] = { director1, director2 };

    bool wall = false;

    for (int i = 0; i < 2; ++i)
    {
        vect current = plusVect (box_coor, dir_test[i]);
        while (!wall)
        {
            char val = tab2d[current.x][current.y];
            if (val == WALL)
                wall = true;
            if (val == TARGET)
                return false;

            vect cur_nor = plusVect (current, normal);
            val = tab2d[cur_nor.x][cur_nor.y];
            if (val != WALL || val != BOX || val != BOX_ON_TARGET)
            {
                return false;
            }
        }
    }
    return true;
    perror ("error in blockBox");
    exit (0);
}

/**
 * \brief Cette fonction renvois transforme le forma time en texte. (min:sec)
 * \param time Le temps qu'on veux convertire.
 * \return char Le string du texte.
 */
char *timeToText (time_t time)
{
    char *result = calloc (20, sizeof (char));
    result[0] = '\0';
    unsigned int min = time / 60;
    unsigned int sec = time % 60;
    snprintf (result, 20, "Time : %02d:%02d", min, sec);
    return result;
}

void nullScore(score *player_score)
{
    player_score->after = 0;
    player_score->before = 0;
    player_score->move_box = 0;
    player_score->move_player = 0;
}