/**
  @file /ai/PathFind/pathfindskelet.h
  @brief Header s implementaci obecne kostry A* algoritmu na vyhledavani cesty.
  
  Header s implementaci obecne kostry A* algoritmu na vyhledavani cesty.
  
  @author PZ
  @version 0.1
*/

#ifndef __PETR_ZITA_PATHFINDING_SKELET__
#define __PETR_ZITA_PATHFINDING_SKELET__

#pragma warning( disable : 4290 )

#include "common/mm.h"
#include "common/exc.h"
#include "common/types.h"
#include "ai/ai_makra.h"
#include "ai/PathFind/pathenv.h"

namespace ai_ns {
namespace pathfind_ns {

/**
Trida CPathFindingSkelet obsahuje univerzalni kostru A* algoritmu.
Je ciste virtualni, tudiz nemuze byt instanciovana.
*/
class CPathFindSkelet
{
public:
  /** Konstruktor. */
  CPathFindSkelet();
  /** Destruktor. */
  ~CPathFindSkelet();

  /**
    Metoda pro nalezeni cesty zakladni verzi A* algoritmu.

    @param unit_id                  ID jednotky hledajici cestu
    @param start                    souradnice startovni pozice
    @param target                   souradnice cilove pozice
    @param pathfind_transparency    pozadovana transparence pri vyhledavani cesty
    @return TPATH                   (kontajner s nalezenou cestou)
  */
  TPATH astarSimple(int unit_id,COORDS & start,COORDS & target,const TPathFindTransparency & pathfind_transparency);
  /**
    Metoda pro nalezeni cesty verzi A* algoritmu vyuzivajiciho haldy.

    @param unit_id                  ID jednotky hledajici cestu
    @param start                    souradnice startovni pozice
    @param target                   souradnice cilove pozice
    @param pathfind_transparency    pozadovana transparence pri vyhledavani cesty
    @return TPATH                   (kontajner s nalezenou cestou)
  */
  TPATH astarHeaps(int unit_id,COORDS & start,COORDS & target,const TPathFindTransparency & pathfind_transparency);
  /**
    Metoda realizujici floodfill algoritmus vyuzivajici zakladni verzi A* algoritmu.

    @param unit_id                  ID jednotky hledajici cestu
    @param start                    souradnice startovni pozice
    @param gmmff                    vstupni mapa priznaku kde vsude prohledavat
    @param rc                       vystupni maska floodfill algoritmu
    @param pathfind_transparency    pozadovana transparence pri floodfilu
    @return void                   
  */
  void astarFloodSimple(int unit_id,COORDS & start,PF_MARKMAP & gmmff,FLOOD_MASK &rc,const TPathFindTransparency & pathfind_transparency) throw(E_8K_AI_Pathfind_BadFloodFillStartingPoint);
  /**
    Metoda realizujici floodfill algoritmus vyuzivajici verzi A* algoritmu s haldami.

    @param unit_id                  ID jednotky hledajici cestu
    @param start                    souradnice startovni pozice
    @param gmmff                    vstupni mapa priznaku kde vsude prohledavat
    @param rc                       vystupni maska floodfill algoritmu
    @param pathfind_transparency    pozadovana transparence pri floodfilu
    @return void                   
  */
  void astarFloodHeaps(int unit_id,COORDS & start,PF_MARKMAP & gmmff,FLOOD_MASK &rc,const TPathFindTransparency & pathfind_transparency) throw(E_8K_AI_Pathfind_BadFloodFillStartingPoint);

  /** Metoda pro zjisteni sirky mapy na ktere je realizovano vyhledavani. */
  virtual int getMapWidth()=0;
  /** Metoda pro zjisteni vysky mapy na ktere je realizovano vyhledavani. */
  virtual int getMapHeight()=0;
  /** Metoda pro nastaveni sirky mapy na ktere je realizovano vyhledavani. */
  virtual void setMapWidth(int value)=0;
  /** Metoda pro nastaveni vysky mapy na ktere je realizovano vyhledavani. */
  virtual void setMapHeight(int value)=0;

protected:
  /** Mapa priznaku pro A* Pathfind algoritmus. */
  PF_MARKMAP mm;
  /** Mapa priznaku pro A* Floodfill algoritmus. */
  PF_MARKMAP mmff;
  /** Pozadovana transparence. */
  TPathFindTransparency pft;
  /** Souradnice ciloveho hexu. */
  COORDS target_hex_coords;

private:
  /** Seznam pro otevrene uzly v zakladni verzi A* algoritmu. */
  TLIST Open;
  /** Seznam pro uzavrene uzly v zakladni verzi A* algoritmu. */
  TLIST Closed;
  /**
    Metoda pro alokaci a naplneni uzlu pro zakladni verzi A* algoritmu.

    @param su       souradnice uzlu
    @param g        cena za dosazeni uzlu
    @param h        odhad ceny cesty z nove vytvoreneho uzlu do ciloveho
    @param _parent  ukazatel na rodicovsky uzel
    @return TNode*  (ukazatel na vytvoreny uzel)
  */
  TNode* createNode(COORDS & su,int g,int h,TNode* _parent);
  /** Metoda, ktera prida uzel do seznamu otevrenych uzlu. */
  void addToOpen(TNode* au);
  /** Metoda, ktera presune uzel ze seznamu otevrenych uzlu do seznamu uzavrenych uzlu. */
  void moveToClosed(TNode* mu);
  /** Metoda, ktera vrati nejvhodnejsi otevreny uzel pro expanzi. */
  TNode* bestNode();
  /** Metoda, ktera dealokuje seznam uzlu. */
  void freeList(TLIST & lh);

  
  /** Halda pro otevrene uzly A* algoritmu vyuzivajici haldy. */
  THEAP OpenHeap;
  /** Halda pro uzavrene uzly A* algoritmu vyuzivajici haldy. */
  THEAP ClosedHeap;
  /** Pole ukazatelu na hodnoty uzlu pro danou mapu. */
  THeapNodeValues** HeapNodesMap;
  /**
    Metoda pro alokaci a naplneni hodnot uzlu pro A* algoritmus vyuzivajici haldy.

    @param su                 souradnice uzlu
    @param g                  cena za dosazeni uzlu
    @param h                  odhad ceny cesty z nove vytvoreneho uzlu do ciloveho
    @param _parent            ukazatel na rodicovske hodnoty uzlu
    @return THeapNodeValues*  (ukazatel na vytvorene hodnoty uzlu)
  */
  THeapNodeValues* createHeapNode(COORDS & su,int g,int h,THeapNodeValues* _parent);
  /**
    Metoda pridavajici uzel s predanymi hodnotami do haldy.

    @param heap                     halda, do ktere se pridava uzel s hodnotami
    @param added_heap_node_values   pridavane hodnoty uzlu
    @param CheckHeapNodesMap        priznak, zdali updatovat pole ukazatelu na hodnoty uzlu pro danou mapu
    @return void
  */
  void addToHeap(THEAP& heap,THeapNodeValues* added_heap_node_values,bool CheckHeapNodesMap);
  /** Metoda vracejici hodnoty uzlu v koreni, odebirajici koren i s naslednou konsolidaci haldy. */
  THeapNodeValues* popHeapRoot(THEAP& heap);
  /** Metoda vracejici priznak, zdali je halda prazdna. */
  bool heapIsEmpty(THEAP& heap);
  /** Metoda, ktera dealokuje uzel haldy a jeho potomky. */
  void freeHeapTree(THeapNode* & heap_root);
  /** Metoda, ktera dealokuje haldu. */
  void freeHeap(THEAP& heap);

  /* Metoda realizujici inicializaci mapy priznaku pro A* Pathfind. */
  void initMarkMap();
  /* Metoda realizujici inicializaci mapy priznaku pro A* Flooding. */
  void initMarkMapForFlood(PF_MARKMAP &gmmff);

  /** Metoda zjistujici validitu souradnic na mape. */
  virtual bool validSou(COORDS & s)=0;
  /**
    Metoda zjistujici cenu prechodu z jednoho hexu na druhy pro danou jednotku.
    Pro samotny vypocet se vola modul World.

    @param unit_id      ID jednotky, se kterou chci pohyb udelat
    @param done_cost    cena cesty, kterou jiz jednotka usla
    @param startsou     souradnice startovniho hexu
    @param targetsou    souradnice ciloveho hexu
    @return int (cena prechodu)
  */  
  virtual int getCost(int unit_id,int done_cost,COORDS & startsou,COORDS & targetsou)=0;
  /** Metoda vracejici seznam sousednich uzlu pro urcity typ mapy. */
  virtual TNEIGHBOURS chooseNeighbours(COORDS & sour)=0;
  /** Metoda vracejici heuristicky odhad cesty pro urcity typ mapy. */
  virtual int heuristicFunction(COORDS & start,COORDS & target)=0;
};

} // end of namespace "pathfind_ns"
} // end of namespace "ai_ns"

#endif