#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <wchar.h>
#include <wctype.h>

# define STEP 5
# define N 3
# define D 5
struct Sentence {
    wchar_t *str;
    int count;
    int size;
    int last;
    int words;
    int max_length;
    wchar_t *words1;
    wchar_t *max_length1;
    struct sent *words_arr;

};

struct Text {
    struct Sentence **sents;
    int size;
    int n;
};

struct sent {
    wchar_t **words;
    int size;
};

//очистка памяти
void clean(struct Text *text) {
    for (int i = 0; i < text->n; i++) {
        free((text->sents)[i]->str);
        free((text->sents)[i]->words1);
        free((text->sents)[i]->max_length1);
        free((text->sents)[i]->words_arr);
    }
    free(text->sents);
}


struct Sentence *get_sent();

// проверка на конец предложения
int sent_end(wchar_t sym) {
    if (sym == L'.' || sym == L'\n')
        return 0;
    return 1;
}

int count_words(wchar_t *sent) {
    int words = 1;
    for (int i = 0; i < wcslen(sent); i++) {
        if ((sent[i] == L' ' || sent[i] == L',') && sent[i + 1] != L' ' && sent[i + 1] != L',')
            words++;
    }
    return words;
}

int max_length(wchar_t *sent) {
    int max_ln = 0;
    int ln = 0;
    for (int i = 0; i < wcslen(sent); i++) {
        if (sent[i] != ' ') {
            ln++;
            if (ln > max_ln)
                max_ln = ln;
        } else {
            ln = 0;
        }
    }
    return max_ln;
}

//888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888
// встечалось ли предложение ранее
int is_repeated(struct Sentence **temp, struct Sentence *sentence, int i) {
    for (int j = 0; j < i; j++) {
        if (wcscasecmp(temp[j]->str, sentence->str) == 0)
            return 1;
    }
    return 0;
}


wchar_t *fix(int kl) {
    wchar_t *words1 = malloc((N + 1) * sizeof(wchar_t));
    words1[0] = kl / 10 + '0';
    words1[1] = kl % 10 + '0';
    words1[2] = '\0';
    return words1;
}

struct sent *arr_words(wchar_t *sent);

// считывание предложения
struct Sentence *get_sent() {
    int i = 0;
    int size = STEP * sizeof(wchar_t);
    wchar_t *sent = malloc(size);
    wchar_t *words1 = malloc(size);
    wchar_t *max_length1 = malloc(size);
    wchar_t sym;
    int flag_end = 0;
    int flag_beg = 0; // табуляция в начале предложения(буквы ещё не
    // встретились)
    do {
        sym = getwchar();

        if (flag_beg == 0 && sym != L' ') {
            flag_beg = 1;
        }
        if (flag_beg == 1 && sym != L'.' && sym != L'\n') {
            sent[i] = sym;
            i++;
            size += STEP * sizeof(wchar_t);
            sent = realloc(sent, size);
        }
        if (sym == L'\n')
            flag_end = 1;
    } while (sent_end(sym));
    sent[i] = L'\0';
    int j;
    // удаляем лишние пробелы в конце
    for (j = i - 1; j >= 0; j--) {
        if (sent[j] == L' ') {
            sent[j] = L'\0';
            size -= STEP * sizeof(wchar_t);
            sent = realloc(sent, size);
        } else
            break;
    }
    struct Sentence *sentence = malloc(sizeof(struct Sentence));
    sentence->str = sent;
    sentence->size = size;
    sentence->count = j + 1;
    sentence->last = flag_end;
    sentence->words = count_words(sent);
    sentence->max_length = max_length(sent);
    sentence->words_arr = arr_words(sent);
    sentence->words1 = fix(sentence->words);
    sentence->max_length1 = fix(sentence->max_length);
    return sentence;
}

// запись в память текста
void get_text(struct Text *text) {
    int size = STEP * sizeof(struct Sentence *);
    struct Sentence **temp = malloc(size);
    struct Sentence *sentence;
    int i = 0;
    do {
        sentence = get_sent();
        if (is_repeated(temp, sentence, i) == 0) {
            temp[i] = sentence;
            i++;
            size += STEP * sizeof(struct Sentence *);
            temp = realloc(temp, size);
        }
    } while (sentence->last == 0);
    text->sents = temp;
    text->n = i;
    text->size = size;
}

void hello() {
    wchar_t *one = L"1 - Для каждого предложения вывести строку-дату вида “ДД-ММ-ГГГГ”.";
    wchar_t *two = L"2 - Вывести предложения так, чтобы слова шли в обратном порядке.";
    wchar_t *three = L"3 - Отсортировать предложения по длине первого слова в предложении.";
    wchar_t *four = L"4 - Удалить все предложения у которых все слова имеют длину не больше 3 "
                    "символов.";
    wchar_t *five = L"5 - Выйти из программы";
    wprintf(L"\n%ls\n%ls\n%ls\n%ls\n%ls\n", one, two, three, four, five);
}

// ДД-ММ-ГГГГ
void date(struct Text *text) {
    int i = 0;
    struct Sentence **now = text->sents;
    while (now[i]->last == 0) {
        wprintf(L"%ls %ls-%ls-%d\n", now[i]->str, now[i]->words1,
                now[i]->max_length1, 1900 + now[i]->count);
        i++;
    }
    if (wcslen(now[i]->str) > 1) {
        wprintf(L"%ls %ls-%ls-%d\n", now[i]->str, now[i]->words1,
                now[i]->max_length1, 1900 + now[i]->count);
    }
}


void reverse_sent(wchar_t *s, wchar_t *divider) {
    wchar_t *word;
    wchar_t *p;
    s = wcstok(s, divider, &p);
    if (s) {
        word = wcsdup(s);
        reverse_sent(L'\0', divider);
        wprintf(L"%s ", word); //выводить слова будем при выходе из рекурсии
        free(word); //освобождаем память
    }
}

struct sent *arr_words(wchar_t *sent) {
    int size = STEP;
    wchar_t **words = calloc(STEP, sizeof(wchar_t *));
    struct sent *arr_of_sent = malloc(sizeof(struct sent));
    int i = 0;
    wchar_t *str1 = calloc(wcslen(sent), sizeof(wchar_t *));
    wcscpy(str1, sent);
    wchar_t *buffer;
    wchar_t *token = wcstok(str1, L" ,", &buffer);

    while (token) {
        words[i] = token;
        token = wcstok(NULL, L" ,", &buffer);
        i++;
        if (i == size - 1) {
            size += STEP;
            words = realloc(words, size * sizeof(wchar_t *));
        }
    }

    if (words[1] == NULL) {
        words[1] = (wchar_t *) "\0";
    }

    if (words[2] == NULL) {
        words[2] = (wchar_t *) "\0";
    }
    arr_of_sent->words = words;
    arr_of_sent->size = i;

    return arr_of_sent;
}

void reverse(struct Text *text) {
    int i;
    for (i = 0; i < text->n; i++) {
        for (int j = text->sents[i]->words_arr->size - 1; j >= 0; j--) {
            wprintf(L"%ls ", text->sents[i]->words_arr->words[j]);
        }
        if (i != text->n - 1)
            wprintf(L"\n");
    }
}

int first_len(wchar_t *sent) {
    int kl = 0;
    for (int i = 0; i < wcslen(sent); i++) {
        if (sent[i] != L' ' && sent[i] != L',')
            kl++;
        else break;
    }
    return kl;
}

wchar_t **bubble_sort(wchar_t **data0, int size) {
    int i, j;
    for (i = 0; i < size; ++i) {
        for (j = size - 1; j > i; --j) {
            if (first_len(data0[j]) < first_len(data0[j - 1])) {
                wchar_t *t = data0[j - 1];
                data0[j - 1] = data0[j];
                data0[j] = t;
            }
        }
    }
    return data0;
}

int is_short(wchar_t *sentence) {
    int kl = 0;
    for (int i = 0; i < wcslen(sentence); i++) {
        if (sentence[i] != ' ' && sentence[i] != ',') {
            kl++;
            if (kl > 3)
                return 1;
        } else
            kl = 0;
    }
    return 0;
}

// получит динамический массив из всех предложений
wchar_t **sent_arr(struct Text *text) {
    wchar_t **arr1 = malloc(text->n * sizeof(wchar_t *));
    for (int i = 0; i < text->n; i++) {
        arr1[i] = text->sents[i]->str;
    }
    return arr1;
}

void del(struct Text *text) {
    wchar_t **arr;
    arr = sent_arr(text);
    for (int i = 0; i < text->n; i++) {
        if (is_short(arr[i]))
            wprintf(L"%ls\n", arr[i]);
    }
}


void sort_list(struct Text *text) {
    wchar_t **arr;
    arr = sent_arr(text);
    for (int i = 0; i < text->n; i++) {
        arr[i] = text->sents[i]->str;
    }
    arr = bubble_sort(arr, text->n);
    for (int i = 1; i < text->n; i++) {
        wprintf(L"%ls\n", arr[i]);
    }
}

int main() {
    setlocale(LC_ALL, "");
    wchar_t answer[D];
    struct Text text;
    get_text(&text);
    hello();
    int kl = 0;
    do {
        wprintf(L"Выберите одно действие: ");
        fgetws(answer, 3, stdin);
        switch (answer[0]) {
            case L'1':
                date(&text);
                break;
            case L'2':
                reverse(&text);
                break;
            case L'3':
                sort_list(&text);
                break;
            case L'4':
                del(&text);
                break;
            case L'5':
                wprintf(L"Выход из программы\n");
                break;
            default:
                wprintf(L"Ошибка ввода!\n");
                break;
        };
    } while (answer[0] != '5');
    clean(&text);
    return 0;
}