/**
******************************************************************************

  @file /common/rm/rmmapi.h
  @brief Interface k RMmap
  
  @author Vta
  @version 1.0

******************************************************************************/

#ifndef _RMmapi_
#define _RMmapi_

#include "common/rm/rmmap.h"


namespace rm
{

/// Interface k RMmap
class TRM_map_i
{
  public:

/** @name Informace o mapach */
//@{
    
    /** Ziska (priradi na misto kam ukazaju info ukazatel) informace o mape. Jelikoz je index jednoznacny pro nove i ulozene mapy, staci k identifikaci jeden index id. */
    void getMapInfo(TMapInfo ** info,int id);

    /** Ziska informace o mapach nebo ulozenych hrach. Je nutne to povazovat za readonly data. */
    void getMapsInfo(DA<TMapInfo*> ** info,int maptype);

    /** Vraci pocet map k dispozici (podle poctu nactenych hlavicek map) */
    int getMapsCount(int maptype); 

    /** Vraci nejvetsi pouzite id */
    int getMapsMaxId(int maptype); 

    /** Nacte aktualni informace o danem typu map. Puvodni informace se smazou a jsou nacteny vsechny znovu.
        @param maptype nabyva bud \ref MAP_TYPE_NEW_GAME nebo \ref MAP_TYPE_SAVE_GAME
        @param refresh zda se maji informace nacitat znovu (pokud 1), pokud uz byly nactene
    */
    void loadMapsInfo(int maptype,int refresh); 

//@}

/** @name Nacitani a uvolnovani dat */
//@{

    /** Nacte okamzite mapu, ve stejnem vlakne */
    void loadMapNow(int id); 

    void loadMap(char * filename,int maptype);

    /** Prida pozadavek na nacteni. Ma smysl davat pozadavek pouze na jednu mapu, jelikoz v pameti muze byt nactena pouze jedna */
    void request(int id);

    /** Zpracuje pozadavky na nacteni */
    void loadBuffer();
 
    /** Zpracuje pozadavky na nacteni v jinem vlakne */
    void prepareGame();

    /** Uvolni nactenou mapu. Pokud se zrovna nacita mapa v jinem vlakne, pocka az se donacte */
    void freeData();

    /** Vraci jestli je mapa nactena */
    int isMapLoaded();

    /** Vraci id aktualne nactene mapy */
    int idOfLoadedMap();

    /** Oznaceni mapy pro pozdejsi vyber */
    void selectMap(int id);

//@}

/** @name Ziskani a vraceni dat */
//@{

    /** Ziska ukazatel na hex s danym id z dat v RM */
    World::HEX * getHex(int id);

    /** Ziska hexy. Pred koncem programu je nutne volat \ref setHexes(HEX ** map)
        @param map je ukazatel na pole ukazatelu na struktury, predava se odkaz na data v RM
    */
    int getHexes(World::HEX *** map);

    /** Ziska zivouci jednotky. Predava se odkaz na data v RM. Pred koncem programu je nutne volat \ref setLivingUnits, do te doby nelze data znovu ziskat */
    void getLivingUnits(DA<World::LIVING_UNIT *> ** units);

    /** Ziska jednu jednotku. Predava se odkaz na zaznam v poli z RM */
    void getLivingUnit(World::LIVING_UNIT ** unit,int id);

    /** Ziska zivouci budovy. Predava se odkaz na data v RM. Pred koncem programu je nutne volat \ref setLivingBuildings, do te doby nelze data znovu ziskat */
    void getLivingBuildings(DA<World::LIVING_BUILDING *> ** buildngs);

    /** Ziska jednu budovu. Predava se odkaz na zaznam v poli z RM */
    void getLivingBuilding(World::LIVING_BUILDING ** building,int id);

    /** Ziska informace o kralovstvi. Predava se odkaz na data v RM. Pred koncem programu je nutne volat \ref setKingdoms, do te doby nelze data znovu ziskat */
    void getKingdoms(TKingdomInfo *** kingdoms);

    /** Ziska informace o mestech. Predava se odkaz na data v RM. Pred koncem programu je nutne volat \ref setCities, do te doby nelze data znovu ziskat */
    void getCities(DA<TCityInfo *> ** cities);

    /** Ziska informace o historicke mape 
        @param hmap je ukazatel na pole ukazatelu na pole (pro kazdeho hrace jedna mapa) ukazatelu na struktury (vlastni data), predava se odkaz na data v RM
    */
    void getHistoryHexes(World::HISTORY_HEX **** hmap); 

    /** Ziska informace o aktualnim stavu. Predava se odkaz na data v RM. Pred koncem programu je nutne volat \ref setCurrentState, do te doby nelze data znovu ziskat */
    void getCurrentState(TStateInfo ** state);

    /** Ziska plan AI */
    void getAIPlan(TAIPlan ** plan);


    /** Zaznamena predtim odebrane hexy. \see getHexes(HEX *** map) */
    void setHexes(World::HEX ** map); 

    /** Vraci predtim odebrane budovy */
    void setLivingUnits(DA<World::LIVING_UNIT *> * units); 

    /** Vraci predtim odebrane jednotky */
    void setLivingBuildings(DA<World::LIVING_BUILDING *> * buildngs);

    /** Vraci predtim odebrane informace o kralovstvi */
    void setKingdoms(TKingdomInfo ** kingdoms); 

    /** Vraci predtim odebrane informace o mestech */
    void setCities(DA<TCityInfo *> * cities); 

    /** Vraci predtim odebrane informace o historicke mape */
    void setHistoryHexes(World::HISTORY_HEX *** hmap); 

    /** Vraci informace o aktualnim stavu */
    void setCurrentState(TStateInfo * state);

    /** Vrati plan AI */
    void setAIPlan(TAIPlan * plan);

//@}

/** @name Pridavani a mazani map */
//@{
    /** Prida mapu (zaradi se mezi ostatni). Data se kopiruji. Vraci id, na ktere se mapa pridala. */
    int addMap(TMapInfo * info, int maptype);

    /** Smaze ze seznamu map i z disku */
    void delMap(int id); // odebere mapu

    /** Zapise mapu do jejiho souboru.
        @param maptype pouze urcuje, jestli bude zapsana mezi nove mapy nebo rozehrane hry
        @param newname jmeno (noveho) souboru, do ktereho se ma mapa ulozit. Pokud je newname prazdne (tj. newname[0] je 0), ulozi se to do pudovniho souboru.
    */
    void saveMap(int maptype,char * newname);
//@}

    /** Konstruktor, ktery musi obsahovat odkaz na RM, ke kteremu toto bude interface */
    TRM_map_i(TRM_map * globalrmmap); 

    /** Destruktor */
    ~TRM_map_i();
  private:
    /** RM ke kteremu je tento interface */
    TRM_map * rmmap;

    /** Id treadu pri nacitani mapy */
    struct SDL_Thread * threadid; 
};

} // namespace rm

#endif // indef _RMmapi_
/*****************************************************************************/