/**
  @file /ai/Strategizer/planning.cpp
  @brief Zdrojovy kod implementace planovacich struktur a interfacu pro komunikaci s WORLDem.
  
  Zdrojovy kod implementace planovacich struktur a interfacu pro komunikaci s WORLDem.
  
  @author PZ
  @version 0.1
*/

#include "ai/Strategizer/planning.h"

namespace ai_ns
{
namespace strategizer_ns
{

// CPlanAction implementace
CPlanAction::CPlanAction()
{
  priority=DEFAULT_PLAN_ACTION_PRIORITY;
  done=false;
}

CPlanAction::~CPlanAction() {}

bool CPlanAction::operator<(const CPlanAction* & opa)
{
  return (this->priority<opa->priority);
}

// CUnitPlanAction implementace
CUnitPlanAction::CUnitPlanAction(int unit_id)
{
  this->unit_id=unit_id;
}

CUnitPlanAction::~CUnitPlanAction()
{
}

// CUnitPlanAction_Go implementace
CUnitPlanAction_Go::CUnitPlanAction_Go(int unit_id)
:CUnitPlanAction(unit_id)
{
}

CUnitPlanAction_Go::~CUnitPlanAction_Go()
{
}

// CUnitPlanAction_Attack implementace
CUnitPlanAction_Attack::CUnitPlanAction_Attack(int unit_id)
:CUnitPlanAction(unit_id)
{
}

CUnitPlanAction_Attack::~CUnitPlanAction_Attack()
{
}

// CUnitPlanAction_HealWounded implementace
CUnitPlanAction_HealWounded::CUnitPlanAction_HealWounded(int unit_id)
:CUnitPlanAction(unit_id)
{
}

CUnitPlanAction_HealWounded::~CUnitPlanAction_HealWounded()
{
}

// CUnitPlanAction_EliteRecruit implementace
CUnitPlanAction_EliteRecruit::CUnitPlanAction_EliteRecruit(int unit_id)
:CUnitPlanAction(unit_id)
{
}

CUnitPlanAction_EliteRecruit::~CUnitPlanAction_EliteRecruit()
{
}

// CUnitPlanAction_NonEliteRecruit implementace
CUnitPlanAction_NonEliteRecruit::CUnitPlanAction_NonEliteRecruit(int unit_id)
:CUnitPlanAction(unit_id)
{
}

CUnitPlanAction_NonEliteRecruit::~CUnitPlanAction_NonEliteRecruit()
{
}

// CUnitPlanAction_Release implementace
CUnitPlanAction_Release::CUnitPlanAction_Release(int unit_id)
:CUnitPlanAction(unit_id)
{
}

CUnitPlanAction_Release::~CUnitPlanAction_Release()
{
}

// CUnitPlanAction_Build implementace
CUnitPlanAction_Build::CUnitPlanAction_Build(int unit_id)
:CUnitPlanAction(unit_id)
{
}

CUnitPlanAction_Build::~CUnitPlanAction_Build()
{
}

// CUnitPlanAction_Repair implementace
CUnitPlanAction_Repair::CUnitPlanAction_Repair(int unit_id)
:CUnitPlanAction(unit_id)
{
}

CUnitPlanAction_Repair::~CUnitPlanAction_Repair()
{
}

// CUnitPlanAction_Spell implementace
CUnitPlanAction_Spell::CUnitPlanAction_Spell(int unit_id)
:CUnitPlanAction(unit_id)
{
}

CUnitPlanAction_Spell::~CUnitPlanAction_Spell()
{
}

// CBuildingPlanAction implementace
CBuildingPlanAction::CBuildingPlanAction(int building_id)
{
  this->building_id=building_id;
}

CBuildingPlanAction::~CBuildingPlanAction()
{
}

// CBuildingPlanAction_TrainUnit implementace
CBuildingPlanAction_TrainUnit::CBuildingPlanAction_TrainUnit(int building_id)
:CBuildingPlanAction(building_id)
{
}

CBuildingPlanAction_TrainUnit::~CBuildingPlanAction_TrainUnit()
{
}

// CBuildingPlanAction_Destroy implementace
CBuildingPlanAction_Destroy::CBuildingPlanAction_Destroy(int building_id)
:CBuildingPlanAction(building_id)
{
}

CBuildingPlanAction_Destroy::~CBuildingPlanAction_Destroy()
{
}

// CBuildingPlanAction_SellBonus implementace
CBuildingPlanAction_SellBonus::CBuildingPlanAction_SellBonus(int building_id)
:CBuildingPlanAction(building_id)
{
}

CBuildingPlanAction_SellBonus::~CBuildingPlanAction_SellBonus()
{
}

// CCityPlanAction implementace
CCityPlanAction::CCityPlanAction(int city_id)
{
  this->city_id=city_id;
}

CCityPlanAction::~CCityPlanAction()
{
}

// CCityPlanAction_TrainBuilder implementace
CCityPlanAction_TrainBuilder::CCityPlanAction_TrainBuilder(int city_id)
:CCityPlanAction(city_id)
{
}

CCityPlanAction_TrainBuilder::~CCityPlanAction_TrainBuilder()
{
}


// CPlan implementace
CPlan::CPlan(int player_id)
{
  actions.clear();
  idcounter=0;
  this->player_id=player_id;
}

CPlan::~CPlan()
{
  std::PLAN_ACTIONS_CONTAINER<CPlanAction*>::iterator aIt;

  for (aIt=actions.begin();aIt!=actions.end();aIt++) delete (*aIt);
  actions.clear();
}

int CPlan::addActionToFront(CPlanAction* addedAction,bool process_plan_immediately)
{
  std::PLAN_ACTIONS_CONTAINER<CPlanAction*>::iterator aIt;

  actions.push_front(addedAction);
  aIt=actions.begin();
  (*aIt)->id=++idcounter;
#ifndef _K_EDITOR_
  if (process_plan_immediately)
  {
    processPlan();
    deleteAllDoneActions();
  }
#endif
  return idcounter;
}

int CPlan::addActionToBack(CPlanAction* addedAction,bool process_plan_immediately)
{
  std::PLAN_ACTIONS_CONTAINER<CPlanAction*>::iterator aIt;

  actions.push_back(addedAction);
  aIt=actions.end();
  aIt--;
  (*aIt)->id=++idcounter;
#ifndef _K_EDITOR_
  if (process_plan_immediately)
  {
    processPlan();
    deleteAllDoneActions();
  }
#endif
  return idcounter;
}

void CPlan::removeAction(int actionID)
{
  std::PLAN_ACTIONS_CONTAINER<CPlanAction*>::iterator aIt;
  
  for (aIt=actions.begin();aIt!=actions.end();aIt++)
  {
    if ((*aIt)->id==actionID)
    {
      delete (*aIt);
      actions.erase(aIt);
      return;
    }
  }
  THROW(E_8K_AI_Strategy_ActionIDNotFound,"Akce s danym ID nenalezena.")
}

void CPlan::deleteAllDoneActions()
{
  std::PLAN_ACTIONS_CONTAINER<CPlanAction*>::iterator aIt;
  
  for (aIt=actions.begin();aIt!=actions.end();)
  {
    if ((*aIt)->done)
      aIt=actions.erase(aIt);
    else
      aIt++;
  }
}

void CPlan::sortByPriorities()
{
  actions.sort();
  actions.reverse();
}

void CPlan::processPlan()
{
  std::PLAN_ACTIONS_CONTAINER<CPlanAction*>::iterator aIt;
  TPacket_SyncResult* retval;
  for (aIt=actions.begin();aIt!=actions.end();aIt++)
  {
    if (dynamic_cast<CUnitPlanAction*>(*aIt)) // akce jednotek
    {
      if (dynamic_cast<CUnitPlanAction_Go*>(*aIt))
      {
        CUnitPlanAction_Go* plan=dynamic_cast<CUnitPlanAction_Go*>(*aIt);
        PACKET_ACT_UNIT_MOVE paum;
        paum.player_id=player_id;
        paum.type=MSG_ACT_UNIT_MOVE;
        paum.unit_id=plan->unit_id;
        paum.target=plan->path_target;
        paum.transparency=plan->transparency;
        retval=(TPacket_SyncResult*) KSendGlobalMessage(MSG_WORLD_AI,MOD_STRATEGY,MOD_WORLD_SERVER,&paum);
#ifdef AI_LOGGING        
        LogAIActions.LogMsg("AI player %d action UNIT GO - {Unit ID: %d },{ Path Target: %d },{Path Transparency: %d }",player_id,plan->unit_id,plan->path_target,((int) (plan->transparency)));
#endif
      }
      else
      if (dynamic_cast<CUnitPlanAction_Attack*>(*aIt))
      {
        CUnitPlanAction_Attack* plan=dynamic_cast<CUnitPlanAction_Attack*>(*aIt);
        PACKET_ACT_UNIT_ATTACK paua;
        paua.player_id=player_id;
        paua.type=MSG_ACT_UNIT_ATTACK;
        paua.attacker=plan->unit_id;
        paua.target=plan->attack_target;
        retval=(TPacket_SyncResult*) KSendGlobalMessage(MSG_WORLD_AI,MOD_STRATEGY,MOD_WORLD_SERVER,&paua);
#ifdef AI_LOGGING        
        LogAIActions.LogMsg("AI player %d action UNIT ATTACK - {Unit ID: %d },{ Attack Target: %d }",player_id,plan->unit_id,plan->attack_target);
#endif
      }
      else
      if (dynamic_cast<CUnitPlanAction_HealWounded*>(*aIt))
      {
        CUnitPlanAction_HealWounded* plan=dynamic_cast<CUnitPlanAction_HealWounded*>(*aIt);
        PACKET_ACT_UNIT_HEAL pauh;
        pauh.player_id=player_id;
        pauh.type=MSG_ACT_UNIT_HEAL;
        pauh.unit_id=plan->unit_id;
        retval=(TPacket_SyncResult*) KSendGlobalMessage(MSG_WORLD_AI,MOD_STRATEGY,MOD_WORLD_SERVER,&pauh);
#ifdef AI_LOGGING        
        LogAIActions.LogMsg("AI player %d action UNIT HEAL - {Unit ID: %d }",player_id,plan->unit_id);
#endif
      }
      else
      if (dynamic_cast<CUnitPlanAction_EliteRecruit*>(*aIt))
      {
        CUnitPlanAction_EliteRecruit* plan=dynamic_cast<CUnitPlanAction_EliteRecruit*>(*aIt);
        PACKET_ACT_UNIT_RECRUIT_ELITE paure;
        paure.player_id=player_id;
        paure.type=MSG_ACT_UNIT_RECRUIT_ELITE;
        paure.unit_id=plan->unit_id;
        retval=(TPacket_SyncResult*) KSendGlobalMessage(MSG_WORLD_AI,MOD_STRATEGY,MOD_WORLD_SERVER,&paure);
#ifdef AI_LOGGING        
        LogAIActions.LogMsg("AI player %d action UNIT ELITE RECRUIT - {Unit ID: %d }",player_id,plan->unit_id);
#endif
      }
      else
      if (dynamic_cast<CUnitPlanAction_NonEliteRecruit*>(*aIt))
      {
        CUnitPlanAction_NonEliteRecruit* plan=dynamic_cast<CUnitPlanAction_NonEliteRecruit*>(*aIt);
        PACKET_ACT_UNIT_RECRUIT paur;
        paur.player_id=player_id;
        paur.type=MSG_ACT_UNIT_RECRUIT;
        paur.unit_id=plan->unit_id;
        retval=(TPacket_SyncResult*) KSendGlobalMessage(MSG_WORLD_AI,MOD_STRATEGY,MOD_WORLD_SERVER,&paur);
#ifdef AI_LOGGING        
        LogAIActions.LogMsg("AI player %d action UNIT NONELITE RECRUIT - {Unit ID: %d }",player_id,plan->unit_id);
#endif
      }
      else
      if (dynamic_cast<CUnitPlanAction_Release*>(*aIt))
      {
        CUnitPlanAction_Release* plan=dynamic_cast<CUnitPlanAction_Release*>(*aIt);
        PACKET_ACT_UNIT_SUICIDE paus;
        paus.player_id=player_id;
        paus.type=MSG_ACT_UNIT_SUICIDE;
        paus.unit_id=plan->unit_id;
        retval=(TPacket_SyncResult*) KSendGlobalMessage(MSG_WORLD_AI,MOD_STRATEGY,MOD_WORLD_SERVER,&paus);
#ifdef AI_LOGGING        
        LogAIActions.LogMsg("AI player %d action UNIT SUICIDE - {Unit ID: %d }",player_id,plan->unit_id);
#endif
      }
      else
      if (dynamic_cast<CUnitPlanAction_Build*>(*aIt))
      {
        CUnitPlanAction_Build* plan=dynamic_cast<CUnitPlanAction_Build*>(*aIt);
        PACKET_ACT_START_BUILDING pasb;
        pasb.player_id=player_id;
        pasb.type=MSG_ACT_START_BUILDING;
        pasb.location=plan->build_target;
        pasb.building_type=plan->building_type;
        pasb.orientation=plan->building_orientation;
        pasb.unit_id=plan->unit_id;
        retval=(TPacket_SyncResult*) KSendGlobalMessage(MSG_WORLD_AI,MOD_STRATEGY,MOD_WORLD_SERVER,&pasb);
#ifdef AI_LOGGING        
        LogAIActions.LogMsg("AI player %d action UNIT BUILD - {Unit ID: %d },{Build Target: %d },{Building Type: %d },{Building Orientation: %d }",player_id,plan->unit_id,plan->build_target,plan->building_type,plan->building_orientation);
#endif
      }
      else
      if (dynamic_cast<CUnitPlanAction_Repair*>(*aIt))
      {
        CUnitPlanAction_Repair* plan=dynamic_cast<CUnitPlanAction_Repair*>(*aIt);
        PACKET_ACT_REPAIR_BUILDING parb;
        parb.player_id=player_id;
        parb.type=MSG_ACT_REPAIR_BUILDING;
        parb.building_id=plan->building_id;
        parb.unit_id=plan->unit_id;
        retval=(TPacket_SyncResult*) KSendGlobalMessage(MSG_WORLD_AI,MOD_STRATEGY,MOD_WORLD_SERVER,&parb);
#ifdef AI_LOGGING        
        LogAIActions.LogMsg("AI player %d action UNIT REPAIR - {Unit ID: %d },{Building ID: %d }",player_id,plan->unit_id,plan->building_id);
#endif
      }
      else
      if (dynamic_cast<CUnitPlanAction_Spell*>(*aIt))
      {
      }
    }
    else
    if (dynamic_cast<CBuildingPlanAction*>(*aIt)) // akce budov
    {
      if (dynamic_cast<CBuildingPlanAction_TrainUnit*>(*aIt))
      {
        CBuildingPlanAction_TrainUnit* plan=dynamic_cast<CBuildingPlanAction_TrainUnit*>(*aIt);
        PACKET_ACT_BUILDING_RECRUIT_UNIT pabru;
        pabru.player_id=player_id;
        pabru.type=MSG_ACT_BUILDING_RECRUIT_UNIT;
        pabru.building_id=plan->building_id;
        pabru.unit_type=plan->trained_unit_type;
        retval=(TPacket_SyncResult*) KSendGlobalMessage(MSG_WORLD_AI,MOD_STRATEGY,MOD_WORLD_SERVER,&pabru);
#ifdef AI_LOGGING        
        LogAIActions.LogMsg("AI player %d action BUILDING TRAIN - {Building ID: %d },{Trained Unit Type: %d }",player_id,plan->building_id,plan->trained_unit_type);
#endif
      }
      else
      if (dynamic_cast<CBuildingPlanAction_Destroy*>(*aIt))
      {
        CBuildingPlanAction_Destroy* plan=dynamic_cast<CBuildingPlanAction_Destroy*>(*aIt);
        PACKET_ACT_BUILDING_SUICIDE pabs;        
        pabs.player_id=player_id;
        pabs.type=MSG_ACT_BUILDING_SUICIDE;
        pabs.building_id=plan->building_id;
        retval=(TPacket_SyncResult*) KSendGlobalMessage(MSG_WORLD_AI,MOD_STRATEGY,MOD_WORLD_SERVER,&pabs);
#ifdef AI_LOGGING        
        LogAIActions.LogMsg("AI player %d action BUILDING SUICIDE - {Building ID: %d }",player_id,plan->building_id);
#endif
      }
      else
      if (dynamic_cast<CBuildingPlanAction_SellBonus*>(*aIt))
      {
        CBuildingPlanAction_SellBonus* plan=dynamic_cast<CBuildingPlanAction_SellBonus*>(*aIt);
        PACKET_ACT_SELL_BONUS pasb;
        pasb.player_id=player_id;
        pasb.type=MSG_ACT_SELL_BONUS;
        pasb.building_id=plan->building_id;
        pasb.bonus_id=plan->bonus_type;
        retval=(TPacket_SyncResult*) KSendGlobalMessage(MSG_WORLD_AI,MOD_STRATEGY,MOD_WORLD_SERVER,&pasb);
#ifdef AI_LOGGING        
        LogAIActions.LogMsg("AI player %d action BUILDING SUICIDE - {Building ID: %d },{Bonus Type: %d }",player_id,plan->building_id,plan->bonus_type);
#endif
      }
    }
    else
    if (dynamic_cast<CCityPlanAction*>(*aIt))
    {
      if (dynamic_cast<CCityPlanAction_TrainBuilder*>(*aIt))
      {
      }
    }

    if (!retval) // chyba programu
    {
      THROW(E_8K_AI_Strategy_WrongPlanActionResponse,"Chybna odezva na AI akci !!!");
    }
    else
    if (!(retval->status)) // akce byla v poradku provedena
    {
      (*aIt)->done=true;
#ifdef AI_LOGGING        
      LogAIActions.LogMsg(" > DONE\n");
#endif
    }
    else
    if (retval->status) // nejaka herni chyba - neco co AI nepredpokladala
    {
      (*aIt)->done=false;
#ifdef AI_LOGGING        
      LogAIActions.LogMsg(" > NOT DONE - Return Status:  %d\n",retval->status);
#endif
    }

    delete retval; // smazu navratovou classu
  }
}

}
}