/*
 * Soubor:  proj1.c
 * Autor:   Tomáš Dlabka, [email protected]
 * Projekt: Jednoduchá komprese textu, projekt è. 1 pro pøedmìt IZP
 * Popis:   Program komprimuje nebo dekomprimuje text dle zadaných parametrù.
 */

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

/* Fce */

void help(void); /* tiskne napovedu */
void compression(char *p); /* spusti kompresi */
void decompression(char *p); /* spusti dekompresi */
void addchar(char c); /* Komprese - nacteni znaku do bufferu */
void comp(int i); /* Komprese - komprese */
void decomp(int i); /* Dekomprese - dekomprese */


/* Globalni promenne - Komprese */

char    *buffer /* FIFO buffer */ ,
        *matchbuffer /* buffer pro ukladani shodnych znaku */;

int     first = 0 /* prvni pole bufferu (vystup) */ ,
        last = 0 /* posledni pole bufferu (vstup) */,
        matchc = 0 /* citac shodnych znaku */ ,
        blockmatch = 1 /* citac shodnych bloku */,
        mbindex = 0 /* index matchbufferu */,
        i, N;


/* nacteni znaku do bufferu */

void addchar(char c) {
    if ((last + 1) % (2 * N) != first) {
                buffer[last] = c;
                last = (last + 1) % (2 * N);
        }
        else {
            int i;
            buffer[last] = c;
            for (i = 0; i < last + 2; i++) {
                buffer[i] = buffer[i + 1];
            }
        }
}

/* komprese */

void comp(int i) {

    if (buffer[first] == buffer[first + N]) { /* kontrola shody znaku */
                matchbuffer[mbindex] = buffer[first]; /* zapise shodny znak do matchbufferu */
                mbindex++; /* navysi index mathcbufferu */
                matchc++; /* navysi citac shodnych znaku */
                if (matchc == N) {
                    blockmatch++; /* pokud pocet shodnych znaku = N, navysi citac shodnych bloku */
                    matchc = 0;
                }
            }
            else if (matchc != 0 && blockmatch > 1) { /* ..po opakovani nasleduji
                dalsi shodne znaky */
                putchar('0' + blockmatch);
                for(i = 0; i < matchc; i++) {/* vypise opakovany retezec z matchbufferu */
                    putchar(matchbuffer[i]);
                }
                blockmatch = 1;
                mbindex = 0;
                matchc = 0;
                putchar(buffer[first]); /* zapis z bufferu*/
            }

            else if (matchc != 0 && blockmatch == 1) { /* ..opakujici se znaky
                delky < N */
                for(i = 0; i < matchc; i++) {/* vypise opakovany retezec z matchbufferu*/
                    putchar(matchbuffer[i]);
                }
                mbindex = 0;
                matchc = 0;
                putchar(buffer[first]);
            }

            else { /* ..po opakovani nasleduje rozdilny znak */
                if (blockmatch > 1) {
                    putchar('0' + blockmatch);/* vypise pocet shodnych bloku*/
                    blockmatch = 1;
                    mbindex = 0;
                    matchc = 0;
                }
                putchar(buffer[first]);
            }
}

/* Fce compression */

void compression(char *p) {

    char input /* vstupni znak */ ;

    int bcondition = 0 /* podminka spoustejici vypis */ ;


    N = atoi(p);

    if (N < 2 || N > 9) { /* kontrola spravnosti parametru */
        printf("Nespravny parametr!");
    }
    else {
        matchbuffer = (char *) malloc(((2 * N) - 1) * sizeof(char));
        buffer = (char *) malloc(2 * N * sizeof(char));

        printf("Zadejte vstup: ");

        do {
            if (input != '\n') {
                input = getchar(); /* zapis do bufferu */
            }

            if (isdigit(input)) { /* najde-li na vstupu cislo, zahlasi chybu */
                printf(" Chybny vstup!");
                break;
            }
            else if(isprint(input) || input == '\n') { /* pokud je na vstupu tisknutelny znak probehne komprese, pri \n
                se cyklus prerusi */

                addchar(input);

                if (bcondition != (2 * N) - 1) /* navysovani podminky pro zacatek vystupu */
                    bcondition++;

                if (bcondition == (2 * N) - 1)
                /* podminka pro zamezeni opakovanemu vypisu prvniho clene pred nactenim bufferu */
                comp(i); /* volani kompresni fce */
            }
            else {
                printf("Chybny vstup!"); /* najde-li na vstupu netisknutelny znak, zahlasi chybu*/
                break;
            }

        } while (buffer[first] != '\n');
    }
    free(buffer);
    free(matchbuffer);
}


/* Fce main */

int main(int argc, char *argv[])
{
    if (argc == 2 && strcmp("-h", argv[1]) == 0) { /* print help */
        help();
        return 0;
    }

    else if (argc == 3 && strcmp("-c", argv[1]) == 0 ) { /* komprese */
         compression(argv[2]);
         return 0;
    }

    else if (argc == 3 && strcmp("-d", argv[1]) == 0) { /* dekomprese */
        decompression(argv[2]);
        return 0;
    }
}

/* Fce help */

void help(void) {
    printf(":: Help :: \n \n");
    printf("Program Jednoducha komprese \n");
    printf("Autor: Tomas Dlabka \n");
    printf("Program provadi jednoduchou kompresi textu v zavislosti na velikosti uzivatelem urceneho parametru N. \n");
    printf("Pouziti: \n");
    printf("    projekt1 -h     - tiskne napovedu \n");
    printf("    projekt1 -c N   - spusti kompresi retezcu o delce N \n");
    printf("    projekt1 -h N   - spusti dekompresi retezcu o delce N \n");
}

/* Fce - dekomprese */

void decompression(char *p) {

    char    input /* vstupni znak */ ;

    int bcondition = 0 /* podminka spoustejici vypis */ ;

    N = atoi(p);

    if (N < 2 || N > 9) { /* kontrola spravnosti parametru */
        printf("Nespravny parametr!");
    }
    else {
        matchbuffer = (char *) malloc(((2 * N) - 1) * sizeof(char));
        buffer = (char *) malloc(2 * N * sizeof(char));

        printf("Zadejte vstup: ");

        do {
            if (input != '\n') {
                input = getchar(); /* zapis do bufferu */
            }

            if(isprint(input) || input == '\n') { /* pokud je na vstupu tisknutelny znak probehne dekomprese, pri \n
                se cyklus prerusi */

                addchar(input);

                if (bcondition != (2 * N) - 1) /* navysovani podminky pro zacatek vystupu */
                    bcondition++;

                if (bcondition == (2 * N) - 1)
                /* podminka pro zamezeni opakovanemu vypisu prvniho clene pred nactenim bufferu */
                decomp(i); /* volani dekompresni fce */
            }
            else {
                printf("Chybny vstup!"); /* najde-li na vstupu netisknutelny znak, zahlasi chybu*/
                break;
            }

        } while (buffer[first] != '\n');
    }

    free(buffer);
    free(matchbuffer);
}

void decomp(int i) {

    char repeat; /* pocet opakovani */
    char crepeat = '0'; /* pocet opakovani cyklu */

    if (isdigit(buffer[first])) { /* vyskytne-li se na vstupu cislice.. */
        repeat = (buffer[first]); /* .. ulozi pocet opakovani retezce.. */
        while (crepeat < repeat - 1) { /* a vypise retezec repeat - 1 -krat (posledni opakovani se opise - line 247) */
            for(i = 1; i <= N; i++) {
                putchar(buffer[i]);
            }
            crepeat++;
        }
    }
    else {
    putchar(buffer[first]); /* opise znak na vystup */
    }
}