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

  @file /gui/contexts/Game.h
  @brief Obrazovka Game
  

  @author Vajicek
  @version 0.1
 
******************************************************************************/
#ifndef GAME_H
#define GAME_H

#include "common/rm/rminit.h"
//
#include "gui/common/ActiveObjects.h"
#include "gui/common/ActiveObjects_ext.h"
#include "gui/common/chatbox.h"
#include "gui/common/Context.h"
#include "gui/model/guimap.h"
//
#include "world/world_messages.h"
//
#include "ai/Diplomacy/diptypes.h"


namespace gui{

/** Typ hernich a jinych gui akci */
enum TGameAction{ 
  gaAttack,         ///< utok
  gaMove,           ///< pohyb
  gaRepair,
  gaRecruitUnit, 
  gaBuild, 
  gaSellBonus,
  gaUnitSuicide, 
  gaBuildingSuicide, 
  gaStopBuilding, 
  gaHeal, 
  gaRecruit, 
  gaRecruitElite,                  
  gaNothing
};


/** Action Panel State */
enum TActionPanelState{ 
  apsBlank,                       ///< prazdno
  apsUnitSelection,               ///< zakladni akce jednotky
    apsUnitMove,                  ///< vyber cile pro pohyb
    apsUnitAttack,                ///< vyber cile pro utok
    apsConstructionSelection,     ///< vyber budovy pro stavbu
      apsConstructionPosition,    ///< vyber pozice pro stavbu
        apsConstructionControl,   ///< vyber orientace
    apsUnitRepair,                ///< vyber cile pro opravu oprava
    apsUnitSuicideConfirmation,   ///< potvrzeni sebevrzdy jednotky
  
  apsBuildingSelection,           ///< vyber akci budovy
    apsRecruitUnitSelection,      ///< vyber postavitelnych jednotek
    apsSellBonusSelection,        ///< vyber bonusu
    apsBuildingSuicideConfirmation///< potvrzeni sebezniceni budovy
};

/** Info Panel State */
enum TInfoPanelState{ 
  ipsBlank,       ///< prazdno
  ipsUnitInfo,    ///< informace o jednotce
  ipsBuildingInfo,///< informace o budove
  ipsHexInfo      ///< informace o hexu
};

/** velikost bufferu pro tlacitka */
//@{
#define MAX_UNITS_COUNT       15
#define MAX_BUILDINGS_COUNT   15
#define MAX_BONUS_COUNT       30
#define COMMON_BUTTONS_COUNT  4
#define MAX_EVENT_STRING_LEN  255
//@}

/** Vyvojarska konzole. */
class TMyConsoleWindow: public TConsoleWindow {
public:
  virtual void consoleInput(char* str);
  TMyConsoleWindow();
};

/** Nastaveni hry. */
class TGameSetting : public TWindow {
public:
  int fspeed;         ///< Puvodni nastaveni rychlosti.
  float fsoundvolume; ///< Puvodni nastaveni hlasitosti zvuku.
  float fmusicvolume; ///< Puvodni nastaveni hlasitosti hudby.

  /// GUI prvky.
  //@{
  TLabel *lsettingcaption;
  TLabel *lspeedcaption;
  TScrollBar *sspeed;
  TLabel *musicvolumecaption;
  TScrollBar *smusicvolume;
  TLabel *soundvolumecaption;
  TScrollBar *ssoundvolume;
  TButton *bok;
  TButton *bcancel;
  //@}
  TGameSetting();
  virtual int workInput(INPUT *input);
  /// Updatuje obsah & zobrazi
  virtual void show();
  /// Obnovi puvodni & zavre
  void cancel();
  /// Ulozi & zavre
  void ok();
};

/** Ulozeni hry. */
class TSaveGame : public TWindow {
private:
  rm::TRM_map_i* rmmapi;
  rm::TRM_txt_i *rmtxti;
public:  
  /// GUI prvky.
  //@{
  TLabel *lsavedgames;
  TLabel *lsaveas;
  TTextButton *bsave;
  TTextButton *bback;
  TTextButton *bdelete;
  TListBar *listbar;
  TLineTextField *lfname;
  //@}
  TSaveGame();
  ~TSaveGame();
  virtual int workInput(INPUT *input);
  /// Updatuje a zobrazi.
  virtual void show();
  /// Obnovi obsah GUI seznamu map.
  void updateMapsList();
  /// Zjisti ID zvolene mapy.
  int selectedMapID();
};

/** Hlavni menu. */
class TGameMenu : public TWindow {
public:
  /// okno s nabidkou
  TWindow* menu;
  /// okno s nastavenim
  TGameSetting *gamesetting;
  /// okno pro ulozeni hry
  TSaveGame *savegame;

  /// obsah nabidky
  //@{
  TTextButton *bsave;
  TTextButton *boptions;
  TTextButton *bresume;
  TTextButton *bquit;
  //@}
  TGameMenu();
  int workInput(INPUT *input);
  /// Upravi obash & zobrazi.
  virtual void show();
  /// Skryje okna.
  virtual void hide();
};

/** Okno diplomacie. */
class TDiplomacyWindow : public TWindow {
private:
  /// GUI prvky.
  //@{
  TTextButton *tbclose;
  TLabel *wincap;
  TGroupBar *relations_frame;
  TGroupBar *diplomat_frame;
  TIconButton *relation[8];
  //@}
  int lastRelationOffer[8]; ///< Pamatuje si stav nabidky pri zobrazeni dialogu.
  int relcount;             ///< Pocet vztahu.
  int playerscnt;           ///< Pocet hracu.
  /// Rmtxt pro dialog.
  rm::TRM_txt_i *rmtxti;
  /// Prevadi id vztahu na id retezce.
  int relText(ai_ns::diplomacy_ns::TRelationship rs);
  /// Vraci ikonu podle id vztahu.
  rm::TSymbolData* relIcon(ai_ns::diplomacy_ns::TRelationship rs);
public:
  TDiplomacyWindow();
  ~TDiplomacyWindow();
  virtual int workInput(INPUT *input);
  /// Aktualizuje obsah GUI.
  virtual void show();
};

/** Okno udalosti. */
class TEventsWindow : public TWindow {
private:
  TListBar* lbenventslist;
  TTextButton* tbClose;
  TTextButton* tbCenter;
  TTextButton* tbWarningsFilter;
  TTextButton* tbInfosFilter;
  TTextButton* tbCommentsFilter;
  TEventVector events;
  //
  int iShowWarnings;
  int iShowInfos;
  int iShowComments;
public:
  TEventsWindow();
  virtual int workInput(INPUT *input);

  /// Updatuje obsah seznamu udalosti podle datovych struktur.
  void updateContent();
  /// Prida radek udalosti do gui.
  void addLine(TEventInfo* ei);
  /// Smaze gui a datovou strukturu.
  void clearList();
  /// Prida udalost do gui a do datove struktury.
  void addEvent(TEventInfo* ei);
};

/** Hra. */
class TGame : public TContext {
private:
  rm::TRM_txt_i *rmtxti;
  wchar_t wtemp[LABEL_MAX_LENGTH];

  /// GUI kontrolky
  //@{
  /// maly panel nahore, kde bude napsano mnozstvi penez,...
  TWindow *statuspanel;
    /// cudlik, ktery kdyz se zmackne, tak se objevi menu
    TTextButton *tbmenu;
    // tlacitko na vyvolani dialogu diplomacie
    TTextButton *tdiplomacy;
    // tlacitko na vyvolani info okna
    TTextButton *tinfo;
    /// okno s menu
    TGameMenu *gamemenu;
    // dialog diplomacy
    TDiplomacyWindow *diplomacywindow;
    /// obrazek zlata
    TIcon *iplayer;
    /// label s jmenem hrace na tahu
    TLabel *lplayername;
    /// obrazek zlata
    TIcon *igold;
    /// kolik zlata ma hrac na tahu
    TLabel *lmoney;
    /// obrazek zlata
    TIcon *ihex;
    /// hex index
    TLabel *lhex;
    ///
    TEventsWindow* eventswindow; 
  /// velka mapa
  TguiMap *guiMap;
  /// osd pres mapu
  TOSD *osd;
  /// chatovani do osd
  TOSDChatBox *osdchat;
  /// console
  TConsoleWindow *console_wnd;
  /// velky panel dole s informacemi
  TWindow *infopanel;
  /// mala mapa v rohu
  TguiMiniMap *guiMiniMap;
  /// bar, kam se budou psat informace o vybranem objektu
  TGroupBar *guiinfo;
  /// portret jednotky/budovy/..
  TIcon *portrait;
  /// jednotka uvnitr budovy
  TIconButton* unitinside;
    /// ikony vlivu na jednotku
    /// bar, kde budou cudliky s akcemi: goto, attack, build, repair..
    TListBar *listOfActions;
      /// pointery na tlacitka akci jednotek
      TIconButton* unit_action_buttons[UNIT_ACTION_COUNT];
      /// pointery na tlacitka akci budov
      TIconButton* building_action_buttons[BUILDING_ACTION_COUNT];
      /// pointery na tlacitka rekrutovani
      TIconButton* recruit_unit_buttons[MAX_UNITS_COUNT];
      /// pointery na tlacitka stavby
      TIconButton* construction_building_buttons[MAX_BUILDINGS_COUNT];
      /// pointery na tlacitka bonusu      
      TIconButton* bonus_buttons[MAX_BONUS_COUNT];
      /// pointery na obecna tlacitka
      TIconButton* common_buttons[COMMON_BUTTONS_COUNT];
    /// tlacitko "dalsi kolo"
    TIconButton* ibNextTurn;
    /// tlacitko "dalsi jednotka"
    TIconButton* ibNextUnit;
    /// tlacitko "predchozi jednotka"
    TIconButton* ibPrevUnit;
    /// alternativni 
    TGroupBar* gbCanvas;    
  /// opona
  TCurtain* curtain;
  //@}

  /// resource manager textu
  rm::TRM_txt_i* RMtxti;

  /// data z worldu
  //@{
  /// mapa sveta - odkaz do Worldu
  World::MAP * map;
  /// maska, co hraci vidi
  World::TVisibilityMapsContainer *visibility_maps;
  /// jednotky - odkaz do Worldu
  World::TLivingUnitsContainer * living_units;
  /// budovy - odkaz do Worldu
  World::TLivingBuildingsContainer * living_buildings;
  /// hraci - odkaz do Worldu
  World::TPlayerContainer * players;
  /// mesta - odkaz do Worldu
  World::TTownsContainer * towns;
  /// mesta - odkaz do Worldu
  World::TKingdomsContainer * kingdoms;
  /// pocasi - odkaz do Worldu
  World::TWeather * weather;
  //@} 

public:

  /// inicializacni, aktivacni a deaktivacni kontextovej balast
  //@{ 
  TGame(TContextParameter contextparameter);
  virtual ~TGame();
  static TContext* createContext(...);
  virtual void activateContext(TContextParameter contextparameter);
  virtual void deactivateContext();
  //@}

  /// vystup a vstup
  //@{
  void updateActionsPanel();
  void updateInfoPanel();
  void updateStatusBar();
  void updateVisibility(int playerid);
  void updateVisibility(int playerid, TStep *stp);
  void updateVisibility(int playerid, TIntContainer *shown, TIntContainer *hidden);
  //
  void DbgInfo();
  virtual void drawContext();
  virtual int workInput(INPUT *input);
  //
  /// Zamek pri zpracovavani akci, ktere chodi z Worldu.
  int actionLock;   
  /// Zamek pri zpracovavani vstupu, ktere chodi z engine.
  int inputLock;  
  /** Zamkne vstup.
    @param logmsg Ladici zprava.
  */
  void lockInput(char* logmsg="");
  /** Odemkne vstup.
    @param logmsg Ladici zprava.
  */
  void unlockInput(char* logmsg="");
  /** Zamkne zpracovani akci.
    @param logmsg Ladici zprava.
  */
  void lockActions(char* logmsg="");
  /** Odemkne zpracovani akci.
    @param logmsg Ladici zprava.
  */
  void unlockActions(char* logmsg="");
  //
  /** Vytvori herni udalost.
    Ulozi do vektoru udalosti hrace player udalost typu eit s popiskem msg.
    @param player Hrac.
    @param eit Typ udalosti.
    @param loc Misto udalosti.
    @param msg Zprava.
    @return Udalost, je mozne modifikovat jeji data.
  */
  TEventInfo* GAME_EVENT(int player, TEventInfoType eit, int loc, wchar_t* msg, ...);
  /** Herni zprava. 
    Zobrazi herni zpravu na OSD.
    @param msg Text zpravy.
    @param r Barevna slozka.
    @param g Barevna slozka.
    @param b Barevna slozka.
  */
  void GAME_MSG(wchar_t* msg, float r=1, float g=1, float b=1);
  //@}

  /// stavove informace
  //@{
  int iLocalGame;                       ///< v gui bezi lokalni hra = vic lidi jedenen pocitac
  int iGUIOwner;                        ///< hrac(role) ktery vidi hru, pravdepodobne jen role ovladane clovekem
  int iPlayerOnTurn;                    ///< hrac na tahu, pouzivat kvuli nesynchronizaci s worldem
  //
  std::map<int, TEventVector*> events;  ///< seznam udalosti pro uzivatele, VLASTNI DATA
  //
  TUnit*            selected_unit;        ///< zakliknuta jednotka
  TBuilding*        selected_building;    ///< zakliknuta budova
  std::map<int,int> selectable_hexes_map; ///< zvolene hexy(klic je id hexu, hodnota jsou dalsi data)
  int               selected_hex_index;   ///< zakliknuty hex
  int               preselected_hex_index;///< zakliknuty hex
  TBuilding*        dummy_building;       ///< falesna budova
  //
  TActionPanelState actionsPanelState;  ///< kouzleni, staveni, rekrutovani, trenovani
  TInfoPanelState   infoPanelState;     ///< jednotka, budova, hex, ...
  //
  int selected_building_to_build;       ///< zvolena budova ke stavbe
  int selected_bonus_to_sell;           ///< zvoleny bonus k nakupu
  int selected_unit_to_recruit;         ///< zvolena jednotka k nakupu
  //
  SDL_Thread *loading_thread;
  //
  /// Vynuluje stavy
  void nullStates();
  /// Vynuluje pole s tlacitky
  void nullButtons();
  //@}
  
  /// udalosti ze senzoru gui(guimapa)
  //@{
  bool isSelectable(int id);
  void hexClicked(int indx);
  void unitClicked(TUnit* unit);
  void buildingClicked(TBuilding* build);
  void animationFinished();
  void visibleEnemyMoved(int hid);        
  void enemyAppeared(int hid);        
  //@}

  /// herni akce(vnitrni stavy, vnejsi stavy=posilani zprav worldu)
  //@{
  void hexSelected(int indx);
  void hexUnselected();
  void unitSelected(TUnit* unit);
  void unitUnselected();
  void buildingSelected(TBuilding* build);
  void buildingUnselected();
  void actionSelected( TGameAction ga );
  //
  void focusUnit(TUnit* found_unit);
  void focusHex(int indx);
  void nextTurn();
  TUnit* nextUnit();
  TUnit* prevUnit();
  //@}

  /// udalosti z worldu(prichozi zpravy)
  //@{
  void attackUnit(TPacket_RCT_UNIT_ATTACK* rua);
  void moveUnit(int luid, TPath *path);
  void unitSuicide(TPacket_RCT_UNIT_SUICIDE* rus);
  void buildingSuicide(TPacket_RCT_BUILDING_SUICIDE* rbs);
  void recruitUnit(TPacket_RCT_BUILDING_RECRUIT_UNIT* rbru);
  void startBuilding(TPacket_RCT_START_BUILDING* rsb);
  void buildingOccupied(TPacket_BUILDING_OCCUPIED* bo);
  void townOccupied(TPacket_TOWN_OCCUPIED *to);
  void kingdomOccupied(TPacket_KINGDOM_OCCUPIED *ko);
  void unitRecruit(TPacket_RCT_UNIT_RECRUIT* ur);
  void unitRecruitElite(TPacket_RCT_UNIT_RECRUIT_ELITE* ure);
  void unitHeal(TPacket_RCT_UNIT_HEAL* uh);  
  void repairBuilding(TPacket_RCT_REPAIR_BUILDING* rb);
  void stopBuilding(TPacket_RCT_STOP_BUILDING* sb);
  void sellBonus(TPacket_RCT_SELL_BONUS* sb);
  void diplomacyChange(TPacket_DIPLOMACY_RELATION_CHANGE* drc);  
  void playerChanged(TPacket_RCT_NEXT_TURN* rnt);
  void playerDefeated(TPacket_PLAYER_DEFEATED* pd);
  void endGame(TPacket_END_GAME* eg);
  void errorResult(TPacket_ErrorResult* er);
  void loadGameMap(PACKET_LETS_GO *plg);
  //@}

  /// ostatni udalosti
  //@{
  /// prichod chatovaci zpravy
  void chatMsg(TPackage *p);
  /// jiny hrac se odpojil od serveru
  void clientDisconnected(int cid);
  /// Someone has returned back
  void clientReconnected(int cid);
  /// ukoncovani hry
  void gameEnding();
  //@}

  /// data z worldu
  //@{
  void getWorldData(World::MAP** m, World::TLivingUnitsContainer** lu, World::TLivingBuildingsContainer** lb);
  void getWorldData(World::TTownsContainer** ts, World::TKingdomsContainer** k);
  void getWorldPlayers(World::TPlayerContainer **pls);
  void getWorldVisibility(World::TVisibilityMapsContainer **vmaps);
  void getWorldWeather(World::TWeather **weat);
  //@}

  /// zjistovaci
  //@{
  /** Prevadti hex s terenem mesto na jmeno mesta
    Pri nenalezeni mesta vrati retezec "mesto".
    @param si Idcko hexu.
    @param[out] w Buffer pro jmeno.
    @param maxlen Delka bufferu.
  */
  void getTownName(int si, wchar_t* w, int maxlen);
  /** Prevadi prevadi typ terenu na jmeno.
    @param tt Typ terenu.
    @param[out] w Buffer pro jmeno.
    @param maxlen Delka bufferu.
  */
  void getTerrainName(World::TERRAIN_TYPE tt, wchar_t* w, int maxlen);
  /** Zjisti vlastnika mesta.
    @param hid Id hexu.
    @return Id vlastnika mesta. 
  */
  int getTownHexOwner(int hid);  
  //@}

  friend int loadingMap_thread(void* data);
  friend class TMyConsoleWindow;
  friend class TGameSetting;
  friend class TEventPlayer;
  friend class TguiMapPreview;
  friend class TguiMap;

  //debug
  int b_loss; 
  int b_kill; 
  int b_dmgs; 
  int b_ad; 
  int b_dd; 
  int b_bd; 
  int b_dbg;
};




}//namespace
#endif