#include <GL/glfw.h>
#include <stdio.h>
#include <time.h>
#include <stdlib.h>

#define	MAX_PARTICULES 50
#define	MAX_TIRS 5

typedef struct Projectile Projectile; // Alias Projectile
struct Projectile
{
    int active; // Activé ou non
    float vie; // Durée de vie des particules

    float size; // Taille des la particule

    long particuleX;   // Coordonnées des particules
    long particuleY;

    float fondu;    // Effet de fondu des particules

    long projectileX; // Coordonées Du projectile
    long projectileY;
};
Projectile projectiles[MAX_PARTICULES][MAX_TIRS]; // Creation d'un tableau de particules a deux dimension une pour les particules et une pour les projectiles

/****************Variables Globales*************************/
int		width, height; // Variable de hauteur largeur pour garder le ratio pdt la redimension
int resetI, resetJ; // Variable de deffilement Reset
int i, j; // Variable de defilement des tableaux
/***********************************************************/

/**************Variable de Gestion du Clavier***************/
long clavierX; // Detection du clavier
long clavierY;

bool Gauche; //Gestion des touches Repetées
bool Droite;
bool Haut;
bool Bas;
/***********************************************************/

/****************Declaration des Fonctions******************/
void GLFWCALL clavier( int touche, int action ); // Fonction de gestion du clavier

void reset(int *i, int *j); // Fonction de gestion des particules
void active ();
void deplace();
void affiche();
void efface();
/***********************************************************/

int main()
{
    int		frame = 0; // Frame à 0
    bool	running = true; // Le programme tourne !

    /*****************Variables du Jeu************************/
    /*********************************************************/

    glfwInit(); // Initialisation de GLFW , avec gestion des erreurs

    if( !glfwOpenWindow( 512, 512, 0, 0, 0, 0, 0, 0, GLFW_WINDOW ) ) // initialisation de la fennetre
    {
        glfwTerminate();
        return 0;
    }

    glfwDisable( GLFW_KEY_REPEAT ); // Desactivation de la repetition des touches

    glfwSetWindowTitle("Projectile Test"); // Titre de la fenetre

    /******************Parametres OpenGL***********************/
    glBlendFunc(GL_SRC_ALPHA, GL_ONE); //Active le blending et change en additif
    glEnable(GL_BLEND);

    glMatrixMode( GL_PROJECTION ); // Mode d'affichage, ici 2D alors projection
    glLoadIdentity(); // On initialise la matrice
    gluOrtho2D(0,500,0,500); // On definie le repere associé à la fenetre
    /**********************************************************/

    /***********************Fonctions**************************/
    glfwSetKeyCallback(clavier);
    /**********************************************************/

    /*********************Initialisation***********************/
    for ( j=0; j<MAX_TIRS; j++)
        {
            active();
        }
    /**********************************************************/
    while(running) // Boucle d'affichage
    {
        frame++; //Une frame en plus !

        glfwGetWindowSize( &width, &height );   // Taille de la page pour avoir le ratio
        height = height > 0 ? height : 1;

        glViewport( 0, 0, width, height ); // Position d'ouverture de la fenetre

        glClearColor( 0.0, 0.0, 0.0, 0.0 ); // Couleur de fond De la fenetre
        glClear( GL_COLOR_BUFFER_BIT );

        /********************Clavier*******************************/
        if (Gauche == true)
        {
            if(clavierX > 0)
                clavierX--;
        }
        if (Droite == true)
        {
            if(clavierX < height )
                clavierX++;
        }
        /**********************************************************/
        /***************Affichage des particules*******************/
        for ( j=0; j<MAX_TIRS; j++)
        {
            deplace();
            affiche();
        }
        /**********************************************************/
        glfwSwapBuffers(); // On affiche le tout !

        running = !glfwGetKey(GLFW_KEY_ESC) && glfwGetWindowParam( GLFW_OPENED); // Si ESC ou fenetre fermée on arrete le programme !
    }

    glfwTerminate(); // Et on quitte GLFW

    return 0;
}

void active ()
{
    for (i=0; i<MAX_PARTICULES; i++)
    {
        projectiles[i][j].active=0;
    }
}

void reset(int i, int varj) // Fonction de reinitialisation des particules , executée au debut
{
    printf ("%d", projectiles[i][varj].active);
    if (projectiles[i][varj].active == 0)
    {
        for (i=0; i<MAX_PARTICULES; i++)
        {
            projectiles[i][varj].active=1;

            projectiles[i][varj].vie=0.5;
            projectiles[i][varj].fondu=float(rand()%100)/1000.0f+0.003f;

            projectiles[i][varj].projectileY=0;
            projectiles[i][varj].projectileX=clavierX;

            projectiles[i][varj].particuleX=projectiles[i][varj].projectileX;
            projectiles[i][varj].particuleY=projectiles[i][varj].projectileY;

            projectiles[i][varj].size=3.5;
        }
    }
}

void affiche() // Fonction qui affiche les particules des projectiles
{
    for (i=0; i<MAX_PARTICULES; i++) // Boucle de generation des particules
    {
        if (projectiles[i][j].active == 1)
        {
            long x=projectiles[i][j].particuleX;
            long y=projectiles[i][j].particuleY;
            float s=projectiles[i][j].size;

            glColor4f(1,0.8,0.8,projectiles[i][j].vie);
            glBegin(GL_QUADS);
                glVertex2f (x-s,y-s);
                glVertex2f (x+s,y-s);
                glVertex2f (x+s,y+s);
                glVertex2f (x-s,y+s);
            glEnd();

            projectiles[i][j].vie-=projectiles[i][j].fondu; // fondu des particules

            if (projectiles[i][j].vie <= 0) // Si la particule est morte on la regenere
            {
                projectiles[i][j].vie=0.5;
                projectiles[i][j].fondu=float(rand()%100)/1000.0f+0.003f;

                projectiles[i][j].particuleX=projectiles[i][j].projectileX;
                projectiles[i][j].particuleY=projectiles[i][j].projectileY;
            }

            if (projectiles[i][j].projectileY > (height+20))
            {
                for (i=0; i<MAX_PARTICULES; i++)
                {
                    projectiles[i][j].active=0;

                    projectiles[i][j].vie=0.5;
                    projectiles[i][j].fondu=float(rand()%100)/1000.0f+0.003f;

                    projectiles[i][j].projectileY=0;
                    projectiles[i][j].projectileX=0;

                    projectiles[i][j].particuleX=projectiles[i][j].projectileX;
                    projectiles[i][j].particuleY=projectiles[i][j].projectileY;

                    projectiles[i][j].size=3.5;
                }
            }
        }
    }
}

void efface() // Fonction de la disparition des particules
{
    for (i=0; i<MAX_PARTICULES; i++) // Idem generation sauf qu'il n'y a plus de regeneration
    {
        if ( projectiles[i][j].active == 1)
        {
            long x=projectiles[i][j].particuleX;
            long y=projectiles[i][j].particuleY;
            float s=projectiles[i][j].size;

            glColor4f(1,0.5,0.5,projectiles[i][j].vie);
            glBegin(GL_QUADS);
                glVertex2f (x,y);
                glVertex2f (x+s,y);
                glVertex2f (x+s,y+s);
                glVertex2f (x,y+s);
            glEnd();

            projectiles[i][j].vie-=projectiles[i][j].fondu; // fondu des particules
            projectiles[i][j].size-=0.1;
        }
    }
}

void deplace()
{
    for (i=0; i<MAX_PARTICULES; i++)
    {
        if ( projectiles[i][j].active == 1)
        {
            projectiles[i][j].projectileY+=2;
        }
    }
}

void GLFWCALL clavier(int touche, int action) // Fonction de gestion du clavier
{
    if(action == GLFW_PRESS)
    {
        switch(touche)
        {
            case GLFW_KEY_UP:
                reset(resetI, resetJ);
                resetJ++;
                if ( resetJ > MAX_TIRS )
                    resetJ = 0;
            break;

            case GLFW_KEY_DOWN:
            break;

            case GLFW_KEY_LEFT:
                Gauche=true;
            break;

            case GLFW_KEY_RIGHT:
                Droite=true;
            break;
        }
    }
    else
    {
        switch(touche)
        {
            case GLFW_KEY_UP:
            break;

            case GLFW_KEY_DOWN:
            break;

            case GLFW_KEY_LEFT:
                Gauche=false;
            break;

            case GLFW_KEY_RIGHT:
                Droite=false;
            break;
        }
    }
}