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

  @file /common/xml/strda.cpp
  @brief Dalsi funkce pro praci s char* resp. DA<char>
 
  @author Vta
  @version 1.0

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

#include "strda.h"
#include "common/exc.h"
#include "common/utils.h"
#include <wchar.h>
#include <string.h>

// zrychleni 
#define KMemAlloc malloc
#define KMemFree free

void addtodanum(DA<char> *big,const char *smallstr,int terminate,size_t count)
{
  size_t k,i=(*big).getMaxId()+1; // +1 = na dalsi volny
  size_t j=count;
  for (k=0;k<j;k++)
  {
    (*big)[i+k]=smallstr[k];
  }
  if (terminate)
    (*big)[i+k]=0;
}

void addtoda(DA<char> *big,const char *smallstr,int terminate)
// Prida nakonec Da<char>big retezec small, a vlozi 0 pokud terminate
{
  size_t k,i=(*big).getMaxId()+1; // +1 = na dalsi volny
  size_t j=strlen(smallstr);
  for (k=0;k<j;k++)
  {
    (*big)[i+k]=smallstr[k];
  }
  if (terminate)
    (*big)[i+k]=0;
}

void addtodawcs(DA<wchar_t> *big,const wchar_t *smallstr,int terminate)
// Prida nakonec Da<wchar_t>big retezec small, a vlozi 0 pokud terminate
{
  size_t k,i=(*big).getMaxId()+1; // +1 = na dalsi volny
  size_t j=wcslen(smallstr);
  for (k=0;k<j;k++)
  {
    (*big)[i+k]=smallstr[k];
  }
  if (terminate)
    (*big)[i+k]=0;
}

void addtodastr(DA<char> *big,const char *smallstr,int terminate)
// Prida nakonec Da<char>big retezec small, a vlozi 0 pokud terminate
{
  size_t k,i=(*big).getMaxId()+1; // +1 = na dalsi volny
  size_t j=strlen(smallstr);
  for (k=0;k<j;k++)
  {
    (*big)[i+k]=smallstr[k];
  }
  if (terminate)
    (*big)[i+k]=0;
}

void addtostr(char **big,const char *smallstr,int terminate)
// Prida nakonec big retezec small, a vlozi 0 pokud terminate
{
  size_t k,i=strlen(*big);
  size_t j=strlen(smallstr);
  for (k=0;k<j;k++)
  {
    (*big)[i+k]=smallstr[k];
  }
  if (terminate)
    (*big)[i+k]=0;
}

size_t newandstrcpy(char ** output, const char * input)
// naalokuje retezec potrebne delky a skopiruje do nej input
{
  if ((*output)!=NULL)
  {
//    printf("ERROR: ReAllokace - sem se to nesmi nikdy dostat");
    THROW(E_8K,"Realloc is not possible");
  }
  size_t i=strlen(input)+1;
  *output=(char *) KMemAlloc(sizeof(char)*(i));
  strcpy(*output,input);
  return i;
}

size_t newandwcscpy(wchar_t ** output, const wchar_t * input)
// naalokuje retezec potrebne delky a skopiruje do nej input
{
  if ((*output)!=NULL)
  {
//    printf("ERROR: ReAllokace - sem se to nesmi nikdy dostat");
    THROW(E_8K,"Realloc is not possible");
  }
  size_t i=wcslen(input)+1;
  *output=(wchar_t *) KMemAlloc(sizeof(wchar_t)*(i));
  wcscpy(*output,input);
  return i;
}

size_t delandnewandstrcpy(char ** output, const char * input, size_t size)
// pokud by se do output input nevesel, tak output zvetsi a pak tam input na kazdy pad nakopiruje, size je aktualni velikost (*output)
{
  if (input!=NULL)
  {
    size_t i=strlen(input)+1;
    if ( i > size )
    {
      if ((*output)!=NULL)
        KMemFree(*output);
      size=i;
      *output=(char *) KMemAlloc(sizeof(char)*(size));
    }
    strcpy(*output,input);
    return size;
  }
  else
  {
    return 0;
  }
}

size_t delandnewandwcscpy(wchar_t ** output, const wchar_t * input, size_t size)
// pokud by se do output input nevesel, tak output zvetsi a pak tam input na kazdy pad nakopiruje, size je aktualni velikost (*output)
{
  if (input!=NULL)
  {
    size_t i=wcslen(input)+1;
    if ( i > size )
    {
      if ((*output)!=NULL)
        KMemFree(*output);
      size=i;
      *output=(wchar_t *) KMemAlloc(sizeof(wchar_t)*(size));
    }
//    if (int(*output)==10692736)
//      printf("X");
    wcscpy(*output,input);
    return size;
  }
  else
  {
    return 0;
  }
}


size_t datostr(char **output, DA<char> *input, size_t size)
// Prevede Da<char>input na retezec
{
  int max=(*input).getActiveMembers();
  int maxid=(*input).getMaxId();

//  if ((*output==NULL) || (size<=max))
  // zatim vzdy ... pada to na free
  {
    if (*output!=NULL)
    {
      KMemFree(*output);
    }
    if ((*input)[maxid]!=0) //chci aby moje retezce byly dycky 0terminated
    {
      size=max+1;
      *output = (char *)KMemAlloc(sizeof(char)* (max+1));
//      printf("dealokuju");
    }
    else
    {
      size=max;
      *output = (char *)KMemAlloc(sizeof(char)* (max));
    }
  }
  int i,j=(*input).getShift();
  for (i=0;i<max;i++)
    (*output)[i]=(*input)[i+j];
  if ((*output)[i-1]!=0)  // aby tam nebyly 2 nuly
    (*output)[i]=0;
  return size;
}

size_t datowcs(wchar_t **output, DA<wchar_t> *input, size_t size)
// Prevede Da<char>input na retezec
{
  int max=(*input).getActiveMembers();
  int maxid=(*input).getMaxId();

//  if ((*output==NULL) || (size<=max))
  // zatim vzdy ... pada to na free
  {
    if (*output!=NULL)
    {
      KMemFree(*output);
    }
    if ((*input)[maxid]!=0) //chci aby moje retezce byly dycky 0terminated
    {
      size=max+1;
      *output = (wchar_t *)KMemAlloc(sizeof(wchar_t)* (max+1));
//      printf("dealokuju");
    }
    else
    {
      size=max;
      *output = (wchar_t *)KMemAlloc(sizeof(wchar_t)* (max));
    }
  }
  int i,j=(*input).getShift();
  for (i=0;i<max;i++)
    (*output)[i]=(*input)[i+j];
  if (max!=0)           // kdyz vubec nic nealokuju (max je furt 0);
    if ((*output)[i-1]!=0)  // aby tam nebyly 2 nuly
      (*output)[i]=0;
  return size;
}

/*
char* wcspath(char ** output, const char *path1, const char *k8pack, const char *path2, wchar_t *input, int & sizeoutput, char *suffix)
{
  int len=WideCharlen(input)+1;
  char * inp=(char*)KMemAlloc(sizeof(char)*(len));
  WideChartoUTF8(input,inp,len+1);
  int sizepath=strlen(path1)+strlen(path2)+strlen(inp)+strlen(k8pack)+strlen(suffix)+1;
  if (sizeoutput<sizepath)
  {
    KMemFree(*output);
    (*output) = (char*) KMemAlloc(sizeof(char)*sizepath);
    sizeoutput=sizepath;
  }
  strcpy((*output),path1);
  strcat((*output),k8pack);
  strcat((*output),path2);
  strcat((*output),inp);
  strcat((*output),suffix);
  return (*output);
}
*/
char* strpath(char ** output, const char *path1, const char *k8pack, const char *path2, char *input, size_t & sizeoutput, char *suffix)
{
  size_t sizepath=strlen(path1)+strlen(path2)+strlen(input)+strlen(k8pack)+strlen(suffix)+1;
  if (sizeoutput<sizepath)
  {
    KMemFree(*output);
    (*output) = (char*) KMemAlloc(sizeof(char)*sizepath);
    sizeoutput=sizepath;
  }
  strcpy((*output),path1);
  strcat((*output),k8pack);
  strcat((*output),path2);
  strcat((*output),input);
  strcat((*output),suffix);
  return (*output);
}

char * strpartpath(char * output, const char *path1, const char *k8pack, const char *path2, char *input, size_t sizeoutput, char *suffix)
{
//  size_t sizepath=strlen(path1)+strlen(path2)+strlen(input)+strlen(k8pack)+strlen(suffix)+1;
  int i=0;
  size_t count=0;
//  int done=0;
  while ((count<sizeoutput) && (path1[i]!=0))
  {
    output[count]=path1[i];
    count++;
    i++;
  }
  if (count==sizeoutput)
  {
    output[count-1]=0;
  }
  else
  {
    i=0;
    while ((count<sizeoutput) && (k8pack[i]!=0))
    {
      output[count]=k8pack[i];
      count++;
      i++;
    }
    if (count==sizeoutput)
    {
      output[count-1]=0;
    }
    else
    {
      i=0;
      while ((count<sizeoutput) && (path2[i]!=0))
      {
        output[count]=path2[i];
        count++;
        i++;
      }
      if (count==sizeoutput)
      {
        output[count-1]=0;
      }
      else
      {
        i=0;
        while ((count<sizeoutput) && (input[i]!=0))
        {
          output[count]=input[i];
          count++;
          i++;
        }
        if (count==sizeoutput)
        {
          output[count-1]=0;
        }
        else
        {
          i=0;
          while ((count<sizeoutput) && (suffix[i]!=0))
          {
            output[count]=suffix[i];
            count++;
            i++;
          }
          if (count==sizeoutput)
          {
            output[count-1]=0; // alespon posledni znak byl umazan (mozna vic)
          }
          else
          {
            output[count]=0; // veslo se cele
          }
        }
      }
    }
  }
  return output;
}

int transformspecialwcs(wchar_t * output,wchar_t * input, int size)
{
  int i=0,j=0;
//  if (input!=NULL)
  {
    while (input[j])
    {
      switch (input[j])
      {
        case 60: // < &#60;
        {
          if ((i+5)>=size)
            return -1;
          output[i]='&'; 
          output[i+1]='#'; 
          output[i+2]='6';
          output[i+3]='0'; 
          output[i+4]=';'; 
          i=i+5;
          break;
        }
        case 62: // > tj. &#62;
        {
          if ((i+5)>=size)
            return -1;
          output[i]='&'; 
          output[i+1]='#'; 
          output[i+2]='6';
          output[i+3]='2'; 
          output[i+4]=';'; // ;
          i=i+5;
          break;
        }
        case 38: // & tj. &#38;
        {
          if ((i+5)>=size)
            return -1;
          output[i]='&'; 
          output[i+1]='#'; 
          output[i+2]='3';
          output[i+3]='8'; 
          output[i+4]=';'; 
          i=i+5;
          break;
        }
        default:
        {
          if ((i+1)>=size)
            return -1;
          output[i]=input[j]; 
          i=i+1;
          break;
        }
      }
      j++;
    }
    output[i]=0;
  }
  return 0;
}

int transformspecialstr(char * output,char * input, size_t size)
{
  size_t i=0,j=0;
//  if (input!=NULL)
  {
    while (input[j])
    {
      switch (input[j])
      {
        case 60: // < &#60;
        {
          if ((i+5)>=size)
            return -1;
          output[i]='&'; 
          output[i+1]='#'; 
          output[i+2]='6';
          output[i+3]='0'; 
          output[i+4]=';'; 
          i=i+5;
          break;
        }
        case 62: // > tj. &#62;
        {
          if ((i+5)>=size)
            return -1;
          output[i]='&'; 
          output[i+1]='#'; 
          output[i+2]='6';
          output[i+3]='2'; 
          output[i+4]=';'; // ;
          i=i+5;
          break;
        }
        case 38: // & tj. &#38;
        {
          if ((i+5)>=size)
            return -1;
          output[i]='&'; 
          output[i+1]='#'; 
          output[i+2]='3';
          output[i+3]='8'; 
          output[i+4]=';'; 
          i=i+5;
          break;
        }
        default:
        {
          if ((i+1)>=size)
            return -1;
          output[i]=input[j]; 
          i=i+1;
          break;
        }
      }
      j++;
    }
    output[i]=0;
  }
  return 0;
}

void strcopy(char * output,char * input,int size)
{
  int i=0;
  while ((i<size) && (input[i]!=0))
  {
    output[i]=input[i];
    i++;
  }
  if (i<size)
    output[i]=0;
  else
    output[i-1]=0; // posleni znak se prepise 0
}

int white_chars_only(char * input,int len)
{
  int white_chars_only=1;
  int i;
  for (i=0;i<(len-1);i++) // bez posledni 0
    if ((input[i]!=' ') && (input[i]!='\n') && (input[i]!='\t'))
      white_chars_only=0;
  return  white_chars_only;
}

int white_chars_only(char * input)
{
  int white_chars_only=1;
  int i=0;
  while (input[i]!=0)
  {
    if ((input[i]!=' ') && (input[i]!='\n') && (input[i]!='\t'))
    {
      white_chars_only=0;
      break;
    }
    i++;
  }
  return  white_chars_only;
}