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

  @file /gui/engine/MapControllers.h
  @brief Zakladni kontrolery pro mapu
            -kamera
            -manager kontroleru
  

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

#include "gui/engine/Camera.h"
#include "gui/engine/Controllers.h"


namespace gui{

//FWD
class TInputController;
class TMainCamera;

/** Kontroler manager pro mapu */
class TMapControllerManager: public TControllerManager{
protected:   
  /// Pointer na strukturu vstupu.
  INPUT* input;
public:
  /** Nastav specificky podle rychlostnich urovni na mape.
    Mapa ma 3 rychlostni stupne.
    @param sf Rychlostni stupen 1, 2, 3.
  */
  virtual void setSpeed(int sf);
  /** Uloz pointer na vstup.
    @param in Ukazatel na strukturu se vstupem.
  */
  void updateInput(INPUT *in);
  /** Updatuj kontrollery.
    @see TControllerManager
  */
  void updateControlers(int absTime);
  /** Konstruktor.
  */
  TMapControllerManager();
  //
  friend class TInputController;
};

/** Kontroler pro prijem vstupu z podsystemu "activeobjects" */
class TInputController: public TController {
protected: 
  /// Pointer na manazer mapy.
  TMapControllerManager *pmcm;
  /** Vrat odkaz na vstup v manazeru
    @return Odkaz na vstup v manazeru.
  */
  INPUT* getInput();
public:
  /** Konstruktor.
    @param mcm Manazer mapy.
  */
  TInputController(TMapControllerManager *mcm);
};

/** Kontroler na kameru. */
class TMainCameraController: public TInputController {
public:
  /** Update.
    @see TController
  */
  virtual void update(int absoluteTime);
  /** Konstruktor.
    @param mcm Manazer mapy.
    @param cam Odkaz na rizenou kameru.
  */
  TMainCameraController(TMapControllerManager *mcm, TMainCamera* cam);
};

//FWD
class TguiMap;

/** Kontroler pro pohyb kamery. */
class TMovingCameraController: public TController{
protected:
  /// Kamera ktera se ma kontrolovat.
  TCamera* camera;
  /// Travani.
  int iDuration;
  /// Rychlost pohybu.
  float fSpeed;  

  /// Focus mode.
  //@{
  P3F p3fFocus;
  P3F p3fStart;
  //@}
  
  /// Fly mode.
  //@{
  /// Krivka pro pohyb.
  TGenericCurve* path; 
  /// Priznak letu. Navazuje nahodne krivky
  int iFreeFlight;
  /// Vyska letu
  float fFlightAltitude;
  /** Vygeneruj krivku.
    @param pos1 Pocatecni pozice.
    @param dir1 Pocatecni smer.
    @param pos2 Koncova pozice.
    @param dir2 Koncovy smer.
  */  
  void move(P3F* pos1, P3F* dir1, P3F* pos2, P3F* dir2);
  /** Vygeneruj z aktualniho mista kamery krivku.
    @param pos Koncova pozice.
    @param dir Koncovy smer.
  */  
  void moveTo(P3F* pos, P3F* dir);
  //@}
  
public:
  /** Typ pohybu.*/
  enum TCameraMoveType{
    cmtFly,         ///< let
    cmtFreeFlight,  ///< nekonecny let
    cmtFocus        ///< scrollovani
  } moveType; 
  /** Konstruktor.
    @param map Mapa.
    @param cam Kamera na mape.
  */
  TMovingCameraController(TguiMap* map, TCamera* cam);
  /** Scrolluj na souradnice pos.
    @param pos Pozice na zamereni.
    @param speed Rychlost pohybu k pozici.
    @return Doba ukonceni letu.
  */
  int focusTo(P3F* pos, float speed);
  /** Nastaveni rychlosti.
    @see TConroller;
  */
  void setTimeRatio(float tr, int recursive);
  /** Zahaj nahodny let.
  */
  void freeFlight();
  /** Ukonci nahodny let.
  */
  void cancelFreeFlight();  
  /** Obnov kontroller.
    @see TConroller;  
  */
  virtual void update(int absoluteTime);
};

/** Typ informace o udalostech. */
enum TEventInfoType{
  eitWarning,         ///< varovani
  eitComment,         ///< komentar, vztahuje se k udalosti
  eitInfo,            ///< info, vztahuje se k jednotce, budove, mistu
  //specialni udalosti
  eitUnitDeserted,    ///< jednotka rozpustena, data1 = u
  eitUnitDied,        ///< jednotka zemrela, data1 = u
  eitUnitMembersDied, ///< umreli panaci v jedotce, data1 = u, data2 = pocet
  eitUnitInterrupted, ///< stavba prerusila, data1 = u
  eitVisibilityUpdate,///< stavba prerusila, data1 = shown, data2 = hidden
  eitEndGame,         ///< konec hry
  eitExitGame         ///< prepnuti kontextu
};

/** Informace o udalostech. */
class TEventInfo //## 
{
public:
  /// Uziv data.
  void* data1;
  /// Uziv data.
  void* data2;
  /// Hodnota lokace.
  int location;
  /// Typ udalosti.
  TEventInfoType type;
  /// Zprava udalosti.
  wchar_t* msg;
  /**  Konstruktor.
    @param t Typ udalosti.
    @param m Zprava udalosti.
    @param l Poloha na mape.
    @param d1 Uzivatelsky data1.
    @param d2 Uzivatelsky data2.
  */
  TEventInfo(TEventInfoType t, wchar_t* m, int l, void* d1=NULL, void* d2=NULL);
};

/** Vektor udalosti */
class TEventVector: public std::vector<TEventInfo*>
{
public:
  void releaseEventsVector();
};

/** Kontroler pro prehravani akci. */
class TEventPlayer: public TScheduler{
protected:
  TguiMap* map;
public:
  /** Konstruktor.
    @param m Mapa pro zobraozvani udalosti.
  */
  TEventPlayer(TguiMap* m);
  /** Destruktor.
  */
  virtual ~TEventPlayer();

  /// Ukazatel na aktualni vektor(data jsou drzena externe)
  TEventVector events; 
  /// Ukazatel na aktualni zaznam.
  TEventVector::iterator current;
  /** Zacni prehravani udalosti.
    @param ev Vektor udalosti.
  */
  void showEvents(TEventVector* ev);
  /** Scrolluje na hex.
    @param h Cil.
    @return Cas kdy se ma doscrollovat.
  */
  int scrollToHex(int h);
  /** Prehrej aktualni udalost.
  */
  void playEvent();
  /** Zobraz zpravu na obrazovce.
    @param msg Zprava. 
  */
  void showMsg(wchar_t* msg);
  /** Updatovani akce.
    @param rtime cas od zacatku akce
    @param sa
  */
  virtual int updateAction(int rtime, TSheduledAction* sa);
};

/** Modifikace viditelnosti. */
class TVisibilityModification{
public:
  int player;
  TIntContainer h;  ///< skruta mapa
  TIntContainer s;  ///< odkryta mapa
};

/** Skryvac a odhalovac mapy. */
class TVisibilityScheduler: public TScheduler{
protected:
  TguiMap* map; ///< mapa
public:
  /** Naplanuje skryti/odkryti mapy.
    @param h Skryte hexy.
    @param s Odkryte hexy.
    @param player Hrac.
    @param delay Cas za ktery se ma odkryt/skryt.
  */
  void alterVisibility(TIntContainer* h, TIntContainer* s, int player, int delay);
  /** Konstruktor
    @param m Mapa.
  */
  TVisibilityScheduler(TguiMap* m);
  /** Update akci.
    @see TScheduler
  */
  virtual int updateAction(int rtime, TSheduledAction* sa);
};

} // namespace;

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