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

  @file /gui/model/guimap.h
  @brief Mapa
  

  @author Pavel
  @version 0.1
 
******************************************************************************/
#ifndef GUIMAP_H
#define GUIMAP_H

#include "gui/common/minimap.h"
#include "gui/model/mapnet.h"
#include "gui/model/hexy.h"
#include "gui/engine/Scene.h"
#include "gui/engine/MapCamera.h"
#include "gui/engine/MapControllers.h"

#include "gui/model/TerrainEntity.h"  
#include "gui/model/guiBuilding.h"
#include "gui/model/guiUnit.h"

#include "world/plan/plan.h"
#include "world/world_messages.h"

#include "common/rm/rminit.h"

namespace gui{

/*******************************************************************************
	mapa lezi v rovine xz a kladna osa y de nahoru
	umisteni hexu [x,y]:
			/ [0,0]	\		
	/ [0,1]	\		/ [1,1]	\
	\		/ [0,2]	\		/
	/ [0,3]	\		/ [1,3]	\
	\		/ [0,4]	\		/

*******************************************************************************/
#define TAG2_TERRAINLIKE     0
#define TAG2_UNITLIKE        1



/** navratove hodnoty ALTITUDE */
#define GUIMAP_OUT		  0		///< dotaz [x,y] lezi mimo mapu
#define GUIMAP_OK		    1		///< dotaz [x,y] lezi v mape a nestoji na nem zadna prekazka
#define GUIMAP_BARRIER	2		///< dotaz [x,y] lezi v mape ale je tam nejaka prekazka


/** Mapa. */
class TguiMap : public TScene {
friend class TguiMapPreview; 
private:
	/// sit bodu pro modelovani terenu
	NET net;
	/// pomocna promenna pro kresleni cary
	float basicLineAltitude;

	/// hlavni kamera
  //@{
  /// Vedlejsi kamera.
	TMainCamera *debugcam;  
  /// Hlavni kamera.
	TMainCamera *maincam;
  /// Kontroler automatickeho pohybu kamery.
  TMovingCameraController* movcam;
  /// Kontroler ovladani kamery uzivatelem.
  TMainCameraController* camctrl;
  //@}

  /// control manager
	TMapControllerManager* cm;  

public: 

	/// data
  //@{
  std::map<int, TUnit*> guimap_units;            ///< pomocny vesak na jednotky
  std::map<int, TBuilding*> guimap_buildings;    ///< pomocny vesak na budovy
  PHex *hexy;						          ///< pole vsech hexu
	int hexycount;					        ///< pocet vech hexu
	int hwidth, hheight;		        ///< rozmery mapy v hexech
	float rwidth, rheight;	        ///< rozmery mapy ve svetovych souradnicich
  TWeatherController* wc;         ///< atmosfericky efekt, pocasi
  TSteeringKernelController* skc; ///< steering controller
  TEventPlayer* ep;               ///< prehravac sekvenci udalosti
  TVisibilityScheduler* vs;       ///< planovac odkryvani mapy
  void dump2DMap();  
  //@}

	/// udalosti na mape
  //@{
	void hexPreselect_sensor(int indx);
	void hexClicked_sensor(int indx);
	void unitClicked_sensor(TUnit* unit);
	void buildingClicked_sensor(TBuilding* build);
  void sceneScriptFinished_sensor();
  void unitMoved_sensor(TStep* step);
  void unitRemoved_sensor(TUnit* unit);
  void buildingRemoved_sensor(TBuilding* building);
  void visibilityAltered_sensor(TIntContainer* shown, TIntContainer* hidden, int player_id);
  //@}

  /// operace na mape
  //@{
  /// Osviti vybrane hexy priznakem tag.
  void highlightHexs(std::vector<HEX_ID>* hexes, int tag);
  /// Zhasne hexy s priznakem tag.
	void disableHexsHighlighting(int tag);
  //@}

  /// brany pro data - zpristupnuji data z worldu
  //@{
  World::MAP* getWorldMap();
  World::TLivingUnitsContainer* getWorldLivingUnits();
  World::TLivingBuildingsContainer* getWorldLivingBuildings();
  World::TTownsContainer* getWorldLivingTowns();
  World::TKingdomsContainer* getKingdoms();
  World::TWeather* getWorldWeather();
  //@}

  /// mesta & kralovstvi
  //@{
  /// Vrati vlastnika hexu(implementace v TGame).
  int getTownHexOwner(int hid);  
  /// Obsazeni mesta.
  void townOccupy(int townid, int newowner);
  /// Obsazeni kralovstvi.
  void kingdomOccupy(int kingdom, int newowner);
  //@}

	/// orientace
  //@{
  /// vrati odkaz na hex
	THex* getHex(int x, int y);
  /// prevod z 2d do 1d
	int getHexIndex(int x, int h);
  /// prevod z 1d do 2d souradnice
	void getHexCoords(int indx, int *x, int *y);
  /// hranice mapy
  void getExtents(float* minx, float* maxx,float* miny,float* maxy);
	/// do [hx,hy] ulozi index hexu ve kterem lezi bod [x,y].	Pokud tento bod lezi v nejakem hexu, funkce vrati 1 jinak 0
	int inWhichHex(float x, float y, int *hx, int *hy);
	/// do *y ulozi nadmorskou vysku bodu [x,z]. Vrati 1 pokud bod [x,z] lezi v planu jinak 0
	int altitude(float x, float y, float *z);
	/// do grad ulozi popis tecne roviny v bode [x,y]. Vraci 1/0 podle toho, zda bod [x,y] lezi v planu	vracene vektory nejsou normalizovane
	int getGradient(float x, float y, TGrad *grad);
	/// do p3f ulozi souradnice stredu hexu s indexem index
	void hexCentre(P3F *p3f, int index);
  //@}

  /// graficke operace na scene
  //@{
	/** nakresli na mape kolecko se stredem [x,y] a polomerem r. segments urcuje pocet car, ze kterych se kolecko sklada*/
	virtual void drawCircle(float x, float y, float r, int segments=16);
	/** nakresli caru z [x1,y1] do [x2, y2] ktera bude jakstaks kopirovat teren */
	void drawLine(float x1, float y1, float x2, float y2);
  /** nakresli vyplneny polygon */
  void drawFilledCircle(float x, float y, float r, int segments);
  //@}

  /// konstrukce & inicializace & destrukce
  //@{
	/// konstruktor, ktery nastavi pozici mapy na obrazovce a jeji rozmery v pixelech
	TguiMap(int _x, int _y, int _width, int _height);
	/// naplni scenu hexama a objektama podle Word
	void init();
	/// uvolni pamet s objektama
	void done();
  /// vytvori a umisti modely hexu, budov,...
	void initModels();
  //@}

  /// ShadowMapping
  //@{
  /// inicializace stinu
  void initShadowMapping();
  //@}
  
  /// Vykresleni & vstup
  //@{
	/// dedictvi po TActiveObject.
	virtual void drawObject();
	/// dedictvi po TActiveObject.
	virtual int workInput(INPUT *input);
  //@}

  /// pro prehlednost oddelene od workInput
	inline void onMouseOver(INPUT *input);
  /// pro prehlednost oddelene od workInput
	inline void onClick(INPUT *input);			
	
  /// Controller manager
  //@{
  /// Vraci Controller manager.
  gui::TMapControllerManager* getCM();
  //@}

  /// Manipulace s kamerou
  //@{
  /// Vrati kameru.
  gui::TCamera* getCam();  
  /// Aktivuje volny prulet nad krajinou.
  void freeFlight();
  /// Zrusi volny prulet nad krajinout.
  void cancelFreeFlight();
  /// Scrollovani na x,y, vraci absolutni cas ukonceni.
  int focus(float x, float y);
	/// Premisti pohled na hex o souradnicich [x,y], vrati 0 pokud takovy hex neexistuje.
	int setFocus(int x, int y);
  /// Premisti pohled nad hex indx.
	int setFocus(int indx);
  /// Synchronizuje druhou kameru s prvni.
  void syncDbgCam();
  //@}
  
  /// viditelnost
  //@{
	/// upravi co je videt na mape pro hrace playerid
	void updateVisibility(int playerid);
	/// upravi co je videt na mape pro hrace playerid (po danem kroku)
  void updateVisibility(int playerid, TIntContainer *shown, TIntContainer *hidden);
	/// upravi viditelnost hexu
	void updateHex(int hindex, World::VISIBILITY visibility);
  //@}  

  ///??
	virtual void reinstalObject(TSceneObject *so);
  ///??
	virtual void addObject(TSceneObject *so);
  /// spocita stupen utlumu v zavislosti na tag (typicky vola TSceneObject)
  virtual int getFadeFromTag(int tag, int tag2);

};


} // namespace;

#endif
/******************************************************************************/