// Palindrome.cpp: определяет точку входа для консольного приложения.
//

#include "stdafx.h"
#include "string.h"
#include "stdio.h"
#include "stdlib.h"
#define SPACE 1                                 /*пробел не должен участвовать в сравнении*/

enum State{ NO_CONCUR, PARTIALLY, OVERLAP, ERR};/*нет совпадений, частичное совпадение, полное, ошибка*/
struct Word{                                    /*структура содержит информацию о "нужности" слова и указатели на само слово и его альтер эго*/
    State state;
    char* word1;
    char* word2;
};

char** Load();                                  /*Функция читает файл и возвращает массив строк, заканчивающийся NULL*/
State Rev_comp(char* word1, char* word2);       /*Функция сравнивает два слова и выносит вердикт о соответствии*/
char* Compilation(int len,Word* arr);                           /*Функция создет палиндром*/
char* Search(Word word, Word* arr, int len);    /*Функция поиска подходящих слов для палиндрома*/
char* Remove_Space(char*);                      /*Функция просто удаляет из слов пробелы*/

char* Remove_Space(char* word){
    int i = 0;
    while(word[i++] != ' ');
    word[i - 1] = '\0';
    return word;
}

char* Search(Word word, Word* arr,int len){
    char buffer4straight[32] = { 0 };                       /*буфер слова, для которого ищется пара*/
    char buffer4compare[32] = { 0 };                        /*буфер слова, с которым в итоге будет сравниваться*/
    char buffer4reverse[64] = { 0 };                        /*буфер соединения и разворачивания слов, хранящихся в buffer4straight и temp_bufer*/
    char temp_bufer[32] = { 0 };                            /*буфер для хранения слова, которое будет подставляться к передаваемому*/
    char* complete_string = NULL;                           /*в конце этот указатель укажет на готовую, подобранную строку*/
    for (int i = 0; i < len; i++){
        if (arr[i].state == PARTIALLY){
            /*удаляем пробелы из слова, для которого ищется пара*/
            strcpy(buffer4straight, word.word1);
            Remove_Space(buffer4straight);
            /*удаляем пробелы из слова, с которым мы будем сравнивать*/
            strcpy(buffer4compare, word.word2);
            Remove_Space(buffer4compare);
            /*разворачиваем слово, для которого ищется пара*/
            strrev(buffer4straight);

            for (int j = 0; j < len && arr[j].word1 != NULL; j++){                  /*получили после цикла либо составленную часть палиндрома, либо ничего*/
                /*даже не рассматриваем слова, для которых есть идеальная пара*/
                if (arr[i].state == OVERLAP)
                    continue;
                /*копируем в temp_buffer тестовое слово, убирая из него пробел*/
                strcpy(temp_bufer, arr[j].word1);
                Remove_Space(temp_bufer);
                /*копируем в буфер для соединения слов тестовое слово, и для которого ищем пару*/
                strcpy(buffer4reverse, temp_bufer);
                strcat(buffer4reverse, buffer4straight);

                /*если строки совпали, то формируем нормальное словосочетание и возвращаем его из функции*/
                if (strcmp(buffer4reverse, buffer4compare) == 0){
                    complete_string = (char*)calloc(strlen(buffer4reverse + SPACE), sizeof(char));
                    strcpy(complete_string, arr[j].word1);
                    strcat(complete_string,word.word1);
                    return complete_string;
                }

            }
        }
    }

    return complete_string;
}


char* Compilation(int len, Word* arr){
    char** palindrome = (char**)calloc(len + 1,sizeof(char*)); /*+1 для обозначения конца списка*/
    char buffer[256] = { 0 };                       /*занулит весь буфер*/
    int i, j, save_i;                               /*будем знать, на какой позиции закончились чистые палиндромы*/
    for (i = 0, j = 0; i < len; i++, j--){
        /*располагаем идеальные слова с концов палиндрома*/
        if (arr[i].state == OVERLAP){
            palindrome[i] = arr[i].word1;
            palindrome[j] = arr[i].word2;
            save_i = i;
        }
    }
    /*я чувствую, что какая-то хрень с этим save_i, но уже не соображаю)))*/
    /*по идее тут в каждую следующую ячейку палиндрома записывается найденное, сформированное словосочетание*/
    for (i = save_i; i < len; i++){
            if (arr[i].state == PARTIALLY){
                palindrome[i] = Search(arr[i],arr,len);
            }
        }
    /*ну это просто с запасом, короче писать, чем маллок*/
    static char output[1024];
    output[0] = ' ';
    for (i = 0; i < len; i++)
        /*конкатинируем все непустые ячейки*/
        if (palindrome[i] != NULL)
            strcat(output,palindrome[i]);
        /*возвращаем результат*/
    return output;
}

State Rev_comp(char* word1, char* word2){
    if (word1 == NULL || word2 == NULL)
        return ERR;
    int size1 = strlen(word1), \
        size2 = strlen(word2);
    char* matching_place = NULL;
    /*так как пробел всегда в конце слова, то его место заменит \0*/
    /*приходится вычитать SPACE, strlen считает не от 0, а от 1*/
    char* word1_wio_space = (char*)malloc((size1)*sizeof(char));
    char* word2_wio_space = (char*)malloc((size2)*sizeof(char));

    strcpy(word1_wio_space, word1);
    word1_wio_space[size1 - SPACE] = '\0';

    strcpy(word2_wio_space, word2);
    word2_wio_space[size2 - SPACE] = '\0';

    /*ищем в большей строке перевернутую меньшую*/
    /*strstr ищет подстроку, strrev - переворачивает строку. STRREV не стандартная функция!*/
    if (size1 < size2){
        strrev(word1_wio_space);
        matching_place = strstr(word2_wio_space, word1_wio_space);
    }
    else{
        strrev(word2_wio_space);
        matching_place = strstr(word1_wio_space, word2_wio_space);
    }

    if (matching_place == NULL)
        return NO_CONCUR;
    /*если размер строк совпадает и указатель на одну из строк совпадает с поисковым, то слова являются полными палиндромами*/
    else if (matching_place == word1_wio_space || matching_place == word2_wio_space && size1 - size2 == 0)
        return OVERLAP;
    /*иначе совпадают частично*/
    else return PARTIALLY;

}

char** Load(){
    /*Функция читает файл и возвращает массив строк, заканчивающийся NULL*/
    FILE* file = fopen("1.txt", "r");

    if (file == NULL){
        printf("\nError occured while reading\n");
        return NULL;
    }


    fseek(file, 0, SEEK_END);
    int FileSize = ftell(file);    //узнаем размер файла
    fseek(file, 0, SEEK_SET);

    char* txt = (char*)malloc(sizeof(char)*FileSize + 1);
    FileSize = fread(txt, sizeof(char), FileSize, file);    //Присваиваем FileSize количество реально прочитанных байт
    txt[FileSize] = '\0';

    void* search_ptr = txt;
    char** strings = (char**)calloc(1000, sizeof(char*));          //выделим побольше памяти, потом ее урежем realloc'ом
    int cnt = 0;
    do{                                    //считаем количество формул
        int length = 0;
        if (memchr(search_ptr, '\n', FileSize*sizeof(char)) != NULL)    //длина формулы
            length = (intptr_t)memchr(search_ptr, '\n', FileSize*sizeof(char)) - (intptr_t)search_ptr + 1;
        else
            length = strlen((char*)search_ptr) + 1;

        strings[cnt] = (char*)calloc(length, sizeof(char));
        memcpy(strings[cnt], search_ptr, length - 1);            //копируем -1 символ, чтобы сохранить \0 в конце строки
        cnt++;
        //+ (intptr_t)sizeof(char) отвечает за пропуск \n, а != (void*)1 за обрыв цикла, когда memchr выдал NULL (\n не найден)
    } while ((search_ptr = (void*)((intptr_t)memchr(search_ptr, '\n', FileSize*sizeof(char)) + (intptr_t)sizeof(char))) != (void*)1);

    strings = (char**)realloc(strings, (cnt + 1)*sizeof(char*));
    fclose(file);
    return strings;
}

void main()
{
    int len;
    int real_len = 0;
    char** strings = Load();
    for (len = 0; strings[len] != NULL; len++);             /*считаем количество слов из файла*/
    Word* check_arr = (Word*)calloc(len*len, sizeof(Word));     /*массив, из которого выкинем ненужные слова*/

    State state;
    for (int i = 0,k = 0; i < len; i++){
        for (int j = 0; j < len; j++){
            if (strings[i] == strings[j])       /*одно и то же слово*/
                continue;
            state = Rev_comp(strings[i], strings[j]);
            if (state == OVERLAP || state == PARTIALLY){
                /*если слова удовлетворяют требованиям, то заносим их в check_arr
                  и больше не проверяем*/

                check_arr[k].state = state;
                check_arr[k].word1 = strings[i];

                check_arr[k].state = state;
                check_arr[k].word2 = strings[j];
                k++;
            }
        }
    }
    while (check_arr[real_len++].word1 != NULL);
    char* out = Compilation(len, check_arr);
    while (1);
}