#include "stdafx.h"
#include <string>
#include <iostream>
#include <fstream>
#include <cstdlib>

using namespace std;
//Catalog_element *mainhead;

class CatFile//элемент побочного списка
{
public:
    int size;
    string name;
    CatFile *prev;
    CatFile *next;
public:
    CatFile(string file_name, int file_num)
    {
        size = file_num;
        name = file_name;
    }
    CatFile()
    {
        size = NULL;
        name = "";
    }
    void set_size(int file_size)
    {
        size = file_size;
    }
    int get_size()
    {
        return size;
    }

    void set_name(string file_name)
    {
        name = file_name;
    }
    string get_name()
    {
        return name;
    }
    void set_prev(CatFile *file_prev)
    {
        prev = file_prev;
    }
    CatFile* get_prev()
    {
        return prev;
    }
    void set_next(CatFile *file_next)
    {
        next = file_next;
    }
    CatFile* get_next()
    {
        return next;
    }
    ~CatFile()
    {
        size = NULL;
        name = "";
        next = nullptr;
        prev = nullptr;
    }
};

class Catalog//побочный список
{
private:
    int info;
    CatFile *tempsub;//список указывает на первый элемент
    CatFile *prev;
    CatFile *next;
    //CatFile *first;

public:
    Catalog()
    {
        tempsub = new CatFile;
        tempsub->set_name("");
        tempsub->set_size(NULL);
        tempsub->set_next(tempsub);
        tempsub->set_prev(tempsub);
    }
    void InitialSub()
    {
        tempsub = new CatFile;
        tempsub->set_name("");
        tempsub->set_size(NULL);
        tempsub->set_next(tempsub);
        tempsub->set_prev(tempsub);
        //return tempsub;
    }
    void set_next(CatFile *nextt)
    {
        *next = *nextt;
    }
    CatFile get_next()
    {
        return *next;
    }
    void set_prev(CatFile *prevv)
    {
        *prev = *prevv;
    }
    CatFile get_prev()
    {
        return *prev;
    }
    void set_info(int infoo)
    {
        info = infoo;
    }
    int get_info()
    {
        return info;
    }

    void traverse_head()
    {
        CatFile *t = tempsub;
        t = t->get_next();
        int c = 0;
        while (t != tempsub)
        {
            cout << t->get_name() << "\t";
            cout << t->get_size() << "\n";
            t = t->get_next();
        }
        cout << endl;
    }

    void traverse_tail()
    {
        CatFile *t = tempsub;
        t = t->get_prev();
        int c = 0;
        while (t != tempsub)
        {
            cout << t->get_name() << "\t";
            cout << t->get_size() << "\n";
            t = t->get_prev();
        }
        cout << endl;
    }

    int SearchFile(string sname)
    {
        CatFile *t = tempsub;
        t = t->get_next();
        while (t != tempsub)
        {
            if (t->get_name() == sname)
            {
                return 1;
            }
            else
            {
                t = t->get_next();
                continue;
            }
        }
        return 0;
    }

    int SearchFileReverse(string sname)
    {
        CatFile *t = tempsub;
        t = t->get_prev();
        while (t != tempsub)
        {
            if (t->get_name() == sname)
            {
                return 1;
            }
            else
            {
                t = t->get_prev();
                continue;
            }
        }
        return 0;
    }

    CatFile *SearchFileToDelete(string sname)
    {
        CatFile *t = tempsub;
        t = t->get_next();
        while (t != tempsub)
        {
            if (t->get_name() == sname)
            {

                return t;

            }
            else
            {
                t = t->get_next();
                continue;
            }
        }
    }

    void AddCatFile(string name, int size)//готово
    {
        if (tempsub->get_next() == tempsub)//список пуст
        {
            CatFile *temp = new CatFile(name, size);
            tempsub->set_next(temp);
            tempsub->set_prev(temp);
            temp->set_next(tempsub);
            temp->set_prev(tempsub);
        }
        else
        {
            //список не пустой-> ищем место куда добавить
            CatFile *temp = tempsub->get_next();
            if ( (name) <  (tempsub->get_next()->get_name()))//отдельный случай для добавления первого
            {
                CatFile *newtemp = new CatFile(name, size);
                tempsub->get_next()->set_prev(newtemp);
                newtemp->set_next(tempsub->get_next());
                tempsub->set_next(newtemp);
                newtemp->set_prev(tempsub);
            }
            else
            {
                if ( (name) >  (tempsub->get_prev()->get_name()))
                {
                    CatFile *newtemp = new CatFile(name, size);
                    tempsub->get_prev()->set_next(newtemp);
                    newtemp->set_next(tempsub);
                    newtemp->set_prev(tempsub->get_prev());
                    tempsub->set_prev(newtemp);
                }
                else
                {

                    CatFile *newtemp = new CatFile(name, size);
                    CatFile *temp = tempsub->get_next();
                    //отдельно для добавления последнего
                    while (temp != tempsub)//между
                    {
                        if ( (name) <  (temp->get_name()))//новый меньше , то вставляем перед
                        {
                            newtemp->set_prev(temp->get_prev()->get_next());
                            temp->get_prev()->set_next(newtemp);
                            temp->set_prev(newtemp);
                            newtemp->set_next(temp);
                            break;
                        }
                        temp = temp->get_next();
                    }
                }
            }
        }
    }
    void traverse_head_file()
    {
        ofstream file;
        file.open("myfile.txt", ofstream::app);
        if (!file)
        {
            cout << "couldn't open file." << endl;
        }

        else {
            //file.seekp(0, file.end);
            file << "  ";//какого-то фига первые 2 символа иначе сотрет
            CatFile *t = tempsub;
            t = t->get_next();
            int c = 0;
            while (t != tempsub)
            {
                file << t->get_name();
                file << "(";
                file << t->get_size();
                file << ")";
                if (t->get_next() == tempsub)
                {
                    file << "." << endl;
                    //file.close();
                }
                else {
                    file << ",";
                }
                t = t->get_next();
            }

/*
e.
2-f(1).
6-z(4).
*/
        }

    }
    void RemoveCatFile(string sname)
    {
        {
            //список не пустой-> ищем место откуда удалить
            CatFile *todel = SearchFileToDelete(sname);
            if (todel != NULL)
            {
                todel->get_prev()->set_next(todel->get_next());
                todel->get_next()->set_prev(todel->get_prev());
                delete todel;

            }
            else
            {
                cout << "not found" << endl;

            }
            /*if ((todel->get_name()) < (tempsub->get_next()->get_name()))//отдельный случай для удаления первого
            {
                tempsub->set_next(todel->get_next());
                todel->get_next()->set_prev(tempsub);
                //free(todel);
                return;
            }*/
        }
    }

    ~Catalog()
    {
        CatFile *my = tempsub;
        CatFile *catfile = my;//голова
        while (my != nullptr)
        {
            tempsub = my->get_next();
            my->~CatFile();
            my = catfile;
        }
        info = 0;
    }
};

class Catalog_element//элемент главного стека
{
private:
    string Catalog_name;
    Catalog *HeadSub;
public:
    Catalog_element(string Catalog_name)
    {
        Catalog_name = Catalog_name;
        HeadSub = NULL;
    }
    Catalog_element()
    {
        Catalog_name = "";
        HeadSub = NULL;//NULL
    }
    void set_name(string Catalog_nam)
    {
        Catalog_name = Catalog_nam;
    }
    string get_name()
    {
        return Catalog_name;
    }
    void set_list(Catalog *list)
    {
        HeadSub = list;
    }
    Catalog* get_list(int num)
    {
        return HeadSub;
    }
    ~Catalog_element()
    {
        Catalog_name = ("");
        if (HeadSub != nullptr)
        {
            HeadSub->~Catalog();
        }
    }

};
class Device//готово
{
private:
    string deviceName;
    Catalog_element *substack;
    int top;
public:
    Device(string devName)
    {
        deviceName = devName;
        substack = new Catalog_element[5];
        top = -1;
    }
    void set_deviceName(string deviceNamee)
    {
        deviceName = deviceNamee;
    }
    string get_name()
    {
        return deviceName;
    }
    int get_top()
    {
        return top;
    }
    Catalog_element* get_substack(int num)
    {
        return &substack[num];
    }
    void set_top(int topp)
    {
        top = topp;
    }
    int StackIsEmpty()
    {
        if (top == -1)
            return 1;
        else
        return 0;
    }

    int StackIsFull()
    {
        if (top == 4)
            return 1;
        else
            return 0;
    }

    int Search(string name)
    {
        int i;
        int flag = 0;
        for (i = 0; i <= top;)
        {
            if (name == substack[i].get_name())
            {
                cout << "catalog was found, its' index: " << i << endl;
                flag = 1;
                break;
            }
            else
            {
                i++;
            }
        }
        if (flag == 0)
        {
            cout << "catalog wasn't found" << endl;
            return 6;
        }
        return i;
    }

    int SearchSub(string sname)
    {
        if (StackIsEmpty() != 1)
        {
            int i;
            for (i = top; i >= 0; i--)
            {
                if (substack[i].get_list(i) != NULL)
                {
                    if (substack[i].get_list(i)->SearchFile(sname) == 1&& substack[i].get_list(i)->SearchFileReverse(sname) == 1)
                    {
                        return 1;
                    }
                }
            }
        }
        else
        {
            cout << "empty" << endl;
        }
    }

    int AddToSub(string main, int snum, string sname)//добавление в подсписок
    {

        int i = Search(main);
        Catalog *tempcatalog = new Catalog;
        if (substack[i].get_list(i) != nullptr)
        {
            tempcatalog = substack[i].get_list(i);
        }
        tempcatalog->AddCatFile(sname, snum);
        substack[i].set_list(tempcatalog);
        return 1;
    }

    int RemoveFromSub(string main, int snum, string sname)//добавление в подсписок
    {

        int i = Search(main);
        Catalog *tempcatalog = new Catalog;
        if (substack[i].get_list(i) != nullptr)
        {
            tempcatalog = substack[i].get_list(i);
        }
        tempcatalog->RemoveCatFile(sname);
        substack[i].set_list(tempcatalog);
        return 1;
    }

    void AddCatalog(string Catalog_name)//добавление в главный стек
    {
        int temp = 0;

        int i = 0;
        if(get_top() == 4)
        {
            cout << "stack overflow" << endl;
        }
        else if (get_top() < 4)
        {
            Catalog_element *temp = new Catalog_element(Catalog_name);
            temp->set_name(Catalog_name);
            substack[top + 1].set_name(temp->get_name());
            top++;
            cout << "catalog #" << substack[top].get_name() << " was added " << endl;
        }
    }

    void DeleteCatalog()
    {
        if (top == -1) {
            cout << "error" << endl;
            return;
        }
        else
        {
            if (substack[top].get_list(top) != nullptr)
            {
                while (substack[top].get_list(top)->get_info()!=NULL)
                {
                    substack[top].get_list(top)->RemoveCatFile("");
                }
                substack[top].set_name("");
                substack[top].set_list(nullptr);
            }
        }
        top--;
    }

    void PrintCatalog() {
        int i;
        string name = get_name();
        cout << "device's name: " << name << endl;
        for (i = top; i >= 0; i--)
        {
            cout << "catalog #" << substack[i].get_name() << endl;
            //проверка на пустоту списка
            if (substack[i].get_list(i) != NULL)
            {
                substack[i].get_list(i)->traverse_head();
            }
            else
                cout << "no files." << endl;
        }
    }

    void PrintCatalogReverse() {
        int i;
        string name = get_name();
        cout <<"device's name:"<< name << endl;
        for (i = top; i >= 0; i--)
        {
            cout << "catalog #" << substack[i].get_name() << endl;
            //проверка на пустоту списка
            if (substack[i].get_list(i) != NULL)
            {
                substack[i].get_list(i)->traverse_tail();
            }
            else
                cout << "no files." << endl;
        }
    }


    void SaveToFile()
    {
        int i;
        ofstream file;
        file.open("myfile.txt", ofstream::out);
        if (!file)
        {
            cout << "couldn't open file." << endl;
        }
        else
        {
            file.clear();
            if (!StackIsEmpty())
            {
                string name = get_name();
                file << name << "." << endl;
                for (i = top; i >= 0;i--)
                {
                    file << substack[i].get_name() << "-";
                    if (substack[i].get_list(i) != NULL)
                    {
                        //file << "flag" << endl; //видит элементы со списками - нормально
                        //вывести список как q(1),w(2).
                        substack[i].get_list(i)->traverse_head_file();//только один раз?

                    }
                    else
                    {
                        file << "." << endl;
                    }

                }


            }
            else
            {
                cout << "empty." << endl;
            }
            file.close();
            cout << "success." << endl;
        }

    }

    bool is_empty(std::ifstream&file)
    {
        return file.peek() == std::ifstream::traits_type::eof();
    }

    bool CheckString(string tmp, int type)
    {
        int i = 1, r = 0, l = 0, z = 0, zplace = 0, lin = 0;
        string number;
        bool find = false, line = false, bracket = false, onlynum = false;
        if (type != NULL)
        {
            if (tmp[int(tmp.length()) - 1] == '.')
            {
                find = true;
            }
            else
            {
                find = false;
            }
        }
        else
        {
            if (tmp[int(tmp.length() - 1)] == '.'&& tmp[int(tmp.length()) - 2] == '-')
            {
                lin = int(tmp.length()) - 2;
                find = true;
                onlynum = true;
            }
            if (tmp[int(tmp.length()) - 1] == '.'&& tmp[int(tmp.length()) - 2] == ')')
            {
                find = true;
            }
            else
            {
                if (onlynum == false)
                {
                    find = false;
                }
            }
            if (find == true && onlynum == false)
            {
                find = false;
                while (i < int(tmp.length() - 1))
                {       //наличие -
                    if (tmp[i] == '-' && tmp[i - 1] != ' ' && tmp[i + 1] != ' ')
                    {
                        lin = i;
                        line = true;
                    }
                    //чекнуть скобки и ,
                    if (tmp[i] == '(' && tmp[i + 1] != ')' && tmp[i + 1] != '('  && tmp[i + 1] != ' '  && tmp[i - 1] != ' ')//(
                    {
                        l++;
                    }
                    else
                    {
                        if (tmp[i] == ')'&& tmp[i + 1] != ' '  && tmp[i - 1] != ' ')//)
                        {
                            r++;
                            if (tmp[i + 1] == ',' && tmp[i + 2] != ' ')
                            {
                                zplace++;
                            }
                        }
                    }
                    i++;
                }
                if (r = l == zplace + 1)
                {
                    bracket = true;
                }
                if (bracket == true && line == true)
                {
                    find = true;
                }
                else
                {
                    if (onlynum == false)
                    {
                        find = false;
                    }
                }
            }
        }
        i = 0;
        if (find == true && type == NULL)
        {
            number = "";
            while (i < lin)
            {
                number += tmp[i];
                i++;
            }
            if (number != "")
            {
                try
                {
                    stoi(number);
                }
                catch (const std::exception&)
                {
                    find = true;
                }
            }
            else
            {
                find = false;
            }
            if (onlynum == false && find == true)
            {
                while (tmp[i] != '.' && find != false)
                {
                    number = "";
                    if (tmp[i] == '(')//просто отрежем букву, если попадется в номере
                    {
                        i++;
                        while (tmp[i] != ')')
                        {
                            number += tmp[i];
                            i++;
                        }
                        if (number != "")
                        {
                            try
                            {
                                stoi(number);
                            }
                            catch (const std::exception&)
                            {
                                find = false;
                            }
                        }
                        else
                        {
                            find = false;
                        }
                    }
                    i++;
                }
            }
        }
        return(find);
    }


    void File(Device *dev)
    {

        int num = 0;
        ifstream file("myfile.txt");
        if (!file.is_open())
        {
            cout << "couldn't open file." << endl;
        }
        else if (dev->is_empty(file))
        {
            cout << "file is empty. switching to console." << endl;
        }
        else
        {
            string tmp, tmp2, name;
            string name2, tm;
            int i = 0;
            //char p = ' ';
            getline(file, tmp);
            bool point, stop = false;
            point = CheckString(tmp, 1);//проверка формы ввода
            if (point != true)
            {
                cout << "Name was corrupted, changing to some_name" << endl;
                dev->set_deviceName("some_name");
            }
            else
            {
                while (tmp[i] != '.')
                {
                    tmp2 += tmp[i];
                    i++;
                }
                dev->set_deviceName(tmp2);
            }
            i = 0;
            while (!file.eof() && !dev->StackIsFull())
            {
                point = false;
                i = 0;
                getline(file, name);
                if (name != "")
                {
                    cout << name << endl;
                    system("pause");
                    point = CheckString(name, NULL);
                    if (point == true)
                    {
                        name2 = "";
                        while (name[i] != '-')
                        {
                            name2 += name[i];
                            i++;
                        }
                        if (!dev->StackIsEmpty())
                        {
                            num = dev->Search((name2));
                        }
                        {
                            dev->AddCatalog((name2));//стек
                            if (name[int(name.length() - 1)] == '.'&& name[int(name.length()) - 2] == '-')
                            {
                                cout << "In string " << name << " there's no list's elements." << endl;
                            }
                            else //списки
                            {
                                tmp2 = name2;
                                while (name[i] != '.')
                                {
                                    i++;
                                    name2 = "";
                                    while (name[i] != '(')
                                    {
                                        name2 += name[i];
                                        i++;
                                    }
                                    i++;
                                    tm = name2;
                                    name2 = "";
                                    while (name[i] != ')')
                                    {
                                        name2 += name[i];
                                        i++;
                                    }
                                    i++;

                                    num = dev->Search((tmp2));//stoi(name) номер, tm - название - нормально находит
                                    //cout << tmp2 << endl;//каталог, куда добавлять
                                    //cout << num << endl;
                                    //cout << stoi(name2) << endl;//2 - номер
                                    //cout << tm << endl;//w - название
                                    dev->AddToSub(tmp2, stoi(name2), tm);

                                }
                            }
                        }

                    }
                    else
                    {
                        cout << "string ( " << name << " ) was corrupted." << endl;
                    }
                }
            }
            cout << "success." << endl;
            file.close();
        }
    }

    ~Device()
    {
        deviceName = "";
        top = -1;
        while (top < 5)
        {
            Catalog_element *el = &substack[top];
            el->~Catalog_element();
            top++;
        }
        top = 0;
    }
};


int main()
{
    setlocale(LC_ALL, "Russian");
    string name;
    cout << "enter the device's name: ";
    cin >> name;
    Device *dev = new Device(name);
    int menu = 99;
    int menu2 = 0;
    while (menu2 != 1 && menu2 != 2)
    {
        cout << "1 - use console" << endl;
        cout << "2 - use file" << endl;
        cin >> menu2;
        while (cin.fail())
        {
            cin.clear();
            cin.ignore(INT_MAX, '\n');
            cout << "enter only numbers" << endl << "try again" << endl;
            cin >> menu2;
        }
        switch (menu2)
        {
        case(2):
        {
            dev->File(dev);
            break;
        }
        case(1):
        {
            break;
        }
        default:
            break;
        }
    }
    while (menu != 0)
    {
        cout << "------------------------------------------------------------------------------" << endl;
        cout << "main stack:" << endl;
        cout << "1 - add catalog" << endl;
        cout << "2 - delete catalog" << endl;
        cout << "3 - search catalog" << endl;
        cout << "4 - print catalogs" << endl;
        cout << "------------------------------------------------------------------------------" << endl;
        cout << "sublists:" << endl;
        cout << "5 - add file" << endl;
        cout << "6 - delete file" << endl;
        cout << "7 - search file" << endl;
        cout << "8 - print catalogs with reversed lists" << endl;
        cout << "------------------------------------------------------------------------------" << endl;
        cout << "9 - save to file" << endl;
        cout << "10 - exit" << endl;
        cout << "------------------------------------------------------------------------------" << endl;
        cout << "11 - change device's name" << endl;
        cout << "------------------------------------------------------------------------------" << endl;
        cout << "enter your choice:" << endl;
        cout << "------------------------------------------------------------------------------" << endl;
        cin >> menu;
        while (cin.fail())
        {
            cin.clear();
            cin.ignore(INT_MAX, '\n');
            cout << "enter only numbers" << endl << "try again" << endl;
            cin>>menu;
        }
        switch (menu)
        {

        case (1):
        {
            if (dev->StackIsFull() != 1) {
                dev->get_top();
                string catnum;
                cout << "enter the element: ";
                cin >> catnum;
                dev->AddCatalog(catnum);
            }
            else
            {
                cout << "stack overflow" << endl;
            }
            break;
        }
        case (2):
        {

            if (dev->StackIsEmpty())
            {
                cout << "empty." << endl;
            }
            else
            {
                dev->DeleteCatalog();
            }
            break;
        }
        case (3):
        {
            if (dev->StackIsEmpty())
            {
                cout << "empty." << endl;
                break;
            }
            else
            {
                string name;
                cout << "enter catalog's name" << endl;
                cin >> name;
                dev->Search(name);
                break;
            }
            break;
        }
        case (4):
        {
            if (dev->StackIsEmpty())
            {
                cout << "device is empty." << endl;
            }
            else
            {
                dev->PrintCatalog();
            }
            break;
        }
        case (5):
        {
            if (dev->StackIsEmpty())
            {
            cout << "empty - nowhere to add." << endl;
            break;
            }
            else
            {
                string mainelement;
                string sname;
                int size = 0;
                cout << "to which catalog should we add?" << endl;
                cin >> mainelement;
                if ((dev->Search(mainelement)) != 6) {
                    cout << "enter file's size" << endl;
                    cin >> size;
                    while (cin.fail())
                    {
                        cin.clear();
                        cin.ignore(INT_MAX, '\n');
                        cout << "enter only numbers" << endl << "try again" << endl;
                        cin >> size;
                    }
                    cout << "enter file's name" << endl;
                    cin >> sname;
                    if ((dev->SearchSub(sname)) != 1)
                    {
                        dev->AddToSub(mainelement, size, sname);
                    }
                    //cout << "success" << endl;
                    else
                        cout << "duplicates are not allowed. try again." << endl;
                }
                else
                {
                    break;
                }
                break;
            }
        }
        case (6):
        {
            if (dev->StackIsEmpty())
            {
                cout << "empty." << endl;
                break;
            }
            else
            {
                string mainelement, sname;
                int size = 0;
                cout << "from which catalog should we delete?" << endl;
                cin >> mainelement;
                cout << "enter file's size" << endl;
                cin >> size;
                while (cin.fail())
                {
                    cin.clear();
                    cin.ignore(INT_MAX, '\n');
                    cout << "enter only numbers" << endl << "try again" << endl;
                    cin >> size;
                }
                cout << "enter file's name" << endl;
                cin >> sname;
                if ((dev->SearchSub(sname)) == 1)
                {
                    dev->RemoveFromSub(mainelement, size, sname);
                }

                else
                    cout << "element not found." << endl;
                break;
            }
        }
        case(7):
        {
            string sname;
            cout << "enter file's name" << endl;
            cin >> sname;
            if (dev->SearchSub(sname) == 1)
            {
                cout << "found" << endl;
                break;
            }
            else
            {
                cout << "not found" << endl;
                break;
            }
           }
        case(8):
        {
            if (dev->StackIsEmpty())
            {
                cout << "device is empty." << endl;
            }
            else
            {
                dev->PrintCatalogReverse();
            }
            break;
        }
        case(9):
        {
            dev->SaveToFile();
            break;
        }
        case(10):
            exit(1);
            dev->~Device();
        case(11):
            string name;
            cout << "enter new name for a device: " << endl;
            cin >> name;
            dev->set_deviceName(name);
            break;
        }
    }
    return 0;
}