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

#define delta 100000L

int ArrondirPixel(int nombre) /* Calcule un arrondi du pixel pour pouvoir respecter la norme des 40 lignes et 60 colonnes */
{
    /* Calcul du reste de la division par 15 */
    int reste = nombre % 15;

    /* Calcul de l'arrondi au multiple de 15 le plus proche */
    int arrondi = (reste <= 7) ? nombre - reste : nombre + (15 - reste);

    return arrondi;
}

PIXELS gen_pastille(PIXELS *serpent,PIXELS *pastilles,int longueur_serpent)

                                   /* nb_pastille = int nombre de pastille voulue , p_pastilles est un pointeur d'un tableau de pixels qui sont des pastilles*/
                                   /*Générer une pastille dans la grid*/
                                   /*Code n'est pas complet*/
                                   /*-Elles se génèrent à des endroits qui peuvent être les mêmes ou gêner le snake*/
{
    int x_pastille,y_pastille,i;
    int ok = 0;
    PIXELS pastille;
    do{
        ok = 0;
        x_pastille= ArrondirPixel(rand()%W_GAME);
        y_pastille = ArrondirPixel(rand()%H_GAME);
        for(i=0;i<longueur_serpent;i++)
        {
            if(x_pastille == serpent[i].x && y_pastille == serpent[i].y && x_pastille == pastilles[i].x && y_pastille == pastilles[i].y )
            {
                ok = 1; /* Check si la pastille se genère sur une coordonné du serpent ou d'une pastille existante */
            }

        }       
    }while(ok);

    if(x_pastille < DECALEMENT)
    {
        x_pastille =+ DECALEMENT;
    }

    if(y_pastille < DECALEMENT)
    {
        y_pastille =+ DECALEMENT;
    }


    pastille.x = x_pastille ;
    pastille.y = y_pastille ;

    return pastille;
}

void InitialisationDuSerpent(PIXELS *p_serpent) /* L'initialisation du serpent */
{
    int x_millieu = 0, y_millieu = 0 , compteur = 0;
    couleur j;
    j=CouleurParNom("yellow");
    ChoisirCouleurDessin(j);
    x_millieu = T_PIXEL*30; /* 30 = 60 colonnes divisé par 2*/
    y_millieu = T_PIXEL*20; /* 20 = 40 colonnes divisé par 2*/
    ChoisirEcran(2);
    RemplirRectangle(x_millieu,y_millieu,T_PIXEL,T_PIXEL);

    /* printf("x_millieu : %d | y_millieu : %d\n",x_millieu,y_millieu);        DEBUG*/

    p_serpent[0].x = x_millieu;
    p_serpent[0].y = y_millieu;
    for(compteur=0;compteur<=9;compteur++) /* Commence par 1 car p_serpent index 0 initialisées pour la tête et 2 + 2x9 = 10 couples de coordonnées 2D */
    {
        p_serpent[compteur+1].x = p_serpent[compteur].x+T_PIXEL;
        p_serpent[compteur+1].y = p_serpent[compteur].y;

        /*printf("x_millieu : %d | y_millieu : %d\n",p_serpent[compteur+2],p_serpent[compteur+3]);        DEBUG*/

        RemplirRectangle(p_serpent[compteur+1].x,p_serpent[compteur+1].y,T_PIXEL,T_PIXEL);
    }
}

void DessinerScene(PIXELS *pastilles, PIXELS *serpent, int longueur_serpent) /* Dessine la scène */
{
    couleur c;
    ChoisirEcran(2);
    c=CouleurParNom("lightgreen");
    ChoisirCouleurDessin(c);
    RemplirRectangle(T_PIXEL,T_PIXEL,W_GAME,H_GAME);
    InitialiserPastilles(pastilles,serpent,longueur_serpent);
    InitialisationDuSerpent(serpent);
    
}

int main()
{   
    unsigned char pause = 0;
    unsigned long score =0;
    unsigned long suivant;
    int go_on=1;
    int n = 0;
    int m = 0;
    
    time_t temps;

    size_t longueur_serpent = 12;
    size_t longueur_pastilles = PASTILLES;
    PIXELS *serpent = (PIXELS *)malloc(longueur_serpent * sizeof(PIXELS));
    PIXELS *pastilles = (PIXELS *)malloc(longueur_pastilles * sizeof(PIXELS));

    int direction = 0;
    int direction_davant = 0;

    temps = time(NULL); /*Première mesure du temps*/

    if(serpent == NULL) {
        fprintf(stderr, "Erreur d'allocation de mémoire.\n");
        return EXIT_FAILURE;
    }
    if(pastilles == NULL) {
        fprintf(stderr, "Erreur d'allocation de mémoire.\n");
        return EXIT_FAILURE;
    }


    InitialiserGraphique();
    CreerFenetre(10,10,W_WINDOW,H_WINDOW); /* Peut être changer cette ligne avec la fonction Maxx et Maxy fournie dans graph.h ??*/
    ChoisirTitreFenetre("SNAKE SAE11 IN C");
    DessinerScene(pastilles,serpent,longueur_serpent);

    while(go_on) /* Lancement du cycle pour les Inputs et le Jeu*/
	{   
		if (ToucheEnAttente() == 1)
        {
            switch (Touche())
            {
            case XK_Up:
                direction = 1;
                if(direction_davant == 3 && direction == 1)
                {
                    direction = direction_davant;
                }
                break;
            case XK_Down:
                direction = 3;
                if(direction_davant == 1 && direction == 3)
                {
                    direction = direction_davant;               /* Changements de direction du serpent*/
                }
                break;
            case XK_Left:
                direction = 0;
                if(direction_davant == 2 && direction == 0)
                {
                    direction = direction_davant;
                }
                break;
            case XK_Right:
                direction = 2;
                if(direction_davant == 0 && direction == 2)
                {
                    direction = direction_davant;
                }
                break;

            case XK_space:
                if(pause == 0)
                { 
                    pause = 1 ;
                }                                   /* Faire pause */
                else if(pause == 1) 
                { 
                    pause = 0;
                }
                
            }
        }
		else
		{   if(pause==0){
                
                if (Microsecondes()>suivant)        
			    {                  
                n++;
                if(n%60==0)
                    {
                        m++;
                        n=0;
                    }

                AfficherTimerEtScore(&score,temps);

                suivant=Microsecondes()+delta;

                direction_davant = direction; /* Check si le serpent à le droit de changer de direction */
                MourrirSerpent(serpent,longueur_serpent);
                DeplacementSerpent(direction,serpent,longueur_serpent);
                if(MangerPastille(serpent,pastilles,&score,longueur_serpent) == 1)
                {
                    longueur_serpent+=2;
                    serpent = (PIXELS*) realloc(serpent,longueur_serpent * sizeof(PIXELS));
                }
	            }
            }
            
        }
        }

    FermerGraphique();
    return EXIT_SUCCESS;
}