/**
  @file /ai/Strategizer/strategytransciever.cpp
  @brief Zdrojovy kod s deklaraci transcieveru pro Strategizer.
  
  Zdrojovy kod s deklaraci transcieveru pro Strategizer.
  
  @author PZ
  @version 0.1
*/

#include "ai/Strategizer/strategytransciever.h"
namespace ai_ns
{
namespace strategizer_ns
{

CStrategyTransciever* StrEngine;

CStrategyTransciever::CStrategyTransciever()
{
  StrEngine=this;
  this->AIPlanningSemaphore=NULL;
  AIPlanningThread=((SDL_Thread*) 0);
  ai_planning_thread_state=0;
  AIPlanningMutex=SDL_CreateMutex();
  if (!AIPlanningMutex)
  {
    GLOBALLOGID(PRIORITY_FATAL,"Nelze vytvorit mutex pro AI planovani.");
    THROW(E_8K_AI_Strategy_AIPlanningThreadProblem,"Nelze vytvorit mutex pro AI planovani."); 
  }

  // inicializace transcieveru
  initTransciever();
}
CStrategyTransciever::~CStrategyTransciever()
{
  int ai_thread_return_status;
  if(AIPlanningThread!=0)
  {
    SDL_WaitThread(AIPlanningThread, &ai_thread_return_status);
//    printf("AI THREAD: %i",ai_thread_return_status);
  }
  SDL_DestroyMutex(AIPlanningMutex);
}

void CStrategyTransciever::initTransciever()
{
  strategy_transceiver.fnc = STRATEGY_MSG_HANDLER;
  strategy_transceiver.iActived = true;
  strategy_transceiver.iPriority = 5;
  strategy_transceiver.PrimaryID = MOD_STRATEGY;
  KRegisterGlobalTransceiver(&strategy_transceiver, MOD_STRATEGY);
}

void CStrategyTransciever::lockAIPlanningState()
{
  if (SDL_LockMutex(AIPlanningMutex)<0) 
  {
    GLOBALLOGID(PRIORITY_FATAL,"Nelze uzamknout mutex pro AI planovani.");
    THROW(E_8K_AI_Strategy_AIPlanningThreadProblem,"Nelze uzamknout mutex pro AI planovani."); 
  }
  GLOBALLOGID(PRIORITY_MUTEX,"Lock %i\n",SDL_ThreadID());
}

void CStrategyTransciever::unlockAIPlanningState()
{
  if (SDL_UnlockMutex(AIPlanningMutex)<0) 
  {
    GLOBALLOGID(PRIORITY_FATAL,"Nelze odemknout mutex pro AI planovani.");
    THROW(E_8K_AI_Strategy_AIPlanningThreadProblem,"Nelze odemknout mutex pro AI planovani."); 
  }
  GLOBALLOGID(PRIORITY_MUTEX,"Unlock %i\n",SDL_ThreadID());
}

RVAL STRATEGY_MSG_HANDLER(MESSAGE_ID mid,SENDER s,PARAM p)
{
  GLOBALLOG("Strategy: Message Id: %d; Sender %d; Param %p\n", mid, s, &p);

  switch (mid)
  {
    case MSG_AI_LETS_GO:
      StrEngine->initStrategy((TPacket_AI_LetsGo*) p); 
      break;

    case MSG_AI_ON_TURN:
#ifdef AI_STRATEGIZER_ENABLED

      StrEngine->passed_player_id=((TPacket_AI_ON_TURN*) p)->player_id;
      StrEngine->passed_max_action_id=((TPacket_AI_ON_TURN*) p)->max_action_id;
      StrEngine->passed_ai_level=((TPacket_AI_ON_TURN*) p)->ai_level;
      StrEngine->lockAIPlanningState();
      StrEngine->ai_planning_thread_state=0;
      StrEngine->AIPlanningSemaphore=SDL_CreateSemaphore(0); 
      StrEngine->unlockAIPlanningState();
      StrEngine->AIPlanningThread=SDL_CreateThread(&runAIPlanning,((void*) 0));
      SDL_SemWait(StrEngine->AIPlanningSemaphore);
      SDL_DestroySemaphore(StrEngine->AIPlanningSemaphore);    

#endif
      break;

    case MSG_AI_KILL_AI_PLANNING:
#ifdef AI_STRATEGIZER_ENABLED

      if ((StrEngine->AIPlanningThread!=NULL) && (StrEngine->ai_planning_thread_state==0))
      {
        SDL_KillThread(StrEngine->AIPlanningThread);
        StrEngine->AIPlanningThread=NULL;
        return (void*)1;
      }
      else
      {
        if (StrEngine->ai_planning_thread_state==0)
          return (void*)1;
        else
          return (void*)0; // dobiha vlakno
      }

#endif
      break;

    case MSG_AI_WAIT_AI_PLANNING:
#ifdef AI_STRATEGIZER_ENABLED

      StrEngine->lockAIPlanningState();
      StrEngine->ai_planning_thread_state=1;
      if (StrEngine->AIPlanningThread!=NULL)
      {
        StrEngine->unlockAIPlanningState();
        int ret=0;
        SDL_WaitThread(StrEngine->AIPlanningThread, &ret);
        StrEngine->ai_planning_thread_state=0;  
//        SDL_KillThread(StrEngine->AIPlanningThread);
        StrEngine->AIPlanningThread=NULL;
      }
      else
      {
        StrEngine->ai_planning_thread_state=0;
        StrEngine->unlockAIPlanningState();
      }

#endif
      break;

// testovaci zpravy pro editor
#ifdef _K_EDITOR_

    case MSG_AI_GET_STRENGINE:
      return StrEngine;
      break;

#endif

    default:;
  }
  return 0;
}

int runAIPlanning(void* param)
{
  try
  {
    SDL_SemPost(StrEngine->AIPlanningSemaphore);
    StrEngine->AITurnForPlayer(StrEngine->passed_player_id,StrEngine->passed_max_action_id,StrEngine->passed_ai_level);
  }
  catch (E_8K &e) 
  {
    KSendGlobalMessage(MSG_EXCEPTION_IN_THREAD,MOD_STRATEGY,BROADCAST,&e);
  } 
  return 0;
}

}
}