#include <iostream>
#include <string>

using namespace std;

////////////////////////////////////////////////////////////////////////

// Типы path
// 1) /homework/skyrim.exe        - относительный путь | до файла
// 2) C:/abc/homework/skyrim.exe  - абсолютный    путь | до файла
// 3) /homework/                  - относительный путь | до католога
// 4) C:/abc/                     - абсолютный    путь | до католога

// ДОПУСТИМЫЕ символы
// 1) Буквы
// 2) Цифры
// 3) Символы: ~ @ # $ % ^ - _ ( ) { } ' ` .

////////////////////////////////////////////////////////////////////////

class classPath {
    private:
        string path;   // Путь


    public:
        classPath(string strPath) : path(strPath) { /* ... */ }

        bool itCoorectPath() const;
        void catalog_or_path() const;
        string return_name_file() const;
        classPath operator+(const classPath&) const;
        string operator[] (unsigned int) const;

};

//----------------------------------------------------------------------

bool classPath::itCoorectPath() const {
    bool absolute = false;
    bool coorect = true;
    bool file = false;

    // Проверка на абсолютность путя
    if ( (path.size() > 2) & (path[0] >= 'A') & ('Z' >= path[0]) & (path[1] == ':') ) {
        absolute = true;
    }

    unsigned int i; if (absolute) { i = 2; } else { i = 0; }

    while (path.size() > i) {
        char ch = path[i];

        // Проверка на допустимые символы (парсинг 2000лвл)
        if ( ((ch >= 'A')  & (ch <= 'Z'))  |
                ((ch >= 'a')  & (ch <= 'z'))  |
                ((ch >= '.')  & (ch <= '9'))  |
                ((ch >= '#')  & (ch <= '%'))  |
                ((ch >= '\'') & (ch <= ')'))  |

                (ch == '{')   |   (ch == '}') |
                (ch == '~')   |   (ch == '@') |
                (ch == '^')   |   (ch == '-') |
                (ch == '_')   |   (ch == '`')    )

        {

            // Проверка на корректность окончания пути файла
            if ( (path.size() + 1 == i) & (file) & (path[i] != '.') ) {
                coorect = false; break;
            }

            // Проверка на название файла
            if ( path[i] == '.' ) {
                file = true;
            }

            // Проверка на корректность окончания пути каталога
            if ( (path.size() - 1 == i) & (!file) & (path[i] != '/') ) {
                coorect = false; break;
            }

            // Проверка на корректность окончания пути файла
            if ( (path.size() - 1 == i) & (file) & (path[i] == '.') ) {
                coorect = false; break;
            }

            // Проверка на корректность слэша
            if ( (path[i] == '/') & (i != 0) ) {
                if (file) {
                    coorect = false; break;
                }

                if (path[i - 1] == '/') {
                    coorect = false; break;
                }
            }

            // CЮДА МОЖНО ДОБАВИТЬ НУЖНЫЕ ПРОВЕРКИ
            // CЮДА МОЖНО ДОБАВИТЬ НУЖНЫЕ ПРОВЕРКИ
            // CЮДА МОЖНО ДОБАВИТЬ НУЖНЫЕ ПРОВЕРКИ
        }

        // Если символ не допустим
        else { coorect = false; break; }

        // Итерация
        i++;
    }

    // cout-отладка
    // cout << "Path: "      << path     << endl
    //      << "coorect = "  << coorect  << endl
    //      << "absolute = " << absolute << endl
    //      << "file = "     << file     << endl
    // << endl;



    return coorect;
}

//----------------------------------------------------------------------

void classPath::catalog_or_path() const {
    if (itCoorectPath()) {
        if (find(path.begin(), path.end(), '.') != path.end()) {
            cout << "Its path file" << endl;
        } else {
            cout << "Its path catalog" << endl;
        }
    }

    else {
        cout << "Path dont coorect" << endl;
    }
}

//----------------------------------------------------------------------

string classPath::return_name_file() const {
    if (itCoorectPath()) {
        if (find(path.begin(), path.end(), '.') == path.end()) {
            cout << "Its path catalog" << endl;
            return string("");
        } else {
            return string( find(path.rbegin(), path.rend(), '/').base() , path.end() );
        }
    }

    else {
        cout << "Path dont coorect" << endl;
        return string("");
    }
}

//----------------------------------------------------------------------

classPath classPath::operator+(const classPath& obj) const {
    // Возможно суммирование
    // 1. Если оба path корректны
    // 2. Правый path - относительный
    // 3. Левый path - не файл

    // Первая проверка
    if (!(itCoorectPath() & obj.itCoorectPath())) {
        return classPath("error path");
    }

    // Вторая проверка
    if (((obj.path.size() > 2) & (obj.path[0] >= 'A')
            & ('Z' >= obj.path[0]) & (obj.path[1] == ':'))) {
                    return classPath("error path");
    }

    // Третья проверка
    if (find(path.begin(), path.end(), '.') != path.end()) {
        return classPath("error path");
    }

    return classPath(string(path.begin(), path.end() - 1) + obj.path);
}

//----------------------------------------------------------------------

string classPath::operator[] (unsigned int index) const {
    auto iter_left = path.begin();
    unsigned int k = 1;

    while ((k++ != index) & (iter_left != path.end())) {
        iter_left = find(iter_left, path.end(), '/');
        iter_left++;
    }

    return string(iter_left, find(iter_left, path.end(), '/'));
}

////////////////////////////////////////////////////////////////////////

int main() {
    classPath test1("/homework/skyrim.exe");
    classPath test2("C:/abc/homework/skyrim.exe/");
    classPath test3("/homework/L()L");
    classPath test4("/homework/skyrim.exe");

    cout << "Name file test1: " << test1.return_name_file() << endl;
    cout << "Coorect test1: " << test1.itCoorectPath() << endl;
    cout << "test1 "; test1.catalog_or_path(); cout << endl;

    cout << "Coorect test2: " << test2.itCoorectPath() << endl;

    cout << "Coorect test3: " << test3.itCoorectPath() << endl;

    cout << "Name file test4: " << test4.return_name_file() << endl;

    cout << endl;

    classPath testLeft("C:/Desktop/");
    classPath testRight("/labs/Adobe_PS.exe");
    classPath newPath(testLeft + testRight);
    cout << "Name file newPath: " << newPath.return_name_file() << endl;
    cout << "Coorect newPath: " << newPath.itCoorectPath() << endl;
    cout << "newPath "; newPath.catalog_or_path();
    cout << "newPath[2]: " << newPath[2] << endl;
    cout << "newPath[3]: " << newPath[3] << endl;
    cout << "newPath[4]: " << newPath[4] << endl;



    return 0;
}