// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
 // ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
 // THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
 // PARTICULAR PURPOSE.
 //
 // Copyright (c) Microsoft Corporation. All rights reserved.
 
 #include "ThreadEmulation.h"
 
 #include <assert.h>
 #include <vector>
 #include <set>
 #include <map>
 #include <mutex>
 
 using namespace std;
 using namespace Platform;
 using namespace Windows::Foundation;
 using namespace Windows::System::Threading;
 
 
 namespace ThreadEmulation
 {
     // Stored data for CREATE_SUSPENDED and ResumeThread.
     struct PendingThreadInfo
     {
         LPTHREAD_START_ROUTINE lpStartAddress;
         LPVOID lpParameter;
         HANDLE completionEvent;
         int nPriority;
     };
 
     static map<HANDLE, PendingThreadInfo> pendingThreads;
     static mutex pendingThreadsLock;
 
     
     // Thread local storage.
     typedef vector<void*> ThreadLocalData;
 
     static __declspec(thread) ThreadLocalData* currentThreadData = nullptr;
     static set<ThreadLocalData*> allThreadData;
     static DWORD nextTlsIndex = 0;
     static vector<DWORD> freeTlsIndices;
     static mutex tlsAllocationLock;
 
 
     // Converts a Win32 thread priority to WinRT format.
     static WorkItemPriority GetWorkItemPriority(int nPriority)
     {
         if (nPriority < 0)
             return WorkItemPriority::Low;
         else if (nPriority > 0)
             return WorkItemPriority::High;
         else
             return WorkItemPriority::Normal;
     }
 
 
     // Helper shared between CreateThread and ResumeThread.
     static void StartThread(LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, HANDLE completionEvent, int nPriority)
     {
         auto workItemHandler = ref new WorkItemHandler([=](IAsyncAction^)
         {
             // Run the user callback.
             try
             {
                 lpStartAddress(lpParameter);
             }
             catch (...) { }
 
             // Clean up any TLS allocations made by this thread.
             TlsShutdown();
 
             // Signal that the thread has completed.
             SetEvent(completionEvent);
             CloseHandle(completionEvent);
 
         }, CallbackContext::Any);
 
         ThreadPool::RunAsync(workItemHandler, GetWorkItemPriority(nPriority), WorkItemOptions::TimeSliced);
     }
 
 
     _Use_decl_annotations_ HANDLE WINAPI CreateThread(LPSECURITY_ATTRIBUTES unusedThreadAttributes, SIZE_T unusedStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD unusedThreadId)
     {
         // Validate parameters.
         assert(unusedThreadAttributes == nullptr);
         assert(unusedStackSize == 0);
         assert((dwCreationFlags & ~CREATE_SUSPENDED) == 0);
         assert(unusedThreadId == nullptr);
 
         // Create a handle that will be signalled when the thread has completed.
         HANDLE threadHandle = CreateEventEx(nullptr, nullptr, CREATE_EVENT_MANUAL_RESET, EVENT_ALL_ACCESS);
 
         if (!threadHandle)
             return nullptr;
 
         // Make a copy of the handle for internal use. This is necessary because
         // the caller is responsible for closing the handle returned by CreateThread,
         // and they may do that before or after the thread has finished running.
         HANDLE completionEvent;
         
         if (!DuplicateHandle(GetCurrentProcess(), threadHandle, GetCurrentProcess(), &completionEvent, 0, false, DUPLICATE_SAME_ACCESS))
         {
             CloseHandle(threadHandle);
             return nullptr;
         }
 
         try
         {
             if (dwCreationFlags & CREATE_SUSPENDED)
             {
                 // Store info about a suspended thread.
                 PendingThreadInfo info;
 
                 info.lpStartAddress = lpStartAddress;
                 info.lpParameter = lpParameter;
                 info.completionEvent = completionEvent;
                 info.nPriority = 0;
 
                 lock_guard<mutex> lock(pendingThreadsLock);
 
                 pendingThreads[threadHandle] = info;
             }
             else
             {
                 // Start the thread immediately.
                 StartThread(lpStartAddress, lpParameter, completionEvent, 0);
             }
     
             return threadHandle;
         }
         catch (...)
         {
             // Clean up if thread creation fails.
             CloseHandle(threadHandle);
             CloseHandle(completionEvent);
 
             return nullptr;
         }
     }
 
 
     _Use_decl_annotations_ DWORD WINAPI ResumeThread(HANDLE hThread)
     {
         lock_guard<mutex> lock(pendingThreadsLock);
 
         // Look up the requested thread.
         auto threadInfo = pendingThreads.find(hThread);
 
         if (threadInfo == pendingThreads.end())
         {
             // Can only resume threads while they are in CREATE_SUSPENDED state.
             assert(false);
             return (DWORD)-1;
         }
 
         // Start the thread.
         try
         {
             PendingThreadInfo& info = threadInfo->second;
 
             StartThread(info.lpStartAddress, info.lpParameter, info.completionEvent, info.nPriority);
         }
         catch (...)
         {
             return (DWORD)-1;
         }
 
         // Remove this thread from the pending list.
         pendingThreads.erase(threadInfo);
 
         return 0;
     }
 
 
     _Use_decl_annotations_ BOOL WINAPI SetThreadPriority(HANDLE hThread, int nPriority)
     {
         lock_guard<mutex> lock(pendingThreadsLock);
 
         // Look up the requested thread.
         auto threadInfo = pendingThreads.find(hThread);
 
         if (threadInfo == pendingThreads.end())
         {
             // Can only set priority on threads while they are in CREATE_SUSPENDED state.
             return false;
         }
 
         // Store the new priority.
         threadInfo->second.nPriority = nPriority;
 
         return true;
     }
 
 
     _Use_decl_annotations_ VOID WINAPI Sleep(DWORD dwMilliseconds)
     {
         static HANDLE singletonEvent = nullptr;
 
         HANDLE sleepEvent = singletonEvent;
 
         // Demand create the event.
         if (!sleepEvent)
         {
             sleepEvent = CreateEventEx(nullptr, nullptr, CREATE_EVENT_MANUAL_RESET, EVENT_ALL_ACCESS);
 
             if (!sleepEvent)
                 return;
 
             HANDLE previousEvent = InterlockedCompareExchangePointerRelease(&singletonEvent, sleepEvent, nullptr);
             
             if (previousEvent)
             {
                 // Back out if multiple threads try to demand create at the same time.
                 CloseHandle(sleepEvent);
                 sleepEvent = previousEvent;
             }
         }
 
         // Emulate sleep by waiting with timeout on an event that is never signalled.
         WaitForSingleObjectEx(sleepEvent, dwMilliseconds, false);
     }
 
 
     DWORD WINAPI TlsAlloc()
     {
         lock_guard<mutex> lock(tlsAllocationLock);
         
         // Can we reuse a previously freed TLS slot?
         if (!freeTlsIndices.empty())
         {
             DWORD result = freeTlsIndices.back();
             freeTlsIndices.pop_back();
             return result;
         }
 
         // Allocate a new TLS slot.
         return nextTlsIndex++;
     }
 
 
     _Use_decl_annotations_ BOOL WINAPI TlsFree(DWORD dwTlsIndex)
     {
         lock_guard<mutex> lock(tlsAllocationLock);
 
         assert(dwTlsIndex < nextTlsIndex);
         assert(find(freeTlsIndices.begin(), freeTlsIndices.end(), dwTlsIndex) == freeTlsIndices.end());
 
         // Store this slot for reuse by TlsAlloc.
         try
         {
             freeTlsIndices.push_back(dwTlsIndex);
         }
         catch (...)
         {
             return false;
         }
 
         // Zero the value for all threads that might be using this now freed slot.
         for each (auto threadData in allThreadData)
         {
             if (threadData->size() > dwTlsIndex)
             {
                 threadData->at(dwTlsIndex) = nullptr;
             }
         }
 
         return true;
     }
 
 
     _Use_decl_annotations_ LPVOID WINAPI TlsGetValue(DWORD dwTlsIndex)
     {
         ThreadLocalData* threadData = currentThreadData;
 
         if (threadData && threadData->size() > dwTlsIndex)
         {
             // Return the value of an allocated TLS slot.
             return threadData->at(dwTlsIndex);
         }
         else
         {
             // Default value for unallocated slots.
             return nullptr;
         }
     }
 
 
     _Use_decl_annotations_ BOOL WINAPI TlsSetValue(DWORD dwTlsIndex, LPVOID lpTlsValue)
     {
         ThreadLocalData* threadData = currentThreadData;
 
         if (!threadData)
         {
             // First time allocation of TLS data for this thread.
             try
             {
                 threadData = new ThreadLocalData(dwTlsIndex + 1, nullptr);
                 
                 lock_guard<mutex> lock(tlsAllocationLock);
 
                 allThreadData.insert(threadData);
 
                 currentThreadData = threadData;
             }
             catch (...)
             {
                 if (threadData)
                     delete threadData;
 
                 return false;
             }
         }
         else if (threadData->size() <= dwTlsIndex)
         {
             // This thread already has a TLS data block, but it must be expanded to fit the specified slot.
             try
             {
                 lock_guard<mutex> lock(tlsAllocationLock);
 
                 threadData->resize(dwTlsIndex + 1, nullptr);
             }
             catch (...)
             {
                 return false;
             }
         }
 
         // Store the new value for this slot.
         threadData->at(dwTlsIndex) = lpTlsValue;
 
         return true;
     }
 
 
     // Called at thread exit to clean up TLS allocations.
     void WINAPI TlsShutdown()
     {
         ThreadLocalData* threadData = currentThreadData;
 
         if (threadData)
         {
             {
                 lock_guard<mutex> lock(tlsAllocationLock);
 
                 allThreadData.erase(threadData);
             }
 
             currentThreadData = nullptr;
 
             delete threadData;
         }
     }
 }