#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MALLOC_ERROR 4

const unsigned int MAX_LENGTH = 1 * 1024 * 1024;  // Не выделять больше мегабайта памяти
const unsigned int CHUNK_SIZE = 1024;             // Выделять блоками по килобайту

char** specialReadText(
        size_t *string_size,
        int numberOfStrings
);

void readString(char *string, size_t *string_size);

void memory_error();

int main() {
    //  Ввести массив строк текста с заданным количеством строк и массив символов разделителей с
    //  заранее неизвестным количеством.
    //  Признаком окончания ввода элементов массива с символами разделителями
    //  является повторный ввод любого из ранее введенных симоволов разделителей.
    //  Из строк введенного текста удалить слова, имеющие длину меньше заданной пользователем величины,
    //  с одновременным удалением и символов разделителей, стоящих перед этими словами.
    //  Удалить строки, не содержащие слов.
    //  Вывести преобразованный текст.

    size_t delimitersArray_size = CHUNK_SIZE;
    char *delimitersArray = malloc(delimitersArray_size);
    if (delimitersArray == NULL) {
        memory_error();
    }
    printf("Введите символы-разделители:\n");
    readString(delimitersArray, &delimitersArray_size);

    int numberOfStrings = 0;
    printf("Введите количество строк: ");
    scanf("%d", &numberOfStrings);

    int wordMinLength = 0;
    printf("Введите минимальную длину для слов (слова, с длиной меньше заданной, будут удалены): ");
    scanf("%d", &wordMinLength);

    size_t inputText_size = CHUNK_SIZE;
    char **inputText = (char**) malloc(inputText_size);
    if (inputText == NULL) {
        memory_error();
    }
    printf("Введите текст:\n");

    getchar();                  // перехват ложной новой строки

    inputText = specialReadText(&inputText_size, numberOfStrings);

    size_t newText_size = inputText_size;
    char **newText = (char**) malloc(newText_size);
    if (newText == NULL) {
        memory_error();
    }
    int counter = 0, rowCounter = 0;
    int symbolsInWord = 0;

    for (int i = 0; i < numberOfStrings; i++) {
        if (strlen(inputText[i]) > 0) {
            newText[rowCounter] = malloc(newText_size);
            counter = 0, symbolsInWord = 0;
            for (int j = 0; j < strlen(inputText[i]); j++) {
                int isDelimiter = 0;
                for (int k = 0; k < strlen(delimitersArray); k++) {
                    if (inputText[i][j] == delimitersArray[k] || j == (strlen(inputText[i]) - 1)) {
                        isDelimiter = 1;
                        break;
                    }
                }
                if (isDelimiter == 0) {
                    symbolsInWord++;
                } else {
                    if ((symbolsInWord / 2) >= wordMinLength ||
                        ((j == strlen(inputText[i]) - 1) && ((symbolsInWord / 2)) + 1) >= wordMinLength) {
                        for (int k = j - symbolsInWord; k <= j; k++) {
                            newText[rowCounter][counter] = inputText[i][k];
                            counter++;
                        }
                    } else if (symbolsInWord == 0) {
                        newText[rowCounter][counter] = inputText[i][j];
                        counter++;
                    }
                    symbolsInWord = 0;
                }
            }
            rowCounter++;
            newText = realloc(newText, (rowCounter) * newText_size);
        }
    }

    printf("\nИсходный текст:\n");
    for (int i = 0; i < numberOfStrings; i++) {
        printf("\"%s\"\n", inputText[i]);
    }

    printf("\nОтформатированный текст:\n");
    for (int i = 0; i < rowCounter; i++) {
        printf("\"%s\"\n", newText[i]);
    }

    free(delimitersArray);
    for (int i = 0; i < numberOfStrings; i++) {
        free(inputText[i]);
    }
    free(inputText);
    for (int i = 0; i < counter; i++) {
        free(newText[i]);
    }
    free(newText);

    return 0;
}

char** specialReadText(
        size_t *string_size,
        int numberOfStrings
        ) {
    // функция считывает текст

    *string_size = CHUNK_SIZE;
    char **text = (char**) malloc(CHUNK_SIZE);
    for (int i = 0; i < numberOfStrings; i++) {
        int c = EOF;

        text[i] = (char*) malloc(*string_size);

        if (text == NULL || text[i] == NULL) {
            memory_error();
        }

        for (int j = 0; (c = getchar()); j++) {
            if (c == '\n') {
                text[i][j] = '\0';
                text = realloc(text, ((i + 1) * (*string_size)));

                if (text == NULL) {
                    memory_error();
                }
                break;
            } else {
                if (j == (*string_size - 1)) {
                    *string_size += j;
                    text = realloc(text, (i * (*string_size)));
                    if (text == NULL) {
                        memory_error();
                    }
                }

                if (j == MAX_LENGTH) {
                    free(text);
                    memory_error();
                }

                text[i][j] = c;
            }
        }
    }
    return text;
}

void readString(char *string, size_t *string_size) {
    // функция, считывающая текст из консоли

    int c = EOF;

    for (int i = 0; (c = getchar()); i++) {
        if (c == '\n') {
            i--;
        } else {
            if (i == (*string_size - 1)) {
                // проверяем, есть ли еще свободная память, если нет, то выделяем
                *string_size += i;
                string = realloc(string, *string_size);
                if (string == NULL) {
                    memory_error();
                }
            }

            if (*string_size == MAX_LENGTH) {
                // проверяем, достиг ли размер массива максимального значения. Если да, то освобождаем память.
                free(string);
                memory_error();
            }

            int isExit = 0;
            for (int j = 0; j < i; j++) {
                if (c == string[j]) {
                    isExit = 1;
                    break;
                }
            }
            if (isExit == 1) {
                break;
            }
            string[i] = c;
        }
    }
}

void memory_error() {
    // необхоидмо вызывать, если не удалось динамически выделить память
    printf("Произошла ошибка. Запросили слишком много памяти??\n");
    exit(MALLOC_ERROR);
}