/*
 * Copyright (c) 2014, 2019, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

#include "FilePath.h"

#include <algorithm>
#include <list>
#include <ShellAPI.h>

bool FilePath::FileExists(const TString FileName) {
    bool result = false;
    WIN32_FIND_DATA FindFileData;
    TString fileName = FixPathForPlatform(FileName);
    HANDLE handle = FindFirstFile(fileName.data(), &FindFileData);

    if (handle != INVALID_HANDLE_VALUE) {
        if (FILE_ATTRIBUTE_DIRECTORY & FindFileData.dwFileAttributes) {
            result = true;
        }
        else {
            result = true;
        }

        FindClose(handle);
    }
    return result;
}

bool FilePath::DirectoryExists(const TString DirectoryName) {
    bool result = false;
    WIN32_FIND_DATA FindFileData;
    TString directoryName = FixPathForPlatform(DirectoryName);
    HANDLE handle = FindFirstFile(directoryName.data(), &FindFileData);

    if (handle != INVALID_HANDLE_VALUE) {
        if (FILE_ATTRIBUTE_DIRECTORY & FindFileData.dwFileAttributes) {
            result = true;
        }

        FindClose(handle);
    }
    return result;
}

std::string GetLastErrorAsString() {
    // Get the error message, if any.
    DWORD errorMessageID = ::GetLastError();

    if (errorMessageID == 0) {
        return "No error message has been recorded";
    }

    LPSTR messageBuffer = NULL;
    size_t size = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER
            | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
            NULL, errorMessageID, MAKELANGID(LANG_NEUTRAL,
            SUBLANG_DEFAULT), (LPSTR)&messageBuffer, 0, NULL);

    std::string message(messageBuffer, size);

    // Free the buffer.
    LocalFree(messageBuffer);

    return message;
}

bool FilePath::DeleteFile(const TString FileName) {
    bool result = false;

    if (FileExists(FileName) == true) {
        TString lFileName = FixPathForPlatform(FileName);
        FileAttributes attributes(lFileName);

        if (attributes.Contains(faReadOnly) == true) {
            attributes.Remove(faReadOnly);
        }

        result = ::DeleteFile(lFileName.data()) == TRUE;
    }

    return result;
}

bool FilePath::DeleteDirectory(const TString DirectoryName) {
    bool result = false;

    if (DirectoryExists(DirectoryName) == true) {
        SHFILEOPSTRUCTW fos = {0};
        TString directoryName = FixPathForPlatform(DirectoryName);
        DynamicBuffer<TCHAR> lDirectoryName(directoryName.size() + 2);
        if (lDirectoryName.GetData() == NULL) {
            return false;
        }
        memcpy(lDirectoryName.GetData(), directoryName.data(),
                (directoryName.size() + 2) * sizeof(TCHAR));
        lDirectoryName[directoryName.size() + 1] = NULL;
        // Double null terminate for SHFileOperation.

        // Delete the folder and everything inside.
        fos.wFunc = FO_DELETE;
        fos.pFrom = lDirectoryName.GetData();
        fos.fFlags = FOF_NO_UI;
        result = SHFileOperation(&fos) == 0;
    }

    return result;
}

TString FilePath::IncludeTrailingSeparator(const TString value) {
    TString result = value;

    if (value.size() > 0) {
        TString::iterator i = result.end();
        i--;

        if (*i != TRAILING_PATHSEPARATOR) {
            result += TRAILING_PATHSEPARATOR;
        }
    }

    return result;
}

TString FilePath::IncludeTrailingSeparator(const char* value) {
    TString lvalue = PlatformString(value).toString();
    return IncludeTrailingSeparator(lvalue);
}

TString FilePath::IncludeTrailingSeparator(const wchar_t* value) {
    TString lvalue = PlatformString(value).toString();
    return IncludeTrailingSeparator(lvalue);
}

TString FilePath::ExtractFilePath(TString Path) {
    TString result;
    size_t slash = Path.find_last_of(TRAILING_PATHSEPARATOR);
    if (slash != TString::npos)
        result = Path.substr(0, slash);
    return result;
}

TString FilePath::ExtractFileExt(TString Path) {
    TString result;
    size_t dot = Path.find_last_of('.');

    if (dot != TString::npos) {
        result  = Path.substr(dot, Path.size() - dot);
    }

    return result;
}

TString FilePath::ExtractFileName(TString Path) {
    TString result;

    size_t slash = Path.find_last_of(TRAILING_PATHSEPARATOR);
    if (slash != TString::npos)
        result = Path.substr(slash + 1, Path.size() - slash - 1);

    return result;
}

TString FilePath::ChangeFileExt(TString Path, TString Extension) {
    TString result;
    size_t dot = Path.find_last_of('.');

    if (dot != TString::npos) {
        result = Path.substr(0, dot) + Extension;
    }

    if (result.empty() == true) {
        result = Path;
    }

    return result;
}

TString FilePath::FixPathForPlatform(TString Path) {
    TString result = Path;
    std::replace(result.begin(), result.end(),
            BAD_TRAILING_PATHSEPARATOR, TRAILING_PATHSEPARATOR);
    // The maximum path that does not require long path prefix. On Windows the
    // maximum path is 260 minus 1 (NUL) but for directories it is 260 minus
    // 12 minus 1 (to allow for the creation of a 8.3 file in the directory).
    const int maxPath = 247;
    if (result.length() > maxPath &&
        result.find(_T("\\\\?\\")) == TString::npos &&
        result.find(_T("\\\\?\\UNC")) == TString::npos) {
        const TString prefix(_T("\\\\"));
        if (!result.compare(0, prefix.size(), prefix)) {
            // UNC path, converting to UNC path in long notation
            result = _T("\\\\?\\UNC") + result.substr(1, result.length());
        } else {
            // converting to non-UNC path in long notation
            result = _T("\\\\?\\") + result;
        }
    }
    return result;
}

TString FilePath::FixPathSeparatorForPlatform(TString Path) {
    TString result = Path;
    std::replace(result.begin(), result.end(),
            BAD_PATH_SEPARATOR, PATH_SEPARATOR);
    return result;
}

TString FilePath::PathSeparator() {
    TString result;
    result = PATH_SEPARATOR;
    return result;
}

bool FilePath::CreateDirectory(TString Path, bool ownerOnly) {
    bool result = false;

    std::list<TString> paths;
    TString lpath = Path;

    while (lpath.empty() == false && DirectoryExists(lpath) == false) {
        paths.push_front(lpath);
        lpath = ExtractFilePath(lpath);
    }

    for (std::list<TString>::iterator iterator = paths.begin();
            iterator != paths.end(); iterator++) {
        lpath = *iterator;

        if (_wmkdir(lpath.data()) == 0) {
            result = true;
        } else {
            result = false;
            break;
        }
    }

    return result;
}

void FilePath::ChangePermissions(TString FileName, bool ownerOnly) {
}

#include <algorithm>

FileAttributes::FileAttributes(const TString FileName, bool FollowLink) {
    FFileName = FileName;
    FFollowLink = FollowLink;
    ReadAttributes();
}

bool FileAttributes::WriteAttributes() {
    bool result = false;

    DWORD attributes = 0;

    for (std::vector<FileAttribute>::const_iterator iterator =
            FAttributes.begin();
        iterator != FAttributes.end(); iterator++) {
        switch (*iterator) {
            case faArchive: {
                attributes = attributes & FILE_ATTRIBUTE_ARCHIVE;
                break;
            }
            case faCompressed: {
                attributes = attributes & FILE_ATTRIBUTE_COMPRESSED;
                break;
            }
            case faDevice: {
                attributes = attributes & FILE_ATTRIBUTE_DEVICE;
                break;
            }
            case faDirectory: {
                attributes = attributes & FILE_ATTRIBUTE_DIRECTORY;
                break;
            }
            case faEncrypted: {
                attributes = attributes & FILE_ATTRIBUTE_ENCRYPTED;
                break;
            }
            case faHidden: {
                attributes = attributes & FILE_ATTRIBUTE_HIDDEN;
                break;
            }
            case faNormal: {
                attributes = attributes & FILE_ATTRIBUTE_NORMAL;
                break;
            }
            case faNotContentIndexed: {
                attributes = attributes & FILE_ATTRIBUTE_NOT_CONTENT_INDEXED;
                break;
            }
            case faOffline: {
                attributes = attributes & FILE_ATTRIBUTE_OFFLINE;
                break;
            }
            case faSystem: {
                attributes = attributes & FILE_ATTRIBUTE_SYSTEM;
                break;
            }
            case faSymbolicLink: {
                attributes = attributes & FILE_ATTRIBUTE_REPARSE_POINT;
                break;
            }
            case faSparceFile: {
                attributes = attributes & FILE_ATTRIBUTE_SPARSE_FILE;
                break;
            }
            case faReadOnly: {
                attributes = attributes & FILE_ATTRIBUTE_READONLY;
                break;
            }
            case faTemporary: {
                attributes = attributes & FILE_ATTRIBUTE_TEMPORARY;
                break;
            }
            case faVirtual: {
                attributes = attributes & FILE_ATTRIBUTE_VIRTUAL;
                break;
            }
        }
    }

    if (::SetFileAttributes(FFileName.data(), attributes) != 0) {
        result = true;
    }

    return result;
}

#define S_ISRUSR(m)    (((m) & S_IRWXU) == S_IRUSR)
#define S_ISWUSR(m)    (((m) & S_IRWXU) == S_IWUSR)
#define S_ISXUSR(m)    (((m) & S_IRWXU) == S_IXUSR)

#define S_ISRGRP(m)    (((m) & S_IRWXG) == S_IRGRP)
#define S_ISWGRP(m)    (((m) & S_IRWXG) == S_IWGRP)
#define S_ISXGRP(m)    (((m) & S_IRWXG) == S_IXGRP)

#define S_ISROTH(m)    (((m) & S_IRWXO) == S_IROTH)
#define S_ISWOTH(m)    (((m) & S_IRWXO) == S_IWOTH)
#define S_ISXOTH(m)    (((m) & S_IRWXO) == S_IXOTH)

bool FileAttributes::ReadAttributes() {
    bool result = false;

    DWORD attributes = ::GetFileAttributes(FFileName.data());

    if (attributes != INVALID_FILE_ATTRIBUTES) {
        result = true;

        if (attributes | FILE_ATTRIBUTE_ARCHIVE) {
            FAttributes.push_back(faArchive);
        }
        if (attributes | FILE_ATTRIBUTE_COMPRESSED) {
            FAttributes.push_back(faCompressed);
        }
        if (attributes | FILE_ATTRIBUTE_DEVICE) {
            FAttributes.push_back(faDevice);
        }
        if (attributes | FILE_ATTRIBUTE_DIRECTORY) {
            FAttributes.push_back(faDirectory);
        }
        if (attributes | FILE_ATTRIBUTE_ENCRYPTED) {
            FAttributes.push_back(faEncrypted);
        }
        if (attributes | FILE_ATTRIBUTE_HIDDEN) {
            FAttributes.push_back(faHidden);
        }
        if (attributes | FILE_ATTRIBUTE_NORMAL) {
            FAttributes.push_back(faNormal);
        }
        if (attributes | FILE_ATTRIBUTE_NOT_CONTENT_INDEXED) {
            FAttributes.push_back(faNotContentIndexed);
        }
        if (attributes | FILE_ATTRIBUTE_SYSTEM) {
            FAttributes.push_back(faSystem);
        }
        if (attributes | FILE_ATTRIBUTE_OFFLINE) {
            FAttributes.push_back(faOffline);
        }
        if (attributes | FILE_ATTRIBUTE_REPARSE_POINT) {
            FAttributes.push_back(faSymbolicLink);
        }
        if (attributes | FILE_ATTRIBUTE_SPARSE_FILE) {
            FAttributes.push_back(faSparceFile);
        }
        if (attributes | FILE_ATTRIBUTE_READONLY ) {
            FAttributes.push_back(faReadOnly);
        }
        if (attributes | FILE_ATTRIBUTE_TEMPORARY) {
            FAttributes.push_back(faTemporary);
        }
        if (attributes | FILE_ATTRIBUTE_VIRTUAL) {
            FAttributes.push_back(faVirtual);
        }
    }

    return result;
}

bool FileAttributes::Valid(const FileAttribute Value) {
    bool result = false;

    switch (Value) {
        case faHidden:
        case faReadOnly: {
            result = true;
            break;
        }
        default:
            break;
    }

    return result;
}

void FileAttributes::Append(FileAttribute Value) {
    if (Valid(Value) == true) {
        FAttributes.push_back(Value);
        WriteAttributes();
    }
}

bool FileAttributes::Contains(FileAttribute Value) {
    bool result = false;

    std::vector<FileAttribute>::const_iterator iterator =
            std::find(FAttributes.begin(), FAttributes.end(), Value);

    if (iterator != FAttributes.end()) {
        result = true;
    }

    return result;
}

void FileAttributes::Remove(FileAttribute Value) {
    if (Valid(Value) == true) {
        std::vector<FileAttribute>::iterator iterator =
            std::find(FAttributes.begin(), FAttributes.end(), Value);

        if (iterator != FAttributes.end()) {
            FAttributes.erase(iterator);
            WriteAttributes();
        }
    }
}