/**
  @file /ai/Strategizer/attacks.h
  @brief Header modulu utoku AI hrace.
  
  Header modulu utoku AI hrace.
  
  @author PZ
  @version 0.1
*/

#ifndef __PETR_ZITA_STRATEGY_ATTACKS__
#define __PETR_ZITA_STRATEGY_ATTACKS__

#pragma warning( disable : 4290 )

#include <iostream>
#include <vector>
#include <list>
#include <stdlib.h>
#include <time.h>

#include "ai/aiscriptids.h"
#include "ai/aiscriptcaller.h"
#include "ai/Strategizer/planning.h"
#include "ai/Strategizer/strategytypes.h"
#include "ai/Strategizer/strategyserialization.h"
#include "common/Interface.h"
#include "common/exc.h"
#include "common/Msg.h"
#include "common/Log.h"
#include "common/Interface.h"
#include "world/world_messages.h"
#include "world/useful.h"
#include "world/plan/plan.h"
#include "world/buildings/building.h"
#include "world/units/unit.h"


namespace ai_ns {
namespace strategizer_ns {

/** 
  Trida pro zpravu utocnych procesu a veskere utocne snahy AI hrace.
*/
class CStrategyAttackEngine
{
  public:
    /**
      Konstruktor.
      @param WorldPointers        sada ukazatelu zpristupnujici veskere struktury WORLDu
      @param SS                   ukazatel na instanci komponenty pro ukladani AI dat
    */
    CStrategyAttackEngine(TPacket_AI_LetsGo* WorldPointers,CStrategySerialization* SS);

    /** Destruktor. */
    ~CStrategyAttackEngine();

    /**
      Nastavi aktualniho AI hrace.
      @param passed_player_ID         World ID AI hrace
    */
    void setPlayer(int passed_player_ID);

    /** Zpracovava zaznamy o utocich. */
    void updateAttacks();

    /** Provede utoceni s jednotkami, jenz utocit mohou a maji v dosahu nejakeho nepritele. */
    void processAttackingWithUnusedUnits();

    /** Provede pruzkum neprozkoumanych oblasti mapy s nevyuzitymi jednotkami urcenymi pro utok. */
    void processExploringWithUnassignedAttackers();

  private:
    TPacket_AI_LetsGo* SIP;             ///< sada ukazatelu zpristupnujici veskere struktury WORLDu.
    int playerID;                       ///< World ID AI hrace
    CStrategySerialization* SS;         ///< ukazatel na instanci komponenty pro ukladani AI dat

    float AttackingGroupStrengthRatio;  ///< koeficient urcujici kolikrat musi byt sila utocne skupiny vetsi nezli sila obrancu
    int MinimalAttackPower;             ///< koeficient urcujici minimalni silu jakehokoliv utoku

    /** Nacte koeficienty specificke pro utocne manevry z TCL skriptu. */
    void loadAttackCoefs();

    /** 
      Pro daneho hrace identifikuje dle stavu diplomacie nejhorsiho nepritele.
      @param excluded_players         kontajner s IDcky hracu, jenz maji byt z identifikace vynechani
      @return int                     World ID nejhorsiho nepritele pro AI hrace
    */
    int identifyWorstEnemy(std::list<int>* excluded_players);

    /** 
      Zpracovava predany zaznam o utocnem procesu a provadi akce s prirazenymi jednotkami.
      @param attack_info          predany zaznam o utocnem procesu
    */
    void processAttack(TAIAttackInfo* attack_info);

    /** 
      Nalezne pro danou utocici jednotku nejvhodnejsi pozici pro utok na dany cil.
      @param attacker_id              World ID utocici jednotky
      @param target_hex               ID hexu, na kterem se nachazi cil utoku
      @return int                     ID hexu nejvhodnejsi pozice pro utok
    */
    int findBestAttackPosition(int attacker_id,int target_hex);

    /** 
      Nalezne nejvhodnejsi cil k utoku.
      @param attack_filter            filtr udavajici, jake cile utoku maji byt brany pri hledani v potaz
      @return int                     ID hexu s nejvhodnejsim cilem pro utok
    */
    int findBestAttackTarget(TAttackTargetFilter attack_filter);

    /** 
      Nalezne nejvhodnejsi synchronizacni bod pro utok (tj. misto shromazdeni jednotek) vzhledem k cili utoku.
      @param attack_target            ID hexu s cilem utoku
      @return int                     ID hexu s bodem synchronizace
    */
    int setSynchronizationPoint(int attack_target);

    /** 
      Urci dle k souradnic cile utoku jeho typ.
      @param attack_target              ID hexu s cilem utoku
      @return TAttackTargetType         typ cile utoku
    */
    TAttackTargetType getTargetType(int attack_target);

    /** 
      Urci branici silu cile utoku zadaneho jeho souradnicemi.
      @param attack_target              ID hexu s cilem utoku
      @return int                       sila obrany cile utoku
    */
    int getAttackTargetStrenght(int attack_target) throw(E_8K_AI_Strategy_InvalidAttackTarget);

    /** 
      Urci silu jednotky dle jejiho typu.
      @param unit_type                ID typu jednotky
      @return int                     sila jednotky
    */
    int getNewUnitStrength(int unit_type);

    /** 
      Urci nahodne typ nove jednotky (ze vsech dostupnych moznosti), jenz bude produkovana pro utok.
      @param unit_type                ID typu jednotky
      @return throw E_8K_AI_Strategy_CantFindUnitForAttack
      @return int                     typ nove jednotky, jenz bude produkovana pro utok
    */
    int selectToProduceRandomPossibleUnitForAttack() throw(E_8K_AI_Strategy_CantFindUnitForAttack);
};

} // end of namespace "strategizer_ns"
} // end of namespace "ai_ns"

#endif