#include "path.h"
#include "StdString.h"
#include "Trace.h"
#include "TraceModulesCommon.h"

#ifdef _WIN32
#pragma warning(push)
#pragma warning(disable : 4091) // warning C4091: 'typedef ': ignored on left of 'tagGPFIDL_FLAGS' when no variable is declared
#pragma warning(disable : 4996) // warning C4091: 'typedef ': ignored on left of 'tagGPFIDL_FLAGS' when no variable is declared
#include <Shlobj.h>
#include <dos.h>

#include <CommDlg.h>
#pragma warning(pop)
#else
#include <dirent.h>
#include <errno.h>
#include <sys/stat.h>
#include <unistd.h>
#endif
#include "Platform.h"

// g_ModuleLogLevel may be nullptr while AppInit() is still in session in path.cpp.
// The added check to compare to nullptr here is at least a temporary workaround.

#undef WriteTrace
#ifdef _WIN32
#define WriteTrace(m, s, format, ...)                                                        \
    if (g_ModuleLogLevel != nullptr && g_ModuleLogLevel[(m)] >= (s))                         \
    {                                                                                        \
        WriteTraceFull((m), (s), __FILE__, __LINE__, __FUNCTION__, (format), ##__VA_ARGS__); \
    }
#else
#define WriteTrace(m, s, format, ...)                                                               \
    if (g_ModuleLogLevel != nullptr && g_ModuleLogLevel[(m)] >= (s))                                \
    {                                                                                               \
        WriteTraceFull((m), (s), __FILE__, __LINE__, __PRETTY_FUNCTION__, (format), ##__VA_ARGS__); \
    }
#endif

// Constants

#ifdef _WIN32
const char DRIVE_DELIMITER = ':';
const char * const DIR_DOUBLEDELIM = "\\\\";
const char DIRECTORY_DELIMITER = '\\';
const char DIRECTORY_DELIMITER2 = '/';
#else
const char * const DIR_DOUBLEDELIM = "//";
const char DIRECTORY_DELIMITER = '/';
const char DIRECTORY_DELIMITER2 = '\\';
#endif
const char EXTENSION_DELIMITER = '.';
#ifdef _WIN32
void * CPath::m_hInst = nullptr;
#endif

// Helpers

#ifdef _WIN32
void CPath::SethInst(void * hInst)
{
    m_hInst = hInst;
}

void * CPath::GethInst()
{
    return m_hInst;
}
#endif

// Initialization

// Task: Helper function for the various CPath constructors.
// Initializes the data members and establishes various class invariants.

inline void CPath::Init()
{
    m_dwFindFileAttributes = 0;
#ifdef _WIN32
    m_hFindFile = nullptr;
#else
    m_OpenedDir = nullptr;
    m_FindWildcard = "";
#endif
}

// Task: Helper function for the various CPath destructors. Cleans up various internals.

inline void CPath::Exit()
{
#ifdef _WIN32
    if (m_hFindFile != nullptr)
    {
        FindClose(m_hFindFile);
        m_hFindFile = nullptr;
    }
#else
    if (m_OpenedDir != nullptr)
    {
        closedir((DIR *)m_OpenedDir);
        m_OpenedDir = nullptr;
    }
#endif
}

// Construction/Destruction

// Task: Constructs a path

CPath::CPath()
{
    Init();
    Empty();
}

// Task: Constructs a path as copy of another

CPath::CPath(const CPath & rPath)
{
    Init();
    m_strPath = rPath.m_strPath;
}

// Task: Constructs a path and points it to lpszPath

CPath::CPath(const char * lpszPath)
{
    Init();
    m_strPath = lpszPath ? lpszPath : "";
    cleanPathString(m_strPath);
}

CPath::CPath(const char * lpszPath, const char * NameExten)
{
    WriteTrace(TracePath, TraceDebug, "Start (lpszPath: \"%s\" NameExten: \"%s\")", lpszPath ? lpszPath : "(null)", NameExten ? NameExten : "(null)");
    Init();
#ifdef _WIN32
    SetDriveDirectory(lpszPath);
#else
    SetDirectory(lpszPath);
#endif
    SetNameExtension(NameExten);
    WriteTrace(TracePath, TraceDebug, "Done (m_strPath: \"%s\")", m_strPath.c_str());
}

// Task: Constructs a path and points it to strPath

CPath::CPath(const std::string & strPath)
{
    Init();
    m_strPath = strPath;
    cleanPathString(m_strPath);
}

// Task: Constructs a path and points it to strPath

CPath::CPath(const std::string & strPath, const char * NameExten)
{
    Init();
#ifdef _WIN32
    SetDriveDirectory(strPath.c_str());
#else
    SetDirectory(strPath.c_str(), true);
#endif
    SetNameExtension(NameExten);
}

// Task: Constructs a path and points it to strPath

CPath::CPath(const std::string & strPath, const std::string & NameExten)
{
    Init();
#ifdef _WIN32
    SetDriveDirectory(strPath.c_str());
#else
    SetDirectory(strPath.c_str(), true);
#endif
    SetNameExtension(NameExten.c_str());
}

// Task: Cleanup and destruct a path object

CPath::~CPath()
{
    Exit();
}

// Post: Return TRUE if paths are equal
// Task: Check if the two path are the same

bool CPath::operator==(const CPath & rPath) const
{
    // Get fully qualified versions of the paths
    std::string FullyQualified1;
    std::string FullyQualified2;

    GetFullyQualified(FullyQualified1);
    rPath.GetFullyQualified(FullyQualified2);

    // Compare them
    return _stricmp(FullyQualified1.c_str(), FullyQualified2.c_str()) == 0;
}

// Post: Return TRUE if paths are different
// Task: Check if the two path are different

bool CPath::operator!=(const CPath & rPath) const
{
    return !(*this == rPath);
}

// Task: Assign a path to another

CPath & CPath::operator=(const CPath & rPath)
{
    if (this != &rPath)
    {
        m_strPath = rPath.m_strPath;
    }
    return *this;
}

// Post: Return the path, so that assignments can be chained
// Task: Assign a string to a path

CPath & CPath::operator=(const char * lpszPath)
{
    m_strPath = lpszPath ? lpszPath : "";
    return *this;
}

// Post: Return the path, so that assignments can be chained
// Task: Assign a string to a path

CPath & CPath::operator=(const std::string & strPath)
{
    m_strPath = strPath;
    return *this;
}

/*
Post: Converts path to string
Task: Convert path to string
Warning: Because this pointer to string point in the data
of this class, it is possible to cast the result of this
function in any non-constant pointer and alter the data.
Very dangerous!
*/

CPath::operator const char *() const
{
    return (const char *)m_strPath.c_str();
}

CPath::CPath(DIR_CURRENT_DIRECTORY /*sdt*/, const char * NameExten)
{
    // Application's current directory
    Init();
    CurrentDirectory();
    if (NameExten)
    {
        SetNameExtension(NameExten);
    }
}

#ifdef _WIN32
CPath::CPath(DIR_MODULE_DIRECTORY /*sdt*/, const char * NameExten)
{
    // The directory where the executable of this app is
    Init();
    ModuleDirectory();
    if (NameExten)
    {
        SetNameExtension(NameExten);
    }
}

CPath::CPath(DIR_MODULE_FILE /*sdt*/)
{
    // The directory where the executable of this app is
    Init();
    Module();
}
#endif

/*
Post: Returns the drive component without a colon, e.g. "c"
Returns the directory component with a leading backslash,
but no trailing backslash, e.g. "\dir\subdir"
Returns name completely without delimiters, e.g "letter"
Returns extension completely without delimiters, e.g. "doc"
Globals:
I/O:
Task: Return the individual components of this path.
For any given argument, you can pass nullptr if you are not
interested in that component.
Do not rely on pNames being <= 8 characters, extensions
being <= 3 characters, or drives being 1 character.
*/

#ifdef _WIN32
void CPath::GetComponents(std::string * pDrive, std::string * pDirectory, std::string * pName, std::string * pExtension) const
{
    WriteTrace(TracePath, TraceDebug, "Start (m_strPath: \"%s\")", m_strPath.c_str());

    char buff_drive[_MAX_DRIVE + 1] = {0};
    char buff_dir[_MAX_DIR + 1] = {0};
    char buff_name[_MAX_FNAME + 1] = {0};
    char buff_ext[_MAX_EXT + 1] = {0};

    const char * BasePath = m_strPath.c_str();
    const char * DriveDir = strrchr(BasePath, DRIVE_DELIMITER);
    if (DriveDir != nullptr)
    {
        size_t len = sizeof(buff_dir) < (DriveDir - BasePath) ? sizeof(buff_drive) : DriveDir - BasePath;
        strncpy(buff_drive, BasePath, len);
        BasePath += len + 1;
    }

    const char * last = strrchr(BasePath, DIRECTORY_DELIMITER);
    if (last != nullptr)
    {
        size_t len = sizeof(buff_dir) < (last - BasePath) ? sizeof(buff_dir) : last - BasePath;
        if (len > 0)
        {
            strncpy(buff_dir, BasePath, len);
        }
        else
        {
            buff_dir[0] = DIRECTORY_DELIMITER;
            buff_dir[1] = '\0';
        }
        strncpy(buff_name, last + 1, sizeof(buff_name));
    }
    else
    {
        strncpy(buff_dir, BasePath, sizeof(buff_dir));
    }
    char * ext = strrchr(buff_name, '.');
    if (ext != nullptr)
    {
        strncpy(buff_ext, ext + 1, sizeof(buff_ext));
        *ext = '\0';
    }

    if (pDrive)
    {
        *pDrive = buff_drive;
    }
    if (pDirectory)
    {
        *pDirectory = buff_dir;
    }
    if (pName)
    {
        *pName = buff_name;
    }
    if (pExtension)
    {
        *pExtension = buff_ext;
    }
    WriteTrace(TracePath, TraceDebug, "Done (dir: \"%s\" name: \"%s\" ext: \"%s\")", buff_dir, buff_name, buff_ext);
}
#else
void CPath::GetComponents(std::string * pDirectory, std::string * pName, std::string * pExtension) const
{
    WriteTrace(TracePath, TraceDebug, "Start (m_strPath: \"%s\")", m_strPath.c_str());

    char buff_dir[260];
    char buff_name[260];
    char buff_ext[260];

    memset(buff_dir, 0, sizeof(buff_dir));
    memset(buff_name, 0, sizeof(buff_name));
    memset(buff_ext, 0, sizeof(buff_ext));

    const char * BasePath = m_strPath.c_str();
    const char * last = strrchr(BasePath, DIRECTORY_DELIMITER);
    if (last != nullptr)
    {
        int len = sizeof(buff_dir) < (last - BasePath) ? sizeof(buff_dir) : last - BasePath;
        if (len > 0)
        {
            strncpy(buff_dir, BasePath, len);
        }
        else
        {
            buff_dir[0] = DIRECTORY_DELIMITER;
            buff_dir[1] = '\0';
        }
        strncpy(buff_name, last + 1, sizeof(buff_name));
    }
    else
    {
        strncpy(buff_dir, BasePath, sizeof(buff_dir));
    }
    char * ext = strrchr(buff_name, '.');
    if (ext != nullptr)
    {
        strncpy(buff_ext, ext + 1, sizeof(buff_ext));
        *ext = '\0';
    }

    if (pDirectory)
    {
        *pDirectory = buff_dir;
    }
    if (pName)
    {
        *pName = buff_name;
    }
    if (pExtension)
    {
        *pExtension = buff_ext;
    }
    WriteTrace(TracePath, TraceDebug, "Done (dir: \"%s\" name: \"%s\" ext: \"%s\")", buff_dir, buff_name, buff_ext);
}
#endif

// Task: Get drive and directory from path

#ifdef _WIN32
void CPath::GetDriveDirectory(std::string & rDriveDirectory) const
{
    std::string Drive;
    std::string Directory;

    GetComponents(&Drive, &Directory);
    rDriveDirectory = Drive;
    if (!Drive.empty())
    {
        rDriveDirectory += DRIVE_DELIMITER;
    }
    rDriveDirectory += Directory;
}

std::string CPath::GetDriveDirectory(void) const
{
    std::string rDriveDirectory;
    GetDriveDirectory(rDriveDirectory);
    return rDriveDirectory;
}
#endif

// Task: Get directory from path

void CPath::GetDirectory(std::string & rDirectory) const
{
#ifdef _WIN32
    GetComponents(nullptr, &rDirectory);
#else
    GetComponents(&rDirectory);
#endif
}

std::string CPath::GetDirectory(void) const
{
    std::string rDirectory;
    GetDirectory(rDirectory);
    return rDirectory;
}

// Task: Get filename and extension from path

void CPath::GetNameExtension(std::string & rNameExtension) const
{
    std::string Name;
    std::string Extension;

#ifdef _WIN32
    GetComponents(nullptr, nullptr, &Name, &Extension);
#else
    GetComponents(nullptr, &Name, &Extension);
#endif
    rNameExtension = Name;
    if (!Extension.empty())
    {
        rNameExtension += EXTENSION_DELIMITER;
        rNameExtension += Extension;
    }
}

std::string CPath::GetNameExtension(void) const
{
    std::string rNameExtension;
    GetNameExtension(rNameExtension);
    return rNameExtension;
}

// Task: Get filename from path

void CPath::GetName(std::string & rName) const
{
#ifdef _WIN32
    GetComponents(nullptr, nullptr, &rName);
#else
    GetComponents(nullptr, &rName);
#endif
}

std::string CPath::GetName(void) const
{
    std::string rName;
    GetName(rName);
    return rName;
}

// Task: Get file extension from path

void CPath::GetExtension(std::string & rExtension) const
{
#ifdef _WIN32
    GetComponents(nullptr, nullptr, nullptr, &rExtension);
#else
    GetComponents(nullptr, nullptr, &rExtension);
#endif
}

std::string CPath::GetExtension(void) const
{
    std::string rExtension;
    GetExtension(rExtension);
    return rExtension;
}

// Task: Get current directory

void CPath::GetLastDirectory(std::string & rDirectory) const
{
    std::string Directory;

    rDirectory = "";

    GetDirectory(Directory);
    StripTrailingBackslash(Directory);
    if (Directory.empty())
    {
        return;
    }

    std::string::size_type nDelimiter = Directory.rfind(DIRECTORY_DELIMITER);
    rDirectory = Directory.substr(nDelimiter);
    StripLeadingBackslash(rDirectory);
}

std::string CPath::GetLastDirectory(void) const
{
    std::string rDirecotry;
    GetLastDirectory(rDirecotry);
    return rDirecotry;
}

// Task: Get fully qualified path

void CPath::GetFullyQualified(std::string & rFullyQualified) const
{
#ifdef _WIN32
    char buff_fullname[MAX_PATH];

    memset(buff_fullname, 0, sizeof(buff_fullname));

    _fullpath(buff_fullname, m_strPath.c_str(), MAX_PATH - 1);
    rFullyQualified = buff_fullname;
#endif
}

// Post: Return TRUE if path does not start from filesystem root
// Task: Check if path is a relative one (e.g. doesn't start with C:\...)

bool CPath::IsRelative() const
{
#ifdef _WIN32
    if (m_strPath.length() > 1 && m_strPath[1] == DRIVE_DELIMITER)
    {
        return false;
    }
    if (m_strPath.length() > 2 && m_strPath[0] == DIRECTORY_DELIMITER && m_strPath[1] == DIRECTORY_DELIMITER)
    {
        return false;
    }
#else
    if (m_strPath.length() > 1 && m_strPath[0] == DIRECTORY_DELIMITER)
    {
        return false;
    }
#endif
    return true;
}

// Task: Set path components

#ifdef _WIN32
void CPath::SetComponents(const char * lpszDrive, const char * lpszDirectory, const char * lpszName, const char * lpszExtension)
{
    char buff_fullname[MAX_PATH];

    memset(buff_fullname, 0, sizeof(buff_fullname));
    if (lpszDirectory == nullptr || strlen(lpszDirectory) == 0)
    {
        static char empty_dir[] = {DIRECTORY_DELIMITER, '\0'};
        lpszDirectory = empty_dir;
    }

    _makepath(buff_fullname, lpszDrive, lpszDirectory, lpszName, lpszExtension);
    m_strPath.erase();
    m_strPath = buff_fullname;
}
#else
void CPath::SetComponents(const char * lpszDirectory, const char * lpszName, const char * lpszExtension)
{
    char buff_fullname[260];

    memset(buff_fullname, 0, sizeof(buff_fullname));
    if (lpszDirectory != nullptr && lpszDirectory[0] != '\0')
    {
        if (lpszDirectory[0] != DIRECTORY_DELIMITER)
        {
            buff_fullname[0] = DIRECTORY_DELIMITER;
        }
        strncat(buff_fullname, lpszDirectory, sizeof(buff_fullname) - 1);
        std::string::size_type nLength = strlen(buff_fullname);
        if (buff_fullname[nLength - 1] != DIRECTORY_DELIMITER && nLength < sizeof(buff_fullname))
        {
            buff_fullname[nLength] = DIRECTORY_DELIMITER;
        }
    }
    if (lpszName != nullptr)
    {
        strncat(buff_fullname, lpszName, sizeof(buff_fullname) - 1);
    }
    if (lpszExtension != nullptr && lpszExtension[0] != '\0')
    {
        if (lpszExtension[0] != '.')
        {
            strncat(buff_fullname, ".", sizeof(buff_fullname) - 1);
        }
        strncat(buff_fullname, lpszExtension, sizeof(buff_fullname) - 1);
    }
    buff_fullname[sizeof(buff_fullname) - 1] = 0; // Make sure it is null terminated
    m_strPath.erase();
    m_strPath = buff_fullname;
}
#endif

// Task: Set path's drive

#ifdef _WIN32
void CPath::SetDrive(char chDrive)
{
    stdstr_f Drive("%c", chDrive);
    std::string Directory;
    std::string Name;
    std::string Extension;

    GetComponents(nullptr, &Directory, &Name, &Extension);
    SetComponents(Drive.c_str(), Directory.c_str(), Name.c_str(), Extension.c_str());
}
#endif

// Task: Set path's directory

void CPath::SetDirectory(const char * lpszDirectory, bool bEnsureAbsolute /*= false*/)
{
    WriteTrace(TracePath, TraceDebug, "Start (lpszDirectory: \"%s\" bEnsureAbsolute: %s)", lpszDirectory ? lpszDirectory : "(null)", bEnsureAbsolute ? "true" : "false");
    std::string Directory = lpszDirectory;
    std::string Name;
    std::string Extension;

    if (bEnsureAbsolute)
    {
        EnsureLeadingBackslash(Directory);
    }
    if (Directory.length() > 0)
    {
        EnsureTrailingBackslash(Directory);
    }

#ifdef _WIN32
    std::string Drive;
    GetComponents(&Drive, nullptr, &Name, &Extension);
    SetComponents(Drive.c_str(), Directory.c_str(), Name.c_str(), Extension.c_str());
#else
    GetComponents(nullptr, &Name, &Extension);
    SetComponents(Directory.c_str(), Name.c_str(), Extension.c_str());
#endif
    WriteTrace(TracePath, TraceDebug, "Done (m_strPath: \"%s\")", m_strPath.c_str());
}

#ifdef _WIN32

// Task: Set path's drive and directory

void CPath::SetDriveDirectory(const char * lpszDriveDirectory)
{
    std::string DriveDirectory = lpszDriveDirectory;
    std::string Name;
    std::string Extension;

    if (DriveDirectory.length() > 0)
    {
        EnsureTrailingBackslash(DriveDirectory);
        cleanPathString(DriveDirectory);
    }

    GetComponents(nullptr, nullptr, &Name, &Extension);
    SetComponents(nullptr, DriveDirectory.c_str(), Name.c_str(), Extension.c_str());
}
#endif

// Task: Set path's filename

void CPath::SetName(const char * lpszName)
{
    std::string Directory;
    std::string Extension;

#ifdef _WIN32
    std::string Drive;
    GetComponents(&Drive, &Directory, nullptr, &Extension);
    SetComponents(Drive.c_str(), Directory.c_str(), lpszName, Extension.c_str());
#else
    GetComponents(&Directory, nullptr, &Extension);
    SetComponents(Directory.c_str(), lpszName, Extension.c_str());
#endif
}

// Task: Set path's filename

void CPath::SetName(int iName)
{
    std::string Directory;
    std::string Extension;
    char sName[33];

    memset(sName, 0, sizeof(sName));

    _snprintf(sName, sizeof(sName), "%d", iName);

#ifdef _WIN32
    std::string Drive;
    GetComponents(&Drive, &Directory, nullptr, &Extension);
    SetComponents(Drive.c_str(), Directory.c_str(), sName, Extension.c_str());
#else
    GetComponents(&Directory, nullptr, &Extension);
    SetComponents(Directory.c_str(), sName, Extension.c_str());
#endif
}

// Task: Set path's file extension

void CPath::SetExtension(const char * lpszExtension)
{
    std::string Directory;
    std::string Name;

#ifdef _WIN32
    std::string Drive;
    GetComponents(&Drive, &Directory, &Name);
    SetComponents(Drive.c_str(), Directory.c_str(), Name.c_str(), lpszExtension);
#else
    GetComponents(&Directory, &Name);
    SetComponents(Directory.c_str(), Name.c_str(), lpszExtension);
#endif
}

// Task: Set path's file extension

void CPath::SetExtension(int iExtension)
{
    std::string Directory;
    std::string Name;
    char sExtension[20];

    memset(sExtension, 0, sizeof(sExtension));

    _snprintf(sExtension, sizeof(sExtension), "%d", iExtension);

#ifdef _WIN32
    std::string Drive;
    GetComponents(&Drive, &Directory, &Name);
    SetComponents(Drive.c_str(), Directory.c_str(), Name.c_str(), sExtension);
#else
    GetComponents(&Directory, &Name);
    SetComponents(Directory.c_str(), Name.c_str(), sExtension);
#endif
}

// Task: Set path's filename and extension

void CPath::SetNameExtension(const char * lpszNameExtension)
{
    std::string Directory;

#ifdef _WIN32
    std::string Drive;
    GetComponents(&Drive, &Directory);
    SetComponents(Drive.c_str(), Directory.c_str(), lpszNameExtension, nullptr);
#else
    GetComponents(&Directory);
    SetComponents(Directory.c_str(), lpszNameExtension, nullptr);
#endif
}

// Task: Append a subdirectory to path's directory

void CPath::AppendDirectory(const char * lpszSubDirectory)
{
    std::string Directory;
    std::string SubDirectory = lpszSubDirectory;
    std::string Name;
    std::string Extension;

    if (SubDirectory.empty())
    {
        return;
    }

    // Strip out any preceding backslash
    StripLeadingBackslash(SubDirectory);
    EnsureTrailingBackslash(SubDirectory);

#ifdef _WIN32
    std::string Drive;
    GetComponents(&Drive, &Directory, &Name, &Extension);
#else
    GetComponents(&Directory, &Name, &Extension);
#endif
    EnsureTrailingBackslash(Directory);
    Directory += SubDirectory;

#ifdef _WIN32
    SetComponents(Drive.c_str(), Directory.c_str(), Name.c_str(), Extension.c_str());
#else
    SetComponents(Directory.c_str(), Name.c_str(), Extension.c_str());
#endif
}

/*
Pre: If pLastDirectory is given we will store the name of the
deepest directory (the one we're exiting) in it
Task: Remove deepest subdirectory from path
*/

void CPath::UpDirectory(std::string * pLastDirectory /*= nullptr*/)
{
    std::string Directory;

    GetDirectory(Directory);
    StripTrailingBackslash(Directory);
    if (Directory.empty())
        return;

    std::string::size_type nDelimiter = Directory.rfind(DIRECTORY_DELIMITER);

    if (pLastDirectory != nullptr)
    {
        *pLastDirectory = Directory.substr(nDelimiter);
        StripLeadingBackslash(*pLastDirectory);
    }

    if (nDelimiter != std::string::npos)
    {
        Directory = Directory.substr(0, nDelimiter);
    }

    SetDirectory(Directory.c_str());
}

// Task: Set path to current directory

void CPath::CurrentDirectory()
{
    char buff_path[260];
    memset(buff_path, 0, sizeof(buff_path));

    Empty();

#ifdef _WIN32
    ::GetCurrentDirectoryA(sizeof(buff_path), buff_path);
    SetDriveDirectory(buff_path);
#else
    getcwd(buff_path, sizeof(buff_path));
    SetDirectory(buff_path);
#endif
}

// Task: Set path to the name of specified module

#ifdef _WIN32
void CPath::Module(void * hInstance)
{
    char buff_path[MAX_PATH];

    memset(buff_path, 0, sizeof(buff_path));

    GetModuleFileNameA((HINSTANCE)hInstance, buff_path, MAX_PATH);
    m_strPath = buff_path;
}

// Task: Set path to the name of current module

void CPath::Module()
{
    Module(m_hInst);
}

// Task: Set path to the directory of specified module

void CPath::ModuleDirectory(void * hInstance)
{
    Module(hInstance);
    SetNameExtension("");
}

// Task: Set path to the directory of current module

void CPath::ModuleDirectory()
{
    Module();
    SetNameExtension("");
}
#endif

// Post: Return TRUE if it is a directory
// Task: Check if this path represents a directory

bool CPath::IsDirectory() const
{
    // Check if this path has a filename
    std::string file_name;
    GetNameExtension(file_name);

    return file_name.empty();
}

/*
Post: Return TRUE if directory exists
Task: To determine if the directory exists, we need to
create a test path with a wildcard (*.*) extension
and see if FindFirstFile returns anything.  We don't
use CPath::FindFirst() because that routine parses out
'.' and '..', which fails for empty directories.
*/

bool CPath::DirectoryExists() const
{
    WriteTrace(TracePath, TraceDebug, "m_strPath = %s", m_strPath.c_str());
#ifdef _WIN32
    // Create test path
    CPath TestPath(m_strPath.c_str());

    std::string DirName;
    TestPath.UpDirectory(&DirName);
    TestPath.SetNameExtension(DirName.c_str());

    WIN32_FIND_DATAA FindData;
    HANDLE hFindFile = FindFirstFileA((const char *)TestPath, &FindData); // Find anything
    bool res = (hFindFile != INVALID_HANDLE_VALUE);

    if (hFindFile != nullptr) // Make sure we close the search
    {
        FindClose(hFindFile);
    }

#else
    std::string PathText;
    GetDirectory(PathText);
    StripTrailingBackslash(PathText);
    WriteTrace(TracePath, TraceDebug, "Checking if directory \"%s\" exists", PathText.c_str());

    struct stat fileinfo;
    bool res = stat(PathText.c_str(), &fileinfo) == 0 && S_ISDIR(fileinfo.st_mode);
#endif
    WriteTrace(TracePath, TraceDebug, "Exist = %s", res ? "True" : "False");
    return res;
}

// Post: Return TRUE if these is such a file
// Task: Check if file exists

bool CPath::Exists() const
{
#ifdef _WIN32
    WIN32_FIND_DATAA FindData;
    HANDLE hFindFile = FindFirstFileA(m_strPath.c_str(), &FindData);
    bool bSuccess = (hFindFile != INVALID_HANDLE_VALUE);

    if (hFindFile != nullptr) // Make sure we close the search
    {
        FindClose(hFindFile);
    }

    return bSuccess;
#else
    struct stat statbuf;
    return stat(m_strPath.c_str(), &statbuf) == 0;
#endif
}

#ifdef _WIN32
bool CPath::SelectFile(void * hwndOwner, const char * InitialDir, const char * FileFilter, bool FileMustExist)
{
    CPath CurrentDir(CURRENT_DIRECTORY);

    OPENFILENAMEA openfilename;
    char FileName[MAX_PATH];
    memset(&FileName, 0, sizeof(FileName));
    memset(&openfilename, 0, sizeof(openfilename));

    openfilename.lStructSize = sizeof(openfilename);
    openfilename.hwndOwner = (HWND)hwndOwner;
    openfilename.lpstrFilter = FileFilter;
    openfilename.lpstrFile = FileName;
    openfilename.lpstrInitialDir = InitialDir;
    openfilename.nMaxFile = MAX_PATH;
    openfilename.Flags = OFN_HIDEREADONLY | (FileMustExist ? OFN_FILEMUSTEXIST : 0);

    bool res = GetOpenFileNameA(&openfilename) != 0;
    if (CPath(CURRENT_DIRECTORY) != CurrentDir)
    {
        CurrentDir.ChangeDirectory();
    }
    if (!res)
    {
        return false;
    }
    m_strPath = FileName;
    cleanPathString(m_strPath);
    return true;
}
#endif

// Post: Return TRUE on success
// Task: Delete file

bool CPath::Delete(bool bEvenIfReadOnly) const
{
#ifdef _WIN32
    uint32_t dwAttr = ::GetFileAttributesA(m_strPath.c_str());
    if (dwAttr == (uint32_t)-1)
    {
        // File does not exist
        return false;
    }

    if (((dwAttr & FILE_ATTRIBUTE_READONLY) == FILE_ATTRIBUTE_READONLY) && !bEvenIfReadOnly)
    {
        // File is read-only, and we're not allowed to delete it
        return false;
    }

    SetFileAttributesA(m_strPath.c_str(), FILE_ATTRIBUTE_NORMAL);
    return DeleteFileA(m_strPath.c_str()) != 0;
#else
    return unlink(m_strPath.c_str()) == 0;
#endif
}

/*
Post: Return TRUE on success, false if there is such a target file
and we weren't granted permission to overwrite file or if we get an error.
Task: Copy file
Since ::CopyFile will not overwrite read-only files
we will make sure the target file is writable first.
*/

bool CPath::CopyTo(const char * lpcszTargetFile, bool bOverwrite)
{
    if (lpcszTargetFile == nullptr)
    {
        return false;
    }
    WriteTrace(TracePath, TraceDebug, "Copy \"%s\" to \"%s\"", m_strPath.c_str(), lpcszTargetFile);
#ifdef _WIN32
    // Check if the target file exists
    CPath TargetFile(lpcszTargetFile);
    if (TargetFile.Exists())
    {
        // Yeah there is already such a target file
        // Decide if we should overwrite
        if (!bOverwrite)
        {
            return false;
        }

        // Delete any previous target
        if (!TargetFile.Delete(true))
        {
            return false;
        }
    }

    // CopyFile will set the target's attributes to the same as
    // the source after copying
    return CopyFileA(m_strPath.c_str(), lpcszTargetFile, !bOverwrite) != 0;
#else

    bool res = true;
    WriteTrace(TracePath, TraceDebug, "Opening \"%s\" for reading", m_strPath.c_str());
    FILE * infile = fopen(m_strPath.c_str(), "rb");
    if (infile == nullptr)
    {
        WriteTrace(TracePath, TraceWarning, "Failed to open m_strPath = %s", m_strPath.c_str());
        res = false;
    }
    else
    {
        WriteTrace(TracePath, TraceDebug, "Opened \"%s\"", m_strPath.c_str());
    }

    FILE * outfile = nullptr;
    if (res)
    {
        WriteTrace(TracePath, TraceDebug, "Opening \"%s\" for writing", lpcszTargetFile);
        outfile = fopen(lpcszTargetFile, "wb");
        if (outfile == nullptr)
        {
            WriteTrace(TracePath, TraceWarning, "Failed to open m_strPath = %s errno=%d", lpcszTargetFile, errno);
            res = false;
        }
        else
        {
            WriteTrace(TracePath, TraceDebug, "Opened \"%s\"", lpcszTargetFile);
        }
    }

    if (res)
    {
        WriteTrace(TracePath, TraceDebug, "Copying data");
        while (!feof(infile))
        {
            char buffer[1024];
            size_t bytes = fread(buffer, 1, sizeof(buffer), infile);
            if (ferror(infile))
            {
                WriteTrace(TracePath, TraceWarning, "Failed to read from %s", m_strPath.c_str());
                res = false;
                break;
            }
            if (!feof(infile))
            {
                size_t written = fwrite(buffer, 1, sizeof(buffer), outfile);
            }
            if (ferror(outfile))
            {
                WriteTrace(TracePath, TraceWarning, "Failed to write to %s, ferror(outfile) = %X", lpcszTargetFile, ferror(outfile));
                res = false;
                break;
            }
        }
    }

    struct stat ts;
    if (res)
    {
        if (fstat(fileno(infile), &ts) != 0)
        {
            WriteTrace(TracePath, TraceWarning, "fstat failed on %s, ferror(infile) = %X", m_strPath.c_str(), ferror(infile));
            res = false;
        }
    }
    if (res)
    {
        if (fchmod(fileno(outfile), ts.st_mode) != 0)
        {
            WriteTrace(TracePath, TraceWarning, "fchmod failed on %s, errno = %X", lpcszTargetFile, errno);
            res = false;
        }
    }
    if (infile != nullptr)
    {
        fclose(infile);
    }
    if (outfile != nullptr)
    {
        fclose(outfile);
    }
    WriteTrace(TracePath, TraceDebug, "Done, res: %s", res ? "true" : "false");
    return res;
#endif
}

// Post: Return TRUE on success, false if there is such a target file
// and we weren't granted permission to overwrite file or get an error.
// Task: Move file

bool CPath::MoveTo(const char * lpcszTargetFile, bool bOverwrite)
{
#ifdef _WIN32
    // Check if the target file exists
    CPath TargetFile(lpcszTargetFile);
    if (TargetFile.Exists())
    {
        // Yeah there is already such a target file
        // Decide if we should overwrite
        if (!bOverwrite)
        {
            return false;
        }

        // Delete any previous target
        if (!TargetFile.Delete(TRUE))
        {
            return false;
        }
    }

    return MoveFileA(m_strPath.c_str(), lpcszTargetFile) != 0;
#else
    return false;
#endif
}

// Post: Return TRUE if attributes match
// Task: Compare finder attributes

bool CPath::AttributesMatch(uint32_t dwTargetAttributes, uint32_t dwFileAttributes)
{
    if (dwTargetAttributes == FIND_ATTRIBUTE_ALLFILES)
    {
        return true;
    }
    if (dwTargetAttributes == FIND_ATTRIBUTE_FILES)
    {
        return ((FIND_ATTRIBUTE_SUBDIR & dwFileAttributes) == 0);
    }
    return (((dwTargetAttributes & dwFileAttributes) != 0) && ((FIND_ATTRIBUTE_SUBDIR & dwTargetAttributes) == (FIND_ATTRIBUTE_SUBDIR & dwFileAttributes)));
}

/*
Post: Return TRUE if any match found
Task: Find the first file that meets this path and the specified attributes
You can specify the current attributes of the file or directory
The attributes are represented by a combination (|) of the following
constants:
_A_ARCH - Archive. Set whenever the file is changed, and cleared by the BACKUP command.
_A_HIDDEN - Hidden file. Not normally seen with the DIR command, unless the /AH option is used.
Returns information about normal files as well as files with this attribute:
FIND_ATTRIBUTE_FILES - Normal. File can be read or written to without restriction.
_A_RDONLY - Read-only. File cannot be opened for writing, and a file with the same name cannot be created.
FIND_ATTRIBUTE_SUBDIR - Subdirectory
_A_SYSTEM - System file. Not normally seen with the DIR command, unless the /AS option is used.

These attributes do not follow a simple additive logic.
Note that FIND_ATTRIBUTE_FILES is 0x00, so it effectively cannot be
removed from the attribute set. You will therefore always
get normal files, and may also get Archive, Hidden, etc.
if you specify those attributes.
See also: FindFirstFile, FindNextFile
*/

bool CPath::FindFirst(uint32_t dwAttributes /*= FIND_ATTRIBUTE_FILES*/)
{
    // Close handle to any previous enumeration
    Exit();

    m_dwFindFileAttributes = dwAttributes;
#ifdef _WIN32
    BOOL bGotFile;
    BOOL bWantSubdirectory = (BOOL)(FIND_ATTRIBUTE_SUBDIR & dwAttributes);

    // Finding first candidate file
    WIN32_FIND_DATAA FindData;
    m_hFindFile = FindFirstFileA(m_strPath.c_str(), &FindData);
    bGotFile = (m_hFindFile != INVALID_HANDLE_VALUE);

    while (bGotFile)
    {
        // Compare candidate to attributes, and filter out the "." and ".." folders
        if (!AttributesMatch(m_dwFindFileAttributes, FindData.dwFileAttributes))
            goto LABEL_GetAnother;
        if (bWantSubdirectory && (FindData.cFileName[0] == '.'))
            goto LABEL_GetAnother;

        // Found a match, prepare result
        if ((FIND_ATTRIBUTE_SUBDIR & FindData.dwFileAttributes) != 0)
            StripTrailingBackslash(m_strPath);

        SetNameExtension(FindData.cFileName);

        if ((FIND_ATTRIBUTE_SUBDIR & FindData.dwFileAttributes) != 0)
            EnsureTrailingBackslash(m_strPath);
        return TRUE;

        // Not found a match, get another
    LABEL_GetAnother:
        bGotFile = FindNextFileA(m_hFindFile, &FindData);
    }
#else
    std::string Directory, Name, Extension;
    GetComponents(&Directory, &Name, &Extension);

    m_FindWildcard = Name;
    if (!Extension.empty())
    {
        m_FindWildcard += EXTENSION_DELIMITER;
        m_FindWildcard += Extension;
    }

    m_OpenedDir = opendir(Directory.c_str());
    if (m_OpenedDir == nullptr) return false;
    return FindNext();
#endif
    return false;
}

// Post: Return TRUE if a new match found
// Task: Find the next file that meets the conditions specified in the last FindFirst call

bool CPath::FindNext()
{
#ifdef _WIN32
    if (m_hFindFile == nullptr)
    {
        return false;
    }

    WIN32_FIND_DATAA FindData;
    while (FindNextFileA(m_hFindFile, &FindData) != false)
    { // while(FindNext(...))
        if (AttributesMatch(m_dwFindFileAttributes, FindData.dwFileAttributes))
        { // if(AttributesMatch(...)
            if ((_A_SUBDIR & FindData.dwFileAttributes) == _A_SUBDIR)
            {
                if (IsDirectory())
                {
                    // Found a directory
                    UpDirectory();
                }
                else
                {
                    SetNameExtension("");
                }
                AppendDirectory(FindData.cFileName);
            }
            else
            {
                // Found a file
                if (IsDirectory())
                {
                    // Found a directory
                    UpDirectory();
                }
                SetNameExtension(FindData.cFileName);
            }
            if ((_A_SUBDIR & FindData.dwFileAttributes) == _A_SUBDIR)
            {
                EnsureTrailingBackslash(m_strPath);
            }
            return TRUE;
        }
    }
#else
    dirent * pEntry;
    while ((pEntry = readdir((DIR *)m_OpenedDir)))
    {
        uint32_t dwFileAttributes = pEntry->d_type == DT_DIR ? FIND_ATTRIBUTE_SUBDIR : FIND_ATTRIBUTE_FILES;

        WriteTrace(TracePath, TraceVerbose, "m_dwFindFileAttributes = %X dwFileAttributes = %X AttributesMatch: %s", m_dwFindFileAttributes, dwFileAttributes, AttributesMatch(m_dwFindFileAttributes, dwFileAttributes) ? "true" : "false");

        // Compare candidate to attributes, and filter out the "." and ".." folders
        if (!AttributesMatch(m_dwFindFileAttributes, dwFileAttributes) ||
            strcmp(pEntry->d_name, ".") == 0 ||
            strcmp(pEntry->d_name, "..") == 0 ||
            !wildcmp(m_FindWildcard.c_str(), pEntry->d_name))
        {
            WriteTrace(TracePath, TraceVerbose, "Continue, d_name = %s", pEntry->d_name);
            continue;
        }
        if ((FIND_ATTRIBUTE_SUBDIR & dwFileAttributes) == FIND_ATTRIBUTE_SUBDIR)
        {
            WriteTrace(TracePath, TraceVerbose, "is a directory");
            if (IsDirectory())
            {
                // Found a directory
                UpDirectory();
            }
            else
            {
                SetNameExtension("");
            }
            AppendDirectory(pEntry->d_name);
        }
        else
        {
            WriteTrace(TracePath, TraceVerbose, "is a file");
            // Found a file
            if (IsDirectory())
            {
                // Found a directory
                UpDirectory();
            }
            SetNameExtension(pEntry->d_name);
            WriteTrace(TracePath, TraceVerbose, "m_strPath: %s pEntry->d_name: %s", m_strPath.c_str(), pEntry->d_name);
        }
        if ((FIND_ATTRIBUTE_SUBDIR & dwFileAttributes) == FIND_ATTRIBUTE_SUBDIR)
        {
            EnsureTrailingBackslash(m_strPath);
        }
        return true;
    }
#endif
    return false;
}

// Post: Return TRUE on success
// Task: Change current working directory of application to path

bool CPath::ChangeDirectory()
{
#ifdef _WIN32
    std::string DriveDirectory;
    GetDriveDirectory(DriveDirectory);

    return SetCurrentDirectoryA(DriveDirectory.c_str()) != 0;
#else
    std::string Dir;
    GetDirectory(Dir);

    return chdir(Dir.c_str()) == 0;
#endif
}

void CPath::NormalizePath(CPath BaseDir)
{
#ifdef _WIN32
    stdstr Directory = BaseDir.GetDriveDirectory();
#else
    stdstr Directory = BaseDir.GetDirectory();
#endif
    bool Changed = false;
    if (IsRelative())
    {
        EnsureTrailingBackslash(Directory);
        Directory += GetDirectory();
        Changed = true;
    }
    strvector Parts = Directory.Tokenize(DIRECTORY_DELIMITER);
    strvector NormalizesParts;
    for (strvector::const_iterator itr = Parts.begin(); itr != Parts.end(); itr++)
    {
        if (*itr == ".")
        {
            Changed = true;
        }
        else if (*itr == "..")
        {
            NormalizesParts.pop_back();
            Changed = true;
        }
        else
        {
            NormalizesParts.push_back(*itr);
        }
    }
    if (Changed)
    {
        Directory.clear();
        for (strvector::const_iterator itr = NormalizesParts.begin(); itr != NormalizesParts.end(); itr++)
        {
            Directory += *itr + DIRECTORY_DELIMITER;
        }
#ifdef _WIN32
        SetDriveDirectory(Directory.c_str());
#else
        SetDirectory(Directory.c_str());
#endif
    }
}

// Pre: If bCreateIntermediates is TRUE, create all eventually missing parent directories too
// Post: Return TRUE on success
// Task: Create new directory

bool CPath::DirectoryCreate(bool bCreateIntermediates /*= TRUE*/)
{
    WriteTrace(TracePath, TraceDebug, "m_strPath = %s bCreateIntermediates = %s", m_strPath.c_str(), bCreateIntermediates ? "true" : "false");
    std::string PathText;
    bool bSuccess;

    if (DirectoryExists())
    {
        WriteTrace(TracePath, TraceDebug, "Directory already exists, res = true");
        return true;
    }

#ifdef _WIN32
    GetDriveDirectory(PathText);
    StripTrailingBackslash(PathText);
    WriteTrace(TracePath, TraceDebug, "Create %s", PathText.c_str());
    bSuccess = ::CreateDirectoryA(PathText.c_str(), nullptr) != 0;
#else
    GetDirectory(PathText);
    StripTrailingBackslash(PathText);
    WriteTrace(TracePath, TraceDebug, "Create %s", PathText.c_str());
    bSuccess = mkdir(PathText.c_str(), S_IRWXU) == 0;
    if (!bSuccess)
    {
        WriteTrace(TracePath, TraceWarning, "Failed to create \"%s\" errno: %d", PathText.c_str(), errno);
    }
#endif
    if (!bSuccess && bCreateIntermediates)
    {
        WriteTrace(TracePath, TraceDebug, "Failed creating intermediates");
        std::string::size_type nDelimiter = PathText.rfind(DIRECTORY_DELIMITER);
        if (nDelimiter == std::string::npos)
        {
            return false;
        }

        PathText.resize(nDelimiter + 1);
        CPath SubPath(PathText);

        return SubPath.DirectoryCreate() ? DirectoryCreate(false) : false;
    }
    WriteTrace(TracePath, TraceDebug, "res = %s", bSuccess ? "true" : "false");
    return bSuccess;
}

// Helpers

// Task: Remove first character (if any) if it's chLeading

void CPath::cleanPathString(std::string & rDirectory) const
{
    std::string::size_type pos = rDirectory.find(DIRECTORY_DELIMITER2);
    while (pos != std::string::npos)
    {
        rDirectory.replace(pos, 1, &DIRECTORY_DELIMITER);
        pos = rDirectory.find(DIRECTORY_DELIMITER2, pos + 1);
    }

    bool AppendEnd = !_strnicmp(rDirectory.c_str(), DIR_DOUBLEDELIM, 2);
    pos = rDirectory.find(DIR_DOUBLEDELIM);
    while (pos != std::string::npos)
    {
        rDirectory.replace(pos, 2, &DIRECTORY_DELIMITER);
        pos = rDirectory.find(DIR_DOUBLEDELIM, pos + 1);
    }
    if (AppendEnd)
    {
        rDirectory.insert(0, stdstr_f("%c", DIRECTORY_DELIMITER).c_str());
    }
}

void CPath::StripLeadingChar(std::string & rText, char chLeading) const
{
    std::string::size_type nLength = rText.length();
    if (nLength == 0)
        return;

    if (rText[0] == chLeading)
        rText = rText.substr(1);
}

// Task: Remove first character if '\'

void CPath::StripLeadingBackslash(std::string & Directory) const
{
    std::string::size_type nLength = Directory.length();

    // If directory is of the form '\', don't do it
    if (nLength <= 1)
        return;

    if (Directory[0] == DIRECTORY_DELIMITER)
        Directory = Directory.substr(1);
}

// Task: Remove last character (if any) if it's chTrailing

void CPath::StripTrailingChar(std::string & rText, char chTrailing) const
{
    std::string::size_type nLength = rText.length();
    if (nLength == 0)
        return;

    if (rText[nLength - 1] == chTrailing)
        rText.resize(nLength - 1);
}

// Task: Remove last character if '\'

void CPath::StripTrailingBackslash(std::string & rDirectory) const
{
    for (;;)
    {
        std::string::size_type nLength = rDirectory.length();
        if (nLength <= 1)
        {
            return;
        }

        if (rDirectory[nLength - 1] == DIRECTORY_DELIMITER || rDirectory[nLength - 1] == DIRECTORY_DELIMITER2)
        {
            rDirectory.resize(nLength - 1);
            continue;
        }
        return;
    }
}

// Task: Add a backslash to the end of the directory if there is not already one there

void CPath::EnsureTrailingBackslash(std::string & Directory) const
{
    std::string::size_type nLength = Directory.length();

    if (Directory.empty() || (Directory[nLength - 1] != DIRECTORY_DELIMITER))
    {
        Directory += DIRECTORY_DELIMITER;
    }
}

// Task: Add a backslash to the beginning of the directory if there is not already one there

void CPath::EnsureLeadingBackslash(std::string & Directory) const
{
    if (Directory.empty() || (Directory[0] != DIRECTORY_DELIMITER))
    {
        Directory = stdstr_f("%c%s", DIRECTORY_DELIMITER, Directory.c_str());
    }
}

#ifndef _WIN32
bool CPath::wildcmp(const char * wild, const char * string)
{
    const char *cp = nullptr, *mp = nullptr;

    while ((*string) && (*wild != '*'))
    {
        if ((*wild != *string) && (*wild != '?'))
        {
            return 0;
        }
        wild++;
        string++;
    }

    while (*string)
    {
        if (*wild == '*')
        {
            if (!*++wild)
            {
                return 1;
            }
            mp = wild;
            cp = string + 1;
        }
        else if ((*wild == *string) || (*wild == '?'))
        {
            wild++;
            string++;
        }
        else
        {
            wild = mp;
            string = cp++;
        }
    }

    while (*wild == '*')
    {
        wild++;
    }
    return !*wild;
}
#endif