/**** Bibliotheque graphique ****/

/** Fichiers d'inclusion **/

#include <SDL/SDL.h>
#include <SDL/SDL_ttf.h>
#include "libgraph.h"

/** Types **/

typedef struct
{
    int r, v, b;
} couleur;

/** Constantes **/

#define BITS_PAR_PIXEL 32
#define TAILLE_POLICE 20

static const couleur couleurs[] = { { 255, 255, 255 }, { 0, 0, 0 },   { 255, 0, 0 },
                                    { 0, 255, 0 },     { 0, 0, 255 }, { 255, 105, 180 },
                                    { 150, 150, 150 }, { -1, -1, -1 } };

static const char policeDefaut[]="/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf";

/** Variables globales **/

static SDL_Surface *surface;
TTF_Font* police;

/** Fonctions **/

void choisirPolice(const char *chemin, int taille){
  police=TTF_OpenFont(chemin, taille);
}

void initialiserTexte() {
  TTF_Init();
  choisirPolice(policeDefaut, TAILLE_POLICE);
}

/* Initialisation de la surface dessinable */
unsigned char creerSurface (int largeur, int hauteur, char *titre)
{
    SDL_Init (SDL_INIT_VIDEO);
    SDL_WM_SetCaption (titre, titre);
    surface = SDL_SetVideoMode (largeur, hauteur, BITS_PAR_PIXEL, SDL_DOUBLEBUF);
    initialiserTexte();
    
    return (surface != NULL && police != NULL);
}

/* Fermeture de la surface dessinable */

void fermerSurface (void)
{
    if (surface != NULL) SDL_FreeSurface (surface);
    if (police != NULL) TTF_CloseFont(police);
    TTF_Quit();
    SDL_Quit ();
}

/* Creation d'une couleur */

static int creerCouleur (int ncouleur)
{
    couleur c = couleurs[ncouleur];
    return SDL_MapRGB (surface->format, c.r, c.v, c.b);
}

/* Dessin d'un rectangle plein */

void rectanglePlein (int x, int y, int l, int h, int c)
{
    SDL_Rect rectangle = { x, y, l, h };
    SDL_FillRect (surface, &rectangle, creerCouleur (c));
    // SDL_Flip(surface);
}

/* Manipulation de lutins */

static SDL_Surface *lutins[MAX_LUTINS];
static int          lutins_nb = 0;

int lutinTexte(char* texte, int couleurTexte) {
  couleur c=couleurs[couleurTexte];
  SDL_Color couleur={c.r, c.v, c.b};
  SDL_Surface* lutin=TTF_RenderText_Solid(police, texte, couleur);
  if (lutin != NULL)
    {
      lutins[lutins_nb++] = lutin;
      return lutins_nb - 1;
    }
  return -1;
}

static void configurerLutin (SDL_Surface *lutin, int ncouleur)
{
    couleur c    = couleurs[ncouleur];
    int     fond = SDL_MapRGB (lutin->format, c.r, c.v, c.b);
    SDL_SetColorKey (lutin, SDL_SRCCOLORKEY | SDL_RLEACCEL, fond);
}

int chargerLutin (char *fichier, int couleur)
{
    if (lutins_nb >= MAX_LUTINS) return -2;
    SDL_Surface *lutin = SDL_LoadBMP (fichier);
    if (lutin != NULL)
    {
        lutins[lutins_nb++] = lutin;
        if (couleur >= 0) configurerLutin (lutin, couleur);
        return lutins_nb - 1;
    }
    return -1;
}

void afficherLutin (int lutin, int x, int y)
{
    SDL_Rect position;
    position.x = x;
    position.y = y;
    SDL_BlitSurface (lutins[lutin], NULL, surface, &position);
}

int creerLutin (int x, int y, int largeur, int hauteur, int couleur)
{
    if (lutins_nb >= MAX_LUTINS) return -2;
    int rmask, gmask, bmask, amask;
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
    rmask = 0xff000000;
    gmask = 0x00ff0000;
    bmask = 0x0000ff00;
    amask = 0x000000ff;
#else
    rmask = 0x000000ff;
    gmask = 0x0000ff00;
    bmask = 0x00ff0000;
    amask = 0xff000000;
#endif
    if (couleur < 0) amask = 0x00000000;
    SDL_Surface *lutin =
    SDL_CreateRGBSurface (0, largeur, hauteur, BITS_PAR_PIXEL, rmask, gmask, bmask, amask);
    SDL_Rect fenetre;
    fenetre.x = x;
    fenetre.y = y;
    fenetre.h = hauteur;
    fenetre.w = largeur;
    SDL_BlitSurface (surface, &fenetre, lutin, NULL);
    lutins[lutins_nb++] = lutin;
    if (couleur >= 0) configurerLutin (lutin, couleur);
    return lutins_nb - 1;
}

void tailleLutin (int lutin, int *largeur, int *hauteur)
{
    *largeur = lutins[lutin]->w;
    *hauteur = lutins[lutin]->h;
}

int sauverLutin (int lutin, char *nom) { return SDL_SaveBMP (lutins[lutin], nom); }

/* Manipulation de copie de surface en BMP */

int sauverSurface (char *fichier) { return SDL_SaveBMP (surface, fichier); }

unsigned char chargerSurface (char *fichier)
{
    SDL_Surface *image = SDL_LoadBMP (fichier);
    if (image != NULL)
    {
        SDL_BlitSurface (image, NULL, surface, NULL);
        SDL_Flip (surface);
    }
    return (image != NULL);
}

void majSurface (void) { SDL_Flip (surface); }

/* Trouver la couleur d'un pixel */

int couleurPixel (int x, int y)
{
    int     bpp = surface->format->BytesPerPixel;
    Uint32 *p   = (Uint32 *)(surface->pixels + y * surface->pitch + x * bpp);
    Uint8   r, v, b;
    SDL_GetRGB (*p, surface->format, &r, &v, &b);
    int i = 0;
    while (1)
    {
        if (couleurs[i].r < 0) break;
        if (r == couleurs[i].r && v == couleurs[i].v && b == couleurs[i].b) break;
        i++;
    }
    if (couleurs[i].r < 0)
        return -1;
    else
        return i;
}

/* Fonction de traitement des événements */

void lireEvenement (evenement *evt, char *touche, void **detail)
{
    static SDL_keysym _detail;
    SDL_Event         event;
    while (SDL_PollEvent (&event))
    {
        if (event.type == SDL_QUIT) *evt = quitter;
        if (event.type == SDL_KEYDOWN || event.type == SDL_KEYUP)
        {
            *evt      = (event.type == SDL_KEYDOWN) ? toucheBas : toucheHaut;
            char *nom = SDL_GetKeyName (event.key.keysym.sym);
            if (strlen (nom) == 1 && nom[0] >= 32 && nom[0] < 128)
                *touche = nom[0];
            else
                *touche = 0;
            if (detail != NULL)
            {
                _detail = event.key.keysym;
                *detail = &_detail;
            }
	    break;
        }
    }
}

void attendreEvenement (void)
{
    SDL_Event event;
    while (SDL_WaitEvent (&event)) switch (event.type)
        {
        case SDL_QUIT:
            exit (0);
        case SDL_KEYDOWN:
        case SDL_MOUSEBUTTONDOWN:
            return;
        }
}