#include "CGeniusAI.h"

#include <iostream>
#include <boost/lexical_cast.hpp>

#include "../../hch/CBuildingHandler.h"
#include "../../hch/CHeroHandler.h"
#include "../../lib/VCMI_Lib.h"
#include "../../lib/NetPacks.h"
#include "AIPriorities.h"

using std::cout;
using std::endl;
using geniusai::CGeniusAI;

#if defined (_MSC_VER) && (_MSC_VER >= 1020) || (__MINGW32__)
// Excludes rarely used stuff from windows headers - delete this line if
// something is missing.
#define WIN32_LEAN_AND_MEAN 
#include <windows.h>
#endif

void DbgBox(const char* msg, bool messageBox)
{
#if defined PRINT_DEBUG
#if defined _DEBUG
//# if 0
#	if defined (_MSC_VER) && (_MSC_VER >= 1020)
	if (messageBox)
	{
		MessageBoxA(NULL, msg, "Debug message", MB_OK | MB_ICONASTERISK);
	}
#	endif
	std::cout << msg << std::endl;
#endif
#endif
}


// TODO: Rewrite those i-s, o-s to something meaningful.
bool CGeniusAI::AIObjectContainer::operator<(
    const AIObjectContainer& b) const
{
	if (o->pos != b.o->pos)
		return o->pos < b.o->pos;
  else
	  return o->id < b.o->id;
}

CGeniusAI::HypotheticalGameState::HeroModel::HeroModel(
    const CGHeroInstance* h)
    : h(h), finished(false)
{
	pos = h->getPosition(false);
  remainingMovement = h->movement;
}

CGeniusAI::HypotheticalGameState::TownModel::TownModel(
    const CGTownInstance* t)
    : t(t)
{
	hasBuilt = static_cast<bool>(t->builded);
	creaturesToRecruit = t->creatures;
	creaturesInGarrison = t->army;
}

CGeniusAI::HypotheticalGameState::HypotheticalGameState(CGeniusAI& ai)
    : knownVisitableObjects(ai.knownVisitableObjects)
{
	AI = &ai;
	std::vector<const CGHeroInstance*> heroes = ai.m_cb->getHeroesInfo();	
	for (std::vector<const CGHeroInstance*>::iterator i = heroes.begin();
       i != heroes.end();
       i++)
		heroModels.push_back(HeroModel(*i));
	
	std::vector<const CGTownInstance*> towns = ai.m_cb->getTownsInfo();	
	for (std::vector <const CGTownInstance*>::iterator i = towns.begin();
       i != towns.end();
       i++) {
		if ( (*i)->tempOwner == ai.m_cb->getMyColor() )
		  townModels.push_back(TownModel(*i));
  }

  if (ai.m_cb->howManyTowns() != 0) {
    AvailableHeroesToBuy = 
      ai.m_cb->getAvailableHeroes(ai.m_cb->getTownInfo(0,0));
  }

	for (int i = 0; i < 8; i++)
    resourceAmounts.push_back(ai.m_cb->getResourceAmount(i));
}


void CGeniusAI::HypotheticalGameState::update(CGeniusAI& ai)
{
	AI = &ai;
	knownVisitableObjects = ai.knownVisitableObjects;
	std::vector<HeroModel> oldModels = heroModels;
	heroModels.clear();

	std::vector<const CGHeroInstance*> heroes = ai.m_cb->getHeroesInfo();
	for (std::vector<const CGHeroInstance*>::iterator i = heroes.begin();
       i != heroes.end();
       i++)
		heroModels.push_back(HeroModel(*i));

  for (int i = 0; i < oldModels.size(); i++) {
    for (int j = 0; j < heroModels.size(); j++) {
			if (oldModels[i].h->subID == heroModels[j].h->subID) {
				heroModels[j].finished = oldModels[i].finished;
				heroModels[j].previouslyVisited_pos = oldModels[i].previouslyVisited_pos;
			}
    }
  }
	
	townModels.clear();
	std::vector<const CGTownInstance*> towns = ai.m_cb->getTownsInfo();	
	for (std::vector<const CGTownInstance*>::iterator i = towns.begin();
       i != towns.end();
       i++) {
		if ( (*i)->tempOwner == ai.m_cb->getMyColor() )
			townModels.push_back(TownModel(*i));
  }

  if (ai.m_cb->howManyTowns() != 0) {
		AvailableHeroesToBuy =
      ai.m_cb->getAvailableHeroes(ai.m_cb->getTownInfo(0,0));
  }

	resourceAmounts.clear();
	for (int i = 0; i < 8; i++)
    resourceAmounts.push_back(ai.m_cb->getResourceAmount(i));
}

CGeniusAI::HeroObjective::HeroObjective(const HypotheticalGameState &hgs,
                                        Type t,
                                        const CGObjectInstance* object,
                                        HypotheticalGameState::HeroModel* h,
                                        CGeniusAI* ai)
                                        : object(object), hgs(hgs)
{
	AI = ai;
	pos = object->pos;
	type = t;
	whoCanAchieve.push_back(h);
	_value = -1;
}


float CGeniusAI::HeroObjective::getValue() const
{
	if (_value >= 0)
    return _value - _cost;

  // TODO: each object should have an associated cost to visit IE 
  // (tree of knowledge 1000 gold/10 gems)
	vector<int> resourceCosts;
	for (int i = 0; i < 8; i++)
		resourceCosts.push_back(0);

	if (object->ID == 47) // School of magic
		resourceCosts[6] += 1000;

  // TODO: Add some meaningful (and not exploitable) number here.
	float bestCost = 9e9f;
	HypotheticalGameState::HeroModel* bestHero = NULL;
	if (type != AIObjective::finishTurn)
	{
		for (int i = 0; i < whoCanAchieve.size(); i++)
		{
			int distOutOfTheWay = 0;
			CPath path3;
			//from hero to object
			if (AI->m_cb->getPath(whoCanAchieve[i]->pos,
                            pos,
                            whoCanAchieve[i]->h,
                            path3)) {
				distOutOfTheWay+=path3.nodes[0].dist;
      }

			// from object to goal
			if (AI->m_cb->getPath(pos,
                            whoCanAchieve[i]->interestingPos,
                            whoCanAchieve[i]->h,
                            path3)) {
				distOutOfTheWay += path3.nodes[0].dist;
				// from hero directly to goal
				if (AI->m_cb->getPath(whoCanAchieve[i]->pos,
                              whoCanAchieve[i]->interestingPos,
                              whoCanAchieve[i]->h,
                              path3))
					distOutOfTheWay-=path3.nodes[0].dist;
			}
			
			float cost = AI->m_priorities->getCost(resourceCosts,
                                             whoCanAchieve[i]->h,
                                             distOutOfTheWay);
			if (cost < bestCost) {
				bestCost = cost;
				bestHero = whoCanAchieve[i];
			}
    } // for (int i = 0; i < whoCanAchieve.size(); i++)
  } else  // if (type != AIObjective::finishTurn)
    bestCost = 0;

	if (bestHero) {
		whoCanAchieve.clear();
		whoCanAchieve.push_back(bestHero);
	}

	_value = AI->m_priorities->getValue(*this);
	_cost = bestCost;
	return _value - _cost;
}


bool CGeniusAI::HeroObjective::operator<(
    const HeroObjective& other) const
{
	if (type != other.type)
		return type < other.type;
  else if (pos != other.pos)
		return pos < other.pos;
	else if (object->id != other.object->id)
		return object->id < other.object->id;
  else if ((dynamic_cast<const CGVisitableOPH*>(object) != NULL) &&
           (whoCanAchieve.front()->h->id != other.whoCanAchieve.front()->h->id))
		return whoCanAchieve.front()->h->id < other.whoCanAchieve.front()->h->id;
  else
    return false;
}


void CGeniusAI::HeroObjective::print() const
{
	switch (type) {
	case visit:
		cout << "visit " << object->hoverName
         << " at (" <<object->pos.x << ","<< object->pos.y << ")" ;
		break;
	case attack:
		cout << "attack " << object->hoverName;
		break;
	case finishTurn:
		cout << "finish turn";
    // TODO: Add a default, just in case.
	}
	if (whoCanAchieve.size() == 1)
		cout << " with " << whoCanAchieve.front()->h->hoverName;
}


CGeniusAI::TownObjective::TownObjective(
    const HypotheticalGameState& hgs,
    Type t,
    HypotheticalGameState::TownModel* tn,
    int Which,
    CGeniusAI * ai)
    : whichTown(tn), which(Which), hgs(hgs)
{
	AI = ai;
	type = t;
	_value = -1;
}

float CGeniusAI::TownObjective::getValue() const
{
	if (_value >= 0)
		return _value - _cost;

  // TODO: Include a constant stating the meaning of 8 (number of resources).
	vector<int> resourceCosts(8,0);
	CBuilding* b        = NULL;
	CCreature* creature = NULL;
  float cost          = 0; // TODO: Needed?
	int ID              = 0;
  int newID           = 0;
  int howMany         = 0;
  ui32 creatures_max  = 0;

	switch (type) {
		case recruitHero:
			resourceCosts[6] = 2500;  // TODO: Define somehow the meaning of gold etc.
			break;

		case buildBuilding:
			b = VLC->buildh->buildings[whichTown->t->subID][which];
			for (int i = 0;
          b && ( i < b->resources.size() ); // TODO: b what??
          i++)
				resourceCosts[i] = b->resources[i];
			break;

	  case recruitCreatures:
      // Buy upgraded if possible.
		  ID = whichTown->creaturesToRecruit[which].second.back();
		  creature = &VLC->creh->creatures[ID];
		  howMany = whichTown->creaturesToRecruit[which].first;
      creatures_max = 0; // Max creatures you can recruit of this type.
      
      for (int i = 0; i < creature->cost.size(); i++) {
        if (creature->cost[i] != 0)
          creatures_max = hgs.resourceAmounts[i]/creature->cost[i];
        else
          creatures_max = INT_MAX; // TODO: Will have to rewrite it.
        // TODO: Buy the best units (the least I can buy)?
			  amin(howMany, creatures_max);
      }
      // The cost of recruiting the stack of creatures.
		  for (int i = 0;
          creature && ( i < creature->cost.size() ); // TODO: Creature what??
          i++)
			  resourceCosts[i] = creature->cost[i]*howMany;
		  break;

	  case upgradeCreatures:
		  UpgradeInfo ui = AI->m_cb->getUpgradeInfo(whichTown->t,which);
		  ID = whichTown->creaturesInGarrison.slots[which].first;
		  howMany = whichTown->creaturesInGarrison.slots[which].second;

		  newID = ui.newID.back();
		  int upgrade_serial = ui.newID.size() - 1;
		  for (std::set< std::pair<int,int> >::iterator
          j = ui.cost[upgrade_serial].begin();
          j != ui.cost[upgrade_serial].end();
          j++)
		    resourceCosts[j->first] = j->second*howMany;
		break;
	}

	_cost = AI->m_priorities->getCost(resourceCosts, NULL, 0);
	_value = AI->m_priorities->getValue(*this);
	return _value - _cost;
}


bool CGeniusAI::TownObjective::operator<(const TownObjective &other) const
{
	if (type != other.type)
		return type < other.type;
	else if (which != other.which)
		return which < other.which;
	else if (whichTown->t->id != other.whichTown->t->id)
		return whichTown->t->id < other.whichTown->t->id;
  else
	  return false;
}


void CGeniusAI::TownObjective::print() const
{
  HypotheticalGameState::HeroModel hm;
	CBuilding* b              = NULL;
	const CCreature* creature = NULL;
	int ID                    = 0;
  int howMany               = 0;
  int newID                 = 0; // TODO: Needed?
  int hSlot                 = 0; // TODO: Needed?
  ui32 creatures_max;

	switch (type) {
	  case recruitHero:
		  cout << "recruit hero.";
      break;

	  case buildBuilding:
		  b = VLC->buildh->buildings[whichTown->t->subID][which];
		  cout << "build " << b->Name() << " cost = ";
		  if (b->resources.size() != 0) {
			  if (b->resources[0] != 0)
          cout << b->resources[0] << " wood. ";
			  if (b->resources[1] != 0)
          cout << b->resources[1] << " mercury. ";
			  if (b->resources[2] != 0)
          cout << b->resources[2] << " ore. ";
			  if (b->resources[3] != 0)
          cout << b->resources[3] << " sulfur. ";
			  if (b->resources[4] != 0)
          cout << b->resources[4] << " crystal. ";
			  if (b->resources[5] != 0)
          cout << b->resources[5] << " gems. ";
			  if (b->resources[6] != 0)
          cout << b->resources[6] << " gold. ";
		  }
		  break;

	  case recruitCreatures:
      // Buy upgraded if possible.
		  ID = whichTown->creaturesToRecruit[which].second.back();
		  creature = &VLC->creh->creatures[ID];
		  howMany = whichTown->creaturesToRecruit[which].first;
      creatures_max = 0;

      for (int i = 0; i < creature->cost.size(); i++) {
        if (creature->cost[i] != 0)
          creatures_max = hgs.resourceAmounts[i]/creature->cost[i];
        else
          creatures_max = INT_MAX;
        amin(howMany, creatures_max);
      }
		  cout << "recruit " << howMany  << " " << creature->namePl
           << " (Total AI Strength " << creature->AIValue*howMany
           << "). cost = ";
  		
		  if (creature->cost.size() != 0)
		  {
			  if (creature->cost[0] != 0)
          cout << creature->cost[0]*howMany << " wood. ";
			  if (creature->cost[1] != 0)
          cout << creature->cost[1]*howMany << " mercury. ";
			  if (creature->cost[2] != 0)
          cout << creature->cost[2]*howMany << " ore. ";
			  if (creature->cost[3] != 0)
          cout << creature->cost[3]*howMany << " sulfur. ";
			  if (creature->cost[4] != 0)
          cout << creature->cost[4]*howMany << " cristal. ";
			  if (creature->cost[5] != 0)
          cout << creature->cost[5]*howMany << " gems. ";
			  if (creature->cost[6] != 0)
          cout << creature->cost[6]*howMany << " gold. ";
		  }
		  break; // case recruitCreatures.

		  case upgradeCreatures:
			  UpgradeInfo ui = AI->m_cb->getUpgradeInfo(whichTown->t,which);
			  ID = whichTown->creaturesInGarrison.slots[which].first;
			  cout << "upgrade " << VLC->creh->creatures[ID].namePl;
			  //ui.cost	
		  break;
	} // switch(type)
}


CGeniusAI::CGeniusAI() : m_generalAI(), m_state(NO_BATTLE)
{
	m_priorities = new Priorities("AI/GeniusAI.brain");
}


CGeniusAI::~CGeniusAI()
{
	delete m_priorities;
}


void CGeniusAI::init(ICallback *CB)
{
	m_cb = CB;
	m_generalAI.init(CB);

	human = false;
	playerID = m_cb->getMyColor();
	serialID = m_cb->getMySerial();
	std::string info = std::string("GeniusAI initialized for player ") 
                   + boost::lexical_cast<std::string>(playerID);
	m_battleLogic = NULL;
	DbgBox(info.c_str());
}


void CGeniusAI::reportResources()
{
	cout << "Day " << m_cb->getDate() << ": ";
	cout << "AI Player " <<m_cb->getMySerial()<< " with "
       <<  m_cb->howManyHeroes(true) << " heroes. " << endl;
	cout << m_cb->getResourceAmount(0) << " wood. ";
	cout << m_cb->getResourceAmount(1) << " mercury. ";
	cout << m_cb->getResourceAmount(2) << " ore. ";
	cout << m_cb->getResourceAmount(3) << " sulfur. ";
	cout << m_cb->getResourceAmount(4) << " cristal. ";
	cout << m_cb->getResourceAmount(5) << " gems. ";
	cout << m_cb->getResourceAmount(6) << " gold.";
	cout << endl;
}


void CGeniusAI::addHeroObjectives(CGeniusAI::HypotheticalGameState::HeroModel& h,
                                  CGeniusAI::HypotheticalGameState& hgs)
{
	int3 hpos = h.pos;
  int3 destination;
  int3 interestingPos;
  CPath path;
	int movement = h.remainingMovement;
	int maxInteresting = 0;
	AIObjective::Type tp = AIObjective::visit;

	if (h.finished)
    return;

	for (std::set<AIObjectContainer>::const_iterator
      i = hgs.knownVisitableObjects.begin();
      i != hgs.knownVisitableObjects.end();
      i++) {
		tp = AIObjective::visit;
		if(	h.previouslyVisited_pos==i->o->getSightCenter())
			continue;

		//TODO: what would the hero actually visit if he went to that spot
		// maybe the hero wants to visit a seemingly unguarded enemy town,
    // but there is a hero on top of it.
		// if(i->o->)
    if (i->o->ID != HEROI_TYPE) {// Unless you are trying to visit a hero.
			bool heroThere = false;
      for(int j = 0; j < hgs.heroModels.size(); j++) {
				if (hgs.heroModels[j].pos == i->o->getSightCenter())
          heroThere = true;
      }
			if (heroThere) // It won't work if there is already someone visiting that spot.
				continue;
		}
		if (i->o->ID == HEROI_TYPE && // Visiting friendly heroes not yet supported.
        i->o->getOwner() == m_cb->getMyColor())
			continue;
		if (i->o->id == h.h->id)	// Don't visit yourself (should be caught by above).
			continue;
    // Don't visit a mine if you own, there's almost no
    // point(maybe to leave guards or because the hero's trapped).
		if (i->o->ID == 53
        && i->o->getOwner() == m_cb->getMyColor())
			continue;

		if (i->o->getOwner() != m_cb->getMyColor()) {
      // TODO: I feel like the AI shouldn't have access to this information.
      // We must get an approximation based on few, many, ... zounds etc.
			int enemyStrength = 0;  

      // TODO: should be virtual maybe, army strength should be
      // comparable across objects.
      // TODO: Rewrite all those damn i->o. For someone reading it the first
      // time it's completely inconprehensible.
      // TODO: NO MAGIC NUMBERS !!!
			if (dynamic_cast<const CArmedInstance*> (i->o))
				enemyStrength =
          (dynamic_cast<const CArmedInstance*> (i->o))->getArmyStrength();
			if (dynamic_cast<const CGHeroInstance*> (i->o))
				enemyStrength =
          (dynamic_cast<const CGHeroInstance*> (i->o))->getTotalStrength();
      // TODO: Make constants of those 1.2 & 2.5.
			if (dynamic_cast<const CGTownInstance*> (i->o))
				enemyStrength = static_cast<int>(
          (dynamic_cast<const CGTownInstance*> (i->o))->getArmyStrength() * 1.2);
			float heroStrength = h.h->getTotalStrength();
      // TODO: ballence these numbers using objective cost formula.
      // TODO: it would be nice to do a battle simulation.
			if (enemyStrength * 2.5 > heroStrength)  
				continue;

			if (enemyStrength > 0)
        tp = AIObjective::attack;
		}

    //don't visit things that have already been visited this week.
		if ((dynamic_cast<const CGVisitableOPW*> (i->o) != NULL) &&
        (dynamic_cast<const CGVisitableOPW*> (i->o)->visited))
			continue;

    //don't visit things that you have already visited OPH
		if ((dynamic_cast<const CGVisitableOPH*> (i->o) != NULL) &&
        vstd::contains(dynamic_cast<const CGVisitableOPH*> (i->o)->visitors,
                       h.h->id))
			continue;

    // TODO: Some descriptions of those included so someone can undestand them.
		if (i->o->ID == 88 || i->o->ID == 89 || i->o->ID == 90) {
			//TODO: if no spell book continue
			//TODO: if the shrine's spell is identified, and the hero already has it, continue
		}

		destination = i->o->getSightCenter();

    // Don't try to take a path from the underworld to the top or vice versa.
    // TODO: Will have to make some calculations so that the AI can enter the
    // underground.
    if (hpos.z == destination.z) {
      //TODO: fix get path so that it doesn't return a path unless z's are \
      // the same, or path goes through sub gate.
			if (m_cb->getPath(hpos, destination, h.h, path)) {
				path.convert(0);
				if (path.nodes[0].dist < movement) {
          // TODO: So easy to understand...
					HeroObjective ho(hgs, tp, i->o, &h, this);
					std::set<HeroObjective>::iterator found = currentHeroObjectives.find(ho);
					if (found == currentHeroObjectives.end())
						currentHeroObjectives.insert(ho);
					else {
            // TODO: Try to rewrite if possible...
            // A cast to a pointer, from a reference, to a pointer
            // of an iterator.
						HeroObjective* objective = (HeroObjective*)&(*found);
						objective->whoCanAchieve.push_back(&h);
					}
				}

				// Find the most interesting object that is eventually reachable,
        // and set that position to the ultimate goal position.
        // TODO: replace random numbers with some sort of ranking system.
				int hi = rand();
				if (hi > maxInteresting) {
					maxInteresting = hi;
					interestingPos = destination;
				}
      } // if (m_cb->getPath(hpos, destination, h.h, path))
    } // if (hpos.z == destination.z)
	} // for (std::set<AIObjectContainer>::const_iterator 
    // i = knownVisitableObjects.begin();

	h.interestingPos = interestingPos;
  // there ought to be a path
  // if(h.remainingMovement>0&&m_cb->getPath(hpos,interestingPos,h.h,path))
	currentHeroObjectives.insert(HeroObjective(hgs,
                                             HeroObjective::finishTurn,
                                             h.h,
                                             &h,
                                             this));
}


void CGeniusAI::HeroObjective::fulfill(CGeniusAI& cg,
                                       HypotheticalGameState& hgs)
{
	cg.m_cb->waitTillRealize = true;
	HypotheticalGameState::HeroModel* h = NULL;
	int3 hpos;
  int3 destination;
  int3 bestPos;
  int3 currentPos;
  int3 checkPos;
	CPath path;
	CPath path2;
	int howGood = 0;
	
  switch (type) {
	case finishTurn:
		h = whoCanAchieve.front();
		h->finished=true;
		hpos = h->pos;
		destination = h->interestingPos;
		
    if (!cg.m_cb->getPath(hpos, destination, h->h, path)) {
      cout << "AI error: invalid destination" << endl;
      return;
    }
		destination = h->pos;
    // Find closest coord that we can get to.
    for (int i = path.nodes.size() - 2; i >= 0; i--) {
      // TODO: getPath what??
			if ((cg.m_cb->getPath(hpos, path.nodes[i].coord, h->h, path2)) &&
          (path2.nodes[0].dist <= h->remainingMovement))
				destination = path.nodes[i].coord;
    }

		if (destination == h->interestingPos)
      break;
		
    // ! START ! //
		// Find close pos with the most neighboring empty squares. We don't want to
    // get in the way.
		bestPos = destination;
		howGood = 0;
    // TODO: Add a meaning to 3.
    for (int x = -3; x <= 3; x++) {
			for (int y = -3; y <= 3; y++) {
				currentPos = destination + int3(x,y,0);
        // There better not be anything there.
				if (cg.m_cb->getVisitableObjs(currentPos).size() != 0)
					continue;
				if ((cg.m_cb->getPath(hpos, currentPos, h->h, path) == false) ||
            // It better be reachable from the hero
            // TODO: remainingMovement > 0...
            (path.nodes[0].dist>h->remainingMovement))
					continue;
				
				int count = 0;
        for (int xx = -1; xx <= 1; xx++) {
					for (int yy = -1; yy <= 1; yy++) {
						checkPos = currentPos + int3(xx, yy, 0);
						if (cg.m_cb->getPath(currentPos, checkPos, h->h, path) != false)
							count++;
					}
        }
				if (count > howGood) {
					howGood = count;
					bestPos = currentPos;
				}
      }
    }

		destination = bestPos;
		// ! END ! //
		cg.m_cb->getPath(hpos, destination, h->h, path);
		path.convert(0);
		break;

	case visit:
  case attack:
		h = whoCanAchieve.front();		//lowest cost hero
		h->previouslyVisited_pos = object->getSightCenter();
		hpos = h->pos;
		destination = object->getSightCenter();
		break;
  } // switch(type)

  if ((type == visit || type == finishTurn || type == attack) &&
      (cg.m_cb->getPath(hpos, destination, h->h, path) != false))
	  path.convert(0);
	
	if (cg.m_state.get() != NO_BATTLE)
    cg.m_state.waitUntil(NO_BATTLE); // Wait for battle end
  
  // Wait over, battle over too. hero might be killed. check.
	for (int i = path.nodes.size() - 2;
       (i >= 0) && (cg.m_cb->getHeroSerial(h->h) >= 0);
       i--) {
		cg.m_cb->moveHero(h->h,path.nodes[i].coord);

		if (cg.m_state.get() != NO_BATTLE)
			cg.m_state.waitUntil(NO_BATTLE); // Wait for battle end
  }

	h->remainingMovement -= path.nodes[0].dist;
	if (object->blockVisit)
		h->pos = path.nodes[1].coord;
	else
		h->pos = destination;

	std::set<AIObjectContainer>::iterator
    i = hgs.knownVisitableObjects.find(AIObjectContainer(object));
	if (i != hgs.knownVisitableObjects.end())
		hgs.knownVisitableObjects.erase(i);

  const CGTownInstance* town = dynamic_cast<const CGTownInstance*> (object);
  if (town && object->getOwner() == cg.m_cb->getMyColor()) {
	  //upgrade hero's units
	  cout << "visiting town" << endl;
	  CCreatureSet hcreatures = h->h->army;
	  for (std::map< si32, std::pair<ui32,si32> >::const_iterator
         i = hcreatures.slots.begin();
         i != hcreatures.slots.end();
         i++) { // For each hero slot.
		  UpgradeInfo ui = cg.m_cb->getUpgradeInfo(h->h,i->first);

		  bool canUpgrade = false;
      if (ui.newID.size() != 0) { // Does this stack need upgrading?
			  canUpgrade = true;
			  for (int ii = 0; ii < ui.cost.size(); ii++) // Can afford the upgrade?
				  for (std::set<std::pair<int,int> >::iterator
               j = ui.cost[ii].begin();
               j != ui.cost[ii].end();
               j++)
					  if (hgs.resourceAmounts[j->first] < j->second * i->second.second)
						  canUpgrade = false;
		  }
			
      if (canUpgrade)
		  {
			  cg.m_cb->upgradeCreature(h->h, i->first, ui.newID.back());
			  cout << "upgrading hero's "
             << VLC->creh->creatures[i->second.first].namePl
             << endl;
		  }
	  }

	  // Give town's units to hero.
	  CCreatureSet tcreatures = town->army;
	  int weakestCreatureStack;
	  int weakestCreatureAIValue = 99999; // TODO: Wtf??

	  for (std::map< si32, std::pair<ui32,si32> >::const_iterator
         i = tcreatures.slots.begin();
         i != tcreatures.slots.end();
         i++) {
		  if (VLC->creh->creatures[i->second.first].AIValue < 
          weakestCreatureAIValue) {
			  weakestCreatureAIValue  = VLC->creh->creatures[i->second.first].AIValue;
			  weakestCreatureStack    = i->first;
		  }
    }
	  for (std::map< si32, std::pair<ui32, si32> >::const_iterator
        i = tcreatures.slots.begin();
        i != tcreatures.slots.end();
        i++) { // For each town slot.
		  hcreatures = h->h->army;
		  int hSlot = hcreatures.getSlotFor(i->second.first);

		  if (hSlot == -1)
        continue;
		  cout << "giving hero "
           << VLC->creh->creatures[i->second.first].namePl
           << endl;
		  if (hcreatures.slots.find(hSlot) != hcreatures.slots.end()) {
        // Can't take garrisonHero's last unit.
			  if ( (i->first == weakestCreatureStack)
            && (town->garrisonHero != NULL) )
				  cg.m_cb->splitStack(town, h->h, i->first, hSlot, i->second.second - 1);
			  else
          // TODO: the comment says that this code is not safe for the AI.
				  cg.m_cb->mergeStacks(town, h->h, i->first, hSlot);
		  } else
			  cg.m_cb->swapCreatures(town, h->h, i->first, hSlot);	
    } // for (std::map< si32, std::pair<ui32, si32> >::const_iterator ...
  } // if (town && object->getOwner == cg.m_cb->getMyColor())
}


void CGeniusAI::addTownObjectives(HypotheticalGameState::TownModel& t,
                                  HypotheticalGameState& hgs)
{
	//recruitHero
	//buildBuilding
	//recruitCreatures
	//upgradeCreatures

  // Recruit hero.
	if ( (hgs.heroModels.size() < 3) && (hgs.resourceAmounts[6] >= 2500) ) {
		bool heroAtTown = false;
    for (int i = 0; i < hgs.heroModels.size(); i++) {
			if (hgs.heroModels[i].pos == t.t->getSightCenter())
				heroAtTown = true;
    }
    // No visiting hero and built tavern.
		if (!heroAtTown && vstd::contains(t.t->builtBuildings, 5)) {
      for (int i = 0; i < hgs.AvailableHeroesToBuy.size(); i++) {
				if ( (hgs.AvailableHeroesToBuy[i] != NULL)
            && (t.t->subID ==
              hgs.AvailableHeroesToBuy[i]->type->heroType / 2) ) {
					TownObjective to(hgs,AIObjective::recruitHero,&t,0,this);
					currentTownObjectives.insert(to);
				}
      }
    }
  }
	
  // Build a building.
	if (!t.hasBuilt) {
    // m_cb->getCBuildingsByID(t.t);
		std::map<int, CBuilding*> thisTownsBuildings =
      VLC->buildh->buildings[t.t->subID];
		for (std::map<int, CBuilding*>::iterator i = thisTownsBuildings.begin();
        i != thisTownsBuildings.end();
        i++) {
			if (m_cb->canBuildStructure(t.t, i->first) == 7) {
				TownObjective to(hgs, AIObjective::buildBuilding, &t, i->first ,this);
				currentTownObjectives.insert(to);
			}
		}
	}
	
	// Recruit creatures.
	for (int i = 0; i < t.creaturesToRecruit.size(); i++) {
		if (t.creaturesToRecruit[i].first == 0
        || t.creaturesToRecruit[i].second.empty())
      continue;
		
    int ID = t.creaturesToRecruit[i].second.back();
    // m_cb->getCCreatureByID(ID);
		const CCreature *creature = &VLC->creh->creatures[ID];
		bool canAfford = true;
		for (int ii = 0; ii < creature->cost.size(); ii++)
			if (creature->cost[ii] > hgs.resourceAmounts[ii])
				canAfford = false; // Can we afford at least one creature?
		if (!canAfford) continue;
				
		//cout << "town has " << t.t->creatures[i].first  << " "<< creature->namePl << " (AI Strength " << creature->AIValue << ")." << endl;
		TownObjective to(hgs, AIObjective::recruitCreatures, &t, i, this);
		currentTownObjectives.insert(to);
	}

  // Upgrade creatures.
	for (std::map< si32, std::pair<ui32, si32> >::iterator
      i = t.creaturesInGarrison.slots.begin();
      i != t.creaturesInGarrison.slots.end();
      i++) {
		UpgradeInfo ui = m_cb->getUpgradeInfo(t.t, i->first);
		if (ui.newID.size() != 0) {
			bool canAfford = true;
			
			int upgrade_serial = ui.newID.size() - 1;
			for (std::set< std::pair<int, int> >::iterator
          j = ui.cost[upgrade_serial].begin();
          j != ui.cost[upgrade_serial].end();
          j++)
				if (hgs.resourceAmounts[j->first] < j->second * i->second.second)
					canAfford = false;
			if (canAfford) {
				TownObjective to(hgs,AIObjective::upgradeCreatures,&t,i->first,this);
				currentTownObjectives.insert(to);
			}
    } // if (ui.netID.size() != 0)
  } // for (std::map< si32, std::pair ...
}


void CGeniusAI::TownObjective::fulfill(CGeniusAI& cg,
                                       HypotheticalGameState& hgs)
{
	cg.m_cb->waitTillRealize = true;
	CBuilding * b;
	const CCreature *creature;
	HypotheticalGameState::HeroModel hm;
	int ID, howMany, newID, hSlot;

	switch (type) {
	case recruitHero:
		cg.m_cb->recruitHero(whichTown->t, hgs.AvailableHeroesToBuy[which]);
		hm = HypotheticalGameState::HeroModel(hgs.AvailableHeroesToBuy[which]);
		hm.pos = whichTown->t->getSightCenter();
		hm.remainingMovement = hm.h->maxMovePoints(true);
		hgs.heroModels.push_back(hm);
		hgs.resourceAmounts[6] -= 2500;
		break;

	case buildBuilding:
		b = VLC->buildh->buildings[whichTown->t->subID][which];
		if (cg.m_cb->canBuildStructure(whichTown->t,which) == 7) {
			cout << "built " << b->Name() << "." << endl;
			if (!cg.m_cb->buildBuilding(whichTown->t, which))
        cout << "really tried to build unbuildable building" << endl;
			for (int i = 0; b && i < b->resources.size(); i++) // TODO: b what?
				hgs.resourceAmounts[i] -= b->resources[i];
		} else
      cout << "trying to build a structure we cannot build" << endl;
		whichTown->hasBuilt=true;
		break;

	case recruitCreatures:
    // Buy upgraded if possible.
		ID = whichTown->creaturesToRecruit[which].second.back();
		creature = &VLC->creh->creatures[ID];
		howMany = whichTown->creaturesToRecruit[which].first;
		for (int i = 0; i < creature->cost.size(); i++)
      // TODO: rewrite.
			amin(howMany, creature->cost[i] ? hgs.resourceAmounts[i]/creature->cost[i] : INT_MAX);
		if (howMany == 0)
      cout << "tried to recruit without enough money.";
		cout << "recruiting " << howMany  << " "
         << creature->namePl << " (Total AI Strength "
         << creature->AIValue*howMany << ")." << endl;
		cg.m_cb->recruitCreatures(whichTown->t, ID, howMany);
		break;

	case upgradeCreatures:
		UpgradeInfo ui = cg.m_cb->getUpgradeInfo(whichTown->t, which);
		ID = whichTown->creaturesInGarrison.slots[which].first;
		newID = ui.newID.back();
    // TODO: reduce resources in hgs
		cg.m_cb->upgradeCreature(whichTown->t, which, newID);
		cout << "upgrading " << VLC->creh->creatures[ID].namePl << endl;
		break;
	}
}


void CGeniusAI::fillObjectiveQueue(HypotheticalGameState & hgs)
{
	objectiveQueue.clear();
	currentHeroObjectives.clear();
	currentTownObjectives.clear();
	
	for (std::vector <CGeniusAI::HypotheticalGameState::HeroModel>::iterator
      i = hgs.heroModels.begin();
      i != hgs.heroModels.end();
      i++)
		addHeroObjectives(*i, hgs);

	for (std::vector <CGeniusAI::HypotheticalGameState::TownModel>::iterator
      i = hgs.townModels.begin();
      i != hgs.townModels.end();
      i++)
		addTownObjectives(*i, hgs);
	
	for (std::set<CGeniusAI::HeroObjective>::iterator
      i = currentHeroObjectives.begin();
      i != currentHeroObjectives.end();
      i++)
    // TODO: Recheck and try to write simpler expression.
		objectiveQueue.push_back(AIObjectivePtrCont((CGeniusAI::HeroObjective*)&(*i)));

	for (std::set<CGeniusAI::TownObjective>::iterator
      i = currentTownObjectives.begin();
      i != currentTownObjectives.end();
      i++)
		objectiveQueue.push_back(AIObjectivePtrCont((CGeniusAI::TownObjective*)&(*i)));
}


CGeniusAI::AIObjective * CGeniusAI::getBestObjective()
{
	trueGameState.update(*this);	
	fillObjectiveQueue(trueGameState);

// TODO: Write this part.
//	if(!objectiveQueue.empty())
//		return max_element(objectiveQueue.begin(),objectiveQueue.end())->obj;
	m_priorities->fillFeatures(trueGameState);
	if (objectiveQueue.empty())
    return NULL;
//	sort(objectiveQueue.begin(),objectiveQueue.end());
//	reverse(objectiveQueue.begin(),objectiveQueue.end());
	int num = 1;
//	for(std::vector<AIObjectivePtrCont> ::iterator i = objectiveQueue.begin(); i < objectiveQueue.end();i++)
//	{
//		if(!dynamic_cast<HeroObjective*>(i->obj))continue;
//		cout << num++ << ": ";
//		i->obj->print();
//		cout << " value: " << i->obj->getValue();
//		cout << endl;
//	}
//	int choice = 0;
//	cout << "which would you do? (enter 0 for none): ";
//	cin >> choice;
	cout << "doing best of " << objectiveQueue.size() << " ";
	CGeniusAI::AIObjective* best =
    max_element(objectiveQueue.begin(), objectiveQueue.end())->obj;
	best->print();
	cout << " value = " << best->getValue() << endl;
	if (!objectiveQueue.empty())
		return best;
	return objectiveQueue.front().obj;
}


void CGeniusAI::yourTurn()
{
	static boost::mutex mutex;
	boost::mutex::scoped_lock lock(mutex);
	m_cb->waitTillRealize = true;
	static int seed = rand();
	srand(seed);
	if (m_cb->getDate() == 1) {
	//	startFirstTurn();
		
	//	m_cb->endTurn();
	//	return;
	}
	//////////////TODO: replace with updates. Also add suspected objects list./////////
	knownVisitableObjects.clear();
	int3 pos = m_cb->getMapSize();
  for (int x = 0; x < pos.x; x++) {
    for (int y = 0; y < pos.y; y++) {
			for (int z = 0; z < pos.z; z++)
				tileRevealed(int3(x,y,z));
    }
  }
	///////////////////////////////////////////////////////////////////////////////////

	reportResources();

	trueGameState = HypotheticalGameState(*this);
	AIObjective * objective;
	while ((objective = getBestObjective()) != NULL)
		objective->fulfill(*this,trueGameState);

	seed = rand();
	m_cb->endTurn();
	m_cb->waitTillRealize = false;
}


void CGeniusAI::startFirstTurn()
{
	HypotheticalGameState hgs(*this);
	
	const CGTownInstance * town = m_cb->getTownInfo(0,0);
	const CGHeroInstance * heroInst = m_cb->getHeroInfo(0,0);
	
	TownObjective(hgs,
                AIObjective::recruitHero,
                &hgs.townModels.front(),
                0,
                this).fulfill(*this, hgs);
	
	m_cb->swapGarrisonHero(town);
	hgs.update(*this);
	for (int i = 0; i < hgs.townModels.front().creaturesToRecruit.size(); i++) {
		if (hgs.townModels.front().creaturesToRecruit[i].first == 0)
      continue;
		int ID = hgs.townModels.front().creaturesToRecruit[i].second.back();
		const CCreature *creature = &VLC->creh->creatures[ID];
		bool canAfford = true;
    for (int ii = 0; ii < creature->cost.size(); ii++) {
			if (creature->cost[ii] > hgs.resourceAmounts[ii])
				canAfford = false;  // Can we afford at least one creature?
    }
		if (!canAfford)
      continue;
		TownObjective(hgs,AIObjective::recruitCreatures,&hgs.townModels.front(),i,this).fulfill(*this,hgs);
  }
	hgs.update(*this);

	HypotheticalGameState::HeroModel* hero;
  for (int i = 0; i < hgs.heroModels.size(); i++) {
		if (hgs.heroModels[i].h->id == heroInst->id)
		  HeroObjective(hgs, AIObjective::visit, town, hero = &hgs.heroModels[i], this).fulfill(*this,hgs);
  }
	hgs.update(*this);
 //	m_cb->swapGarrisonHero(town);
	//TODO: choose the strongest hero.
}


void CGeniusAI::heroKilled(const CGHeroInstance* hero)
{
}


void CGeniusAI::heroCreated(const CGHeroInstance* hero)
{
}


void CGeniusAI::tileRevealed(int3 pos)
{
	std::vector<const CGObjectInstance*> objects = m_cb->getVisitableObjs(pos);
	for (std::vector < const CGObjectInstance* >::iterator o = objects.begin();
      o != objects.end();
      o++) {
		if ((*o)->id != -1)
			knownVisitableObjects.insert(*o);
  }
	objects = m_cb->getFlaggableObjects(pos);
	for (std::vector<const CGObjectInstance*>::iterator
      o = objects.begin();
      o != objects.end();
      o++)
		if ((*o)->id != -1)
			knownVisitableObjects.insert(*o);
}

// eg. ship built in shipyard
void CGeniusAI::newObject(const CGObjectInstance* obj)
{
  knownVisitableObjects.insert(obj);
}


void CGeniusAI::objectRemoved(const CGObjectInstance *obj) //eg. collected resource, picked artifact, beaten hero
{
	std::set<AIObjectContainer>::iterator o = knownVisitableObjects.find(obj);
	if (o != knownVisitableObjects.end())
		knownVisitableObjects.erase(o);
}


void CGeniusAI::tileHidden(int3 pos)
{
}


void CGeniusAI::heroMoved(const TryMoveHero& TMH)
{
	// DbgBox("** CGeniusAI::heroMoved **");
}


void CGeniusAI::heroGotLevel(const CGHeroInstance *hero,
                             int pskill,
                             std::vector<ui16>& skills,
                             boost::function<void(ui32)>& callback)
{
	callback(rand() % skills.size());
}


void geniusai::CGeniusAI::showGarrisonDialog(const CArmedInstance* up,
                                             const CGHeroInstance* down,
                                             bool removableUnits,
                                             boost::function<void()>& onEnd)
{
	onEnd();
}


void geniusai::CGeniusAI::playerBlocked(int reason)
{
	if (reason == 0) // Battle is coming...
		m_state.setn(UPCOMING_BATTLE);
}


void geniusai::CGeniusAI::battleResultsApplied()
{
	assert(m_state.get() == ENDING_BATTLE);
	m_state.setn(NO_BATTLE);
}

// TODO: Shouldn't the parameters be made const (apart from cancel)?
void CGeniusAI::showBlockingDialog(const std::string& text,
                                   const std::vector<Component> &components,
                                   ui32 askID,
                                   const int soundID,
                                   bool selection,
                                   bool cancel)
{
	m_cb->selectionMade(cancel ? false : true, askID);
}


/**
 * occurs AFTER every action taken by any stack or by the hero
 */
void CGeniusAI::actionFinished(const BattleAction* action)
{
	std::string message("\t\tCGeniusAI::actionFinished - type(");
	message += boost::lexical_cast<std::string>((unsigned)action->actionType);
	message += "), side(";
	message += boost::lexical_cast<std::string>((unsigned)action->side);
	message += ")";
	DbgBox(message.c_str());
}


/**
 * occurs BEFORE every action taken by any stack or by the hero
 */
void CGeniusAI::actionStarted(const BattleAction *action)
{
	std::string message("\t\tCGeniusAI::actionStarted - type(");
	message += boost::lexical_cast<std::string>((unsigned)action->actionType);
	message += "), side(";
	message += boost::lexical_cast<std::string>((unsigned)action->side);
	message += ")";
	DbgBox(message.c_str());
}


/**
 * called when stack is performing attack
 */
void CGeniusAI::battleAttack(BattleAttack* ba)
{
	DbgBox("\t\t\tCGeniusAI::battleAttack");
}


/**
 * called when stack receives damage (after battleAttack())
 */
void CGeniusAI::battleStacksAttacked(std::set<BattleStackAttacked>& bsa)
{
	DbgBox("\t\t\tCGeniusAI::battleStacksAttacked");
}


/**
 * called by engine when battle starts; side=0 - left, side=1 - right
 */
void CGeniusAI::battleStart(CCreatureSet *army1, CCreatureSet *army2, int3 tile, CGHeroInstance *hero1, CGHeroInstance *hero2, bool side)
{
  // TODO: Battle logic what...
	assert(!m_battleLogic);
  // We have been informed that battle will start (or we are neutral AI)
	assert( (playerID > PLAYER_LIMIT) || (m_state.get() == UPCOMING_BATTLE) );

	m_state.setn(ONGOING_BATTLE);
	m_battleLogic = new BattleAI::CBattleLogic(m_cb, army1, army2, tile, hero1,
    hero2, side);

	DbgBox("** CGeniusAI::battleStart **");
}


/**
 *
 */
void CGeniusAI::battleEnd(BattleResult* br)
{
	switch (br->winner) {
		case 0:	std::cout << "The winner is the attacker." << std::endl;break;
		case 1:	std::cout << "The winner is the defender." << std::endl;break;
		case 2:	std::cout << "It's a draw." << std::endl;break;
	};
	cout << "lost ";
	for (std::map<ui32,si32>::iterator i = br->casualties[0].begin();\
       i != br->casualties[0].end();
       i++)
		cout << i->second << " " << VLC->creh->creatures[i->first].namePl << endl;
				
	delete m_battleLogic;
	m_battleLogic = NULL;

	assert(m_state.get() == ONGOING_BATTLE);
	m_state.setn(ENDING_BATTLE);

	DbgBox("** CGeniusAI::battleEnd **");
}

/*
 * Called at the beggining of each turn, round = -1 is the tactic phase,
 * round = 0 is the first "normal" turn.
 */
void CGeniusAI::battleNewRound(int round)
{
	std::string message("\tCGeniusAI::battleNewRound - ");
	message += boost::lexical_cast<std::string>(round);
	DbgBox(message.c_str());

	m_battleLogic->SetCurrentTurn(round);
}

/**
 *
 */
void CGeniusAI::battleStackMoved(int ID, int dest, int distance, bool end)
{
	std::string message("\t\t\tCGeniusAI::battleStackMoved ID(");
	message += boost::lexical_cast<std::string>(ID);
	message += "), dest(";
	message += boost::lexical_cast<std::string>(dest);
	message += ")";
	DbgBox(message.c_str());
}


/**
 *
 */
void CGeniusAI::battleSpellCast(SpellCast *sc)
{
	DbgBox("\t\t\tCGeniusAI::battleSpellCast");
}


/**
 * called when battlefield is prepared, prior the battle beginning
 */
void CGeniusAI::battlefieldPrepared(int battlefieldType,
                                    std::vector<CObstacle*> obstacles)
{
	DbgBox("CGeniusAI::battlefieldPrepared");
}


/**
 *
 */
void CGeniusAI::battleStackMoved(int ID,
                                 int dest,
                                 bool startMoving,
                                 bool endMoving)
{
	DbgBox("\t\t\tCGeniusAI::battleStackMoved");
}


/**
 *
 */
void CGeniusAI::battleStackAttacking(int ID, int dest)
{
	DbgBox("\t\t\tCGeniusAI::battleStackAttacking");
}


/**
 *
 */
void CGeniusAI::battleStackIsAttacked(int ID,
                                      int dmg,
                                      int killed,
                                      int IDby,
                                      bool byShooting)
{
	DbgBox("\t\t\tCGeniusAI::battleStackIsAttacked");
}


/**
 * called when it's turn of that stack
 */
BattleAction CGeniusAI::activeStack(int stackID)
{
	std::string message("\t\t\tCGeniusAI::activeStack stackID(");

	message += boost::lexical_cast<std::string>(stackID);
	message += ")";
	DbgBox(message.c_str());

	BattleAction bact = m_battleLogic->MakeDecision(stackID);
	assert(m_cb->battleGetStackByID(bact.stackNumber));
	return bact;
};