/* [DESTRUCTOR] Destruction de la surface
=========================================================*/
Sprite::~Sprite(){
	SDL_DestroyTexture( _texture );
	_manager = NULL;
}


/* [CONSTRUCTOR] Construction de la surface vide
=========================================================*/
Sprite::Sprite(sdltl *m){
	_manager = m;
	_texture = NULL;
}



/* [CONSTRUCTOR] Construction de la surface avec couleur
=========================================================*/
Sprite::Sprite(sdltl *m, const int rgb[]){
	_manager = m;
	_texture = NULL;

	
	cout << "a: [" << (sizeof(rgb)/sizeof(*rgb)) << "]" << endl;

	SDL_Surface *surf = SDL_CreateRGBSurface(0, 0, 0, 32, 0, 0, 0, rgb[3]);

	// On recupere la couleur
	Uint32 color = SDL_MapRGBA( surf->format, rgb[0], rgb[1], rgb[2], rgb[3]);
		

	// On cree la texture a partir de la surface
	_texture = SDL_CreateTextureFromSurface(_manager->renderer(), surf);


	// On libere la surface inutile maintenant
	SDL_FreeSurface( surf );
	surf = NULL;

}



/* [CONSTRUCTOR] Construction de la surface avec image
=========================================================*/
Sprite::Sprite(sdltl *m, const char *url){
	
	_manager = m;
	_texture = NULL;

	/* (1) On cree la texture directement */
	_texture = IMG_LoadTexture(_manager->renderer(), url);


	/* (1bis) On cree la surface puis on la copie dans la texture */
	// SDL_Surface *surf = IMG_Load( url );

	// _texture = SDL_CreateTextureFromSurface(_manager->renderer(), surf);

	// SDL_FreeSurface(surf);
	// surf = NULL;

	// Gestion erreur
	if( _texture == NULL )
		return;
}


/* [DIMENSIONS] Definition des dimensions par defaut
=========================================================*/
void Sprite::dimensions(){
	cout <<"A"<<endl;

	/* (1) On recupere les informations de la texture */
	int w, h;
	SDL_QueryTexture(_texture, NULL, NULL, &w, &h);


	/* (2) On definit les dimensions par defaut */
	_dst = (SDL_Rect){0, 0, w, h};
	_src = (SDL_Rect){0, 0, w, h};
}


/* [DIMENSIONS] Definition des dimensions de la texture
=========================================================*/
void Sprite::dimensions(SDL_Rect r){
	cout <<"B"<<endl;

	/* (1) On recupere les informations de la texture */
	int w, h;
	SDL_QueryTexture(_texture, NULL, NULL, &w, &h);


	/* (2) On definit les dimensions */
	_dst = (SDL_Rect){r.x, r.y, r.w, r.h};
	_src = (SDL_Rect){0, 0, w, h};
}

/* [DIMENSIONS] Definition des dimensions de la texture+clip
=========================================================*/
void Sprite::dimensions(SDL_Rect r, SDL_Rect clip){
	cout <<"C"<<endl;
	
	/* (1) On definit les dimensions */
	_dst = (SDL_Rect){r.x, r.y, r.w, r.h};
	_src = (SDL_Rect){clip.x, clip.y, clip.w, clip.h};
}

/* [PUSH] Ajoute le Sprite au rendu
=========================================================*/
void Sprite::push(){
	_manager->push(_texture, &_src, &_dst);
}

/* [PULL] Retire une sprite du rendu
=========================================================*/
void Sprite::pull(){
	_manager->pull( _texture );
}

/* [UPDATE] Mise a jour du rendu
=========================================================*/
void Sprite::update(){
	_manager->update();
}


/* [TEXTURE] Retourne la texture
=========================================================*/
SDL_Texture *Sprite::texture(){ return _texture; }

/* [MANAGER] Retourne le manager
=========================================================*/
sdltl *Sprite::manager(){ return _manager; }
















/**********************************/
/*********** SPRITEGROUP **********/
/**********************************/
/* [CONSTRUCTOR] Initialisation de la liste de Sprite
=========================================================*/
SpriteGroup::SpriteGroup(){
	// _sprites = new vector<Sprite*>(0);
}

/* [ADD] Ajoute un Sprite au groupe
=========================================================*/
void SpriteGroup::add(Sprite *s){
	_sprites.push_back( s );
}

/* [REMOVE] Suppression d'un Sprite du groupe
=========================================================*/
void SpriteGroup::remove(Sprite *s){
	int index = -1; // on cherche l'indice du sprite

	// On parcours la liste pour trouver l'indice
	for( int i = 0 ; i < _sprites.size() ; i++ )
		if( _sprites[i] == s ) index = i;

	// Si on a pas trouve l'indice
	if( index == -1 ) return;

	// On supprime le sprite de la liste
	_sprites.erase(_sprites.begin() + index );

}

/* [PUSH] Ajoute tous les Sprite du groupe a une surface parente
=========================================================*/
void SpriteGroup::push(){
	for( int i = 0 ; i < _sprites.size() ; i++ )
		_sprites[i]->push();
}

/* [PULL] Retire une sprite de la surface parents
=========================================================*/
void SpriteGroup::pull(){
	for( int i = 0 ; i < _sprites.size() ; i++ )
		_sprites[i]->pull();
}



/* [UPDATE] Mise a jour du rendu
=========================================================*/
void SpriteGroup::update(){
	if( _sprites.size() > 0 )
		_sprites[0]->update();
}


/* [GET] Retourne le Sprite d'index donne
=========================================================*/
Sprite* SpriteGroup::get(int i){
	return _sprites[i];
}




/* [TRHEAD] Process de l'animation
=========================================================*/
void SpriteGroupAnimation(SpriteGroup *sg, int t, int flags){
	int length = sg->_sprites.size();
	int timer = 0;
	int step  = 1;
	int start = 0;
	int stop = length;
	int lastindex = -1;

	while( flags&SPRITE_ANIM_INFINITE ){

		/* (1) Pour chaque sprite */
		for( int i = start ; i != stop ; i+=step ){
			timer = SDL_GetTicks();
			

			// On retire le sprite precedent
			if( lastindex > -1 )
				sg->get(lastindex)->pull();

			// On ajoute le sprite
			sg->get(i)->push();

			// On met a jour le rendu
			sg->get(i)->update();


			if( SDL_GetTicks()-timer < t )
				SDL_Delay( t - (SDL_GetTicks()-timer) );

			lastindex = i;

		}

		/* (2) Gestion des flags */
			
		// SPRITE_ANIM_REVERSE
		if( flags&SPRITE_ANIM_REVERSE ){
			step *= -1;
			start = (step==1) ? 0 : length-1;
			stop  = (step==1) ? length-1 : 0;
		}

	}


	/* (n) On termine le thread */
	return;
}




/* [ANIMATE] Modifie le Sprite dans l'ordre du SpriteGroup
=========================================================*/
thread* SpriteGroup::animate(int t, int flags){
	_animation = new thread(SpriteGroupAnimation, this, t, flags);

	// On attends pas le thread
	_animation->detach();

	return _animation;
}