/*
 * Soubor:  proj1-kostra.c
 * Datum:   2010/08/12
 * Autor:   Kačer Donald, donald@fit.vutbr.cz
 * Projekt: Jednoduchá komprese textu, projekt č. 1 pro předmět IZP
 * Popis:   Program provádí... (doplňte)
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <stdbool.h>
#include <assert.h>
#include <limits.h>
#include <errno.h>


enum tecodes                                                  /** Kódy chyb programu */
{
  EOK = 0,                                                    /**< Bez chyby */
  ECLWRONG,                                                   /**< Chybný příkazový řádek. */
  EUNKNOWN,                                                   /**< Neznámá chyba */
};

enum tstates                                                  /** Stavové kódy programu */
{
  CHELP,                                                      /**< Nápověda */
  CCOMP,                                                      /**< Komprimovat. */
  CDECOMP,                                                    /**< Dekomprimovat. */
};

const char *ECODEMSG[] =                                      /** Chybová hlášení odpovídající chybovým kódům. */
{
  "Vše v pořádku.\n",                                         /* EOK */
  "Chybné parametry příkazového řádku!\n",                    /* ECLWRONG */
  "Nastala nepředvídaná chyba! Vypněte počítač a rychle utečte.\n",
};

const char *HELPMSG =
  "Program Jednoduchá komprese - vzorová implementace.\n"
  "Autor: Kačer Donald (c) 2010\n"
  "Program provádí...\n"
  "Použití: proj1 -h\n"
  "         proj1 -c N\n"
  "         proj1 -d N\n"
  "Popis parametrů:\n"
  "  [-c N - komrpimace]\n"
  "  [-d N - dekomprimace]\n";

typedef struct params                                          /** Struktura obsahující hodnoty parametrů příkazové řádky */
{
  unsigned int N;                                              /**< Hodnota N z příkazové řádky. */
  int ecode;                                                   /**< Chybový kód programu, odpovídá výčtu tecodes. */
  int state;                                                   /**< Stavový kód programu, odpovídá výčtu tstates. */
} TParams;

/**Vytiskne hlášení odpovídající chybovému kódu.
 * @param ecode kód chyby programu
 */
void printECode(int ecode)
{
  if (ecode < EOK || ecode > EUNKNOWN)
  { ecode = EUNKNOWN; }

  fprintf(stderr, "%s", ECODEMSG[ecode]);
}

/**
 * Zpracuje argumenty příkazového řádku a vrátí je ve struktuře TParams.
 * Pokud je formát argumentů chybný, ukončí program s chybovým kódem.
 * @param argc Počet argumentů.
 * @param argv Pole textových řetězců s argumenty.
 * @return Vrací analyzované argumenty příkazového řádku.
 */
TParams getParams(int argc, char *argv[])
{
  TParams result =
  {                                                                     // inicializace struktury
    .N = 0,
    .ecode = EOK,
    .state = CCOMP,
  };


  if (argc == 2 && strcmp("-h", argv[1]) == 0)
  {                                                                     // tisk nápovědy
    result.state = CHELP;
  }
  else if (argc == 3)
  {                                                                     // dva parametry


    if ((strcmp("-c", argv[1]) == 0))
    {
    result.state = CCOMP;
    }

    else if ((strcmp("-d", argv[1]) == 0))
    {
    result.state = CDECOMP;
    }


int prevodN (int argc, char *argv[])
{
    char *endptr, *str; // do str musis dat ten argv[2] (2. parametr) - ale predtim testnout, jestli argc == 3
// tady neni long ale unsigned long
    unsigned long val;

// toto pak neni potreba, toto je jen pro testovani
  if (argc < 2)
    {
    fprintf(stderr, "Usage: %s str [base]\n", argv[0]);
    exit(EXIT_FAILURE);
    }

   errno = 0;

    val = strtoul(str, &endptr, 10);

   if (!isdigit(str[0]))
    {
    fprintf(stderr, "Prvni znak neni cislo");
    exit(EXIT_FAILURE);
    }

   if ((errno == ERANGE && (val == ULONG_MAX || val == 0)) || (errno != 0 && val == 0))
    {
    perror("strtoul");
    exit(EXIT_FAILURE);
    }

   if (endptr == str)
    {
    fprintf(stderr, "No digits were found\n");
    exit(EXIT_FAILURE);
    }

   printf("strtoul() returned %lu\n", val);

  // toto je potreba taky osetrit
   if (*endptr != '\0')        /* Not necessarily an error... */
        printf("Further characters after number: %s\n", endptr);

   exit(EXIT_SUCCESS);
}

    //
    // testování parametrů příkazového řádku
    // a nastavení result.ecode a result.state
    // na správnou hodnotu
    //

  }
  else
  { // příliš mnoho parametrů
    result.ecode = ECLWRONG;
  }

  return result;
}



int i=10;
int *p1, *p2;


int dekomprimace(char *strN)
{
  int c;
  int i=0, isIn=0, pocet=0;
  char *pole=malloc(N*sizeof(char));
  if(pole==NULL)
    return 0;

  while((c=getchar())!=EOF)
    {
    if(!isdigit(c) && !isIn )
    {
    putchar(c);
    }
    else if(isdigit(c))
    {
      if(isIn)
      {
      free(pole);
      return 1;
      }
      isIn=1;
      i=0;
      pocet=c-'0';
    }
    else if(isIn)
    {
    pole[i]=(char)c;
      i++;
      if(i==N)
      {
        for(int j=0; j<pocet; j++)
        {
          for(int m=0; m<N; m++)
            putchar(pole[m]);
        }
        isIn=0;
      }
    }
  }

    free(pole);
    return 1;
}



int komprimace (void)
{

int c;
int predchozi_znak = NULL;
int stejne_znaky = 0;                                        /* nejsou stejne znaky */
int i = 1;                                                   /* pocitadlo */
int max_i = 9;                                               /* maximum pocitadla na jeden znak */

  while ((c=getchar()) != EOF)  {

    if (isdigit(c) && (!isspace(c) || !isprint(c) || !ispunct(c)))          /* kontrola znaků */
      {
      putchar(i + '0');
      putchar(predchozi_znak);
      fprintf(stderr, "\nText obsahuje nepovolene znaky!");
      return EXIT_FAILURE;
      }

    else if (i == max_i)                                    /* pocitadlo presahlo maximum */
      {
      putchar(i + '0');
      putchar(predchozi_znak);
      i = 1;
      }

    else if (predchozi_znak == c)                           /* stejne znaky posobe */
      {
      i++;
      stejne_znaky = 1;
      predchozi_znak = c;
      }

     else if ((predchozi_znak != c) && stejne_znaky == 1)   /* byly stejne znaky a nasleduje jiny znak */
      {
      putchar(i + '0');
      putchar(predchozi_znak);
      i = 1;
      stejne_znaky = 0;
      predchozi_znak = c;
      }

    else if (predchozi_znak == NULL)
      {

      predchozi_znak = c;
      }

    else
      {
      putchar(predchozi_znak);
      predchozi_znak = c;
      }
    }
}



int main(int argc, char *argv[])
{
  TParams params = getParams(argc, argv);
  if (params.ecode != EOK)
  { // něco nestandardního
    printECode(params.ecode);
    return EXIT_FAILURE;
  }

  if (params.state == CHELP)
  {
    printf("%s", HELPMSG);
    return EXIT_SUCCESS;
  }

  if (params.state == CCOMP)
  {
    int komprimace(char *strN)
    return EXIT_SUCCESS;
  }

  if (params.state == CDECOMP)
  {
    int dekomprimace(char *strN)
    return EXIT_SUCCESS;
  }


  return EXIT_SUCCESS;
}

/* konec proj1-kostra.c */