#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#include <progbase.h>
#include <progbase/console.h>

struct Sentence {
    int startIndex;
    char sentenceBuffer[128];
};

struct SentenceArray {
    struct Sentence *sentences;
    int sizeofarray;
};

//tasks
int task_1_1(char txt[]);
int task_1_2(char txt[], char buffer[], int sizeofbuffer);
int task_2_1(struct Sentence sentence, struct Sentence sentence2);
int task_2_2(struct SentenceArray sentenceArr, struct SentenceArray sentenceArr2);
struct Sentence task_2_3(char txt[]);
struct SentenceArray *getAllSentencesArrayNew(char * txt);
void arrayFree(struct SentenceArray *array);
int task4(char text[]);

void TestTask(int number);

//
int ispunctend(char symb);
int iscons(char symb);

//helpers
int FindSentence(char txt[], int sentenceToFind, int arraytofill[]);
int GetSentence(int sentencetofind, char txt[], char buffer[], int sizeofbuffer);
struct Sentence CreateSentenceStruct(char txt[], int numsentence);

//
int fileExists(const char *fileName);
long getFileSize(const char *fileName);
int readFileToBuffer(const char *fileName, char *buffer, int bufferLength);

int main(int argc, char * argv[]) {
    if(argc <= 1) return 1;
    else if(argc == 2){
        if(strcmp("task1", argv[1]) == 0) TestTask(1);
        else if(strcmp("task2", argv[1]) == 0) TestTask(2);
        else if(strcmp("task3", argv[1]) == 0) TestTask(3);
        else return 1;
    }
    else if(argc == 3){
        if(strcmp("task4", argv[1]) == 0) {
            if(fileExists(argv[2])){
                long size = getFileSize(argv[2]);
                char buffer[size];
                readFileToBuffer(argv[2], buffer, size);
                return task4(buffer);
            }
            else return 1;
        }
        else return 1;
    }
    else return 1;

    return 0;
}

void TestTask(int number) {
    char txt[] = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum volutpat elit vitae mollis pellentesque. Phasellus dignissim interdum consequat. Proin cursus feugiat augue, vitae laoreet quam interdum in. Duis vehicula urna ac dui rhoncus, ac blandit sem finibus. Maecenas id justo aliquet, tristique risus et, dictum enim. Etiam tempus malesuada augue eget dapibus. Maecenas neque quam, lacinia eget placerat et, malesuada ac leo.";

    switch(number){
        case 1:
            assert(task_1_1(txt) == 57);

            char buffer[128];
            task_1_2(txt, buffer, 128);
            char expecting[] = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
            assert(strcmp(buffer, expecting) == 0);
            break;
        case 2:{
            struct Sentence sent1 = {148, "Proin cursus feugiat augue, vitae laoreet quam interdum in."};
            struct Sentence sent2 = {148, "Proin cursus feugiat augue, vitae laoreet quam interdum in."};
            struct Sentence sent3 = {26, "Proin cursus feugiat augue, vitae laoreet quam interdum in."};
            struct Sentence sent4 = {327, "Etiam tempus malesuada augue eget dapibus."};
            assert(task_2_1(sent1, sent2) == 1);
            assert(task_2_1(sent1, sent3) == 0);
            assert(task_2_1(sent1, sent4) == 0);

            //22
            /*struct SentenceArray sentArr1 = {
                struct Sentence sentences[8] = {
                    {0, ""},{0, ""},{0, ""},{0, ""}
                },
                8
            };*/

            struct Sentence firstSentence = task_2_3(txt);

            char expecting[] = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
            assert(firstSentence.startIndex == 0);
            assert(strcmp(firstSentence.sentenceBuffer, expecting) == 0);
            break;
        }
        case 3:{
            struct SentenceArray *result = getAllSentencesArrayNew(txt);

            assert(result->sentences[5].startIndex == 267);
            assert(result->sizeofarray == 8);
            assert(result->sentences[8].startIndex == 0);

            arrayFree(result);
            break;
        }
    }
}

int task_1_2(char txt[], char buffer[], int sizeofbuffer) {
    return GetSentence(1, txt, buffer, sizeofbuffer);
}

int task_2_1(struct Sentence sentence, struct Sentence sentence2) {
    if(sentence.startIndex != sentence2.startIndex) return 0;
    else if(strcmp(sentence.sentenceBuffer,sentence2.sentenceBuffer) != 0) return 0;
    return 1;
}

int task_2_2(struct SentenceArray sentenceArr, struct SentenceArray sentenceArr2) {
    if(sentenceArr.sizeofarray != sentenceArr2.sizeofarray) return 0;
    else {
        for(int i = 0; i > sentenceArr.sizeofarray; i++){
            if(sentenceArr.sentences[i].startIndex != sentenceArr2.sentences[i].startIndex) return 0;
            else if(strcmp(sentenceArr.sentences[i].sentenceBuffer, sentenceArr2.sentences[i].sentenceBuffer) != 0) return 0;
        }
    }
    return 1;
}

struct Sentence task_2_3(char txt[]){
    return CreateSentenceStruct(txt, 1);
}

struct SentenceArray *getAllSentencesArrayNew(char *txt) {
    struct SentenceArray *sentencearray = malloc(sizeof(struct SentenceArray)); // init
    sentencearray->sentences = malloc(sizeof(struct Sentence) * 1); // init

    int i = 1,
        indexes[] = {0,0},
        state = FindSentence(txt, i, indexes);

    while(state){
        sentencearray->sentences = realloc(sentencearray->sentences, sizeof(struct Sentence) * i); // reallocate for new sentence

        struct Sentence currentSentence = CreateSentenceStruct(txt, i);
        sentencearray->sentences[i - 1] = currentSentence;

        i++;
        state = FindSentence(txt, i, indexes);
    }

    sentencearray->sizeofarray = i - 1;

    return sentencearray;
}

void arrayFree(struct SentenceArray *array) {
    free(array->sentences);
    free(array);
}

int task4(char text[]) {
    Console_clear();

    printf("_______________________Завдання_______________________\n");
    printf("Шкала розфарбовування речень: менше 10 символів - червоний, від 10 до 25 - жовтий, більше 25 - зелений\n\
Окремо вивести список тих речень, у яких більше 10 символів, а перше слово починається на приголосну літеру.\n");
    printf("______________________________________________________\n");

    char buffer[128];
    int i = 1,
        len = 0,
        state = GetSentence(i, text, buffer, 128);

    int * specSentences = malloc(sizeof(int));
    if(NULL == specSentences) {
        printf("Can't allocate memory");
        return 1;
    }
    int used = 0;

    while(state){
        Console_setCursorAttribute(FG_DEFAULT);
        len = strlen(buffer);

        if(len < 10) Console_setCursorAttribute(FG_RED);
        else if(len < 25) Console_setCursorAttribute(FG_YELLOW);
        else Console_setCursorAttribute(FG_GREEN);

        if(len > 10){
            //BCDFGHJKLMNPQRSTVWXZ
            if(iscons(buffer[0])){
                specSentences = realloc(specSentences, sizeof(int) * (used + 1));
                if(NULL == specSentences) {
                    printf("Can't reallocate memory");
                    return 1;
                }
                specSentences[used] = i;
                used++;
            }
        }

        printf("%s", buffer);

        i++;
        state = GetSentence(i, text, buffer, 128);
    }
    Console_setCursorAttribute(FG_DEFAULT);

    if(used) {
        printf("\n\nРечення у яких більше 10 символів, а перше слово починається на приголосну літеру:\n");
        for(int i = 0; i < used; i++){
            GetSentence(specSentences[i], text, buffer, 128);
            printf("[%d] - %s", specSentences[i], buffer);
        }
    }
    printf("\n");

    free(specSentences);
    return 0;
}

int ispunctend(char symb){
    if(symb == '.' || symb == '!' || symb == '?') return 1;
    return 0;
}
int iscons(char symb){
    char cons[] = "BCDFGHJKLMNPQRSTVWXZ";
    for(int i = 0; i < strlen(cons); i++){
        if(symb == cons[i]) return 1;
    }
    return 0;
}

int FindSentence(char txt[], int sentenceToFind, int arraytofill[]){
    int sentencesPassed = 0,
        foundComplete = 0,
        j,
        indexHistory = 0;

    for(int i = 0; i < strlen(txt) && !foundComplete; i++){
        if(ispunctend(txt[i])) {
            for(j = i + 1; j < strlen(txt); j++){
                if(!ispunctend(txt[j])) {
                    j--;
                    break;
                }
            }
            sentencesPassed++;
            foundComplete = (sentencesPassed == sentenceToFind) ? 1 : 0;

            if(!foundComplete) indexHistory = j;

            i = j;
        }
    }

    if(foundComplete) {
        arraytofill[0] = (indexHistory != 0) ? (indexHistory + 1) : indexHistory;
        arraytofill[1] = j;
    }

    return foundComplete;
}

int GetSentence(int sentencetofind, char txt[], char buffer[], int sizeofbuffer) {
    int indexes[] = {0, 0};
    int state = FindSentence(txt, sentencetofind, indexes);

    if(state) {
        for(int i = indexes[0], j = i - indexes[0]; i <= indexes[1] && j <= sizeofbuffer; i++, j = i - indexes[0]){
            buffer[j] = txt[i];
            if(j == sizeofbuffer) buffer[j] = '\0';
            else if(i == indexes[1]) buffer[j + 1] = '\0';
        }
    }

    return state;
}

struct Sentence CreateSentenceStruct(char txt[], int numsentence){
    int indexes[] = {0, 0};
    int state = FindSentence(txt, numsentence, indexes);

    struct Sentence sentence = {-1, ""};

    if(state) {
        char buffer[128];
        GetSentence(numsentence, txt, buffer, 70);

        strcpy(sentence.sentenceBuffer, buffer);
        sentence.startIndex = indexes[0];
    }

    return sentence;
}

int task_1_1(char txt[]){
    int indexes[] = {0, 0};
    int state = FindSentence(txt, 2, indexes);

    if(state){
        if(txt[indexes[0]] == ' ') return indexes[0] + 1;
        return indexes[0];
    }
    return -1;
}

int fileExists(const char *fileName) {
    FILE *f = fopen(fileName, "rb");
    if (!f) return 0;  // false: not exists
    fclose(f);
    return 1;  // true: exists
}

long getFileSize(const char *fileName) {
    FILE *f = fopen(fileName, "rb");
    if (!f) return -1;  // error opening file
    fseek(f, 0, SEEK_END);  // rewind cursor to the end of file
    long fsize = ftell(f);  // get file size in bytes
    fclose(f);
    return fsize;
}

int readFileToBuffer(const char *fileName, char *buffer, int bufferLength) {
    FILE *f = fopen(fileName, "rb");
    if (!f) return 0;  // read 0 bytes from file
    long readBytes = fread(buffer, 1, bufferLength, f);
    fclose(f);
    return readBytes;  // number of bytes read
}