
#include "ArmyStupid2.h"

#include "MemoryManager/debugNew.h"

using namespace ground;

ArmyStupid2::ArmyStupid2(std::string& color) : Army(color)
{
	init = false;
}

ArmyStupid2::~ArmyStupid2(void)
{
}

void ArmyStupid2::updateAI()
{
	this->groundArmyInfo.update();

	//************************************************************
	//* On ne redonne des cibles que quand la courante est morte *
	//************************************************************

	//les iterator
	std::map<float,Unit*> sortTarget;
	std::map<Unit*,EnnemyUnit*>::iterator itTarget;
	std::vector<Unit*>::iterator itUnit;
	//les pointeur sur vector
	std::vector<Unit*> ennemies = this->ennemyArmy->getUnits();

	//à cause de ceci, on n'a pas le droit de rajouter des unité après la premier lancement de l'IA...
	if(init==false)
	{
		init = true;
		for(itUnit=this->units.begin(); itUnit!=this->units.end(); ++itUnit)
		{
			target[(*itUnit)] = NULL;
		}
	}

	//on va redonner des cible au unité qui n'ont pas de cible ou qui on des cibles mortes
	for(itTarget=this->target.begin(); itTarget!=this->target.end(); ++itTarget)
	{
		if(!itTarget->first->isAlive()) continue;

		if(itTarget->second==NULL || !itTarget->second->isAlive())
		{
			if(itTarget->second!=NULL && itTarget->second->isAlive())
			{
				//l'unité poursuivait un ennemi et celui-ci est mort
				delete itTarget->second;
				itTarget->second = NULL;
			}

			//on recherche la prochaine cible
			//calcul de l'unité ennemi la plus proche
			sortTarget.clear();
			std::vector<Unit*>::iterator itEn;
			for(itEn=ennemies.begin(); itEn!=ennemies.end(); ++itEn)
			{
				if((*itEn)->isAlive())
				{
					sortTarget[ ((*itEn)->getPosition()-itTarget->first->getPosition()).getLength() ] = (*itEn);
				}
			}

			if(sortTarget.size()!=0)
			{
				//printf("assignation");
				EnnemyUnit* eu = new EnnemyUnit(sortTarget.begin()->second,EnnemyUnit::VISIBLE);
				itTarget->second = eu;
				itTarget->first->eraseAllAction();
				itTarget->first->attack(*eu);
			}
		}
	}

	sortTarget.clear();


	//***************************************************
	//* On assigne l'unité la plus proche à chaque tour *
	//***************************************************

	/*std::map<float,Unit*> sortTarget;
	std::map<Unit*,EnnemyUnit*> findTarget;

	std::vector<Unit*> ennemies = this->ennemyArmy->getUnits();

	//on va réassigner les cibles : pour cela, on nettoie le vecteur de cible de nos unités
	target.clear();
	std::map<Unit*,EnnemyUnit*>::iterator itTarget;
	for(itTarget=this->target.begin(); itTarget!=this->target.end(); ++itTarget)
	{
		delete itTarget->second;
	}

	std::vector<Unit*>::iterator itUnit;
	for(itUnit=this->units.begin(); itUnit!=this->units.end(); ++itUnit)
	{
		if((*itUnit)->isAlive())
		{
			//calcul de l'unité ennemi la plus proche
			sortTarget.clear();
			std::vector<Unit*>::iterator itEn;
			for(itEn=ennemies.begin(); itEn!=ennemies.end(); ++itEn)
			{
				if((*itEn)->isAlive())
				{
					sortTarget[ ((*itEn)->getPosition()-(*itUnit)->getPosition()).getLength() ] = (*itEn);
				}
			}

			if(sortTarget.size()!=0)
			{
				EnnemyUnit* eu = new EnnemyUnit(sortTarget.begin()->second,EnnemyUnit::VISIBLE);
				target[(*itUnit)] = eu;
				(*itUnit)->eraseAllAction();
				(*itUnit)->attack(*eu);
			}
		}
	}*/
}

void ArmyStupid2::updateUnit()
{
	this->groundArmyInfo.removeAllUnits();
	std::vector<Unit*>::iterator it;
	for(it=this->units.begin(); it!=this->units.end();++it){
		if( (*it)->isAlive() ) {
			this->groundArmyInfo.addUnit((*it));
		}
		(*it)->update();
	}
	this->groundArmyInfo.update();
}

void ArmyStupid2::setEnnemyArmy(Army* ea)
{
	this->ennemyArmy = ea;
}