#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

enum ecodes
//ecodes - CHYBOVE HLASKY
{
EOK=0, //vse je vporadku
ECLWRONG, //chybny vstup - chybne parametry(1)
EUNKNOWN, //neznama chyba(2)
};//!zakoncit strednikem

enum states
//states - stavove hlasky
{
HELP=0,//NULA NEMUSI BYT, JE ZADANA DEFAULTNE
COMP,
DECOMP
};

const char *ECODEMSG[]=
//chybova hlasky, ktere se budou pojit s ecodes
//musi byt oddeleno carkou (podle toho se vybere, ktera hlaska se zobrazi)
{
  "Vse v poradku.\n",   //pro EOK
  "Chybné parametry prikazového radku!\n",    //pro ECLWRONG
  "Nastala nepredvidana chyba! Vypnete pocítac a rychle utecte.\n",    //pro EUNKNOWN
};


const char MSGHELP[]=
{
"Autor: Ondrej Chrastina\n"
"Program provadí komprimaci a dekomprimaci, pripradne vytiskne napovedu, v zavislostina zadanych parametrech.\n"
"Pouziti: proj1 -h\n"
"         proj1 -c N\n"
"     proj1 -d N\n"
"\n"
"Popis parametrù:\n"
"  -h    Vypise tuto obrazovku s nápovedou.\n"
"  -c    Program zkomprimuje vlozeny text podle zadanych kriterii.\n"
"  -d    Program dekomprimuje vlozeny text podle zadanych kriterii.\n"
"Priklad pouziti:\n"
"  Vstup:       proj1 -c 3 <<< ''blabla ahoj''\n"
"  Vystup:  2bla ahoj \n"
"  Vstup2:  proj1 -d 3 <<< ''2bla ahoj''\n"
"  Vysptup2 blabla ahoj\n"
};


typedef struct params //definice datoveho typu struktury
{
unsigned int N;
int ecode;
int state;
} TParams;

/*-------------------------------------------------------------------- funkce pro tisk Ecodu-----------------------------------------------------------------------*/

void printECode(int ecode) //funkce, z nazvem printEcode, s parametrem typu int, nic nevraci
{
if (ecode < EOK || ecode > EUNKNOWN)//pokud neni ecode v rozmezi eok(to je 0) a euknown(to je 2) tak vystup ecode je eunknown
  {
  ecode = EUNKNOWN;
  }

  fprintf(stderr, "%s", ECODEMSG[ecode]);// vytiskne do chybovaho hlaseni stderr rezetec ecodemesg, ktery ma hodnotu (ecode)
 }
/*-----------------------------------------------------------Funkce pro pretypovani N---------------------------------------------------------------------------*/

unsigned int convert(char *hodnota)//funkce, ktera pretypuje N (vstup char a vystup unsigned int
{
unsigned int cislo=0,preteceni=0;
int i=0;
while(hodnota[i]!='\0')
  {
  if (hodnota[i]<'0' && hodnota[i]>'9') //osetreni, ze N je cislo (osetreni i pro to, ze cilo je kladne)
    {
    return 0;
    }
  hodnota[i]=hodnota[i]-'0';    //zaskani presne hodnoty cisla z nejake ascii hodnoty

  preteceni=cislo;
  cislo=cislo*10;
  cislo=cislo+hodnota[i]; //pokud uz proslo pripocte k 10tinasobku predchoziho cila prave nastene cislo
  i++;
  if(preteceni>cislo)   //doslo k preteceni - jednicka vypadla ven a jede se od nuly
    {
    return 0;       //kdyz vrati nulu - doslo k chybe (zde z duvodu preteceni)
    }
  }
return cislo;
}


/*---------------------------------------------------------------Zpracovani parametru-------------------------------------------------------------------------*/


TParams getParams(int argc, char *argv[])  //Zpracovani parametru - nastaveni ecodes a estates + kontrola zadani parametrů (vcetne N)
{
TParams result=
  {//inicializace struktury
  .N=0,
  .ecode=EOK,
  .state=COMP
  };

  if (argc==2&&strcmp("-h",argv[1])==0) //pokud ma vlozeni 2 parametry (jmeno a parametr) - zkontroluju, jetli parametr je -h
  {
  result.state=HELP;
  }

else if (argc==3) //pokud to ma ty parametry 3 (jmeno a dva parametry)
  {
  if(strcmp ("-c", argv[1])==0) //pokud je 1. parametr -c
    {
    result.state=COMP;
    if ((result.N=convert(argv[2]))==0) //pokud ve funkci convert vysla nula - stala se chyba(doslo k preteceni pravdepodobne)
      {
      result.ecode=ECLWRONG;
      }
    result.ecode=EOK;
    }
  else if(strcmp("-d",argv[1])==0)
    {
    result.state=DECOMP;
    if ((result.N=convert(argv[2]))==0)
      {
      result.ecode=ECLWRONG;
      }
    result.ecode=EOK;
    }
  else
    {//zadany jiny parametr, nez -c,-d nebo -h
    result.ecode=ECLWRONG;
    }
  }
  else
    {//prilis mnoho parametru
    result.ecode=ECLWRONG;
    }
return result;
}
/*-------------------------------------------------------------------- DEKOMPRIMACE-----------------------------------------------------------------------------*/

int dekomprimace(unsigned int N)
{
printf("Dekomprimace\n");
int c=0;
char *buffer = malloc((N+1) * sizeof(char));
if(buffer==NULL)        //ochrana proti nedodtatku paměti
{
return 1;
}
while((c = getchar()) != EOF)
  {
  if(isdigit(c)!=0)
    {
    int x;
    x = c - '0';
    for(unsigned int i=0; i < N; i++)
      {
      buffer[i] = getchar();
      if(isdigit(buffer[i])!=0)
        {                                           //TADY JE PORTEBA DOPSAT OCHRANU, ABY NA VSTUPU NABYLY
        printf("Byla zadana 2 cisla vedle sebe - Musim pak prepsat na estate.eclwrong ;-)") ;   //2 CISLA
        }                                           //!!!!!! POZOR
      }
    for (; x>0;x--)
      {
      for(unsigned int i = 0; i<N; i++)
        {
        putchar(buffer[i%N]);
        }
      }
    }
  else
    {
    putchar(c);
    }
  }
return 0;
}
/*-----------------------------------------------------------------------KOMPRIMACE-----------------------------------------------------------------------------*/


int komprimace(unsigned int N)
{
printf("Komprimace\n");
char *buffer1 = malloc((N+1) * sizeof(char));//definice bufferù a jejich dynamické alokování
char *buffer2 = malloc((N+1) * sizeof(char));

if(buffer1==NULL)
{
return 1;
}

if (buffer1==NULL)
{
return 1;
}
unsigned int i=0,pocet=1; //vlozeni pomocnych promenych (pocet je promena, do ktere se bude vkladat pocet shodujicich se blokù znakù)
char c=0;

while((c = getchar()) != EOF && i!=(2*N))
  {
    if(i < N)               //prvotní nacteni do bufferu ze vstupu
      {
      buffer1[i%N] = c;
      i++;
      }
      else if(i < 2 * N)
        {
        buffer2[i%N] = c;
        i++;
        }
  }
while(strcmp(buffer1, buffer2) == 0)        //porovvnani buffer (jestli se bloky neopakuji
  {
  pocet++;                                  //pokud se tovnaji naèti do bufferu 2 dalsi blok znakù a znovu skoc na provnavani
  unsigned int ochrana=0;
  while((c=getchar())!= EOF && ochrana<N)
    {
    ochrana++;
    i++;
    c=getchar();
    buffer2[i%N]=c;
    }
  }
  putchar(pocet);
  putchar(buffer1[i%N]);

  while((c = getchar()) != EOF)             //vytisknuti prvniho znaku a posunuti znaku o jeden a nacteni dalsiho znaku
    {
    unsigned int j=0;
    putchar(buffer1[j%N]);
    while(j<N)
      {
      buffer1[j%N]=buffer1[(j+1)%N];
      j++;
      }
    while(j==N)
      {
       buffer1[(j-1)%N]=buffer2[j%N];     // PRESUNUTI PRVNIHO ZNAKU Z BUFFERU2 NA POSLEDNI ZNAK BUFFERU 1
       j++;
      }
    while (j>N&&j<(2*N))
      {
      buffer2[j%N]=buffer2[(j+1)%N];
      j++;
      }
    c=buffer2[(j-1)%N];
      while(strcmp(buffer1, buffer2) == 0)
        {
        pocet++;
        unsigned int ochrana=0;
        while((c=getchar())!= EOF && ochrana<N)
          {
          ochrana++;
          i++;
          c=getchar();
          buffer2[i%N]=c;
          }
        }
  putchar(pocet);
  putchar(buffer1[i%N]);

  }
unsigned int k=0;
while(k<(2*N))
  {
    if(k < N)
      {
      putchar (buffer1[i%N]);
      k++;
      i--;
      }
      else if(k < (2 * N))
        {
        putchar (buffer2[i%N]);
        k++;
        }
  }

free(buffer1);
free(buffer2);
return 0;
}

int main (int argc, char *argv[])
{
TParams params = getParams(argc, argv);

if (params.ecode !=EOK)
  {//pokud je neco nestandartniho
  printECode(params.ecode);
  return EXIT_FAILURE;
  }
unsigned int N=0;

if (params.state==HELP)
  {
  printf("%s", MSGHELP);
return EXIT_SUCCESS;
  }
if (params.state==COMP)
  {
  N=convert(argv[2]);
  komprimace(N);
  return EXIT_SUCCESS;
  }
if (params.state==DECOMP)
  {//zde volat funkci dekomprese
  N=convert(argv[2]);
  dekomprimace(N);
  return EXIT_SUCCESS;
  }

else
  {
  return EXIT_SUCCESS;
  }
}