struct Liste
{
    Element *premier;
    Element *dernier;
};

#include <sdl/sdl.h>
#include <time.h>

/* Dimensions de la grille de jeu */
#define W           50
#define H           50
/* Taille maximale du serpent */
#define MAX_LEN     (W * H)
/* Taille en pixel d'un morceau du serpent */
#define NODE_SIZE   10
/* Nombre de directions */
#define N_DIR       4

/* Une structure pour stocker les coordonnées de la tête de la queue */
typedef struct pos
{
    int lin, col;
} Pos;

typedef struct snake
{
    /* direction actuelle */
    int dir;
    /* indice de la tête et de la queue dans notre tableau */
    int hd, tl;
    /* file implémentée sous forme de tableau */
    Pos nodes[MAX_LEN];
    /* Indique si le snake grandit ou pas */
    SDL_bool grow;
    /* Le sanke est mort ? */
    SDL_bool dead;
} Snake;

/* Contenu possbile pour une case de la grille */
enum {EMPTY, SNAKE, APPLE};
/* Directions possibles, pour clarifier la gestion des touches */
enum {UP, RIGHT, DOWN, LEFT};

void Snake_init( Snake *snk, int ( *grd )[W] );
SDL_bool Snake_alive( Snake *snk, int ( *grd )[W] );
void Snake_move( Snake *snk, int ( *grd )[W] );
void Game_init( Snake *snk, int ( *grd )[W] );
void Game_newApple( int ( *grd )[W] );
void Game_display( int ( *grd )[W] );

/* Game --------------------------------------------------------------------- */
void Game_init( Snake *snk, int ( *grd )[W] )
{
    Snake_init( snk, grd );
    Game_newApple( grd );
}


/* Place une pomme dans la grille en prenant garde de na pas la
 * placer sur le serpent.
 * La méthode est très laide...
 */
void Game_newApple( int ( *grd )[W] )
{
    int lin, col;
    do
    {
        lin = rand() % H;
        col = rand() % W;
    } while( grd[lin][col] != EMPTY );

    grd[lin][col] = APPLE;
}

/* On affiche simplement le contenu de la grille à l'ecran */
void Game_display( int ( *grd )[W] )
{
    int lin, col;
    SDL_Surface *screen = SDL_GetVideoSurface();

    SDL_FillRect( screen, NULL, 0 );
    for( lin = 0; lin < H; lin++ )
    {
        for( col = 0; col < W; col++ )
        {
            if( grd[lin][col] != EMPTY )
            {
                SDL_Rect dst;
                dst.x = NODE_SIZE * col + 1;
                dst.y = NODE_SIZE * lin + 1;
                dst.w = NODE_SIZE - 1;
                dst.h = NODE_SIZE - 1;
                if( grd[lin][col] == SNAKE )
                    SDL_FillRect( screen, &dst, SDL_MapRGB( screen->format, 255, 255, 255 ) );
                if( grd[lin][col] == APPLE )
                    SDL_FillRect( screen, &dst, SDL_MapRGB( screen->format, 255, 0, 0 ) );
            }
        }
    }
}
/* Snake -------------------------------------------------------------------- */
/* On initialise tous les champs de notre structure */
void Snake_init( Snake *snk, int ( *grd )[W] )
{
    Pos startPos;
    /* Au début du jeu, bah la tête c'est la queue ! */
    snk->hd = 0;
    snk->tl = 0;

    snk->dead = SDL_FALSE;
    snk->grow = SDL_FALSE;
    /* Le milieu de l'ecran */
    startPos.lin = H / 2;
    startPos.col = W / 2;
    /* On place la tête dans la grille */
    grd[startPos.lin][startPos.col] = SNAKE;
    /* On renseigne les coordonnées de la tête */
    snk->nodes[snk->hd] = startPos;
    /* On choisi une direction au hasard */
    snk->dir = rand() % N_DIR;
}

/* On teste si tête du snake est dans les limites de la grille et qu'il ne
 * se mange pas.
 */
SDL_bool Snake_alive( Snake *snk, int ( *grd )[W] )
{
    int lin = snk->nodes[snk->hd].lin;
    int col = snk->nodes[snk->hd].col;

    return lin >= 0 && lin < H
           && col >= 0 && col < W
           && grd[lin][col] != SNAKE;
}


/* Déplacement du serpent */
void Snake_move( Snake *snk, int ( *grd )[W] )
{
    /* Nos 4 directions
     * Chaque direction est représentée par un couple lin, col
     */
    static const Pos dir[N_DIR] = {{ -1, 0}, {0, 1}, {1, 0}, {0, -1}};

    /* Position actuelle de la tête */
    Pos hdPos = snk->nodes[snk->hd];
    /* Position actulle de la queue */
    Pos tlPos = snk->nodes[snk->tl];

    if( !snk->grow )
    {
        /* Le serpent ne grandit pas
        * on efface l'ancienne queue */
        grd[tlPos.lin][tlPos.col] = EMPTY;
        /* On avance dans la file circulaire
         * % MAX_LEN pour resté dans l'intervalle [0, MAX_LEN[ */
        snk->tl = ( snk->tl + 1 ) % MAX_LEN;
    }
    else
    {
        /* Le serpent grandit, la queue reste en place */
        /* il ne grandira pas 2 fois de suite  */
        snk->grow = SDL_FALSE;
    }

    /* On avance la tête, dans la file circulaire */
    snk->hd = ( snk->hd + 1 ) % MAX_LEN;
    /* On calcule la nouvelle position de la tête */
    hdPos.lin += dir[snk->dir].lin;
    hdPos.col += dir[snk->dir].col;
    snk->nodes[snk->hd] = hdPos;

    if ( Snake_alive( snk, grd ) )
    {
        /* La nouvelle position de la tête est valide */
        if( grd[hdPos.lin][hdPos.col] == APPLE )
        {
            /* On a mangé une pomme */
            /* Le serpent grandira au tour prochain */
            snk->grow = SDL_TRUE;
            /* On place une nouvelle pomme */
            Game_newApple( grd );
        }
        /* On place un morceau de serpent au coordonnées de la nouvelle tête
         * dans la grille
         */
        grd[hdPos.lin][hdPos.col] = SNAKE;
    }
    else
    {
        /* La case n'est pas valide
         * -> couic le snake
         */
          snk->dead = SDL_TRUE;
    }
}


int main( int argc, char *argv[] )
{
    SDL_Surface *screen;
    Uint8 *keys;
    Snake snake;
    static int grid[H][W];
    if( SDL_Init( SDL_INIT_VIDEO ) < 0 )
    {
        fprintf( stderr, "%s\n", SDL_GetError() );
        exit ( EXIT_FAILURE );
    }

    screen = SDL_SetVideoMode( W * NODE_SIZE, H * NODE_SIZE, 32, SDL_SWSURFACE );
    if( screen == NULL )
    {
        fprintf( stderr, "%s\n", SDL_GetError() );
        exit ( EXIT_FAILURE );
    }

    srand( ( unsigned )time( NULL ) );

    keys = SDL_GetKeyState( NULL );

    Game_init( &snake, grid );

    while( !SDL_QuitRequested() && !snake.dead )
    {
        SDL_PumpEvents();
        if( keys[SDLK_LEFT] )
            snake.dir = LEFT;
        else if( keys[SDLK_RIGHT] )
            snake.dir = RIGHT;
        else if( keys[SDLK_UP] )
            snake.dir = UP;
        else if( keys[SDLK_DOWN] )
            snake.dir = DOWN;

        Snake_move( &snake, grid );

        Game_display( grid );

        /* La flemme de faire une gestion de fps */
        SDL_Delay( 40 );
        SDL_Flip( screen );
    }
    /* Pour éviter un warning */
    (void)argc;
    (void)argv;
    SDL_Quit();

    return EXIT_SUCCESS;
}