/*Copyright (C) 2010 Deveaux Duncan

This file is part of Hikou no mizu.

Hikou no mizu is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Hikou no mizu is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Hikou no mizu.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "GestionnaireAnimation.hpp"

GestionnaireAnimation::GestionnaireAnimation(std::string pCheminAnimations, std::string pCheminListeAnimations) :
animBloquanteLancee(false), iAnimation(0), iAnimationRetour(0), sensAnimations(0)
{
	chargeListeAnim(pCheminAnimations, pCheminListeAnimations);
	lanceAnimation(false, iAnimation);
}

void GestionnaireAnimation::lanceAnimation(bool pAnimBloquante, int pIdAnimation, int pIdAnimationRetour)
{
	if (!animBloquanteLancee)
	{
		iAnimation = pIdAnimation;
		if (pAnimBloquante)
		{
			iAnimationRetour = pIdAnimationRetour;
			animBloquanteLancee = true;
		}
	}
}

void GestionnaireAnimation::executeAnimation()
{
	listeAnimations[iAnimation].suivant();
	
	if (animBloquanteLancee)
	{
		if (listeAnimations[iAnimation].getActFrame() == listeAnimations[iAnimation].getNbFrames() - 1)
		{
			animBloquanteLancee = false;
			lanceAnimation(false, iAnimationRetour);
		}
	}
	
	//Placement de l'origine de l'image
	int origineY;
	origineY = getHauteurAnimation();
	
	int origineX;

	if (getSensAnimations() == 0) origineX = getLargeurAnimation();
	else origineX = 0;
	
	//Si l'animation a changé de sens, on adapte sa position
	if (changeSens)
	{
		int nouveauX;
		if (getSensAnimations() == 0)
			nouveauX = getPositionAnimationsX() + getLargeurAnimation();
		else
			nouveauX = getPositionAnimationsX() - getLargeurAnimation();
		
		imageMoteurRendu.SetX(nouveauX);
		changeSens = false;
	}
	
	//Application des modifications
	imageMoteurRendu.SetOrigin(origineX, origineY);
}

void GestionnaireAnimation::demarreAffichage(MoteurGraphique &pMoteurRendu)
{
	pMoteurRendu.ajouteObjet(&imageMoteurRendu);
}

void GestionnaireAnimation::supprimeAffichage(MoteurGraphique &pMoteurRendu)
{
	pMoteurRendu.supprimeObjet(&imageMoteurRendu);
}

void GestionnaireAnimation::chargeListeAnim(std::string pCheminAnimations, std::string pCheminListeAnimations)
{
	TiXmlDocument fichierXMLListeAnimations( pCheminListeAnimations.c_str() );
	fichierXMLListeAnimations.LoadFile();
	
	TiXmlHandle handleXML(&fichierXMLListeAnimations);
	TiXmlElement *elementXMLListeAnimations = handleXML.FirstChildElement().FirstChildElement().FirstChildElement().Element();
	

	while (elementXMLListeAnimations)
	{
		//Récupération des informations sur l'animation (chemin, nombre d'images...)
		std::string nomAnimation = pCheminAnimations + elementXMLListeAnimations->Attribute("nom") + "/";
		int nombreFramesAnimation;
		elementXMLListeAnimations->QueryIntAttribute("nbFrames", &nombreFramesAnimation);
		
		//Création de l'Animation et mise en place de celle ci dans le vector listeAnimations
		listeAnimations.push_back( Animation(nomAnimation, nombreFramesAnimation, &imageMoteurRendu) );
		
		elementXMLListeAnimations = elementXMLListeAnimations->NextSiblingElement();
	}
}

//Fonctions get/set
Animation *GestionnaireAnimation::getActAnimation()
{
	return &listeAnimations[iAnimation];
}

bool GestionnaireAnimation::getAnimBloquanteLancee()
{
	return animBloquanteLancee;
}

const sf::Vector2f &GestionnaireAnimation::getOrigineAnimation() const
{
	return imageMoteurRendu.GetOrigin();
}

void GestionnaireAnimation::setSensAnimations(int pSens)
{
	if (pSens == 0 || pSens == 1)
	{
		imageMoteurRendu.FlipX(pSens);
		
		changeSens = true;
		sensAnimations = pSens;
	}
}

int GestionnaireAnimation::getSensAnimations() const
{
	return sensAnimations;
}

float GestionnaireAnimation::getLargeurAnimation() const
{
	return imageMoteurRendu.GetSize().x;
}

float GestionnaireAnimation::getHauteurAnimation() const
{
	return imageMoteurRendu.GetSize().y;
}

void GestionnaireAnimation::setPositionAnimationsX(float pPosition)
{
	imageMoteurRendu.SetX(pPosition);
}

float GestionnaireAnimation::getPositionAnimationsX() const
{
	return imageMoteurRendu.GetPosition().x;
}

void GestionnaireAnimation::setPositionAnimationsY(float pPosition)
{
	imageMoteurRendu.SetY(pPosition);
}

float GestionnaireAnimation::getPositionAnimationsY() const
{
	return imageMoteurRendu.GetPosition().y;
}
