#include <iostream>
#include <string>
#include <fstream>
#include <vector>

using namespace std;


int inputIntegerNumber(const int MIN_NUMBER, const int MAX_NUMBER) {
    bool IsIncorrect;
    int Number;
    std::string input = "";
    do {
        getline(cin, input);
        IsIncorrect = false;
        try {
            Number = stoi(input);
        }
        catch (invalid_argument ex) {
            cout << "Введите число:\n";
            IsIncorrect = true;
        }
        catch (out_of_range ex) {
            cout << "Число не должно быть меньше " << MIN_NUMBER << " и больше, чем "
                << MAX_NUMBER << "\n";
            IsIncorrect = true;
        }
        if (!IsIncorrect && (Number <  MIN_NUMBER || Number > MAX_NUMBER)) {
            cout << "Число не должно быть меньше " << MIN_NUMBER << " и больше, чем "
                << MAX_NUMBER << "\n";
            IsIncorrect = true;
        }
    } while (IsIncorrect);
    return Number;
}


bool checkExtension(const string& PathToFile) {
    const string extension = "txt";
    bool Flag;
    if (PathToFile.length() > 4 && PathToFile.substr(PathToFile.length() - 3) == extension) {
        Flag = true;
    }
    else {
        cout << "Неверное расширение.\n";
        Flag = false;
    }
    return Flag;
}


bool checkPermissionForWriting(const string& PathToFile) {
    bool Flag;
    ofstream FileOut(PathToFile);
    if (FileOut.is_open()) {
        FileOut.close();
        Flag = true;
    }
    else {
        cout << "Файл не доступен для записи.\n";
        Flag = false;
    }
    return Flag;
}

bool checkPermissionForReading(const string& PathToFile) {
    bool Flag;
    ifstream FileIn(PathToFile);
    if (FileIn.is_open()) {
        FileIn.close();
        Flag = true;
    }
    else {
        cout << "Файл не доступен для чтения.\n";
        Flag = false;
    }
    return Flag;
}


const string inputPathToFileForReading() {
    string PathToFile;
    do {
        cout << "Введите путь к файлу для чтения:\n";
        getline(cin, PathToFile);
    } while (!checkExtension(PathToFile) || !checkPermissionForReading(PathToFile));
    return PathToFile;
}


bool checkFile(const string PathToFile) {
    bool Flag = true;
    int CurrentNumber;
    ifstream InputFile(PathToFile);
    while ((Flag) && (!InputFile.eof())) {
        try {
            InputFile >> CurrentNumber;
        }
        catch (invalid_argument ex) {
            cout << "Некорректные данные в файле.";
            Flag = false;
        }
        catch (out_of_range ex) {
            cout << "Некорректные данные в файле.";
            Flag = false;
        }
        if (!Flag && (CurrentNumber < 0 || CurrentNumber > 20)) {
            cout << "Некорректные данные в файле.";
            Flag = false;
        }
    }
    InputFile.close();
    return Flag;
}



const string inputPathToFileForWriting() {
    string PathToFile;
    do {
        cout << "Введите путь к файлу для записи: \n";
        getline(cin, PathToFile);
    } while (!checkExtension(PathToFile) || !checkPermissionForWriting(PathToFile) || !checkFile(PathToFile));
    return PathToFile;
}


typedef struct Node* PNode;

struct Node {
    PNode Next;
    int Value;
};


struct List {
    PNode PHeader;
    bool IsCreated = false;
    List() : PHeader(new struct Node) {}


    void create() {
        PHeader->Next = PHeader;
        IsCreated = true;
        cout << "Список создан.\n";
    }


    bool isEmpty() {
        if (PHeader->Next == PHeader)
            return true;
        else
            return false;
    }


    void push(int Data) {
        PNode PCurrentNode = PHeader->Next;
        while (PCurrentNode->Next != PHeader)
            PCurrentNode = PCurrentNode->Next;
        PCurrentNode->Next = new struct Node;
        PCurrentNode = PCurrentNode->Next;
        PCurrentNode->Value = Data;
        PCurrentNode->Next = PHeader;
    }


    int length() {
        int Length = 0;
        PNode PCurrentNode = PHeader->Next;
        while (PCurrentNode != PHeader) {
            PCurrentNode = PCurrentNode->Next;
            Length++;
        }
        return Length;
    }


    void deleteList() {
        PNode PCurrentNode = PHeader->Next;
        PNode PTemp;
        while (PCurrentNode != PHeader) {
            PTemp = PCurrentNode;
            PCurrentNode = PCurrentNode->Next;
            free(PTemp);
        }
        PHeader->Next = PHeader;
    }


    void remove(int Index, int NumberOfElementsToDelete) {
        if (NumberOfElementsToDelete >= length())
            deleteList();
        else {
            int Counter = 1;
            int NumberOfDeleted = 0;
            PNode PTempHeader = PHeader;
            PNode PCurrentNode = PTempHeader->Next;
            PNode PDeletingNode = nullptr;
            while (NumberOfDeleted != NumberOfElementsToDelete) {
                if (PCurrentNode->Next == PTempHeader) {
                    if ((Counter + 1) % Index == 0) {
                        PDeletingNode = PTempHeader->Next;
                        PTempHeader->Next = PTempHeader->Next->Next;
                        PCurrentNode = PTempHeader->Next;
                        free(PDeletingNode);
                        NumberOfDeleted++;
                        Counter++;
                    }
                    else
                        PCurrentNode = PTempHeader->Next;
                    Counter++;
                }
                else {
                    if ((Counter + 1) % Index == 0) {
                        PDeletingNode = PCurrentNode->Next;
                        PCurrentNode->Next = PCurrentNode->Next->Next;
                        PCurrentNode = PCurrentNode->Next;
                        free(PDeletingNode);
                        NumberOfDeleted++;
                        Counter++;
                    }
                    else
                        PCurrentNode = PCurrentNode->Next;
                    Counter++;
                }
            }
            PHeader = PTempHeader;
        }
    }


    string toString() {
        PNode PCurrentNode = PHeader->Next;
        string ResultString = " - ";
        while (PCurrentNode != PHeader){
            ResultString += to_string(PCurrentNode->Value) + " - ";
            PCurrentNode = PCurrentNode->Next;
        }
        return ResultString;
    }

};

void saveToFile(List& CircleList) {
    if (!CircleList.isEmpty()) {
        string path = inputPathToFileForWriting();
        string ResultString = CircleList.toString();
        ofstream fileOut;
        fileOut.open(path, ios::trunc);
        fileOut << "Итоговый список:\n" << ResultString;
        fileOut.close();
        cout << "Информация записана в файл.\n";
    }
    else
        cout << "Список пуст.\n";
}


void add(List &CircleList) {
    if (CircleList.IsCreated) {
        int NumberOfElements = 0;
        cout << "Введите количество элементов для добавления:\n";
        NumberOfElements = inputIntegerNumber(1, 10);
        int Data = 0;
        for (int i = 0; i < NumberOfElements; i++) {
            cout << "Введите значение элемента: ";
            Data = inputIntegerNumber(0, 20);
            CircleList.push(Data);
            cout << '\n';
        }
    }
    else
        cout << "Создайте список.\n";
}


vector<int> receiveNumbersFromFile() {
    string PathToFile = inputPathToFileForReading();
    vector<int> Elements;
    int CurrentNumber;
    ifstream InputFile(PathToFile);
    while (!InputFile.eof()) {
        InputFile >> CurrentNumber;
        Elements.push_back(CurrentNumber);
    }
    InputFile.close();
    return Elements;
}


void openFromFile(List& CircleList) {
    if (CircleList.IsCreated) {
        CircleList.deleteList();
    }
    vector<int> Elements = receiveNumbersFromFile();
    CircleList.create();
    for (int i = 0; i < Elements.size(); i++)
        CircleList.push(Elements[i]);
    cout << "Список прочитан из файла.\n";
}


void removeElements(List& CircleList) {
    if (CircleList.IsCreated) {
        if (CircleList.isEmpty())
            cout << "Список пуст.\n";
        else {
            cout << "Введите позицию для удаления: ";
            int Index = inputIntegerNumber(0, 20);
            cout << '\n' << "Введите количество элементов для удаления: ";
            int NumberOfElementsToDelete = inputIntegerNumber(1, CircleList.length());
            CircleList.remove(Index, NumberOfElementsToDelete);
            cout << "\nЭлементы удалены.\n";
        }
    }
    else
        cout << "Создайте список.\n";
}


void printInConsole(List& CircleList) {
    if (CircleList.IsCreated) {
        if (CircleList.isEmpty())
            cout << "Список пуст.\n";
        else
            cout << "Итоговый список:\n" << CircleList.toString() << '\n';
    }
    else
        cout << "Создайте список.\n";
}


int main() {
    system("chcp 1251");
    List CircleList;
    bool IsEnd = false;
    int CurrentInstruction = 0;
    int NumberOfElements = 0;
    int Index = 0;
    cout << "Выберите команду:\n1 - создать пустой список;\n2 - добавить n элементов в конец списка;\n3 - Создать список по данным из файла;\n4 - начиная с начала списка, удалить m элементов через k позиций;\n5 - вывести список в консоль;\n6 - записать в файл.\n7 - завершить программу.\n";
    do {
        cout << "Введите команду:\n";
        CurrentInstruction = inputIntegerNumber(1, 7);
        switch (CurrentInstruction) {
        case 1: {
            CircleList.create();
            break;
        }
        case 2: {
            add(CircleList);
            break;
        }
        case 3: {
            openFromFile(CircleList);
            break;
        }
        case 4: {
            removeElements(CircleList);
            break;
        }
        case 5: {
            printInConsole(CircleList);
            break;
        }
        case 6: {
            saveToFile(CircleList);
            break;
        }
        case 7: {
            IsEnd = true;
            break;
        }
        default: {
            cout << "Неизвестная команда.\n";
        }
        }
    } while (!IsEnd);
    if (CircleList.IsCreated) {
        CircleList.deleteList();
        free(CircleList.PHeader);
    }
    cout << "Выполнение программы завершено.";
    return 0;
}