// ThinThread.cpp : implementation file
// Copyright (C) 1997 by The Windward Group, All Rights Reserved

#include "stdafx.h"
#include "ThinThread.h"
#include <process.h>    /* _beginthread, _endthread */

/////////////////////////////////////////////////////////////////////////////
// ThinThread
CThinThread::CThinThread()
: m_b2ndThread(FALSE)
{
	// Create a signaled, manual-reset event to synchronize destruction
	m_pExitEvent = new CEvent();//TRUE, TRUE);
	ASSERT(m_pExitEvent);

	// Create a non-signaled, auto-reset event to wait on for work cycle
	m_pWorkEvent = new CEvent();
	ASSERT(m_pWorkEvent);
	m_pWorkEvent2 = new CEvent();
	ASSERT(m_pWorkEvent2);
}

BOOL CThinThread::CreateThread(DWORD dwCreateFlags, 
								UINT nStackSize, 
								LPSECURITY_ATTRIBUTES lpSecurityAttrs, 
								UINT nMilliSecs,
								UINT Type)
{
	m_bEndThread = FALSE;
	m_nCycleTime = nMilliSecs;
	m_pExitEvent->ResetEvent();	// exit event is reset until we're done
	
	// Start second thread
	ULONG usThreadAddr;
//	m_hThread2 = reinterpret_cast<HANDLE> (_beginthreadex(lpSecurityAttrs, nStackSize, Start, this, 1, &usThreadAddr));
//	return reinterpret_cast<unsigned long> (m_hThread2);
	if(WORD_THREAD_WITH_HOGA == Type) {
		m_b2ndThread = TRUE;
		m_hThread2 = ::CreateThread(lpSecurityAttrs,nStackSize,Start,this,0,&usThreadAddr); 
	} else {
		m_b3rdThread = TRUE;
		m_hThread3 = ::CreateThread(lpSecurityAttrs,nStackSize,Start2,this,0,&usThreadAddr); 
	}
	return reinterpret_cast<unsigned long> (m_hThread2);
}

CThinThread::~CThinThread()
{
	delete m_pWorkEvent; m_pWorkEvent = NULL;
	delete m_pWorkEvent2; m_pWorkEvent2 = NULL;
	delete m_pExitEvent; m_pExitEvent = NULL;
}

void CThinThread::KillThread2()
{
	// Start up the other thread so it can complete.
	// When it does, it will set the exit event and the object can be destructed.
	m_bEndThread = TRUE;
	m_pWorkEvent->SetEvent();
	m_pWorkEvent2->SetEvent();

	Sleep(0);

	CSingleLock csl(m_pExitEvent);
	csl.Lock();					// wait for 2nd thread to finish
	csl.Unlock();		
}

void CThinThread::Finalize()
{
	KillThread2();
}

int CThinThread::Run(UINT ThreadType)
{
	CSingleLock *pcsl;
	if(WORD_THREAD_WITH_HOGA == ThreadType)
		pcsl = new CSingleLock(m_pWorkEvent);		// synch on the work event
	else if(WORD_THREAD_WITHOUT_HOGA == ThreadType)
		pcsl = new CSingleLock(m_pWorkEvent2);		// synch on the work event2
	else
		ASSERT(FALSE);

	StartWork();						// do derived startup

	while (!m_bEndThread)				// loop until we're done
	{
		pcsl->Lock(m_nCycleTime);			// wait for event or timeout
		pcsl->Unlock();			
		if (!m_bEndThread) 
			DoWork(ThreadType);	// then do derived work
	}

	m_pExitEvent->SetEvent();			// set not waiting signal
	
	if(WORD_THREAD_WITH_HOGA == ThreadType)
		m_b2ndThread = FALSE;
	else
		m_b3rdThread = FALSE;
	
	delete pcsl;
	EndWork();							// do derived shutdown

//	_endthreadex(0);
//	ExitThread(0);
	
	return 0;
}

//unsigned int __stdcall CThinThread::Start(void* pv)
DWORD WINAPI CThinThread::Start(LPVOID pv)
{
	CThinThread* pMT = static_cast<CThinThread*> (pv);
	return pMT->Run(WORD_THREAD_WITH_HOGA);
}

DWORD WINAPI CThinThread::Start2(LPVOID pv)
{
	CThinThread* pMT = static_cast<CThinThread*> (pv);
	return pMT->Run(WORD_THREAD_WITHOUT_HOGA);
}