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

  @file /gui/model/guiBuilding.h
  @brief Predchudce pro vsechny stavby


  @author Vajicek
  @version 0.1
 
******************************************************************************/

#ifndef GUIBUILDING_H
#define GUIBUILDING_H

#include "gui/common/mymath.h"
//
#include "gui/engine/Scene.h"
#include "gui/engine/AdvGeom.h"
#include "gui/engine/BuildingControllers.h"
#include "gui/engine/Effects.h"
//
#include "gui/model/ModelRep.h"
#include "gui/model/hexy.h"
//
#include "common/rm/rminit.h"
//

#include <vector>

namespace gui{

#ifdef SIMPLE_SHADOWS
  /// vykreslovat stiny
  #define DRAW_BUILDING_SHADOWS
#endif

/** Typ struktury. */
enum TStructureType {
  stClosedBuilding= 0, 
  stOpenBuilding  = 1
};

/** Typ sablony pro budovu. */
struct TGUIBuildingInfo{
  int bid;                      ///< id typu
  TModel* mod;                  ///< model postavene budovy
  TModel* construction_mod;     ///< model stavniste
  TStructureType structuretype; ///< typ struktury
  int orientation_count;        ///< pocet orientaci
  int positioning;              ///< zpusob polozeni na terenu
  int maxlives;                 ///< maximalni pocet zivotu
  //
  int orientation;              ///< orientace
  int underconstruction;        ///< priznak, ze jde o staveniste
  int player;                   ///< hrac
  int livingbuilding;           ///< herni id budovy
};

/** Obdelnikova oblast pro umisteni jednotek v otevrene stavbe. */
struct TPlacementArea{
  P2F vp3fCorner[4];  ///< roh oblasti
  float fWidth;       ///< sirka
  float fHeight;      ///< vyska
  P2F vp3fAreaBase[2];///< vektory baze
};

/** Jeden prvek na ceste do budovy. */
struct TGate{
  P2F p1, p2; ///< kraje bran
  P2F c;      ///< stred brany
  P2F norm;   ///< smer bany
  float width;///< sirka brany
};

/** Cesta z/do budovy */
struct TApproachRoute{
  TGate* gates; ///< brany
  int gates_c;  ///< pocet bran
  P2F enter;    ///< stred vstupni brany
  P2F enter_dir;///< vstupni smer
  P2F exit_dir; ///< vystupni smer
};

/** Utocna linie. */
struct TAttackPosition{
  P2F* points;  ///< body tvirici linii
  int points_c; ///< pocet bodu
  float len;    ///< delka linie
  P2F attackdir;///< smer
};

/** Pozice pro stavitele */
struct TBuilderPosition{
  P2F p2fPosition;  ///< pozice
  P2F p2fDirection; ///< smer
};

/** Poskozeni budovy(vybuchy, ohen, kour, trosky) */
struct TDamage{
  TSmoke* smoke;
};



//FWD
class TBuilding;
class TUnit;
class TUnitMember;
struct TUnitMemberPosition;



/** Model budovy.
*/
class TSceneBuildingObject: public TModelSceneObject, public THighlighting
#ifdef DRAW_BUILDING_SHADOWS
, public TSimpleShadow
#endif
{
protected:
  /// Odkaz na budovu
  TBuilding* building;
public:
  /// Matice inverzni transformace do globalnich souradnic.
  MX4 inverse;
  /** Vykresli model.
    @see TSceneObject
  */
  virtual void drawObject();
  /** Update inverzni matice pri zmene pozice.
    @see TSceneObject
  */
	virtual void positionUpdated();               	  
  /** Kliknuti.
    @see TSelectableObject
  */
	virtual void onClick();
  /** Najeti mysi nad objekt.
  */
	virtual void onMouseOver();

  // specialni data z modelu
  TMeshNode* getCheckPoint(char* name);
  /** Vrat metadata modelu.
    @param name Nazev objektu.
    @param[out] verts Vrcholy.
    @return Pocet vrcholu.
  */
  int getStoredVertexes(char* name, TVertex** verts);

  /** Vykresleni zvyrazneni.
  */
  virtual void drawHighlight();
  
  /** Konstruktor.
    @param build Budova.
    @param mid Model.
  */
  TSceneBuildingObject(gui::TBuilding* build, TModel *mid);  

  /// Ladici vykresy.
  //@{
  void drawGates();
  void drawAttackPositions();
  //@}
};



/// Barva vlajky.
#define FLAG_COLOR 1, 1, 1

/** Vlajka na budove. */
class TFlag: public TModelSceneObject {
protected:
  TBuilding* bBuilding; ///< budova na ktere vlajka stoji
public:
  /** Vykresleni vlajky s nastavenim barvy.*/
  virtual void drawObject();
  /** Konstruktor vlajky s parametrem budovy.*/
  TFlag(TModel* mod, TBuilding* b);
};



/** Vektor objektu budov.*/
typedef std::vector<TSceneBuildingObject*> vbuildingobjs;

/// Test na uzavrenou budovu.
#define CLOSEDBUILDING(a) ((a)->guibiInfo.structuretype == stClosedBuilding && !(a)->guibiInfo.underconstruction)

/// Test na otevrenou budovu.
#define OPENBUILDING(a)   ((a)->guibiInfo.structuretype == stOpenBuilding || (a)->guibiInfo.underconstruction)

/// Prepocet zivotu na poskozeni
#define LIVES2DAMAGE(b, l) ((int)ceil(10*l/(float)b->guibiInfo.maxlives))



/** Objekt reprezentujici budovu.
*/
class TBuilding : public TProxyObject, public TSelectableObject
{
public:
  /// Objekty budovy.
  vbuildingobjs objs;
  /// Kontroler budovy.
  TBuildingController *bc;
  /// Info o budove.
  TGUIBuildingInfo guibiInfo;
  /** Ladici vypisy.
    @param f Soubor kam se ma vypisovat.
  */
  virtual void dump2D(FILE* f);  
  /** Konstruktor.
    @param m Mapa.
    @param gbi Vstupni informace.
  */
	TBuilding(TguiMap* m, TGUIBuildingInfo *gbi);
  /** Konstruktor.
    Timto konstruktrem se vytvari fiktivni budova, ktera se nezanasi do struktur a nema majitele.
    @param m Mapa.
    @param info Vstupni informace.
    @param dummy Priznak, ze jde o fiktivni budovu.
  */
  TBuilding(TguiMap* m, TGUIBuildingInfo* info, int dummy);
  /** Destruktor.
  */
	~TBuilding();
  /** Pridej do hexu.
    @see TProxyObject
  */
	virtual int addToHex(int newindex);
  /** Nastav viditelnost.
    @see TProxyObject
  */
	virtual void setFade(int newfade);
  /** Umisti na spravne misto.
  */
  void place();                     
  /** Vrat hlavni model budovy.
  */
	virtual TSceneBuildingObject* getMainStructure();
  /** Vrat 2D pozici na mape.
    @param[out] pos 2D pozice budovy.
  */
  void getPosition(P2F* pos);

  /// AKCE
  //@{
  /** Naplanuj scenar.
    @param c Scenar.
    @param startAt Kdy.
  */
  void script(TSceneScript* c, int startAt = -1);
  /** Odstran ze sceny.
    @param startAt Kdy.
  */
  void remove(int startAt=-1);
  /** Obsad hracem.
    @param player Hrac, ktery obsazuje budovu.
  */
  void occupy(int player);
  //@}

  /// ZMENA VZHLEDU BUDOVY.
  //@{
  /// Pruhlednost budovy
  float fTransparency;
  /// Priznak, zda jde o fiktivni budovu.
  int iDummy;
  /** Nastav hrace.
    @param i Hrac.
  */
  virtual void setPlayer(int i);
  /** Nastav pruhlednost.
    @param trans Nova hodnota pruhlednosti.
  */
  void transparency(float trans);
  /** Zmen orientaci budovy.
    @param deg O kolik jednotek se ma zmenit(dano poctem orientaci).
    @param allowed_orientations Maska povolenych orientaci.
  */
  void changeOrientationBy(int deg, int allowed_orientations);
  //@}

  /// STAVBA & VYROBA.
  //@{
  /// Seznam pozic pro stavitele.
  std::vector<TBuilderPosition> vBuilderPositions;
  /** Najdi nejblizsi pozici pro stavitel.
    @param bpos Puvodni pozice stavitele.
    @param[out] pos Nalezena pozice.
    @param[out] dir Nalezeny smer.
  */
  void findNearestBuilderPosition(P2F* bpos, P2F* pos, P2F* dir);
  /** Nahraj pozice pro stavitele z modelu.
  */
  void loadBuilderPosition();
  /** Zmen rozestavenou na postavenou.
  */
  virtual void buildingCompleted();
  /** Vytvor jednotku.
    @param lui Id jednotky.
  */
  virtual void recruitUnit(int lui);
  //@}

  /// LEZENI Z/DO BUDOV.
  //@{
  /// Pristupove ztezky.
  std::vector<TApproachRoute> vApproachRoutes; 
  /** Nacteni pristupovych cest z dat modelu. */
  void loadApproachRoutes();
  /** Vytvoreni cesty z budovy.
    @param out_dir Vystupni smer.
    @param route_buff Pole pro ridici body.
    @param tangent_buff Pole pro tecny.
    @param route_buff_max Maximalni velikost poli.
    @param unit_width Sirka jednotky.
  */
  virtual int generateRouteOutside(P2F* out_dir, P2F* route_buff, P2F* tangent_buff, int route_buff_max, float unit_width);
  /** Vytvoreni cesty do budovy.
    @param in_dir Vstupni smer.
    @param route_buff Pole pro ridici body.
    @param tangent_buff Pole pro tecny v ridicich bodech.
    @param route_buff_max Maximalni velikost poli.
    @param unit_width Sirka jednotky.
  */
  virtual int generateRouteInside(P2F* in_dir, P2F* route_buff, P2F* tangent_buff, int route_buff_max, float unit_width);
  //@}

  /// BOJ.
  //@{
  /// Pozice pro utok
  std::vector<TAttackPosition> vAttackPositions; 
  /** Nacteni pozic pro utok na budovu.
  */
  void loadAttackPositions();
  /** Vygeneruj pozici pro utok.
    @param cpos Pozice utocnika.
    @param dir  Vygenerovany smer utoku.
    @param pos  Vygenerovana pozice utoku.
  */
  void getAttackPosition(P2F* cpos, P2F* dir, P2F* pos);
  /** Obrana strelba.
    @param target Cil protiutoku.
    @return Instance efektu pro strelbu.
  */
  TDistant_Attack* defensiveFire(TUnitMember* target);
  //@}

  /// POSKOZENI.
  //@{
  /// Poskozeni budovy.
  std::vector<TDamage> vDamage;
  /** Poskozeni budovy.
    @param startAt Cas.
  */
  virtual void sufferDamage(int startAt = -1);
  /** Lehke poskozeni budovy.
    @param startAt Cas.
  */
  virtual void gotHit(int startAt = -1);
  /** Zniceni budovy.
    @param startAt Cas.
  */
  virtual void destroyBuilding(int startAt = -1);
  /** Sebezniceniceni budovy.
    @param h Hexy ktere se maji schovat.
  */
  virtual void demolishBuilding(TIntContainer h);
  /** Opavit budovu.
    @param old_lives Puvodni pocet zivotu.
    @param new_lives Novy pocet zivotu.
    @param total Celkovy pocet zivotu.
  */
  virtual void repairDamage(int old_lives, int new_lives, int total);
  //@}

  /// VLAJKA.
  //@{
  /// Model vlajky.
  TFlag *tfFlag;
  /** Vystavit vlajku.
  */
  virtual void hangDownFlag();
  /** Schovat vlajku.
  */
  virtual void hangUpFlag();
  //@}

  /// VYBER, KLIKNUTI.
  //@{
	virtual void preselect();
	virtual void preunselect();
  virtual void select();
  virtual void unselect();
	virtual void onClick();
  //@}
  
  /// Seznam typu budov.
  static std::map<int, TGUIBuildingInfo*> buildings;
  /** Nacteni typu budov.
  */
  static void initBuildings();
  /** Uvolneni typu bodov.
  */
  static void freeBuildings();
  /** Vytvoreni instance budovy
    @param sc Scena.
    @param lb_indx Herni idcko budovy.
    @param lb Herni struktura budovy.
    @param hindex Index hexu.
  */
  static TBuilding* installBuilding(TguiMap* sc, int lb_indx, World::LIVING_BUILDING* lb, int hindex);
  /** Vytvori fiktivni budovu.
    @param sc Scena.
    @param bid Idcko typu budovy.
    @param hindex Index hexu.
    @param allowed_orientations Maska povolenych orientaci.
  */
  static TBuilding* installDummyBuilding(TguiMap* sc, int bid, int hindex, int allowed_orientations);
  /** Odinstaluj fiktivni budovu.
    @param sc Scena.
    @param b Budova.
  */
  static void uninstallDummyBuilding(TguiMap* sc, TBuilding* b);
  /** Odinstaluj instanci budovy.
    @param sc Scena.
    @param lb_indx Herni idcko budovy.  
  */
  static void uninstallBuilding(TguiMap* sc, int lb_indx);

  //kamosi
  friend class TBuildingController;
  friend class TSceneBuildingObject;
  
  //skripty
  friend class TDemolishBuilding;
};



/** Implementace specialniho typu uzavrene budovy. */
class TClosedStructure : public TBuilding{
public:
  /** Konsturuktor.
    @param m Mapa.
    @param info Vstupni informace.    
  */
  TClosedStructure(TguiMap* m, TGUIBuildingInfo* info);
  /** Dostaveni budovy.
    Pri dostaveni uzavrene budovy se musi umistit stavitel stavitelem.
  */
  virtual void buildingCompleted();
};



/** Implementace specialniho typu otevrene budovy. */
class TOpenStructure : public TBuilding
{
public:
  /** Konsturuktor.
    @param m Mapa.
    @param info Vstupni informace.
  */
  TOpenStructure(TguiMap* m, TGUIBuildingInfo* info);
  /** Pridani do hexu.
    @param newindex Index hexu.
  */
  virtual int addToHex(int newindex);
  /** Dostaveni budovy.
    Pri dostaveni otevrene budovy se musi nove umistit stavitel.
  */
  virtual void buildingCompleted();
  ///pozice v otevrenych strukturach
  //@{
  /// Oblasti pro umisteni jednotek.
  std::vector<TPlacementArea> placement;
  /// Pozice umisteni jednotek.
  std::vector<TUnitMemberPosition> positions;
  /** Nacteni oblasti.
  */
  virtual void findPlacementAreas();
  /** Smazani oblasti.
  */
  virtual void clearPositions();
  /** Nalezeni volneho mista v oblasti.
    @param dim Velikost jednotky.
    @param[out] pos Nalzezena pozice.
  */
  virtual int findPosition(P2F* dim, P2F* pos);
  //@}

  /** Vyskova korekce.
    @param x Souradnice X.
    @param y Souradnice Y.
    @param z Spocitana souradnice Z.
  */
  virtual void surfaceAltitude(float x, float y, float *z);
  //
};

}//namespace
#endif
/*****************************************************************************/