///////////////////////////////////////////////////////////////
//  ATLexe.cpp - implementation of server WinMain            //
//  ver 1.0                                                  //
//                                                           //
//  Language:     Visual C++, ver 6.0                        //
//  Platform:     Micron Dual Pentium Pro 200, Win NT 4.0    //
//  Application:  Demo: CSE791 - Distributed Objects         //
//  Author:       Jim Fawcett, CST 2-187, Syracuse Univ.     //
//                (315) 443-3948, fawcett@ecs.syr.edu        //
///////////////////////////////////////////////////////////////

// Note: Proxy/Stub Information
//      To build a separate proxy/stub DLL, 
//      run nmake -f ATLexeps.mk in the project directory.

#include "stdafx.h"
#include "resource.h"
#include <initguid.h>
#include "ATLexe.h"

#include "ATLexe_i.c"
#include "Sum.h"


const DWORD dwTimeOut = 5000; // time for EXE to be idle before shutting down
const DWORD dwPause = 1000; // time to wait for threads to finish up

//----< Passed to CreateThread to monitor shutdown event >-----

static DWORD WINAPI MonitorProc(void* pv)
{
  CExeModule* p = (CExeModule*)pv;
  p->MonitorShutdown();
  return 0;
}

LONG CExeModule::Unlock()
{
  LONG l = CComModule::Unlock();
  if (l == 0)
  {
    bActivity = true;
    SetEvent(hEventShutdown); // tell monitor that we transitioned to zero
  }
  return l;
}

//

//----< Monitors the shutdown event >--------------------------

void CExeModule::MonitorShutdown()
{
  while (1)
  {
    WaitForSingleObject(hEventShutdown, INFINITE);
    DWORD dwWait=0;
    do
    {
      bActivity = false;
      dwWait = WaitForSingleObject(hEventShutdown, dwTimeOut);
    } while (dwWait == WAIT_OBJECT_0);
    // timed out
    if (!bActivity && m_nLockCnt == 0) // if no activity let's really bail
    {
      #if _WIN32_WINNT >= 0x0400 & defined(_ATL_FREE_THREADED)
        CoSuspendClassObjects();
        if (!bActivity && m_nLockCnt == 0)
      #endif
          break;
    }
  }
  CloseHandle(hEventShutdown);
  PostThreadMessage(dwThreadID, WM_QUIT, 0, 0);
}

//----< start shutdown monitor thread >------------------------

bool CExeModule::StartMonitor()
{
  hEventShutdown = CreateEvent(NULL, false, false, NULL);
  if (hEventShutdown == NULL)
    return false;
  DWORD dwThreadID;
  HANDLE h = CreateThread(NULL, 0, MonitorProc, this, 0, &dwThreadID);
  return (h != NULL);
}

//----< global module instance >-------------------------------

CExeModule _Module;

BEGIN_OBJECT_MAP(ObjectMap)
OBJECT_ENTRY(CLSID_Sum, CSum)
END_OBJECT_MAP()

//

//----< search >-----------------------------------------------

LPCTSTR FindOneOf(LPCTSTR p1, LPCTSTR p2)
{
  while (p1 != NULL && *p1 != NULL)
  {
    LPCTSTR p = p2;
    while (p != NULL && *p != NULL)
    {
      if (*p1 == *p)
        return CharNext(p1);
      p = CharNext(p);
    }
    p1 = CharNext(p1);
  }
  return NULL;
}

/////////////////////////////////////////////////////////////////////////////
//
extern "C" int WINAPI _tWinMain(
                 HINSTANCE hInstance, 
                 HINSTANCE /*hPrevInstance*/, 
                 LPTSTR lpCmdLine, 
                 int /*nShowCmd*/
               )
{
  lpCmdLine = GetCommandLine(); //this line necessary for _ATL_MIN_CRT

#if _WIN32_WINNT >= 0x0400 & defined(_ATL_FREE_THREADED)
  HRESULT hRes = CoInitializeEx(NULL, COINIT_MULTITHREADED);
#else
  HRESULT hRes = CoInitialize(NULL);
#endif
  _ASSERTE(SUCCEEDED(hRes));
  _Module.Init(ObjectMap, hInstance, &LIBID_ATLEXELib);
  _Module.dwThreadID = GetCurrentThreadId();
  TCHAR szTokens[] = _T("-/");

//

  int nRet = 0;
  BOOL bRun = TRUE;
  LPCTSTR lpszToken = FindOneOf(lpCmdLine, szTokens);
  while (lpszToken != NULL)
  {
    if (lstrcmpi(lpszToken, _T("UnregServer"))==0)
    {
      _Module.UpdateRegistryFromResource(IDR_ATLexe, FALSE);
      nRet = _Module.UnregisterServer(TRUE);
      bRun = FALSE;
      break;
    }
    if (lstrcmpi(lpszToken, _T("RegServer"))==0)
    {
      _Module.UpdateRegistryFromResource(IDR_ATLexe, TRUE);
      nRet = _Module.RegisterServer(TRUE);
      bRun = FALSE;
      break;
    }
    lpszToken = FindOneOf(lpszToken, szTokens);
  }

  if (bRun)
  {
    _Module.StartMonitor();
  #if _WIN32_WINNT >= 0x0400 & defined(_ATL_FREE_THREADED)
    hRes = _Module.RegisterClassObjects(
      CLSCTX_LOCAL_SERVER, REGCLS_MULTIPLEUSE | REGCLS_SUSPENDED
    );
    _ASSERTE(SUCCEEDED(hRes));
    hRes = CoResumeClassObjects();
  #else
    hRes = _Module.RegisterClassObjects(CLSCTX_LOCAL_SERVER, 
      REGCLS_MULTIPLEUSE);
  #endif
    _ASSERTE(SUCCEEDED(hRes));

    MSG msg;
    while (GetMessage(&msg, 0, 0, 0))
      DispatchMessage(&msg);

    _Module.RevokeClassObjects();
    Sleep(dwPause); //wait for any threads to finish
  }

  _Module.Term();
  CoUninitialize();
  return nRet;
}