/*****************************************************************************************************************
 *                                                                                                               *
 * Write a program to "fold" long input lines into two or more shorter lines after the last non-blank character  *
 * that occurs before the n-th column of input. Make sure your program does something intelligent with very long *
 * lines, and if there are no blanks or tabs before the specified column.                                        *
 *                                                                                                               *
 *****************************************************************************************************************/

#include <stdio.h>

#define MAXLINE 80                                              /* maximalna dlzka riadka pred pokusom o zalomenie */
#define TABSIZE 8
#define NLYES 1                                                 /* funkcia printBuffer() ma tlacit aj '\n' */
#define NLNO 0                                                  /* funkcia printBuffer() nema tlacit aj '\n' */

int getBuffer(s, start)                                         /* funkcia ocakava pole znakov, do ktoreho od pozicie s[start] nacita znaky az do pozicie s[MAXLINE-1] */
char s[];                                                       /* deklaracia lokalnych premennych */
int start;
{
        while (start < MAXLINE) {                               /* kym sa nedostaneme az na posledny index pola s[] */
                s[start] = getchar();                           /* nacitame znak */
                if (s[start] == EOF || s[start] == '\n') {      /* sme EOF alebo '\n'? */
                        ++start;                                /* ano, tak posunieme index za posledny zapisany znak */
                        break;                                  /* a vyskocime z cyklu "while (start < MAXLINE)" */
                }
                else if (s[start] == '\t')                      /* sme tabulator? */
                        if ((start + TABSIZE) >= MAXLINE) {     /* ano, tak dostaneme sa s tabulaorovou dlzkou TABSIZE na aktualnej pozicii v riadku za MAXLINE dlzku? */
                                s[start++] = '\n';              /* ano, tak nahradime tabulator novym riadkom, posunieme index start za posledny zapisany znak */
                                break;                          /* a zabezpecime vyskocenie z cyklu "while (start < MAXLINE)" */
                        }
                ++start;                                        /* nie sme EOF ani '\n', tak posunieme index na dalsiu poziciu s[] */
        }
        return(start);                                          /* vratime index, ktory ukazuje za posledny zapisany znak do s[] */
}

void printBuffer(s, goal, nl)                                   /* funkcia vytlaci znaky od s[0] az po s[goal]. Podla hodnoty "nl" nasledne moze vytlacit znak '\n' */
char s[];                                                       /* deklaracia lokalnych premennych */
int goal, nl;
{
        int i = 0;                                              /* vzdialenost od zaciatku s[] nastavime na nulu */

        while (i <= goal)                                       /* kym sa nedostaneme az na s[goal] */
                putchar(s[i++]);                                /* vytlacime dany znak a posunieme sa vo vzdialenosti od zaciatku s[] */
        if (nl == NLYES)                                        /* ak sme dostali ako paramter NLYES, vytlacime aj '\n' */
                putchar('\n');
}

int main(void) {
        char buffer[MAXLINE];                                   /* alokujeme si pole znakov o dlzke MAXLINE */
        int loaded = 1;                                         /* zabezpecime uvodne zbehnutie cyklu "while (loaded != 0)" */
        int i = 0;                                              /* vzdialenost od zaciatku pola buffer[] */
        int j = 0;                                              /* vzdialenost od zaciatku pola buffer[] */

        while (loaded != 0) {                                   /* nekonecny cyklus, funkcne pobezykym nedetegujeme EOF */
                loaded = getBuffer(buffer, i);                  /* getBuffer() poviem nech zapise od buffer[i] po buffer[MAXLINE] znaky, vrateny loaded ukazuje "za" posledny zapisany znak do buffer[] */
                if (loaded < MAXLINE)                           /* skoncila funkcia getBuffer() skor, nez zaplnila cely buffer[MAXLINE] ? */
                        if (buffer[--loaded] != '\n')                   /* nacitali sme menej ako MAXLINE znakov a posledny znak nie je '\n'? */
                                loaded = 0;                             /* tak to potom prislo EOF, zabezpecime vyskocenie z "while (loaded != 0)" */
                        else {
                                printBuffer(buffer, loaded, NLNO);      /* dostali sme menej ako MAXLINE znakov a nasledny '\n', tak to vypiseme */
                                i = 0;                                  /* nastavime ukazovatel na zaciatok riadku */
                                loaded = 1;
                        }
                else {                                          /* dostali sme buffer naplneny az po MAXLINE */
                        i = MAXLINE;                            /* nastavime sa "za" posledny znak pola buffer[], aby sme mohli prehladavat jeho polozky odzadu */
                        while (--i >= 0)                        /* budeme odzadu prechadzat celu dlzku pola buffer[] */
                                if (buffer[i] == '\t' || buffer[i] == ' ')      /* sme biely znak? */
                                        break;                                  /* ano, tak vyskocme z "while (--i >= 0)" */
                        if (i > 0) {                            /* skoncil "while (--i >= 0)" skor, nez sme prisli na zaciatok buffer[]? */
                                printBuffer(buffer, i++, NLYES);/* ano, takze sme nasli biely znak, tak vytlacme vsetko od zaciatku az po ten biely znak, i posunme na prvy nepouzity znak z buffer[] */
                                j = 0;
                                while (i < MAXLINE)                     /* mame nacitany buffer az do MAXLINE, v buffer[i] je pozicia prveho este nepouziteho znaku */
                                        buffer[j++] = buffer[i++];      /* od buffer[0] postupne dalej kopirujeme este nepouzite znaky od buffer[i] */
                                i = j;                                  /* i ukazuje na prve pole buffer[], kde je uz buffer[] pripraveny na zapis */
                        }
                        else {                                  /* v buffer[MAXSIZE] sme biely znak nenasli */
                                printBuffer(buffer, loaded, NLNO);      /* tak vytlacime cely buffer ... */
                                while ((buffer[0] = getchar()) != EOF)  /* ... a kym nenacitame EOF alebo biely znak, budeme nacitavat a tlacit, co dostaneme */
                                        if (buffer[0] == '\t' || buffer[0] == '\n' || buffer[0] == ' ')
                                                break;
                                        else
                                                putchar(buffer[0]);
                                if (buffer[0] == '\t' || buffer[0] == '\n' || buffer[0] == ' ') {       /* vyskocili sme z "while ((buffer[0] = getchar()) != EOF)" pre biely znak? */
                                        putchar('\n');                                                  /* ano, tak vytlacime '\n' */
                                        i = 0;                                                          /* nastavime sa na zaciatok riadku */
                                }
                                else                                                                    /* nie, takze musel prist EOF */
                                        loaded = 0;                                                     /* tak zabezpecime vyskocenie z "while (loaded != 0)" */
                        }
                }
        }
        return 0;                                               /* slusne sa rozlucime */
}