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

  @file /common/rm/rmtxti.cpp
  @brief Interface k RMtxt, definice struktur pro výměnu dat
  
  @author Vta
  @version 1.0

******************************************************************************/
#include "common/rm/rmtxti.h"

using namespace rm;

TRM_txt_i::TRM_txt_i(TRM_txt * globalrmtxt)
{
  this->rmtxt=globalrmtxt;
  this->sizeofdata=100;
  this->data=(char*) KMemAlloc(sizeof(char)*100);
  GLOBALLOGID(PRIORITY_CONFIRM ,"RMtxti was created");
}

TRM_txt_i::~TRM_txt_i()
{
  KMemFree(this->data);
  GLOBALLOGID(PRIORITY_CONFIRM ,"RMtxti was destroyed");
}

int TRM_txt_i::loadedLanguage(void)
{
  return this->rmtxt->loadedLanguage();
}

char * TRM_txt_i::loadedLang(void)
{
  int done,i=0;
  do
  {
    i=(this->rmtxt->fileOfLoadedLanguage(this->data,this->sizeofdata));
    if ((i-1)>this->sizeofdata)
    {
      this->sizeofdata=i+2;
      KMemFree(this->data);
      (this->data)=(char*)KMemAlloc(this->sizeofdata*sizeof(char));
      done=-1;
    }
    else
      done=this->sizeofdata;
  } while (done==-1);
  return this->data;
}

void TRM_txt_i::loadBuffer(void)
{
  this->rmtxt->loadBuffer();
}

void TRM_txt_i::request(int iLangCode)
{
  this->rmtxt->request(iLangCode);
}

void TRM_txt_i::selectLangNow(int iLangCode)
{
  this->rmtxt->inputLangData(iLangCode);
}

/// Funkce umoznujici nacitani jazyku v pomocnem vlakne
int selectLangThread(void * data)
{
  int * code = (int *) data;
  int load=*code;
  *code=-1;

  // vytvorim si vlastni RMi (protoze jsem v jinem vlakne!) a pomoci toho nactu do RM data
  TRM_txt_i * RMtxti=(TRM_txt_i *)KSendMessage(RQUEUE,MSG_GET_RM_TXT_I,MOD_RM,MOD_RM,NULL);
  RMtxti->selectLangNow(load);
  delete(RMtxti);
  return 0;
}

void TRM_txt_i::selectLangThr(int iLangCode)
{
  if (iLangCode!=-1)
  {
  /*this->threads[this->threads.getMaxId()+1]=*/SDL_CreateThread(selectLangThread, (void*) &iLangCode);
    while (iLangCode!=-1) // cekam, dokud nepredam vse do vlakna - necekam, az to nacte, jen predavam
    {
    }
  }
}

void TRM_txt_i::addLang(TLang* lang)
{
  this->rmtxt->addLangDataRaw(lang->szName,lang->szCode);
}

void TRM_txt_i::delLang(int iLangCode)
{
  this->rmtxt->delLang(iLangCode);
}

int TRM_txt_i::getStringsCount()
{
  return (this->rmtxt->getNumOfTexts());
}
int TRM_txt_i::getLangsCount()
{
  return (this->rmtxt->getNumOfLanguages());
}

int TRM_txt_i::getIds(DA<int> * ids)
{
  return (this->rmtxt->getAllTextIds(ids));
}


int TRM_txt_i::getIds(int* ids, int n)
{
  DA<int> daids;
  int j=1,max;
  max=this->rmtxt->getAllTextIds(&daids);
  int i;
  for (i=0;i<n;i++)
  {
    if (j==(max+1)) // neni tam vic indexu nez n
    {
      break;
    }
    while ((j<=max) && (daids[j]==0))
      j++;
    if (daids[j]!=0) // kvuli poslednimu prvku ids[max]
    {
      ids[i]=j;
      j++;
    }
  }
  if (j!=(max+1))
    return i;
  else
    return i-1;
}

void TRM_txt_i::getLangCode(char ** code,size_t &size,int lang_id)
{
  this->rmtxt->getLangId(code,size,lang_id,0);
}

void TRM_txt_i::getLangNames(DA<char*>* langs)
{
  this->rmtxt->getAllLanguages(langs,"name");
}


void TRM_txt_i::getLangs(DA<TLang*>* langs)
{
  DA<char *> name;
  DA<char *> code;
  this->rmtxt->getAllLanguages(&name,"name");
  this->rmtxt->getAllLanguages(&code,"code");
  int i;
  for (i=name.getNext(-1);i!=-1;i=name.getNext(i))
  {
    (*langs)[i]=(TLang*)KMemAlloc(sizeof(TLang));
    strncpy((*langs)[i]->szCode,code[i],MAX_LANGUAGE_CODE_LENGTH);
    (*langs)[i]->szCode[MAX_LANGUAGE_CODE_LENGTH-1]=0;
    strncpy((*langs)[i]->szName,name[i],MAX_LANGUAGE_NAME_LENGTH);
    (*langs)[i]->szName[MAX_LANGUAGE_NAME_LENGTH-1]=0;
    (*langs)[i]->iLangCode=i;
    KMemFree(code[i]);
    code[i]=NULL;
    KMemFree(name[i]);
    name[i]=NULL;
  }
}

int TRM_txt_i::getLangs(TLang* langs, int n)
{
  DA<char *> daids;
  int j=1,max;
  max=this->rmtxt->getAllLanguages(&daids,"name");
  int i;
  for (i=0;i<n;i++)
  {
    if (j==(max+1)) // neni tam vic indexu nez n
    {
      break;
    }
    while ((j<=max) && (daids[j]==NULL))
      j++;
    if (daids[j]!=NULL) // kvuli poslednimu prvku ids[max]
    {
      langs[i].iLangCode=j;
      strncpy(langs[i].szName,daids[j],MAX_LANGUAGE_NAME_LENGTH-1);
      KMemFree(daids[j]);
    }
  }
  int l;
  for (l=daids.getNext(j);l!=-1;l=daids.getNext(l))
  {
    KMemFree(daids[l]); // dealokuju zbytek, ktery jsem neskopiroval
  }
  if (j!=(max+1))
    return i;
  else
    return i-1;
}


void TRM_txt_i::writeToFile()
{
  this->rmtxt->writeLangToFile(this->loadedLang());
}


wchar_t * TRM_txt_i::getWChar(wchar_t * data2,int size,int id)
{
  char * d=this->rmtxt->getLangDataRaw(id);
  UTF8toWideChar(d,data2,size);
  return data2;
}

wchar_t * TRM_txt_i::getWCharResize(wchar_t ** data2,int &size,int id)
{
  char * d=this->rmtxt->getLangDataRaw(id);
  int len = UTF8len(d)+1;
  if (len>size)
  {
    if (size!=0)
    {
      KMemFree((*data2));
      (*data2)=(wchar_t*) KMemAlloc(sizeof(wchar_t)*len);
      size=len;
    }
  }
  UTF8toWideChar(d,(*data2),len);
  return (*data2);
}


char * TRM_txt_i::get(int id)
{
  int done,i=0;
  do
  {
    i=(this->rmtxt->getLangData(this->data,this->sizeofdata,id));
    if ((i-1)>this->sizeofdata)
    {
      this->sizeofdata=i+2;
      KMemFree(this->data);
      (this->data)=(char*)KMemAlloc(this->sizeofdata*sizeof(char));
      done=-1;
    }
    else
      done=this->sizeofdata;
  } while (done==-1);

  return data;
}

char * TRM_txt_i::get(int id, int maxsize)
{
  if (maxsize>this->sizeofdata) // chtel bych tam dat neco vetsiho, nez muzu
  {
    this->sizeofdata=maxsize+1; 
    KMemFree(this->data);
    (this->data)=(char*)KMemAlloc(this->sizeofdata*sizeof(char));
  }
  this->rmtxt->getLangData(this->data,maxsize,id);
  if (maxsize>0)
    this->data[maxsize-1]=0;
  return data;
}

char * TRM_txt_i::getRaw(int id)
{
  return this->rmtxt->getLangDataRaw(id);
}

int TRM_txt_i::get(char * buffer,int size, int id)
{
  int i = this->rmtxt->getLangData(buffer,size,id);
  return i;
}

void TRM_txt_i::set(char * buffer, int id)
{
  this->rmtxt->setData(buffer,id);
  this->writeToFile();
}

int TRM_txt_i::addString(char * data, int id, int startid)
{
  return this->rmtxt->addData(data,id,startid);
}

void TRM_txt_i::delString( int id)
{
  this->rmtxt->delData(id);
}