/////////////////////////////////////////////////////////////////////////////
// client.cpp : Implementation of WinMain
//
// Note: Proxy/Stub Information
//      To build a separate proxy/stub DLL, 
//      run nmake -f clientps.mk in the project directory.

#include "stdafx.h"
#include "resource.h"
#include <initguid.h>
#include "client.h"
#include "client_i.c"
#include "Reply.h"
#include "clientDlg.h"
#import "..\server\server.tlb" no_namespace

/////////////////////////////////////////////////////////////////////////////
// global data

HWND hDlg;                    // handle to dialog window, used by thread function
CclientDlg *pDlg = NULL;      // pointer to dialog, used by CReply::Reply

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

/////////////////////////////////////////////////////////////////////////////
// CreateThread to monitor the shutdown event

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

/////////////////////////////////////////////////////////////////////////////
// unlock server so it can shut down

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

//

/////////////////////////////////////////////////////////////////////////////
// Monitors 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

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 CExeModule instance

CExeModule _Module;

BEGIN_OBJECT_MAP(ObjectMap)
  OBJECT_ENTRY(CLSID_Reply, CReply)
END_OBJECT_MAP()

//

/////////////////////////////////////////////////////////////////////////////
// ??

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;
}

/////////////////////////////////////////////////////////////////////////////
// WinMain

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_CLIENTLib);
  _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_Client, FALSE);
      nRet = _Module.UnregisterServer(TRUE);
      bRun = FALSE;
      break;
    }
    if (lstrcmpi(lpszToken, _T("RegServer"))==0)
    {
      _Module.UpdateRegistryFromResource(IDR_Client, 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));

//

///////////////////////////////////////////////////////////////
// start server and send startup request

    IRequestPtr pRequest(_T("Server.Request.1"));
    BSTR reqStr = SysAllocString(OLESTR("request string from client"));
    pRequest->Request(reqStr);
    SysFreeString(reqStr);

///////////////////////////////////////////////////////////////
// build dialog window and start servicing message loop,
// looking for server replies

    _Module.Lock();
    CclientDlg dlg;
    pDlg = &dlg;
    hDlg = dlg.Create(NULL);
    dlg.ShowWindow(SW_SHOW);
    dlg.MoveWindow(100,100,385,500);
    dlg.SetWindowText("Client Dialog");

///////////////////////////////////////////////////////////////
// run message loop looking for server replies

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

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

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