Subversion Repositories spk

#pragma once

#include "WString.h"
#include "WStringList.h"
#include "../File_IO.h"
#include "../DirIO.h"

#include <bitset>
#include <cwctype>
#include <filesystem>

#ifdef _WIN32
#include <windows.h>
#include <direct.h>
#include <shlobj.h>
#else
#include <dirent.h>
#include <sys/types.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <unistd.h>
#include <cstdlib>
#endif

namespace Utils
{
        namespace fs = std::filesystem;

        class CommandLine
        {
        private:
                std::shared_ptr<CFileIO> _file;
                Utils::WStringList              _options;
                CDirIO                                  _myDoc;
                CDirIO                                  _tempDir;
                std::vector<Utils::WString> _args;
                std::bitset<256>                _flags{};
                CPackages                               _p;

        public:
                explicit CommandLine(int argc, char* argv[], bool doFlags = false)
                {
                        _file = std::make_shared<CFileIO>(argv[0]);

                        for (int i = 1; i < argc; ++i)
                        {
                                Utils::WString arg(argv[i]);
                                doCommandLine(std::move(arg), doFlags);
                        }

                        finaliseCommandLine();
                }

                explicit CommandLine(int argc, wchar_t* argv[], bool doFlags = false)
                {
                        _file = std::make_shared<CFileIO>(argv[0]);

                        for (int i = 1; i < argc; ++i)
                        {
                                Utils::WString arg(argv[i]);
                                doCommandLine(std::move(arg), doFlags);
                        }

                        finaliseCommandLine();
                }

                const std::shared_ptr<CFileIO>& file() const noexcept
                {
                        return _file;
                }

                const Utils::WString& cmdName() const noexcept
                {
                        return _file->filename();
                }

                const Utils::WString& cmdDir() const noexcept
                {
                        return _file->dir();
                }

                const Utils::WString& tempDir() const noexcept
                {
                        return _tempDir.dir();
                }

                const Utils::WString& myDoc() const noexcept
                {
                        return _myDoc.dir();
                }

                const Utils::WStringList& options() const noexcept
                {
                        return _options;
                }

                const std::vector<Utils::WString>& args() const noexcept
                {
                        return _args;
                }

                size_t argCount() const noexcept
                {
                        return _args.size();
                }

                Utils::WString arg(size_t i) const
                {
                        if (i >= _args.size())
                                return Utils::WString::Null();
                        return _args[i];
                }

                bool hasSwitch(const Utils::WString& s) const noexcept
                {
                        return _options.contains(s);
                }

                bool hasFlag(unsigned char s) const noexcept
                {
                        return _flags.test(s);
                }

                Utils::WString switchData(const Utils::WString& s, const Utils::WString& defaultValue = Utils::WString::Null()) const
                {
                        if (_options.contains(s))
                                return _options[s]->data;
                        return defaultValue;
                }

                const CPackages& packages() const noexcept
                {
                        return _p;
                }

                CPackages& packages() noexcept
                {
                        return _p;
                }

                const CDirIO& dirIO() const noexcept
                {
                        return _file->dirIO();
                }

                Utils::WString fullFilename(const Utils::WString& s) const
                {
                        // Keep simple cross-platform detection: recognize drive/protocols and path separators.
                        if (s.contains(L":") || s.contains(L"/") || s.contains(L"\\"))
                                return s;
                        return _file->dirIO().file(s);
                }

        private:
                void doCommandLine(Utils::WString arg, bool doFlags)
                {
                        if (arg.startsWith(L"--"))
                        {
                                arg = arg.substr(2);

                                if (arg.contains(L":"))
                                {
                                        Utils::WString a = arg.token(L":", 1);
                                        Utils::WString b = arg.tokens(L":", 2);
                                        _options.pushBack(a, b);
                                }
                                else
                                {
                                        _options.pushBack(arg);
                                }
                        }
                        else
                        {
                                if (doFlags)
                                {
                                        if (arg.startsWith(L"-") && !arg.startsWith(L"--"))
                                        {
                                                Utils::WString flags = arg.substr(1);
                                                for (size_t is = 0; is < flags.length(); ++is)
                                                {
                                                        wchar_t ch = flags[static_cast<int>(is)];
                                                        wchar_t upper = std::towupper(ch);

                                                        if (upper >= L'A' && upper <= L'Z')
                                                        {
                                                                unsigned char idx = static_cast<unsigned char>(upper & 0xFF);
                                                                _flags.set(idx);
                                                        }
                                                }
                                                return;
                                        }
                                }
                                _args.push_back(arg);
                        }
                }

                void finaliseCommandLine()
                {
                        // Ensure command directory is a usable path; prefer std::filesystem current_path.
                        const Utils::WString fileDir = _file->dir();
                        bool looksLikePath = (!fileDir.empty() && (fileDir.contains(L"/") || fileDir.contains(L"\\") || fileDir.contains(L":")));
                        if (_file->dir().empty() || !looksLikePath)
                        {
                                Utils::WString d;
                                try
                                {
                                        fs::path cwd = fs::current_path();
#ifdef _WIN32
                                        d = Utils::WString(cwd.wstring().c_str());
#else
                                        d = Utils::WString(cwd.string().c_str());
#endif
                                }
                                catch (...)
                                {
                                        // fallback
#ifdef _WIN32
                                        d = Utils::WString(_getcwd(NULL, 0));
#else
                                        d = Utils::WString(getcwd(NULL, 0));
#endif
                                }

                                if (d.empty())
                                        d = L"./";
                                _file->setDir(d);
                        }

                        // my documents
                        Utils::WString myDoc = L".";

#ifdef _WIN32
                        TCHAR pszPath[MAX_PATH];
                        if (SUCCEEDED(SHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, SHGFP_TYPE_CURRENT, pszPath)))
                        {
                                myDoc = pszPath;
                        }
#else
                        // on POSIX try HOME, else leave '.',
                        const char* home = std::getenv("HOME");
                        if (home && *home)
                        {
                                myDoc = Utils::WString(home);
                        }
#endif
                        _myDoc.setDir(myDoc);

                        // temp dir via filesystem (fallbacks included)
                        Utils::WString tmp = L".";
                        try
                        {
                                fs::path t = fs::temp_directory_path();
#ifdef _WIN32
                                tmp = Utils::WString(t.wstring().c_str());
#else
                                tmp = Utils::WString(t.string().c_str());
#endif
                        }
                        catch (...)
                        {
#ifdef _WIN32
                                TCHAR szPath[MAX_PATH + 1];
                                DWORD result = GetTempPath(MAX_PATH + 1, szPath);
                                if (result > 0)
                                        tmp = Utils::WString(szPath);
#else
                                // leave as "."
#endif
                        }
                        _tempDir.setDir(tmp);

                        _p.startup(L".", _tempDir.dir(), _myDoc.dir());
                }
        };
}