main.cpp

// { g++ main.cpp -o main -lole32 -loleaut32 -luuid -lshlwapi }
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <stdexcept> // Äîáàâëåí çàãîëîâî÷íûé ôàéë äëÿ std::runtime_error
#include <windows.h> // Äîáàâëåí çàãîëîâî÷íûé ôàéë äëÿ SetConsoleTextAttribute
#include <shlobj.h>
#include <ObjBase.h>
#include "filesystem.hpp"
#include "fs_std.hpp"
// îáðàùàòüñÿ ÷åðåç fs::*
#define FOREGROUND_YELLOW (FOREGROUND_RED | FOREGROUND_GREEN)
#define FOREGROUND_WHITE (FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE)
#pragma comment(lib, "shell32.lib")
#pragma comment(lib, "ole32.lib")
using namespace std;

// Ñòðóêòóðà äëÿ õðàíåíèÿ êàòåãîðèé è ñîîòâåòñòâóþùèõ ðàñøèðåíèé
struct Category
{
    string name;
    vector<string> extensions;
};

// Ñïèñîê êàòåãîðèé
vector<Category> categories{
    {"Video", {".mp4", ".mov", ".avi", ".mkv", ".wmv", ".3gp", ".3g2", ".mpg", ".mpeg", ".m4v", ".h264", ".flv", ".rm", ".swf", ".vob"}},
    {"Code", {".py", ".js", ".html", ".jar", ".json", ".java", ".cpp", ".css", ".php"}},
    {"Data", {".sql", ".sqlite", ".sqlite3", ".csv", ".dat", ".db", ".log", ".mdb", ".sav", ".tar", ".xml", ".xlsx", ".xls", ".xlsm", ".ods"}},
    {"Audio", {".mp3", ".wav", ".ogg", ".flac", ".aif", ".mid", ".midi", ".mpa", ".wma", ".wpl", ".cda", ".aac", ".m4a"}},
    {"Images", {".jpg", ".png", ".bmp", ".ai", ".psd", ".ico", ".jpeg", ".ps", ".svg", ".tif", ".tiff", ".gif", ".eps"}},
    {"Archives", {".zip", ".rar", ".7z", ".z", ".gz", ".rpm", ".arj", ".pkg", ".deb", ".tar.gz", ".tar.bz2"}},
    {"Text", {".pdf", ".txt", ".doc", ".docx", ".rtf", ".tex", ".wpd", ".odt"}},
    {"Presentations", {".pptx", ".ppt", ".pps", ".key", ".odp"}},
    {"Fonts", {".otf", ".ttf", ".fon", ".fnt"}},
    {"Installers", {".torrent", ".msi", ".exe"}},
    {"Mobile", {".apk", ".obb"}},
    {"Backups", {".bak", ".bak2"}},
    {"Other", {}}};

// Êîíñòàíòû äëÿ áîëåå ÿñíîãî êîäà
const char PATH_SEPARATOR = '/';
const string DEFAULT_CATEGORY = "Other";

// Ôóíêöèÿ äëÿ ñîçäàíèÿ êàòåãîðèàëüíûõ ïàïîê
void createCategoryFolders(const fs::path &folderPath)
{
    for (const auto &cat : categories)
    {
        fs::path path = folderPath / cat.name;
        fs::create_directory(path);
    }
}


// Ôóíêöèÿ äëÿ ïåðåìåùåíèÿ ôàéëà â ñîîòâåòñòâóþùóþ ïàïêó
void moveFileToCategory(const fs::path &filePath)
{
    try
    {
        // Ïîëó÷àåì èìÿ ôàéëà è åãî ðàñøèðåíèå
        string fileName = filePath.filename().string();
        string extension = filePath.extension().string();

        // Èùåì êàòåãîðèþ, ñîîòâåòñòâóþùóþ ðàñøèðåíèþ ôàéëà
        auto it = find_if(categories.begin(), categories.end(),
                          [&](const Category &c)
                          {
                              return find(c.extensions.begin(),
                                          c.extensions.end(),
                                          extension) != c.extensions.end();
                          });

        // Åñëè êàòåãîðèÿ íå íàéäåíà, èñïîëüçóåì êàòåãîðèþ ïî óìîë÷àíèþ
        Category *category = it != categories.end() ? &*it : nullptr;

        if (category == nullptr)
        {
            category = &categories.back();
        }

        // Ñòðîèì ïóòü ê íîâîìó ìåñòó ôàéëà
        fs::path destPath = filePath.parent_path() / category->name;

        // Èñïðàâëÿåì ñëåøè â ïóòè (åñëè íåîáõîäèìî)
        destPath = destPath.make_preferred();

        // Åñëè ïàïêà íå ñóùåñòâóåò, ñîçäàåì å¸
        if (!fs::exists(destPath))
        {
            fs::create_directory(destPath);
        }

        // Ïðîâåðÿåì, íå ñóùåñòâóåò ëè óæå ôàéë ñ òàêèì èìåíåì â ïàïêå
        for (int i = 1; fs::exists(destPath / fileName); ++i)
        {
            fileName = filePath.stem().string() + "_" + to_string(i) + extension;
        }

        // Ñòðîèì îêîí÷àòåëüíûé ïóòü äëÿ ôàéëà
        fs::path finalPath = destPath / fileName;
        finalPath = finalPath.make_preferred();

        // Ïåðåèìåíîâûâàåì ôàéë
        fs::rename(filePath, finalPath);

        // Âûâîäèì èíôîðìàöèþ î ïåðåìåùåíèè ôàéëà
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_BLUE);
        cout << "Move: " << fileName << " to " << category->name << endl;
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_WHITE);
    }
    catch (const exception &e)
    {
        // Âûâîäèì ñîîáùåíèå îá îøèáêå ïðè âîçíèêíîâåíèè èñêëþ÷åíèÿ
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED);
        cerr << "Error while moving file: " << e.what() << endl;
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_WHITE);
        // Ìîæíî äîáàâèòü äîïîëíèòåëüíûå äåéñòâèÿ, òàêèå êàê ïðîòîêîëèðîâàíèå èëè âûâîä ïîëüçîâàòåëþ
    }
}

// Ôóíêöèÿ äëÿ ðåêóðñèâíîãî óäàëåíèÿ ïóñòûõ ïàïîê â çàäàííîé äèðåêòîðèè
void removeEmptyFolders(const fs::path &folderPath)
{
    try
    {
        // Ïðîõîäèì ïî âñåì ýëåìåíòàì â òåêóùåé äèðåêòîðèè
        for (const auto &entry : fs::directory_iterator(folderPath))
        {
            // Åñëè òåêóùèé ýëåìåíò ÿâëÿåòñÿ äèðåêòîðèåé
            if (entry.is_directory())
            {
                // Ðåêóðñèâíî âûçûâàåì removeEmptyFolders äëÿ âëîæåííîé äèðåêòîðèè
                removeEmptyFolders(entry.path());
            }
        }

        // Ïðîâåðÿåì, ÿâëÿåòñÿ ëè òåêóùàÿ äèðåêòîðèÿ ïóñòîé
        if (fs::is_empty(folderPath))
        {
            // Ïîëó÷àåì èìÿ òåêóùåé êàòåãîðèè èç èìåíè äèðåêòîðèè
            auto categoryName = folderPath.filename().string();

            // Ïîèñê ñîîòâåòñòâóþùåé êàòåãîðèè ïî èìåíè
            auto it = find_if(categories.begin(), categories.end(), [&](const Category &cat) {
                return cat.name == categoryName;
            });

            // Óäàëÿåì òåêóùóþ äèðåêòîðèþ è âûâîäèì ñîîáùåíèå, åñëè ýòî íå êàòåãîðèàëüíàÿ äèðåêòîðèÿ
            fs::remove_all(folderPath);
            if (it == categories.end())
            {
                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_BLUE);
                cout << "Remove empty folder: " << folderPath.filename() << endl;
                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_WHITE);
            }
        }
    }
    catch (const exception &e)
    {
        // Âûâîäèì ñîîáùåíèå îá îøèáêå ïðè âîçíèêíîâåíèè èñêëþ÷åíèÿ
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED);
        cerr << "Error while removing empty folders: " << e.what() << endl;
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_WHITE);
    }
}


// Ôóíêöèÿ äëÿ ñîðòèðîâêè ôàéëîâ â ïàïêå
void sortFiles(const fs::path &folderPath)
{
    try
    {
        // Ñîçäàåì êàòåãîðèàëüíûå ïàïêè
        createCategoryFolders(folderPath);

        // Ïåðåìåùàåì ôàéëû
        for (const auto &entry : fs::directory_iterator(folderPath))
        {
            if (entry.is_regular_file())
            {
                moveFileToCategory(entry.path());
            }
        }

        // Óäàëÿåì âñå ïóñòûå ïàïêè, êðîìå êàòåãîðèàëüíûõ
        removeEmptyFolders(folderPath);
    }
    catch (const exception &e)
    {
        // Âûâîäèì ñîîáùåíèå îá îøèáêå ïðè âîçíèêíîâåíèè èñêëþ÷åíèÿ
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED);
        cerr << "Error while sorting files: " << e.what() << endl;
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_WHITE);
    }
}

fs::path getFolderPathFromExplorer()
{
    // Îòêðûòèå äèàëîãîâîãî îêíà ïðîâîäíèêà äëÿ âûáîðà ïàïêè
    CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);
    IFileOpenDialog *pFileOpen;

    HRESULT hr = CoCreateInstance(CLSID_FileOpenDialog, NULL, CLSCTX_ALL, IID_IFileOpenDialog, reinterpret_cast<void **>(&pFileOpen));

    if (SUCCEEDED(hr))
    {
        DWORD dwOptions;
        pFileOpen->GetOptions(&dwOptions);
        pFileOpen->SetOptions(dwOptions | FOS_PICKFOLDERS);

        // Îòîáðàæåíèå äèàëîãîâîãî îêíà
        hr = pFileOpen->Show(NULL);

        if (SUCCEEDED(hr))
        {
            IShellItem *pItem;
            hr = pFileOpen->GetResult(&pItem);

            if (SUCCEEDED(hr))
            {
                PWSTR pszFilePath;
                hr = pItem->GetDisplayName(SIGDN_FILESYSPATH, &pszFilePath);

                if (SUCCEEDED(hr))
                {
                    fs::path selectedPath(pszFilePath);
                    CoTaskMemFree(pszFilePath);
                    pItem->Release();
                    pFileOpen->Release();
                    return selectedPath;
                }
            }
        }

        pFileOpen->Release();
    }

    CoUninitialize();
    return fs::path(); // Âîçâðàùàåì ïóñòîé ïóòü, åñëè âûáîð ïàïêè îòìåíåí èëè ïðîèçîøëà îøèáêà
}


int main()
{
    system("chcp 1251");

    while (true)
    {
        system("cls");
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_YELLOW);
        std::cout << "\n------- Íà÷àëî ðàáîòû -------\n";
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_WHITE);


        std::cout << "Ââåäèòå ïóòü ê ïàïêå. Íàæìèòå enter äëÿ âûáîðà ïàïêè Download. \n";
        std::string mainPath = "";

        while (mainPath.empty())
        {
            std::cout << "Ïóòü ê ïàïêå: ";
            std::getline(std::cin, mainPath);

            
            if (mainPath.empty())
            {
                CoInitialize(nullptr);

                CHAR linkPathDef[MAX_PATH];
                HRESULT result = SHGetFolderPathA(NULL, CSIDL_PROFILE, NULL, SHGFP_TYPE_CURRENT, linkPathDef);

                if (result != S_OK)
                    std::cout << "Error: " << result << "\n";
                else
                    strcat_s(linkPathDef, "\\Downloads"); // Äîáàâèì ê ïóòè "Downloads"

                mainPath = linkPathDef;
                std::cout << "Âûáðàíà ïàïêà Download!\n";

                CoUninitialize();
            }
            else
            {
                // Ïðîâåðêà íàëè÷èÿ êàâû÷åê â íà÷àëå è êîíöå ïóòè
                if (!mainPath.empty() && (mainPath.front() == '\"' || mainPath.front() == '\'') &&
                    (mainPath.back() == '\"' || mainPath.back() == '\''))
                {
                    // Óáèðàåì êàâû÷êè èç íà÷àëà è êîíöà ïóòè
                    mainPath = mainPath.substr(1, mainPath.length() - 2);
                }
            }

            cout << mainPath << endl;
            if (!fs::path(mainPath).is_absolute())
            {
                std::cout << "Ââåäåííûé ïóòü íå ÿâëÿåòñÿ äåéñòâèòåëüíûì. Ïîïðîáóéòå ñíîâà.\n";
                mainPath = "";
                continue;
            }

            // Ïðåîáðàçóåì ñòðîêó â îáúåêò std::filesystem::path
            fs::path fsMainPath = mainPath;

            // Ïðåîáðàçîâûâàåì ïóòü ê ïðåäïî÷òèòåëüíîìó ôîðìàòó
            fsMainPath.make_preferred();

            // Äîáàâëåíà ïðîâåðêà íà ñóùåñòâîâàíèå ïàïêè
            if (!mainPath.empty() && !fs::exists(fsMainPath))
            {
                cerr << "Error: Folder does not exist." << endl;
                return 1;
            }

            // Âûçûâàåì ôóíêöèþ ñîðòèðîâêè, ïåðåäàâàÿ std::filesystem::path
            sortFiles(fsMainPath);

            SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_YELLOW);
            std::cout << "------- Êîíåö ðàáîòû -------\n";
            SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_WHITE);
        }

        std::cout << "\nÆåëàåòå ïðîäîëæèòü? (y/n): ";
        std::string choice;
        std::getline(std::cin, choice);

        if (choice != "y" && choice != "í")
        {
            system("cls");
            break;
        }
    }

    return 0;
}