#ifndef _UNICODE
#define _UNICODE
#endif

#ifndef UNICODE
#define UNICODE
#endif

#ifndef _MT
#define _MT
#endif

#ifndef NOMINMAX
#define NOMINMAX
#endif

#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif

#ifndef VC_EXTRALEAN
#define VC_EXTRALEAN
#endif

#ifndef WINVER
#define WINVER 0x0600
#endif

#undef _WIN32_WINNT
#define _WIN32_WINNT WINVER

#include <cstddef>
#include <cstdarg>
#include <cstdio>

extern "C"
{
#include "include/lua/54/luaconf.h"
#include "include/lua/54/lua.h"
#include "include/lua/54/lauxlib.h"
}

#include <share.h>
#include <Windows.h>
#include <Shlwapi.h>

#pragma comment(lib, "lua54.lib")
#pragma comment(lib, "shlwapi.lib")

extern "C" ::IMAGE_DOS_HEADER __ImageBase;

struct Logger
{

   Logger(void) throw()
      : _f(nullptr)
   {
      ::InitializeCriticalSectionAndSpinCount(&_cs, 1000);
   }

   ~Logger(void)
   {
      Close();
      ::DeleteCriticalSection(&_cs);
   }

   int Init(lua_State * s)
   {
      if(_f)
         return ::luaL_error(s, "Logger already initialized");
      wchar_t buf[MAX_PATH];
      if(!::GetModuleFileNameW(reinterpret_cast<HMODULE>(&::__ImageBase), buf, MAX_PATH))
         return ::luaL_error(s, "GetModuleFileName failed (%08X)", ::GetLastError());
      if(!::PathRemoveFileSpecW(buf))
         return ::luaL_error(s, "PathRemoveFileSpec failed (%08X)", ::GetLastError());
      if(!::PathAppendW(buf, L"qtest.dll.log"))
         return ::luaL_error(s, "PathAppend failed (%08X)", ::GetLastError());
      _f = ::_wfsopen(buf, L"w", _SH_DENYWR);
      if(!_f)
         return ::luaL_error(s, "_wfsopen failed (%d)", ::_errno());
      Info("Log created");
      return 0;
   }

   void Close(void) throw()
   {
      if(_f)
      {
         Info("Log closed");
         ::fclose(_f);
         _f = nullptr;
      }
   }

   void Info(const char * fmt, ...)
   {
      va_list vl;
      va_start(vl, fmt);
      _Message('I', fmt, vl);
   }

   void Warning(const char * fmt, ...)
   {
      va_list vl;
      va_start(vl, fmt);
      _Message('W', fmt, vl);
   }

   void Error(const char * fmt, ...)
   {
      va_list vl;
      va_start(vl, fmt);
      _Message('E', fmt, vl);
   }

private:

   Logger(const Logger &);
   Logger(Logger &&);
   Logger & operator=(const Logger &);
   Logger & operator=(Logger &&);

   void __declspec(noinline) _Message(char evt, const char * fmt, va_list vl)
   {
      if(_f)
      {
         ::EnterCriticalSection(&_cs);
         ::SYSTEMTIME st;
         ::GetLocalTime(&st);
         ::fprintf_s(_f, "%02u.%02u.%02u.%03u [%08u] %c: ",
            st.wHour, st.wMinute, st.wSecond, st.wMilliseconds,
            ::GetCurrentThreadId(), evt);
         ::vfprintf_s(_f, fmt, vl);
         ::fprintf_s(_f, "\n");
         ::fflush(_f);
         ::LeaveCriticalSection(&_cs);
      }
   }

   ::CRITICAL_SECTION _cs;
   ::FILE * _f;

};

struct Event
{

   Event(void) throw()
      : _h(NULL)
   {
   }

   ~Event(void)
   {
      Close();
   }

   int Create(lua_State * s, const wchar_t * name = nullptr)
   {
      if(_h)
         return ::luaL_error(s, "Event already initialized");
      HANDLE h = ::CreateEventW(nullptr, TRUE, FALSE, name);
      if(!h)
         return ::luaL_error(s, "CreateEvent failed (%08X)", ::GetLastError());
      _h = h;
      return 0;
   }

   void Close(void) throw()
   {
      HANDLE h = _h;
      _h = NULL;
      if(h)
         ::CloseHandle(h);
   }

   void Set(void) throw()
   {
      ::SetEvent(_h);
   }

   void Reset(void) throw()
   {
      ::ResetEvent(_h);
   }

   HANDLE GetHandle(void) const throw()
   {
      return _h;
   }

private:

   Event(const Event &);
   Event(Event &&);
   Event & operator=(const Event &);
   Event & operator=(Event &&);

   HANDLE _h;

};

struct Timer
{

   Timer(void) throw()
      : _h(NULL)
   {
   }

   ~Timer(void)
   {
      Close();
   }

   int Init(lua_State * s, unsigned int period, long long delay = 100000000, const wchar_t * name = nullptr)
   {
      if(_h)
         return ::luaL_error(s, "Timer already initialized");
      HANDLE h = ::CreateWaitableTimerW(nullptr, FALSE, name);
      if(!h)
         return ::luaL_error(s, "CreateWaitableTimer failed (%08X)", ::GetLastError());
      ::LARGE_INTEGER li;
      li.QuadPart = -delay;
      if(!::SetWaitableTimer(h, &li, period, nullptr, nullptr, FALSE))
      {
         DWORD e = ::GetLastError();
         ::CloseHandle(h);
         return ::luaL_error(s, "SetWaitableTimer failed (%08X)", e);
      }
      _h = h;
      return 0;
   }

   void Close(void) throw()
   {
      HANDLE h = _h;
      _h = NULL;
      if(h)
      {
         ::CancelWaitableTimer(h);
         ::CloseHandle(h);
      }
   }

   HANDLE GetHandle(void) const throw()
   {
      return _h;
   }

private:

   Timer(const Timer &);
   Timer(Timer &&);
   Timer & operator=(const Timer &);
   Timer & operator=(Timer &&);

   HANDLE _h;

};

static ::Logger logger;
static ::Event stopevent;
static ::Timer timer;

static int qOnStop(lua_State *)
{
   ::logger.Info("OnStop()");
   ::stopevent.Set();
   return 0;
}

static int qOnParam(lua_State * s)
{
   const char * s1 = ::lua_tolstring(s, -2, nullptr);
   const char * s2 = ::lua_tolstring(s, -1, nullptr);
   ::logger.Info("OnParam(%s, %s)", s1, s2);
   return 0;
}

static int qmain(lua_State * s)
{
   ::logger.Info("Enter qmain()");
   ::timer.Init(s, 1500);
   for(;;)
   {
      HANDLE waitarray[] =
      {
         ::stopevent.GetHandle(),
         ::timer.GetHandle(),
      };
      switch(::WaitForMultipleObjects(_countof(waitarray), waitarray, FALSE, INFINITE))
      {
      case (WAIT_OBJECT_0 + 0): // stop event
         ::logger.Info("Stop event is set, main about to exit");
         ::timer.Close();
         ::stopevent.Close();
         ::logger.Info("Leave qmain()");
         return 0;
      case (WAIT_OBJECT_0 + 1): // timer
         ::lua_getglobal(s, "getInfoParam");
         ::lua_pushstring(s, "SERVERTIME");
         ::lua_callk(s, 1, 1, 0, nullptr);
         ::logger.Info("Timer event, server time is %s", ::lua_tolstring(s, -1, nullptr));
         ::lua_pop(s, 1);
         break;
      //case (WAIT_OBJECT_0 + 2):
      //   break;
      default:
         return ::luaL_error(s, "WaitForMultipleObjects failed (%08X)", ::GetLastError());
      }
   }
}

extern "C" int __declspec(dllexport) load(lua_State * s)
{
   ::logger.Init(s);
   ::stopevent.Create(s);
   ::lua_pushcclosure(s, ::qmain, 0); ::lua_setglobal(s, "main");
   ::lua_pushcclosure(s, ::qOnStop, 0); ::lua_setglobal(s, "OnStop");
   ::lua_pushcclosure(s, ::qOnParam, 0); ::lua_setglobal(s, "OnParam");
   return 0;
}