#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;             // Выделять блоками по килобайту

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

void readTextAndCount(char *string, char *delimiters, 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("Введите символы-разделители: ");

    // начало считывания символов-разделителей
    readString(delimitersArray, &delimitersArray_size);
    // конец считывания символов-разделителей

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

    // начало считывания символов-разделителей
    readTextAndCount(inputText, delimitersArray, &inputText_size);
    // конец считывания символов-разделителей

//    printf("\"%s\"", inputText);
//    printf("\nstrlen: %lu\n", strlen(inputText));
//    printf("firstElem: \"%c\", lastElem: \"%c\"\n", inputText[0], inputText[strlen(inputText) - 1]);

    int isFirstElemDelimiter = 0, isLastSymbolDelimiter = 0;
    for (int i = 0; i < strlen(delimitersArray); i++) {
        if (inputText[0] == delimitersArray[i]) {
            isFirstElemDelimiter = 1;
        }
        if (inputText[strlen(inputText) - 2] == delimitersArray[i]) {
            isLastSymbolDelimiter = 1;
        }
    }

    if ((isFirstElemDelimiter == 1) && (isLastSymbolDelimiter == 1)) {
        printf("Исходный текст: \n\"%s\"\n", inputText);
        int firstWordStartIndex = 0, firstWordEndIndex = 0, secondWordStartIndex = 0, secondWordEndIndex = 0;
        for (int i = 1; i < strlen(inputText); i++) {
            int isDelimiter = 0;
            for (int j = 0; j < strlen(delimitersArray); j++) {
                if (inputText[i] == delimitersArray[j]) {
                    isDelimiter = 1;
                }
            }
            if (isDelimiter != 1) {
                if (firstWordStartIndex == 0) {
                    // если еще не нашли индекс начала первого слова
                    firstWordStartIndex = i;
                } else if (firstWordEndIndex != 0 && secondWordStartIndex == 0) {
                    // если нашли индекс конца превого слова, а индекс начала второго слова еще не нашли
                    secondWordStartIndex = i;
                }
            } else {
                if (firstWordStartIndex != 0 && firstWordEndIndex == 0) {
                    // если нашли индекс начала первого слова, а индекс конца первого слова еще не нашли
                    firstWordEndIndex = i - 1;
                } else if (secondWordStartIndex != 0 && secondWordEndIndex == 0) {
                    // если нашли индекс начала второго слова, а индекс конца еще не нашли
                    secondWordEndIndex = i - 1;
                }
            }

            if (firstWordStartIndex != 0 &&
                firstWordEndIndex != 0 &&
                secondWordStartIndex != 0 &&
                secondWordEndIndex != 0) {
                // если получили индексы начала/конца первого и второго слова - завершаем поиск
                break;
            }

        }

        char newText[strlen(inputText)];
        int counter = 0;

        for (int i = 0; i < firstWordStartIndex; i++) {
            // копируем все разделители до первого слова
            newText[counter] = inputText[i];
            counter++;
        }

        for (int i = secondWordStartIndex; i <= secondWordEndIndex; i++) {
            // копируем второе слово
            newText[counter] = inputText[i];
            counter++;
        }

        for (int i = firstWordEndIndex + 1; i < secondWordStartIndex; i++) {
            // копируем разделители между первым и вторым словом
            newText[counter] = inputText[i];
            counter++;
        }

        for (int i = firstWordStartIndex; i <= firstWordEndIndex; i++) {
            // копируем первое слово
            newText[counter] = inputText[i];
            counter++;
        }

        for (int i = secondWordEndIndex + 1; i < strlen(inputText); i++) {
            // копируем со следующего элемента после конца второго слова до конца исходной строки.
            newText[counter] = inputText[i];
            counter++;
        }

        printf("Отформатированный текст:\n\"%s\"\n", newText);
    } else {
        printf("Первый и последний символ не разделители.\n");
    }

    free(delimitersArray);
    free(inputText);

    return 0;
}

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

    int c = EOF;

    for (int i = 0; (c = getchar()) && (c != '\n'); i++) {
        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);
        }
        string[i] = c;
    }
}

void readTextAndCount(char *string, char *delimiters, size_t *string_size) {
    // функция считывает текст, а также считает длину слов, а также количетсво разделителей
    int c = EOF, countOfDelimiters = 0, countOfSymbols = 0;

    for (int i = 0; (c=getchar()); i++) {
        if ((countOfDelimiters > countOfSymbols) && c == '\n') {
            string[i] = '\0';
            break;
        } 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);
            }
            string[i] = (char) c;

            int isDelimiter = 0;
            for (int j = 0; j < strlen(delimiters); j++) {
                if (c == delimiters[j]) {
                    isDelimiter = 1;
                    break;
                }
            }

            if (isDelimiter == 1) {
                countOfDelimiters++;
            } else {
                countOfSymbols++;
            }
        }
    }
}

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