/*
*******************************************************************************
  
  @file /gui/GUI.cpp
  @brief Hlavni soubor modulu GUI

  @author vajicek
  @version 0.1

******************************************************************************/
#include "gui/GUI.h"
#include "common/Log.h"
#include "common/Interface.h"
#include "common/Msg.h"
#include "common/rm/rminit.h"
//
#include "net/locator.h"
//
#include "gui/common/init_env.h"
#include "gui/common/BasicFonts.h"
#include "gui/common/Sounds.h"
//
#include "gui/engine/TextureManager.h"
//
#include "gui/contexts/Game.h"
#include "gui/contexts/MainMenu.h"
#include "gui/contexts/MultiJoin.h"
#include "gui/contexts/MultiHost.h"
#include "gui/contexts/LocalMulti.h"
#include "gui/contexts/LoadingScreen.h"
#include "gui/contexts/FinalStatistic.h"

#ifdef TEST
  // test - kontext pro testovaci ucely vykreslovani
  #include "gui/contexts/Test.h"
#endif

//
#include "world/world_messages.h"


namespace gui{
using namespace World;

#ifdef _DEBUG
static TLog guilog(1);
#endif
#define GUILOG //guilog.LogMsg

////////////////////////////////////////////////////////////////////////////////
// rozliseni
////////////////////////////////////////////////////////////////////////////////

int resolutions[RESOLUTIONS_COUNT][3] = { 
  {800, 600, 32}, 
  {1024, 768, 32}, 
  {1280, 768, 32},
  {1280, 960, 32}, 
  {1280, 1024, 32}
};



////////////////////////////////////////////////////////////////////////////////
// resources, experiment
////////////////////////////////////////////////////////////////////////////////

void TGUI::enterResourcePhase(int phase){
  rm::TRM_raster_i* rmr = (rm::TRM_raster_i*) KSendGlobalMessage(MSG_GET_RM_RASTER_I,MOD_GUI,MOD_RM,NULL);
  rm::TRM_symbol_i* rms = (rm::TRM_symbol_i*) KSendGlobalMessage(MSG_GET_RM_SYMBOL_I,MOD_GUI,MOD_RM,NULL);
  rm::TRM_sound_i*  rmsnd = (rm::TRM_sound_i*)KSendGlobalMessage(MSG_GET_RM_SOUND_I,MOD_GUI,MOD_RM,NULL);
  rm::TRM_model_i*  rmm = (rm::TRM_model_i*)  KSendGlobalMessage(MSG_GET_RM_MODEL_I,MOD_GUI,MOD_RM,NULL);
  rm::TRM_advxml_i<UNIT>*   rmu = (rm::TRM_advxml_i<UNIT>*)   KSendGlobalMessage(MSG_GET_RM_UNIT_I, MOD_GUI,MOD_RM,NULL);
  rm::TRM_building_i* rmb = (rm::TRM_building_i*)KSendGlobalMessage(MSG_GET_RM_BUILDING_I, MOD_GUI,MOD_RM,NULL);

  switch(phase){
    case 1:{
    
      //bitmapy
      rmr->request(RASTER_PANEL);
      rmr->request(RASTER_MAINMENU_BG);
      rmr->request(RASTER_ICONS);
      rmr->request(RASTER_CHOOSEMAP_BG);

      rmr->request(RASTER_DEFEAT);
      rmr->request(RASTER_VICTORY);
      rmr->request(RASTER_WAITING);

      //symboly
      rms->requestDep(SYMBOLS_BASIC_ICONS);

      //zvuky
      rmsnd->request(SAMPLE_CLICK);  
      rmsnd->request(MUSIC_MAINMENU_THEME_1);

    }break;
    case 2:{

      //jednotky
      DA<int> uids;
      rmu->getIds(&uids);
      for (int unit_id = uids.getNext(-1); unit_id != -1 ; unit_id = uids.getNext(unit_id))
        rmu->requestDep(unit_id);

      //budovy
      DA<int> bids;
      rmb->getIds(&bids);
      for (int build_id = bids.getNext(-1); build_id != -1;build_id = bids.getNext(build_id))
        rmb->requestDep(build_id);

      //bitmapy - gui
      rmr->request(RASTER_PANEL);
      rmr->request(RASTER_WAITING);
      
      //bitmapy - teren
      rmr->request(RASTER_GRASS);
      rmr->request(RASTER_ROCK);
      rmr->request(RASTER_GRASSROCK);
      rmr->request(RASTER_ROCKGRASS);
      rmr->request(RASTER_SWAMP);
      rmr->request(RASTER_GRASSSWAMP);
      rmr->request(RASTER_SWAMPGRASS);
      rmr->request(RASTER_ROCKSWAMP);
      rmr->request(RASTER_SWAMPROCK);
      rmr->request(RASTER_WATER);

      //bitmapy - efekty
      rmr->request(RASTER_SMOKE);
      rmr->request(RASTER_PARTICLE);
      rmr->request(RASTER_EXNOISE);
      rmr->request(RASTER_WAVE);
      rmr->request(RASTER_SHADOW);
      rmr->request(RASTER_HEART_PARTICLE);
      rmr->request(RASTER_CROSS_PARTICLE);
      rmr->request(RASTER_HEAD_PARTICLE);

      //symboly
      rms->requestDep(SYMBOLS_UNIT_ICONS);
      rms->requestDep(SYMBOLS_BUILDING_ICONS);
      rms->requestDep(SYMBOLS_BONUS_ICONS);
      rms->requestDep(SYMBOLS_TERRAINS);

      //extra modely
      rmm->request(MODEL_FLAG);
      rmm->request(MODEL_ARROW);
      rmm->request(MODEL_CATAPULT_PROJECTILE);
      rmm->request(MODEL_BORDERSTONE);

      //modely terenu
      rmm->request(MODEL_TREE);
      rmm->request(MODEL_TREE2);
      rmm->request(MODEL_TREE3);
      rmm->request(MODEL_TREE4);
      rmm->request(MODEL_ROCK1);
      rmm->request(MODEL_ROCK2);
      rmm->request(MODEL_ROCK3);
      rmm->request(MODEL_FERN1);
      rmm->request(MODEL_HOUSE1);
      rmm->request(MODEL_HOUSE2);

      //zvuky
      rmsnd->request(SAMPLE_THUNDER);  
      rmsnd->request(SAMPLE_DESTRUCTION);
      rmsnd->request(SAMPLE_EXPLOSION);
      rmsnd->request(SAMPLE_ARROW_ATTACK);
      rmsnd->request(SAMPLE_CATAPULT_ATTACK);           
      rmsnd->request(SAMPLE_SPARKLE);
      rmsnd->request(SAMPLE_GONG);
      rmsnd->request(SAMPLE_FIREBALL);

      rmsnd->request(MUSIC_BATTLE_THEME_1);           
      rmsnd->request(MUSIC_BATTLE_THEME_2);
      rmsnd->request(MUSIC_BATTLE_THEME_3);           
           
      rmsnd->request(MUSIC_FINAL_THEME_1);

    }break;
  }
  //nahraj resourcy do RM
  rmb->loadBuffer();
  rmu->loadBuffer();
  rms->loadBuffer();
  rmsnd->loadBuffer();
  rmm->loadBuffer();
  rmr->loadBuffer();

  delete rmb;
	delete rmu;
  delete rms;
  delete rmsnd;
  delete rmm;
  delete rmr;
}

void TGUI::leaveResourcePhase(int phase){
}

void TGUI::main(){
	screen->enterMainLoop();
}

void TGUI::initContexts(){
  // game
  game = TGame::createContext();
  screen->addContext(game);
  // mainmenu
  mainmenu = TMainMenu::createContext();
  screen->addContext(mainmenu);
  // multihost
  multihost = TMultiHost::createContext();
  screen->addContext(multihost);
  // multijoin
  multijoin = TMultiJoin::createContext();
  screen->addContext(multijoin);
  // localmultiplay
  localmulti = TLocalMulti::createContext();
  screen->addContext(localmulti);
  // loadingscreen
  loadingscreen = TLoadingScreen::createContext();
  screen->addContext(loadingscreen);
  // finalstatistic
  finalstatistic = TFinalStatistic::createContext();
  screen->addContext(finalstatistic);

#ifdef TEST
  // test - kontext pro testovaci ucely vykreslovani
	TContext *test = TTest::createContext();
  screen->addContext(test);
#endif
}

void TGUI::freeContexts(){
  // destrukce kontextu
  delete game;
  delete mainmenu;
  delete multihost;
  delete multijoin;
  delete localmulti;
  delete loadingscreen;
  delete finalstatistic;
}

TGUI::TGUI(){
  //HACK
  TGUI::gui_inst=this;

  //transceiver
  gui_transceiver.fnc = GUI_MSG_HANDLER;
  gui_transceiver.iActived = true;
  gui_transceiver.iPriority = 5;
  gui_transceiver.PrimaryID = MOD_GUI;
  KRegisterGlobalTransceiver(&gui_transceiver, MOD_GUI);

  //nasat defaultni hodnoty
  rm::TRM_conf_i *rmconfi = (rm::TRM_conf_i*)KSendGlobalMessage(MSG_GET_RM_CONF_I, MOD_GUI, MOD_RM, NULL);
  int _resolution = rmconfi->getDefaultResolution();
  int _fullscreen = rmconfi->getDefaultFullscreen();
  delete rmconfi;
  if ( (_resolution < 0) || (_resolution >= RESOLUTIONS_COUNT) ) _resolution = 0;
  int _w = resolutions[_resolution][0];
  int _h = resolutions[_resolution][1];

  //inicializace podobektu
  msg_queue_lock = SDL_CreateMutex();
  profile = NULL;
  screen = new TScreen(_w, _h);

  //aktivace podsystemu
  if( InitEnv(_w, _h, _fullscreen) )
    THROW(E_8K_GUI, "TGUI(): gui environment initialization failed");  
  TTextureManager::TextureManager_Init();	
  ACache_Init();
  InitBasicFonts(SCREEN_WIDTH, SCREEN_HEIGHT);
  TSoundInterface::initSound();

  //phase1 - synchronne
  enterResourcePhase(1);

  //dalsi podsystemy
  TaoKernel::initAOKernel();

  //kontexty
  initContexts();
}

TGUI::~TGUI(){
  //kontexty
  freeContexts();

  //vypnuti podsystemu
  TSoundInterface::uninitSound();
  TaoKernel::freeAOKernel();
  UninitBasicFonts();
  ACache_Free();
  TTextureManager::TextureManager_Free();

  //zrus podobjekty
  SDL_DestroyMutex(msg_queue_lock);
  delete screen;
  profile = NULL;

  //
  ShutdownEnv();
  
  //odstran transceiver
  KUnregisterGlobalTransceiver(MOD_GUI);
}

void TGUI::reportState()
{
#ifdef _DEBUG
  printf("GUI REPORT\n");
  printf("--------------------------------------------------\n");
  printf("models alocated: %d\n", TSceneObject::iSceneObjects);
  printf("controllers alocated: %d\n", TController::iControllers);
  printf("active objects alocated: -\n");
#endif
}

void gameMessagesLog(int mid){
  switch(mid){
    case MSG_RCT_UNIT_MOVE:     GUILOG("MSG_RCT_UNIT_MOVE\n");  break;
    case MSG_RCT_NEXT_TURN:     GUILOG("MSG_RCT_NEXT_TURN\n");  break;
    case MSG_RCT_UNIT_ATTACK:   GUILOG("MSG_RCT_UNIT_ATTACK\n");  break;
    case MSG_RCT_UNIT_SUICIDE:  GUILOG("MSG_RCT_UNIT_SUICIDE\n");  break;
    case MSG_RCT_BUILDING_SUICIDE:      GUILOG("MSG_RCT_BUILDING_SUICIDE\n");  break;
    case MSG_RCT_BUILDING_RECRUIT_UNIT: GUILOG("MSG_RCT_BUILDING_RECRUIT_UNIT\n");  break;
    case MSG_RCT_START_BUILDING:    GUILOG("MSG_RCT_START_BUILDING\n");  break;
    case MSG_RCT_UNIT_RECRUIT:      GUILOG("MSG_RCT_UNIT_RECRUIT\n");  break;
    case MSG_RCT_UNIT_RECRUIT_ELITE:GUILOG("MSG_RCT_UNIT_RECRUIT_ELITE\n");  break;
    case MSG_RCT_UNIT_HEAL:         GUILOG("MSG_RCT_UNIT_HEAL\n");  break;
    case MSG_RCT_REPAIR_BUILDING:   GUILOG("MSG_RCT_REPAIR_BUILDING\n");  break;
    case MSG_RCT_STOP_BUILDING: GUILOG("MSG_RCT_STOP_BUILDING\n");  break;
    case MSG_RCT_SELL_BONUS:    GUILOG("MSG_RCT_SELL_BONUS\n");  break;
    case MSG_BUILDING_OCCUPIED: GUILOG("MSG_BUILDING_OCCUPIED\n");  break;
    case MSG_TOWN_OCCUPIED:     GUILOG("MSG_TOWN_OCCUPIED\n");  break;
    case MSG_KINGDOM_OCCUPIED:  GUILOG("MSG_KINGDOM_OCCUPIED\n");  break;
    case MSG_END_GAME:          GUILOG("MSG_END_GAME\n");  break;        
    case MSG_DIPLOMACY_RELATION_CHANGE: GUILOG("MSG_DIPLOMACY_RELATION_CHANGE\n");  break;        
    case MSG_RCT_ERROR: GUILOG("MSG_RCT_ERROR\n");  break;
  }
}

void TGUI::dumpGameMessages(){

  int ord = 0;
  for(std::deque<MSG_TPacket>::iterator it = msg_queue.begin(); 
      it != msg_queue.end();
      it++)
  {
    MSG_TPacket* mp = &(*it);  
    GUILOG("%d ", ord);
    gameMessagesLog(mp->msg); 
    ord++;
  }
}

int TGUI::pumpEndGameMessage()
{
  TContext* ac = TGUI::gui_inst->screen->getActiveContext();
  //
  SDL_LockMutex(msg_queue_lock);  
    //
    MSG_TPacket* mp = &(msg_queue.front());  
    int mid = mp->msg;
    void* p = mp->data;
    //
    if(mid != MSG_END_GAME){
      SDL_UnlockMutex(msg_queue_lock);
      return 0;
    }
    //
    msg_queue.pop_front();
  SDL_UnlockMutex(msg_queue_lock);
  //
  TPacket_END_GAME* eg = (TPacket_END_GAME*)p;
  ((TLoadingScreen*)ac)->endGame(eg);
  delete eg;
  return 1;
}

void TGUI::pumpGameMessage() 
{
  TContext* ac = TGUI::gui_inst->screen->getActiveContext();

 SDL_LockMutex(msg_queue_lock);  
  if( ((TGame*)ac)->actionLock || msg_queue.empty() )
  {
    SDL_UnlockMutex(msg_queue_lock);
    return;  
  }

  //
  MSG_TPacket* mp = &(msg_queue.front());  
  int mid = mp->msg;
  void* p = mp->data;

  //
  msg_queue.pop_front();
 SDL_UnlockMutex(msg_queue_lock);
  
  switch(mid){
    // pohyb
    case MSG_RCT_UNIT_MOVE: {
        TPacket_RCT_UNIT_MOVE* rum = (TPacket_RCT_UNIT_MOVE*)p;
        ((TGame*)ac)->moveUnit( rum->unit_id, &(rum->path) );
        delete rum;
    }break;
    // dalsi kolo
    case MSG_RCT_NEXT_TURN: {
        TPacket_RCT_NEXT_TURN* rnt = (TPacket_RCT_NEXT_TURN*)p;
        ((TGame*)ac)->playerChanged( rnt );
        delete rnt;
    }break;
    // utok  
    case MSG_RCT_UNIT_ATTACK: {
        TPacket_RCT_UNIT_ATTACK* rua = (TPacket_RCT_UNIT_ATTACK*)p;
        ((TGame*)ac)->attackUnit(rua);
        delete rua;
    }break;
    // sebezniceni    
    case MSG_RCT_UNIT_SUICIDE: {
        TPacket_RCT_UNIT_SUICIDE* rus = (TPacket_RCT_UNIT_SUICIDE*)p;
        ((TGame*)ac)->unitSuicide(rus);
        delete rus;
    }break;
    // demolice budovy
    case MSG_RCT_BUILDING_SUICIDE: {
        TPacket_RCT_BUILDING_SUICIDE* rbs = (TPacket_RCT_BUILDING_SUICIDE*)p;
        ((TGame*)ac)->buildingSuicide(rbs);
        delete rbs;
    }break;
    // vyroba jednotky
    case MSG_RCT_BUILDING_RECRUIT_UNIT:{
        TPacket_RCT_BUILDING_RECRUIT_UNIT* rbru = (TPacket_RCT_BUILDING_RECRUIT_UNIT*)p;
        ((TGame*)ac)->recruitUnit(rbru);
        delete rbru;
    }break;
    // stavba budovy
    case MSG_RCT_START_BUILDING: {
        TPacket_RCT_START_BUILDING* rsb = (TPacket_RCT_START_BUILDING*)p;
        ((TGame*)ac)->startBuilding(rsb);
        delete rsb;
    }break;
    // doplnovani
    case MSG_RCT_UNIT_RECRUIT: {
        TPacket_RCT_UNIT_RECRUIT* ur = (TPacket_RCT_UNIT_RECRUIT*)p;
        ((TGame*)ac)->unitRecruit(ur);
        delete ur;
    }break;
    // doplnovani elity
    case MSG_RCT_UNIT_RECRUIT_ELITE: {
        TPacket_RCT_UNIT_RECRUIT_ELITE* ure = (TPacket_RCT_UNIT_RECRUIT_ELITE*)p;
        ((TGame*)ac)->unitRecruitElite(ure);
        delete ure;
    }break;
    // leceni
    case MSG_RCT_UNIT_HEAL: {
        TPacket_RCT_UNIT_HEAL* uh = (TPacket_RCT_UNIT_HEAL*)p;
        ((TGame*)ac)->unitHeal(uh);
        delete uh;
    }break;
    // oprava budov
    case MSG_RCT_REPAIR_BUILDING: {
        TPacket_RCT_REPAIR_BUILDING* rb = (TPacket_RCT_REPAIR_BUILDING*)p;
        ((TGame*)ac)->repairBuilding(rb);
        delete rb;
    }break;
    case MSG_RCT_STOP_BUILDING: {
        TPacket_RCT_STOP_BUILDING* sb = (TPacket_RCT_STOP_BUILDING*)p;
        ((TGame*)ac)->stopBuilding(sb);
        delete sb;
    }break;
    case MSG_RCT_SELL_BONUS: {
        TPacket_RCT_SELL_BONUS* sb = (TPacket_RCT_SELL_BONUS*)p;
        ((TGame*)ac)->sellBonus(sb);
        delete sb;
    }break;
    // zabrani budovy
    case MSG_BUILDING_OCCUPIED: {
        TPacket_BUILDING_OCCUPIED *bo = (TPacket_BUILDING_OCCUPIED*)p;
        ((TGame*)ac)->buildingOccupied(bo);
        delete bo;
    }break;
    // zabrani mesta
    case MSG_TOWN_OCCUPIED: {
        TPacket_TOWN_OCCUPIED *to = (TPacket_TOWN_OCCUPIED*)p;
        ((TGame*)ac)->townOccupied(to);
        delete to;
    }break;
    // zabrani kralovstvi
    case MSG_KINGDOM_OCCUPIED: {
        TPacket_KINGDOM_OCCUPIED *ko = (TPacket_KINGDOM_OCCUPIED*)p;
        ((TGame*)ac)->kingdomOccupied(ko);
        delete ko;
    }break;
    // ukonceni hry
    case MSG_END_GAME: {
        TPacket_END_GAME* eg = (TPacket_END_GAME*)p;
        ((TGame*)ac)->endGame(eg);
        delete eg;
    }break;       
    case MSG_DIPLOMACY_RELATION_CHANGE: {
        TPacket_DIPLOMACY_RELATION_CHANGE* drc = (TPacket_DIPLOMACY_RELATION_CHANGE*)p;
        ((TGame*)ac)->diplomacyChange(drc);
        delete drc;        
    }break;        
    case MSG_PLAYER_DEFETAED: {
        TPacket_PLAYER_DEFEATED* pd = (TPacket_PLAYER_DEFEATED*)p;
        ((TGame*)ac)->playerDefeated(pd);
        delete pd;        
    }break;        
    case MSG_RCT_ERROR: {
        TPacket_ErrorResult* er = (TPacket_ErrorResult*)p;
        ((TGame*)ac)->errorResult(er);
        delete er;
    }break;        
  }  
}





////////////////////////////////////////////////////////////////////////////////
// staticti cleni
////////////////////////////////////////////////////////////////////////////////

TGUI* TGUI::gui_inst;

void TGUI::initGUI()
{
  TGUI::gui_inst = new TGUI();
}

void TGUI::destroyGUI()
{
  delete TGUI::gui_inst;
}











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

RVAL GUI_MSG_HANDLER(MESSAGE_ID mid,SENDER s,PARAM p)
{
  GUILOG("Messag Id: %d\n", mid);
  
  //synchronizace s hlavni smyckou
  TGUI::gui_inst->screen->sync_start();

  //aktualni kontext
  TContext* ac = TGUI::gui_inst->screen->getActiveContext();  

  switch(mid){

    // pripojil se klient, zaregistruj v gui
    case MSG_NEW_CONNECTION_REPORT:
      // update databaze uzivatelu
      KSendGlobalMsg(MSG_GET_NETWORK_PARTICIPANTS, MOD_GUI, MOD_NET, (PARAM)(&TGUI::gui_inst->clientsinfo) );

      if( ac == TGUI::gui_inst->localmulti){
        ((TLocalMulti*)ac)->addClient( *((int*)&p) );
      }
      else if( ac == TGUI::gui_inst->multihost){
        ((TMultiHost*)ac)->addClient( *((int*)&p) );
      }
      else if( ac == TGUI::gui_inst->multijoin){
      }
    break;
    
    // klient odpojen
    case MSG_CLIENT_DISCONNECTION_REPORT:   
      if( ac == TGUI::gui_inst->localmulti){
      }
      else if( ac == TGUI::gui_inst->multihost){
        ((TMultiHost*)ac)->delClient( *((int*)&p) );
      }
      else if( ac == TGUI::gui_inst->multijoin){
      }            
      else if( ac == TGUI::gui_inst->game){
        ((TGame*)ac)->clientDisconnected( *((int*)&p) );
      }
    break;   

    // klient odpojen
    case MSG_CLIENT_RECONNECTION_REPORT:   
      if( ac == TGUI::gui_inst->game){
        ((TGame*)ac)->clientReconnected( *((int*)&p) );
      }
    break;   

    // hra je pripavena muze se pripavit gui
    case MSG_LETS_GO:
      if( ac == TGUI::gui_inst->loadingscreen){
        ((TLoadingScreen*)TGUI::gui_inst->loadingscreen)->letsGo = 1;
        // inicializuje mapu podle prislych parametru
        PACKET_LETS_GO* plg = (PACKET_LETS_GO*)p;       
        ((TGame*)TGUI::gui_inst->game)->loadGameMap(plg);
      }
    break;

    // gui pripraveno
    case MSG_GUIMAP_READY:
      if( ac == TGUI::gui_inst->loadingscreen){
        //guimapa nahrana
        ((TLoadingScreen*)TGUI::gui_inst->loadingscreen)->guiMapReady = 1;
        //fronta neni prazdna => hra zrusena behem nahravani gui
        if( !TGUI::gui_inst->msg_queue.empty() ){
          TGUI::gui_inst->pumpEndGameMessage();
        }
      }
    break;

    // zabiti nahravaciho vlakna
    case MSG_KILL_MAPLOADING:
      if( ac == TGUI::gui_inst->loadingscreen){               
        if( ((TGame*)TGUI::gui_inst->game)->loading_thread != NULL )
        {
          SDL_KillThread( ((TGame*)TGUI::gui_inst->game)->loading_thread );
          ((TGame*)TGUI::gui_inst->game)->loading_thread = NULL;
        }
      }
    break;

    // cekani na dopocitani AI
    case MSG_AI_WAIT_AI_PLANNING:
      if( ac == TGUI::gui_inst->game){
        ((TGame*)TGUI::gui_inst->game)->gameEnding();
      }
    break;

    // zruseni guimapy
    case MSG_GUIMAP_HARAKIRI:
      //nahodou je to stejne jako pri deactivate kontextu
      ((TGame*)TGUI::gui_inst->game)->deactivateContext();
    break;

    // vsichni pripraveni, prepni do hry
    case MSG_GAME_STARTED:
      if( ac == TGUI::gui_inst->loadingscreen){
        //
        TGUI::gui_inst->screen->selectContext(
          "GAMECONTEXT",
          ((TLoadingScreen*)(TGUI::gui_inst->loadingscreen))->gamemode );
      }
    break; 

    // zprava o nahravani na obrazovku
    case MSG_MAPLOADING_MSG:
      if( ac == TGUI::gui_inst->loadingscreen){
        // zpravu do okna
        ((TLoadingScreen*)ac)->showStateMsg( (wchar_t*)p );
      }
    break;
    case MSG_MAPLOADING_PROGRESS:
      if( ac == TGUI::gui_inst->loadingscreen){
        // postup nahravani do okna
        ((TLoadingScreen*)ac)->setProgress( *((float*)&p) );
      }
    break;   

    //vysledek spojeni
    case MSG_NET_CONNECTIONFAILED:
      if( ac == TGUI::gui_inst->mainmenu){
        ((TMainMenu*)ac)->connectionFailed();
      }
    break;
    case MSG_NET_CONNECTIONSUCCESSFUL:
      if( ac == TGUI::gui_inst->mainmenu){
        ((TMainMenu*)ac)->connectionSuccessful();
      }
    break;
    case MSG_NET_LOST_CONNECTION:
      if( ac == TGUI::gui_inst->multijoin){
        ((TMultiJoin*)ac)->disconnect();
      }
    break;

    //vymena dat mezi gui
    case MSG_NET_ROLESETTINGDATA:
      if( ac == TGUI::gui_inst->multijoin){
        ((TMultiJoin*)ac)->receiveNetData((TPackage*)p);
      }
      else if( ac == TGUI::gui_inst->multihost){
        ((TMultiHost*)ac)->receiveNetData((TPackage*)p);
      }
    break;
    case MSG_NET_CHAT:
      if( ac == TGUI::gui_inst->multijoin){
        ((TMultiJoin*)ac)->chatMsg((TPackage*)p);
      }
      else if( ac == TGUI::gui_inst->multihost){
        ((TMultiHost*)ac)->chatMsg((TPackage*)p);
      } else if (ac == TGUI::gui_inst->game) {
        ((TGame*)ac)->chatMsg((TPackage*)p);
      }
    break;

    // localnet
    case MSG_NET_LAN_GAMES_INFO:{
      if( ac == TGUI::gui_inst->mainmenu){
        ((TMainMenu*)ac)->localNetGames((DA<net::TGames*>*)p);
      }
    }break;
    
    // battlenet
    case MSG_NET_OTHER_GAMES_INFO:{
      if( ac == TGUI::gui_inst->mainmenu){
        ((TMainMenu*)ac)->battleNetGames((DA<net::TGames*>*)p);
      }
    }break;

    // osetreni vyjimek v ostatnich na ostatnich vlaknech
    case MSG_EXCEPTION_IN_THREAD:{
      //vypni prijem zprav
      TGUI::gui_inst->gui_transceiver.iActived = 0;
      //vyjimka
      E_8K* e = (E_8K*)p;
      //vytvor zpravu
      char temp[LABEL_MAX_LENGTH];
      strncpy(temp, "Fatal Error: ", LABEL_MAX_LENGTH);
      if(e)strncat(temp, e->getDescription(), LABEL_MAX_LENGTH);
      //osetri zpravu
      if(ac) {
        wchar_t wtemp[LABEL_MAX_LENGTH];
        UTF8toWideChar(temp, wtemp, LABEL_MAX_LENGTH);
        ac->Add( new TErrorWindow(wtemp, ewtFatalError, true) );
      }
      else {
        strcat(temp,"\n");
        CONSOLE(temp);
        exit(-1);
      }
    }break;

    ///////////////////////////////////////////////////////////////////////////
    // reakce na udalosti z worldu/herni zpravy
    ///////////////////////////////////////////////////////////////////////////
    default: {

      //hra || nahravani
      if( ac == TGUI::gui_inst->game || ac == TGUI::gui_inst->loadingscreen ){
        //zafrontuj
        int enqueue = 1;
        static int t = 0;
        MSG_TPacket mp;
        mp.msg = mid;
        mp.data = NULL;      
        mp.t = (t++);
        //okopirovat
        switch(mid){
          case MSG_RCT_UNIT_MOVE:   mp.data = new TPacket_RCT_UNIT_MOVE(*((TPacket_RCT_UNIT_MOVE*)p));  break;
          case MSG_RCT_NEXT_TURN:   mp.data = new TPacket_RCT_NEXT_TURN(*((TPacket_RCT_NEXT_TURN*)p));  break;
          case MSG_RCT_UNIT_ATTACK: mp.data = new TPacket_RCT_UNIT_ATTACK(*((TPacket_RCT_UNIT_ATTACK*)p));break;
          case MSG_RCT_UNIT_SUICIDE:mp.data = new TPacket_RCT_UNIT_SUICIDE(*((TPacket_RCT_UNIT_SUICIDE*)p));break;
          case MSG_RCT_BUILDING_SUICIDE:      mp.data = new TPacket_RCT_BUILDING_SUICIDE(*((TPacket_RCT_BUILDING_SUICIDE*)p));break;
          case MSG_RCT_BUILDING_RECRUIT_UNIT: mp.data = new TPacket_RCT_BUILDING_RECRUIT_UNIT(*((TPacket_RCT_BUILDING_RECRUIT_UNIT*)p));break;
          case MSG_RCT_START_BUILDING:    mp.data = new TPacket_RCT_START_BUILDING(*((TPacket_RCT_START_BUILDING*)p));break;
          case MSG_RCT_UNIT_RECRUIT:      mp.data = new TPacket_RCT_UNIT_RECRUIT(*((TPacket_RCT_UNIT_RECRUIT*)p));break;
          case MSG_RCT_UNIT_RECRUIT_ELITE:mp.data = new TPacket_RCT_UNIT_RECRUIT_ELITE(*((TPacket_RCT_UNIT_RECRUIT_ELITE*)p));break;
          case MSG_RCT_UNIT_HEAL:         mp.data = new TPacket_RCT_UNIT_HEAL(*((TPacket_RCT_UNIT_HEAL*)p));break;
          case MSG_RCT_REPAIR_BUILDING:   mp.data = new TPacket_RCT_REPAIR_BUILDING(*((TPacket_RCT_REPAIR_BUILDING*)p));break;
          case MSG_RCT_STOP_BUILDING: mp.data = new TPacket_RCT_STOP_BUILDING(*((TPacket_RCT_STOP_BUILDING*)p));break;
          case MSG_RCT_SELL_BONUS:    mp.data = new TPacket_RCT_SELL_BONUS(*((TPacket_RCT_SELL_BONUS*)p));break;
          case MSG_BUILDING_OCCUPIED: mp.data = new TPacket_BUILDING_OCCUPIED(*((TPacket_BUILDING_OCCUPIED*)p));break;
          case MSG_TOWN_OCCUPIED:     mp.data = new TPacket_TOWN_OCCUPIED(*((TPacket_TOWN_OCCUPIED*)p));break;
          case MSG_KINGDOM_OCCUPIED:  mp.data = new TPacket_KINGDOM_OCCUPIED(*((TPacket_KINGDOM_OCCUPIED*)p));break;
          case MSG_END_GAME:          mp.data = new TPacket_END_GAME(*((TPacket_END_GAME*)p));break;        
          case MSG_DIPLOMACY_RELATION_CHANGE: mp.data = new TPacket_DIPLOMACY_RELATION_CHANGE(*((TPacket_DIPLOMACY_RELATION_CHANGE*)p));break;        
          case MSG_PLAYER_DEFETAED: mp.data = new TPacket_PLAYER_DEFEATED(*((TPacket_PLAYER_DEFEATED*)p));break;        
          case MSG_RCT_ERROR:       mp.data = new TPacket_ErrorResult(*((TPacket_ErrorResult*)p));break;        
          default: enqueue = 0; break;      
        }
        //do fronty
        if(enqueue){
          SDL_LockMutex(TGUI::gui_inst->msg_queue_lock);
          TGUI::gui_inst->msg_queue.push_back(mp);
          SDL_UnlockMutex(TGUI::gui_inst->msg_queue_lock);       
        }
      }         
      
      // hra zrusena po nebo pred nahrani gui(behem nahravani gui se nesmi rusit)
      if( (ac == TGUI::gui_inst->loadingscreen) && (mid == MSG_END_GAME) &&
          ( ((TLoadingScreen*)ac)->guiMapReady || !((TLoadingScreen*)ac)->letsGo ) ) {
        TGUI::gui_inst->pumpEndGameMessage();
      }
    }//default
  }//firstlevel switch 

  //
  TGUI::gui_inst->screen->sync_end();
  return 0;
}

}//namespace
/*****************************************************************************/