#include <iostream>
#include "Formular.h"
#include "EL1.h"
#include "Line_with_marker.h"
#include "FormularProcessing.h"
#include "CommonProcess.h"
using namespace std;

int main() {
    int lineCountFromInput = 0, FirstNodeNumber = 0, ShouldBeDeletedNode = 0;
    Formular form;
    InitialiseFormular(form);
    if(CheckFile()) {
        return 666;
    }
    lineCountFromInput = LineCount();
    getting_info_from_file(form, lineCountFromInput);
    cout << "Введите номер элемента, с которого вы хотите начать удаление,"
            " и количество элементво, которое вы хотите удалить" << endl;
    cin >> FirstNodeNumber >> ShouldBeDeletedNode;
    DeleteNode(form, FirstNodeNumber, ShouldBeDeletedNode);

    PrintFormular(form);

    DeleteList(form);
    return 0;
}

#include <iostream>
#include <fstream>
#include "CommonProcess.h"
#include "FormularProcessing.h"
#include "EL1Processing.h"
#include "Formular.h"
using namespace std;

void DeleteList(Formular &form) {
    GoBegin(form);
    while(form.Head != nullptr) {
        form.Current = form.Head->next;
        delete[] form.Head->Inf.symbols;
        delete form.Head;
        form.Head = form.Current;
    }
    delete form.Head;
    delete form.Current;
    delete form.Previous;
    form.Last = nullptr;
}

void DeleteEnd(Formular &form) {
    // Работает корректно
    GoBegin(form);
    GoEnd(form);

    delete[] GetCurrent(form)->Inf.symbols;
    delete GetCurrent(form);
    GoBegin(form);
    GoEnd(form);
    SetLast(form, GetPrevious(form));
    GetPrevious(form)->next = nullptr;
}

int DeleteNode(Formular &form, int FirstNodeNumber, int ShouldBeDeletedNode) {
    // Работате корректно
    GoBegin(form);
    SetCurrent(form, form.Head);
    for(int i = 1; i < FirstNodeNumber; i++) {
        GoNext(form);
    }
    if(FirstNodeNumber == LineCount()) {
        DeleteEnd(form);
        return 0;
    }
    if(FirstNodeNumber != 1) {
        if(LineCount() - FirstNodeNumber < ShouldBeDeletedNode) {
            ShouldBeDeletedNode = LineCount() - FirstNodeNumber;
            ShouldBeDeletedNode++;
        }
        for (int j = 0; j < ShouldBeDeletedNode; j++) {
            EL1 *trash;
            trash = GetCurrent(form);
            SetCurrent(form, form.Current->next);
            GetPrevious(form)->next = GetCurrent(form);
            delete[] trash->Inf.symbols;
            delete trash;
        }
    } else {
        for(int i = 0; i < ShouldBeDeletedNode; i++) {
            DeleteBegin(form);
        }
    }
    return 0;
}

void DeleteBegin(Formular &form) {
    // Работает корректно
    GoBegin(form);
    SetHead(form, GetNext(GetCurrent(form)));
    delete GetCurrent(form);
    GoBegin(form);
}

int LineCount() {
    //--------------------------------------------------------Находит количество строк. Строка с маркером не учитывается
    // Работает корректно
    fstream input_file;
    char trash = 0;
    int line_count = 0;
    input_file.open("../cmake-build-debug/input_file.txt", ios::in);
    input_file.unsetf(ios::skipws);

    while(!input_file.eof()) {
        input_file >> trash;
        if(trash == '\n')
            line_count++;
    }
    input_file.setf(ios::skipws);

    input_file.close();
    return line_count;
}

int SymbolsCount(fstream &input_file, char trash) {
    // Работает корректно
    char symbols_count = 0;
    do
    {
        input_file >> trash;
        if(input_file.eof() || (trash == '\n'))
            break;
        symbols_count++;
    } while (true);

    return symbols_count;
}

void InputOneLine(Formular &form, int symbols_count, const char* transit_line, char Marker) {
    // Работает корректно
    auto *trash = new EL1;
    trash->next = nullptr;
    trash->Inf.symbols = new char[symbols_count + 1];
    for(int i = 0; i < symbols_count; i++) {
        trash->Inf.symbols[i] = transit_line[i];
    }
    trash->Inf.symbols[symbols_count] = Marker;
    trash->Inf.Marker = Marker;
    if(form.Head != nullptr) {
        form.Last->next = trash;
        SetLast(form, form.Last->next);
    } else {
        SetHead(form, trash);
        SetLast(form, form.Head);
    }
}

void getting_info_from_file(Formular &form, int lineCountFromInput) {
    //--------------------------------------------------------------------------------------------Чтение данных из файла
    // Работает корректно
    fstream input_file;
    char trash = 0, Marker = 0;
    int symbols_count = 0;
    input_file.open("../cmake-build-debug/input_file.txt", ios::in);
    input_file.unsetf(ios::skipws);
    input_file >> Marker;
    do
    {
        input_file >> trash;
    } while (trash != '\n');

    int position = 0;
    for(int i = 0; i < lineCountFromInput; i++) {
        position = input_file.tellg();
        symbols_count = SymbolsCount(input_file, trash);
        auto transit_line = new char[symbols_count + 1];
        input_file.clear();
        input_file.seekg(position);
        for (int j = 0; j < symbols_count; j++)
            input_file >> transit_line[j];
        input_file >> trash;
        InputOneLine(form, symbols_count, transit_line, Marker);
        form.Last->LineNumber = i;
        delete[] transit_line;
    }

    input_file.setf(ios::skipws);
    input_file.close();
}

bool CheckFile() {
    //----------------------------------------------------------------------------------------------------Проверка файла
    // Работает корректно
    fstream f;
    char Marker = 0;
    f.open("../cmake-build-debug/input_file.txt", ios::in);
    if(f.bad() != 0) {
        cout << "Произошла ошибка открытия файла" << endl;
        return true;
    } else {
        f.unsetf(ios::skipws);
        f >> Marker;
        if(Marker == '\n') {
            cout << "Маркер не может быть пуст" << endl;
            f.setf(ios::skipws);
            Marker = 0;
            return true;
        }
        long file_size;
        f.seekg(0, ios::end);
        file_size = f.tellg();
        if (file_size == 0) {
            cout << "А файл то пуст :D" << endl;
            return true;
        }
    }
    f.close();
    return false;
}

#ifndef PROGA_3_COMMONPROCESS_H
#define PROGA_3_COMMONPROCESS_H

#include "Formular.h"
using namespace std;

void DeleteList(Formular &form);
void DeleteEnd(Formular &form);
void DeleteBegin(Formular &form);
int LineCount();
void InputOneLine(Formular &form, int symbols_count, const char* transit_line, char Marker);
void getting_info_from_file(Formular &form, int lineCountFromInput);
int DeleteNode(Formular &form, int FirstNodeNumber, int ShouldBeDeletedNode);
bool CheckFile();

#endif //PROGA_3_COMMONPROCESS_H

#ifndef PROGA_3_EL1_H
#define PROGA_3_EL1_H

#include "Line_with_marker.h"

struct EL1 {
    Line_with_marker Inf;
    int LineNumber;
    EL1* next;
};


#endif //PROGA_3_EL1_H

#ifndef PROGA_3_LINE_WITH_MARKER_H
#define PROGA_3_LINE_WITH_MARKER_H


struct Line_with_marker {
    char* symbols;
    char Marker;
};


#endif //PROGA_3_LINE_WITH_MARKER_H

#ifndef PROGA_3_FORMULAR_H
#define PROGA_3_FORMULAR_H

#include "EL1.h"

struct Formular {
    EL1 *Head, *Current, *Previous, *Last;
};


#endif //PROGA_3_FORMULAR_H

#include <fstream>
#include "FormularProcessing.h"
#include "EL1Processing.h"
#include "Formular.h"
#include "EL1.h"

void InitialiseFormular(Formular &formular) {
    formular.Head = nullptr;
    formular.Previous = nullptr;
    formular.Current = nullptr;
    formular.Last = nullptr;
}

void SetHead(Formular &formular, EL1 *NewHead) {
    formular.Head = NewHead;
}

void SetPrevious(Formular &formular, EL1 *NewPrevious) {
    formular.Previous = NewPrevious;
}

void SetCurrent(Formular &formular, EL1 *NewCurrent) {
    formular.Current = NewCurrent;
}

void SetLast(Formular &formular, EL1 *NewLast) {
    formular.Last = NewLast;
}

EL1 *GetHead(Formular &formular) {
    return formular.Head;
}

EL1 *GetPrevious(Formular &formular) {
    return formular.Previous;
}

EL1 *GetCurrent(Formular &formular) {
    return formular.Current;
}

EL1 *GetLast(Formular &formular) {
    return formular.Last;
}

void GoBegin(Formular &formular) { // Устанавливает Previous как nullptr, а current элемент переносит на головной
    SetPrevious(formular, nullptr);
    SetCurrent(formular, GetHead(formular));
}

void GoNext(Formular &formular) {
    SetPrevious(formular, GetCurrent(formular));
    SetCurrent(formular, GetNext(GetCurrent(formular)));
}

void GoEnd(Formular &formular) {
    GoBegin(formular);
    do {
        GoNext(formular);
    } while (GetCurrent(formular)->next != nullptr);
}

void PrintFormular(Formular &formular) { // Надо дописать
    std::fstream output_file;
    output_file.open("output_file.txt", std::ios::out);

    auto temp = formular.Head;
    while(temp != nullptr) {
        for(int i = 0; temp->Inf.symbols[i] != temp->Inf.Marker; i++) {
            output_file << temp->Inf.symbols[i];
        }
        temp = temp->next;
        if(temp != nullptr)
            output_file << "  --->" << std::endl;
        else
            output_file << "  --->nullptr";
    }
    output_file.close();
}

#ifndef PROGA_3_EL1PROCESSING_H
#define PROGA_3_EL1PROCESSING_H

#include "EL1.h"

EL1* GetNext(EL1 *lText);

#endif //PROGA_3_EL1PROCESSING_H

#include "EL1Processing.h"
#include "EL1.h"

EL1* GetNext(EL1 *lText) {
    return lText->next;
}