/****************************************************************************
* Copyright (C) 2017 Intel Corporation.   All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
****************************************************************************/

#include "common/os.h"
#include <vector>
#include <array>
#include <sstream>

#if defined(_WIN32)
#include <shlobj.h>
#endif // Windows

#if defined(__APPLE__) || defined(FORCE_LINUX) || defined(__linux__) || defined(__gnu_linux__)
#include <pthread.h>
#endif // Linux



#if defined(_WIN32)
static const DWORD MS_VC_EXCEPTION = 0x406D1388;

#pragma pack(push,8)  
typedef struct tagTHREADNAME_INFO
{
    DWORD dwType; // Must be 0x1000.  
    LPCSTR szName; // Pointer to name (in user addr space).  
    DWORD dwThreadID; // Thread ID (-1=caller thread).  
    DWORD dwFlags; // Reserved for future use, must be zero.  
} THREADNAME_INFO;
#pragma pack(pop)

void LegacySetThreadName(const char* pThreadName)
{
    THREADNAME_INFO info;
    info.dwType = 0x1000;
    info.szName = pThreadName;
    info.dwThreadID = GetCurrentThreadId();
    info.dwFlags = 0;

    if (!IsDebuggerPresent())
    {
        // No debugger attached to interpret exception, no need to actually do it
        return;
    }

#pragma warning(push)  
#pragma warning(disable: 6320 6322)  
    __try {
        RaiseException(MS_VC_EXCEPTION, 0, sizeof(info) / sizeof(ULONG_PTR), (ULONG_PTR*)&info);
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {
    }
#pragma warning(pop)  
}
#endif // _WIN32

void SWR_API SetCurrentThreadName(const char* pThreadName)
{
#if defined(_WIN32)
    // The SetThreadDescription API was brought in version 1607 of Windows 10.
    typedef HRESULT(WINAPI* PFNSetThreadDescription)(HANDLE hThread, PCWSTR lpThreadDescription);
    // The SetThreadDescription API works even if no debugger is attached.
    auto pfnSetThreadDescription =
        reinterpret_cast<PFNSetThreadDescription>(
            GetProcAddress(GetModuleHandleA("Kernel32.dll"), "SetThreadDescription"));

    if (!pfnSetThreadDescription)
    {
        // try KernelBase.dll
        pfnSetThreadDescription =
            reinterpret_cast<PFNSetThreadDescription>(
                GetProcAddress(GetModuleHandleA("KernelBase.dll"), "SetThreadDescription"));
    }

    if (pfnSetThreadDescription)
    {
        std::string utf8Name = pThreadName;
        std::wstring wideName;
        wideName.resize(utf8Name.size() + 1);
        swprintf_s(&(wideName.front()), wideName.size(), L"%S", utf8Name.c_str());
        HRESULT hr = pfnSetThreadDescription(GetCurrentThread(), wideName.c_str());
        SWR_ASSERT(SUCCEEDED(hr), "Failed to set thread name to %s", pThreadName);

        // Fall through - it seems like some debuggers only recognize the exception
    }

    // Fall back to exception based hack
    LegacySetThreadName(pThreadName);
#endif // _WIN32

#if defined(FORCE_LINUX) || defined(__linux__) || defined(__gnu_linux__)
    pthread_setname_np(pthread_self(), pThreadName);
#endif // Linux
}

static void SplitString(std::vector<std::string>& out_segments, const std::string& input, char splitToken)
{
    out_segments.clear();

    std::istringstream f(input);
    std::string s;
    while (std::getline(f, s, splitToken))
    {
        if (s.size())
        {
            out_segments.push_back(s);
        }
    }
}

void SWR_API CreateDirectoryPath(const std::string& path)
{
#if defined(_WIN32)
    SHCreateDirectoryExA(nullptr, path.c_str(), nullptr);
#endif // Windows

#if defined(__APPLE__) || defined(FORCE_LINUX) || defined(__linux__) || defined(__gnu_linux__)
    std::vector<std::string> pathSegments;
    SplitString(pathSegments, path, '/');

    std::string tmpPath;
    for (auto const& segment : pathSegments)
    {
        tmpPath.push_back('/');
        tmpPath += segment;

        int result = mkdir(tmpPath.c_str(), 0777);
        if (result == -1 && errno != EEXIST)
        {
            break;
        }
    }
#endif // Unix
}

/// Execute Command (block until finished)
/// @returns process exit value
int SWR_API  ExecCmd(
    const std::string&  cmd,            ///< (In) Command line string
    const char*         pOptEnvStrings, ///< (Optional In) Environment block for new process
    std::string*        pOptStdOut,     ///< (Optional Out) Standard Output text
    std::string*        pOptStdErr,     ///< (Optional Out) Standard Error text
    const std::string*  pOptStdIn)      ///< (Optional In) Standard Input text
{
    int rvalue = -1;

#if defined(_WIN32)
    struct WinPipe
    {
        HANDLE hRead;
        HANDLE hWrite;
    };
    std::array<WinPipe, 3> hPipes = {};

    SECURITY_ATTRIBUTES saAttr = { sizeof(SECURITY_ATTRIBUTES) };
    saAttr.bInheritHandle = TRUE;   //Pipe handles are inherited by child process.
    saAttr.lpSecurityDescriptor = NULL;

    {
        bool bFail = false;
        for (WinPipe& p : hPipes)
        {
            if (!CreatePipe(&p.hRead, &p.hWrite, &saAttr, 0))
            {
                bFail = true;
            }
        }

        if (bFail)
        {
            for (WinPipe& p : hPipes)
            {
                CloseHandle(p.hRead);
                CloseHandle(p.hWrite);
            }
            return rvalue;
        }
    }

    STARTUPINFOA StartupInfo{};
    StartupInfo.cb = sizeof(STARTUPINFOA);
    StartupInfo.dwFlags = STARTF_USESTDHANDLES;
    StartupInfo.dwFlags |= STARTF_USESHOWWINDOW;
    StartupInfo.wShowWindow = SW_HIDE;
    if (pOptStdIn)
    {
        StartupInfo.hStdInput = hPipes[0].hRead;
    }
    StartupInfo.hStdOutput = hPipes[1].hWrite;
    StartupInfo.hStdError = hPipes[2].hWrite;
    PROCESS_INFORMATION procInfo{};

    // CreateProcess can modify the string
    std::string local_cmd = cmd;

    BOOL ProcessValue = CreateProcessA(
        NULL,
        (LPSTR)local_cmd.c_str(),
        NULL,
        NULL,
        TRUE,
        0,
        (LPVOID)pOptEnvStrings,
        NULL,
        &StartupInfo,
        &procInfo);

    if (ProcessValue && procInfo.hProcess)
    {
        auto ReadFromPipe = [](HANDLE hPipe, std::string* pOutStr)
        {
            char buf[1024];
            DWORD dwRead = 0;
            DWORD dwAvail = 0;
            while (true)
            {
                if (!::PeekNamedPipe(hPipe, NULL, 0, NULL, &dwAvail, NULL))
                {
                    break;
                }

                if (!dwAvail) // no data available, return
                {
                    break;
                }

                if (!::ReadFile(hPipe, buf, std::min<size_t>(sizeof(buf) - 1, size_t(dwAvail)), &dwRead, NULL) || !dwRead)
                {
                    // error, the child process might ended
                    break;
                }

                buf[dwRead] = 0;
                if (pOutStr)
                {
                    (*pOutStr) += buf;
                }
            }
        };
        bool bProcessEnded = false;
        size_t bytesWritten = 0;
        do
        {
            if (pOptStdIn && (pOptStdIn->size() > bytesWritten))
            {
                DWORD bytesToWrite = static_cast<DWORD>(pOptStdIn->size()) - bytesWritten;
                if (!::WriteFile(
                    hPipes[0].hWrite,
                    pOptStdIn->data() + bytesWritten,
                    bytesToWrite, &bytesToWrite, nullptr))
                {
                    // Failed to write to pipe
                    break;
                }
                bytesWritten += bytesToWrite;
            }

            // Give some timeslice (50ms), so we won't waste 100% cpu.
            bProcessEnded = (WaitForSingleObject(procInfo.hProcess, 50) == WAIT_OBJECT_0);

            ReadFromPipe(hPipes[1].hRead, pOptStdOut);
            ReadFromPipe(hPipes[2].hRead, pOptStdErr);
        }
        while (!bProcessEnded);

        DWORD exitVal = 0;
        if (!GetExitCodeProcess(procInfo.hProcess, &exitVal))
        {
            exitVal = 1;
        }

        CloseHandle(procInfo.hProcess);
        CloseHandle(procInfo.hThread);

        rvalue = exitVal;
    }

    for (WinPipe& p : hPipes)
    {
        CloseHandle(p.hRead);
        CloseHandle(p.hWrite);
    }

#else

    // Non-Windows implementation

#endif

    return rvalue;
}
