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

  @file /gui/engine/Controllers.h
  @brief Zaklad animacniho enginu, zakladni kontrolery

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

#include <SDL/SDL.h>
#include <list>
#include <functional>
#include <deque>

#include "common/mm.h"
//
#include "gui/common/mymath_ext.h"
#include "gui/common/KTime.h"
#include "gui/engine/Animation.h"
#include "gui/engine/Scene.h"

namespace gui
{

//FWD
class TController;

/** vektor kontroleru */
typedef std::vector<TController*> vcontrollers;

/** Predek kontroleru. */
class TController //## 
{
protected:  
  TController* parent_controller; ///< rodicovsky kontroler
  TController** childs;           ///< potomci
  int childs_c;                   ///< pocet potomku
  int iActiveChilds;              ///< pocet aktivnich potomku pri poslednim updatu
  //
  void* data;       ///< data
  char szIdent[10]; ///< identifikator
public:
  int iDisposed;        ///< smazan
  int iActived;         ///< aktivovan
  int iActivationTime;  ///< absolutni cas aktivace
  int iLastTime;        ///< naposledy aktualizovan(nepovinne)
  float fTimeRatio;     ///< casovy pomer, <1 zpomaleni, >1 zrychleni
  /** Nastaveni identifikacniho retezce.
    @param ident Nova hodnota identifikacniho retezce.
  */
  void RTTID(char* ident);

  /** Nastavi priznak pro odstraneni. 
    Kontrolery se nesmi odstranovat z pameti klasickym zpusobem. System
    si mohlo by se stat, ze se system dostane do nekonzistentniho stav. 
    Napriklad, kdyby kontroler mazal sam sebe a pritom mel potomky, 
    ktere musi updatovat. Nastavi se proto jen priznak smazani, pri kterem 
    se kontroler smaze na bezpecnem miste pri pruchodu updatem. Pokud by k 
    updatu nedoslo staci smazat koren hieraerchie a rekurzivne se zrusi 
    cely strom. Priznak nastavuje take pri odstranovani potomku metodou 
    removeChildControler.
  */
  virtual void dispose();

  /** Vypis strom na vystup.
    @param level Hloubka stromu.
    @param f Vystup na ktery se vypisuje.
  */
  virtual void printSubtree(int level=0, FILE* f=stdout);
  /** Aktivuj kontroler.
    @param absoluteTime Cas aktivace.
    @param recursive Priznak, jestli se ma aktivovat cely podstrom.
  */
  virtual void activate(int absoluteTime, int recursive = 1);
  /** Deaktivuj kontroler.
    @param recursive Jestli se ma deaktivovat cely podstrom.  
  */
  virtual void deactivate(int recursive = 1);
  /** Update kontroleru.
    @param absoluteTime Hodnota casu pro update
  */
  virtual void update(int absoluteTime);
  /** Update stromu.
    Updatuje tento kontroller a cely strom. Vola vnitrne update.
    @param absoluteTime Hodnota casu pro update
  */
  virtual void updateTree(int absoluteTime);
  /** Nastavuje casovy nasobic.
    Bezpecne updatuje. Musi se brat v potaz, ze v pruchodu potomk se 
    muze nejaky odstranit a zmenit tak pole ktere prochazim.    
    @param tr Nova hodnota nasobice.
    @param recursive Priznak jestli se ma nastavit cely podstrom.
  */
  virtual void setTimeRatio(float tr, int recursive);
  /** Relativni zmena nasobice.
    @param tr Krok o ktery se ma zmenit hodnota nasobice.
    @param recursive Priznak jestli se ma nastavit cely podstrom.
  */
  virtual void changeSpeedBy(float tr, int recursive);
  /** Prida dalsiho potomka.
    @param c Novy potomek.
  */
  virtual void addChildControler(TController* c);
  /** Prida dalsiho potomka.
    @param c Novy potomek.
  */
  virtual void removeChildControler(TController* c);
  /** Konstruktor.
    Zapocita novy kontroler.
  */
  TController();
  /** Destruktor.
    Odecte kontroler.
  */
  virtual ~TController();
  
  static int iControllers; ///< Staticke pocitadlo alokovanych kontroleru.
};





/** kontroler pro animaci geometrie, predek pro konkretni */
class TTRSController: public TController {
protected:
  /// Pointer na hodnotu pozice
  P3F* pos;
  /// Pointer na hodnotu rotace
  AXISANG* rot;
  /** Interpolace rotace.
    @param q1 Prvni poloha.
    @param q2 Druha poloha.
    @param t Interpolacni parametr.
  */
  void InterpolateRotation(QUATER* q1, QUATER* q2, float t);
  /** Interpolace pozice.
    @param pos1 Prvni poloha.
    @param pos2 Druha poloha.
    @param t Interpolacni parametr.    
  */
  void InterpolateTranslation(P3F* pos1, P3F* pos2, float t);
public:
  /** Nastavi modifikovane parametry.
    @param pos Pozice.
    @param rot Rotace.
  */
  void setParametr(P3F* pos, AXISANG* rot);
  /** Konstruktor. 
  */
  TTRSController();
};




/** kontroler pro animaci jednoho uzlu modelu */
class TNodeAnimationController: public TTRSController{
protected:
  /// Id stopy s parametry pro modifikaci rotace.
  int rot_i;
  /// Id stopy s parametry pro modifikaci pozice.
  int tr_i;
public:
  /** Nastav data.
    @param at Animacni tabulka.
    @param tr_chid Cislo stopy s daty pro posunuti.
    @param rot_chid Cislo stopy s daty pro rotaci.
  */
  void setData(TAnimTable* at, int tr_chid, int rot_chid);
  /** Update.
    @see TController.
  */
  void update(int absoluteTime);
  /** Konstruktor.
  */
  TNodeAnimationController();
};



/** animace modelu - zastresuje strom uzlu*/
class TModelAnimationController: public TController{
private:
  int iLoop;  ///< priznak opakovani.
public:
  int iID;    ///< Id animace
  /** Prehrej.
    @param at Cas startu.
  */
  void play(int at);
  /** Prehrej s opakovanim.
    @param at Cas startu.
  */  
  void playLoop(int at);
  /** Prestani opakovat.
  */
  void stopLoop();
  /** Zastav.
  */
  void stop();
  /** Delka animace.
    @return Delka.
  */
  int getLength();
  /** Pozice v prehravane animaci.
    @param time Cas.
    @return Pozice (0,1)
  */
  float getRelativePosition(int time);
  /** Update.
    @see TController.
  */
  virtual void update(int absoluteTime);
  /** Konstruktor.
    @param id Id animace. 
    @param at Animacni tabulka.
  */
  TModelAnimationController(int id, PAnimTable at);
};


#define PC_LOOP 1
//
#define PC_STOP_LOOPING   1
#define PC_IMMEDIATE_STOP 2

 
/** Kontroler pro animace jednoho modelu - zastresuje vic animaci jednoho. */
class TPuppetController: public TController {
private:
  /** Vytvor hierarchii.
  */
  void buildHierarchy(PMeshNode mod_mn, PMeshNode inst_mn, TController *parent, PAnimTable at);
public:
  /** Pridej animaci 
    @param c Animace.
    @param id Id animace..
  */
  void addAnimation(TModelAnimationController* c, int id);
  /** Vrat animaci.
    @param id Id animace.
    @return Animace.
  */
  TModelAnimationController* getAnimation(int id);
  /** Prehrej animaci.
    @param id Id animace. 
    @param flag Zpusob prehrani.
    @return Delka animace, -1 pokud neexistuje.
  */
  int playAnimation(int id, int flag = 0);  
  /** Prehrej animaci.
    @param id Id animace. 
    @param flag Zpusob prehrani.
    @param acttime Cas prehrani.
    @return Delka animace, -1 pokud neexistuje.
  */
  int playAnimation(int id, int flag, int acttime);
  /** Zastav prehravani animace.
    @param id Id animace.
    @param flag zpusob zastaveni.
  */  
  void stopAnimation(int id, int flag = PC_IMMEDIATE_STOP);
  /** Zastav prehravani vsech animaci.
    @param flag zpusob zastaveni.
  */  
  void stopAllAnimations(int flag = PC_IMMEDIATE_STOP);
  /** Inicializace kontroleru
  */
  void initControler();
  /** Inicializace kontroleru
    Nahraje animace z modelu.
    @param inst Instance.
  */
  void initControler(TModelInstance *inst);
  /** Update.
    @see TController.
  */
  virtual void update(int absoluteTime);
  /** Kosntruktor. 
    @param inst Instance modelu pro krery se ma udelat kontroler animaci.
  */
  TPuppetController(TModelInstance *inst);
};






/** Manipulace s objektem na scene(nepouziva se)*/
class TSceneObjectManipulator: public TController {
private:
  Uint8 **keys;
public:
  void setData(Uint8 **k, TModelSceneObject *mod);
  virtual void update(int absoluteTime);
  TSceneObjectManipulator(Uint8 **k, TModelSceneObject *mod);
};









/** Manazer kontroleru, provadi hromadne aktualizace. */
class TControllerManager: public TController{
public:
  /// Rychlostni stupen.
  int iSpeed; 
  /** Nastav rychlost cele hierarchie.
    @param sf Rychlostni stupen.
  */
  virtual void setSpeed(int sf);
  /** Zjisti rychlostni stupen.
    @return Rychlostni stupen.
  */
  int  getSpeed();
  /** Pridej kontroller.
    @param con Kontroler.
  */
  void addController(TController* con);
  /** Odstran kontroler.
    @param con Kontroler. 
  */
  void removeController(TController* con);
  /** Zrus celou hierarchii
  */
  void destroyAllControllers();
  /** Zrus kontroler.
    @param con Kontroler.
  */
  void destroyController(TController* con);
  /** Update hierarchie.
    @param absTime Absolutni cas sceny.
  */
  void updateControlers(int absTime);
  /** Konstruktor.
  */
  TControllerManager();
};




/** Zaznam planovace akci. */
struct TSheduledAction{
  int iAction;    ///< id akce
  void* pData;    ///< user data
  int iStart;     ///< absolutni cas zacatku, -1 zacni okamzite + prepis se na aktualni cas
  int iUpdated;   ///< cas kdy byl naposledy updatovan
  int iDuration;  ///< trvani akce  
  int iStarted;   ///< priznak, ze akce uz zacala
  TSheduledAction* next; ///< nalinkovana akce, ma se vlozit hned po skonceni teto
};

/** Planovac akci. */
class TScheduler: public TController{
protected:
  /// seznam akci
  std::list<TSheduledAction*> actions; 
  /// seznam smazanych akci
  std::list<TSheduledAction*> deleted_actions;  
public:
  /** Konstruktor.
  */
  TScheduler();
  /** Destruktor.
  */
  virtual ~TScheduler();
  /** Pridej akci za posledni.
    @param act Akce.
  */
  void linkActionAfterLast(TSheduledAction* act);
  /** Vloz akci za akci.
    @param sa Akce za kterou se ma vlozit.
    @param act Vkladana akce.
  */
  void insertActionAfter(TSheduledAction* sa, TSheduledAction* act);
  /** Vloz akci.
    @param act Vkladana akce.
  */
  void insertAction(TSheduledAction* act);
  /** Vytvor akci.
    @param act Typ akce. 
    @param data Pridruzena data.
    @param start Start.
    @param dur Trvani.
  */
  virtual TSheduledAction* createAction(int act, void* data, int start, int dur);
  /** Dealokace akce.
    @param ac Akce.
  */
  virtual void disposeAction(TSheduledAction* ac);
  /** Odstraneni vsech akci urciteho typu.
    @param type Typ odstranovanych akci.
  */
  void removeActions(int type);
  /** Odstran vsechny akce.
  */
  void removeAllActions();
  /** Odstran konkretni akci.
    Akce se pred odstranenim umistuji do seznamu deleted_actions
    a odstranuji se az na specialnim bezpecne miste. 
    @param act Odstranovana akce.
  */
  void removeAction(TSheduledAction* act);
  /** Udpate.
    @see TController.
  */
  virtual void update(int absoluteTime);
  /** Update jednotlivych akci.
    @retval 1 akce prokracuje
    @retval 0 akce konci
  */
  virtual int updateAction(int rtime, TSheduledAction* sa) = 0;
  void dumpActions();
};

}//namespace 

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