#include <stdio.h>
#include <stdlib.h>
#include <SDL/SDL.h>

void Put_Pixel(SDL_Surface *surface, int x, int y, Uint8 R, Uint8 G, Uint8 B);
void Draw_Screen(SDL_Surface *screen, int color);

#define DIM_H	800
#define DIM_V	600

int main()
{
	// si inizializza il sistema video
	if( SDL_Init(SDL_INIT_VIDEO) <0 )
	{
		// SDL_GetError() ritorna una descrizione dell'errore
		printf("Errore init SDL: %s\n", SDL_GetError());
	        return 1;
	}

	// all'uscita del programma esegui SDL_Quit per risistemare le cose
	atexit(SDL_Quit);


	//dichiariamo un puntatore ad una superficie ed un int a 32 bit per i flag necessari
	SDL_Surface *screen;
	Uint32 flags;
	//SDL_VideoInfo dą informazioni sulla scheda video
	const SDL_VideoInfo *info_hw;

	//otteniamo le informazioni sul video
	info_hw=SDL_GetVideoInfo();

	//verifichiamo se possiamo creare una superficie hardware, altrimenti software
	if ( info_hw->hw_available )
	        flags = SDL_HWSURFACE;
	else
	        flags = SDL_SWSURFACE;

	//aggiungiamo il buffer doppio
	flags|=SDL_DOUBLEBUF;

	// per rendere disegnabile la Superficie bisogna utilizzare SDL_SetVideoMode
	if(!( screen = SDL_SetVideoMode(DIM_H, DIM_V, 0,flags) ))
	{
		  printf("Problemi con il settaggio dello schermo: %s\n", SDL_GetError());
		  return 1;
	}
	
	//variabile per il ciclo principale
	int done=0;
	//indice del colore 0 rosso, 1 verde , 2 blu
	int color=0;

	//dichiariamo una struttura SDL_Event
	SDL_Event event;

	//game loop, ovvero il loop che viene eseguito finchč non si esce
	while(!done)	
 	{
		// SDL_WaitEvent attende il prossimo evento
		SDL_WaitEvent(&event);
			
		//premendo la x della finestra col mouse si esce
		if ( event.type == SDL_QUIT )  
			done = 1;  

	       	if ( event.type == SDL_KEYDOWN )
		{
			//ma si esce anche premendo Esc
			if ( event.key.keysym.sym == SDLK_ESCAPE ) 
				done = 1; 

			//premendo la freccia GIU ci spostiamo al colore precendete 
			if ( event.key.keysym.sym == SDLK_DOWN)
			{
				//se abbiamo raggiunto l'inizio degli indici torniamo all'ultimo
				if(!color)
					color=2;
				else
					color--;
			}
			//premendo la freccia SU ci spostiamo al prossimo colore
			if ( event.key.keysym.sym == SDLK_UP)
			{
				//se abbiamo raggiunto la fine degli indici torniamo a 0
				if(color==2)
					color=0;
				else
					color++;
			}
			//premendo spazio si passa dalla modalitą schermo intero alla modalitą 
			//finestra e viceversa
			if ( event.key.keysym.sym == SDLK_SPACE ) 
			{
				flags^=SDL_FULLSCREEN;
				screen = SDL_SetVideoMode(DIM_H, DIM_V, 0,flags);
			}
		}
		
		//coloriamo lo schermo
		Draw_Screen(screen,color);

		//SDL_Flip disegna il buffer direttamente sullo schermo
		SDL_Flip(screen);

	}

	return 0;
}
	
//disegna un pixel sullo schermo puntato da screen alle cordinate (x,y) con colori R,G,B
void Put_Pixel(SDL_Surface *surface, int x, int y,Uint8 R, Uint8 G, Uint8 B)
{
	//restituisce la mappatura di un colore RGB in base ai bpp (alla definizione)
	Uint32 color = SDL_MapRGB(surface->format, R, G, B);

	//byte per pixel
	int bpp = surface->format->BytesPerPixel;

	//pixel della superficie da colorare
	Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;

	//verifichiamo il numero di byte usati per la nostra superficie
	switch (bpp)
	{
		case 1: // 1 byte =>  8-bpp
			*p = color;
		        break;
	        case 2: // 2 byte => 16-bpp
      			*(Uint16 *)p = color;
			break;
    		case 3: // 3 byte => 24-bpp
			if(SDL_BYTEORDER == SDL_BIG_ENDIAN) 
			{
				p[0] = (color >> 16) & 0xff;
			        p[1] = (color >> 8) & 0xff;
				p[2] = color & 0xff;
			} 
			else 
			{
			        p[0] = color & 0xff;
				p[1] = (color >> 8) & 0xff;
				p[2] = (color >> 16) & 0xff;
			}
	      		break;
    		case 4: // 4 byte => 32-bpp
			*(Uint32 *)p = color;
      			break;
  	}
}

// esegue la colorazione dello schermo
void Draw_Screen(SDL_Surface *screen, int color)
{
	int l_c[3]={0,0,0};
	int col;
	
	if(color==0)
		l_c[0]=1;
	else if(color==1)
		l_c[1]=1;
	else if(color==2)
		l_c[2]=1;
	
	//blocchiamo lo schermo se necessario
	if ( SDL_MUSTLOCK(screen) )
		SDL_LockSurface(screen);
	
	//disegnamo i pixel sul buffer screen prcedentemente creato
	for(int y=0;y<DIM_V;y++)
	{
		for(int x=0;x<DIM_H;x++)
		{
			col=(x/4)+25;
			
	       		Put_Pixel(screen, x,y,col*l_c[0],col*l_c[1],col*l_c[2]);
		}
	}
	
	//sblocchiamo lo schermo se necessario
	if ( SDL_MUSTLOCK(screen) )
       		SDL_UnlockSurface(screen);
}