/*==========================================================================
 *
 *  Copyright (C) 1999-2002 Microsoft Corporation.  All Rights Reserved.
 *
 *  File:       ThreadPool.h
 *  Content:	Functions to manage a thread pool
 *
 *  History:
 *   Date		By		Reason
 *   ====		==		======
 *	03/01/1999	jtk		Derived from Utils.h
 ***************************************************************************/

#ifndef __THREAD_POOL_H__
#define __THREAD_POOL_H__

//**********************************************************************
// Constant definitions
//**********************************************************************

//**********************************************************************
// Macro definitions
//**********************************************************************

//**********************************************************************
// Structure definitions
//**********************************************************************

//
// forward class and structure references
//
class	CSocketPort;
class	CThreadPool;

typedef	void	TIMER_EVENT_CALLBACK( void *const pContext );
typedef	void	TIMER_EVENT_COMPLETE( const HRESULT hCompletionCode, void *const pContext );

typedef struct	_TIMER_OPERATION_ENTRY
{
	CBilink					Linkage;				// list links
	void					*pContext;				// user context passed back in timer events

	//
	// timer information
	//
	UINT_PTR				uRetryCount;			// number of times to retry this event
	BOOL					fRetryForever;			// Boolean for retrying forever
	DWORD					dwRetryInterval;		// time between enums (milliseconds)
	DWORD					dwIdleTimeout;			// time at which the command sits idle after all retrys are complete
	BOOL					fIdleWaitForever;		// Boolean for waiting forever in idle state
	DWORD					dwNextRetryTime;		// time at which this event will fire next (milliseconds)

	TIMER_EVENT_CALLBACK	*pTimerCallback;		// callback for when this event fires
	TIMER_EVENT_COMPLETE	*pTimerComplete;		// callback for when this event is complete

	CThreadPool *			pThreadPool;			// handle to owning thread pool
	PVOID					pvTimerData;			// cancellable handle to timer, or NULL if not scheduled
	UINT					uiTimerUnique;			// uniqueness value for timer
	BOOL					fCancelling;			// boolean denoting whether the timer is cancelling or not
#ifndef DPNBUILD_ONLYONEPROCESSOR
	DWORD					dwCPU;				// CPU on which timer is scheduled
#endif // ! DPNBUILD_ONLYONEPROCESSOR

	#undef DPF_MODNAME
	#define	DPF_MODNAME	"_TIMER_OPERATION_ENTRY::TimerOperationFromLinkage"
	static _TIMER_OPERATION_ENTRY	*TimerOperationFromLinkage( CBilink *const pLinkage )
	{
		DNASSERT( pLinkage != NULL );
		DBG_CASSERT( OFFSETOF( _TIMER_OPERATION_ENTRY, Linkage ) == 0 );
		return	reinterpret_cast<_TIMER_OPERATION_ENTRY*>( pLinkage );
	}

} TIMER_OPERATION_ENTRY;


#ifndef DPNBUILD_ONLYONETHREAD

typedef	void	BLOCKING_JOB_CALLBACK( void *const pvContext );

typedef struct _BLOCKING_JOB
{
	CBilink					Linkage;					// list links
	void					*pvContext;					// user context passed back in job callback
	BLOCKING_JOB_CALLBACK	*pfnBlockingJobCallback;	// callback for when this job is processed
} BLOCKING_JOB;

#endif // ! DPNBUILD_ONLYONETHREAD


//**********************************************************************
// Variable definitions
//**********************************************************************

//**********************************************************************
// Function prototypes
//**********************************************************************

typedef	BOOL	(CSocketPort::*PSOCKET_SERVICE_FUNCTION)( void );
typedef	void	DIALOG_FUNCTION( void *const pDialogContext );

//
// functions for managing the timer data pool
//
BOOL	TimerEntry_Alloc( void *pItem, void* pvContext );
void	TimerEntry_Get( void *pItem, void* pvContext );
void	TimerEntry_Release( void *pItem );
void	TimerEntry_Dealloc( void *pItem );

//**********************************************************************
// Class prototypes
//**********************************************************************

//
// class for thread pool
//
class	CThreadPool
{
	public:
		static BOOL	PoolAllocFunction( void* pvItem, void* pvContext );
		static void	PoolDeallocFunction( void* pvItem );

		void	Lock( void ) { DNEnterCriticalSection( &m_Lock ); }
		void	Unlock( void ) { DNLeaveCriticalSection( &m_Lock ); }

		#undef DPF_MODNAME
		#define DPF_MODNAME "CThreadPool::AddRef"
		void	AddRef( void ) 
		{ 
			DNInterlockedIncrement( const_cast<LONG*>(&m_iRefCount) ); 
		}

		#undef DPF_MODNAME
		#define DPF_MODNAME "CThreadPool::DecRef"
		void	DecRef( void )
		{
			DNASSERT( m_iRefCount != 0 );
			if ( DNInterlockedDecrement( const_cast<LONG*>(&m_iRefCount) ) == 0 )
			{
				Deinitialize();
				g_ThreadPoolPool.Release( this );
			}
		}


		HRESULT	Initialize( void );
		void	Deinitialize( void );

#if ((! defined(DPNBUILD_NOWINSOCK2)) && (! defined(DPNBUILD_ONLYWINSOCK2)))
		CReadIOData * GetNewReadIOData(READ_IO_DATA_POOL_CONTEXT * const pContext, const BOOL fNeedOverlapped );
#else // DPNBUILD_NOWINSOCK2 or DPNBUILD_ONLYWINSOCK2
		CReadIOData * GetNewReadIOData(READ_IO_DATA_POOL_CONTEXT * const pContext);
#endif // DPNBUILD_NOWINSOCK2 or DPNBUILD_ONLYWINSOCK2

		static void ReturnReadIOData(CReadIOData *const pReadIOData);

#ifndef DPNBUILD_ONLYWINSOCK2
		HRESULT	AddSocketPort( CSocketPort *const pSocketPort );

		void	RemoveSocketPort( CSocketPort *const pSocketPort );

		BOOL	CheckWinsock1IO( FD_SET *const pWinsock1Sockets );

		BOOL	ServiceWinsock1Sockets( FD_SET *pSocketSet, PSOCKET_SERVICE_FUNCTION pServiceFunction );

		static void	WINAPI CheckWinsock1IOCallback( void * const pvContext,
											void * const pvTimerData,
											const UINT uiTimerUnique );
#endif // ! DPNBUILD_ONLYWINSOCK2

#ifdef DPNBUILD_ONLYONEPROCESSOR
		HRESULT	SubmitDelayedCommand( const PFNDPTNWORKCALLBACK pFunction,
									void *const pContext );
#else // ! DPNBUILD_ONLYONEPROCESSOR
		HRESULT	SubmitDelayedCommand( const DWORD dwCPU,
									const PFNDPTNWORKCALLBACK pFunction,
									void *const pContext );
#endif // ! DPNBUILD_ONLYONEPROCESSOR

		static void WINAPI GenericTimerCallback( void * const pvContext,
										void * const pvTimerData,
										const UINT uiTimerUnique );

#ifdef DPNBUILD_ONLYONEPROCESSOR
		HRESULT	SubmitTimerJob( const BOOL fPerformImmediately,
								const UINT_PTR uRetryCount,
								const BOOL fRetryForever,
								const DWORD dwRetryInterval,
								const BOOL fIdleWaitForever,
								const DWORD dwIdleTimeout,
								TIMER_EVENT_CALLBACK *const pTimerCallbackFunction,
								TIMER_EVENT_COMPLETE *const pTimerCompleteFunction,
								void *const pContext );
#else // ! DPNBUILD_ONLYONEPROCESSOR
		HRESULT	SubmitTimerJob( const DWORD dwCPU,
								const BOOL fPerformImmediately,
								const UINT_PTR uRetryCount,
								const BOOL fRetryForever,
								const DWORD dwRetryInterval,
								const BOOL fIdleWaitForever,
								const DWORD dwIdleTimeout,
								TIMER_EVENT_CALLBACK *const pTimerCallbackFunction,
								TIMER_EVENT_COMPLETE *const pTimerCompleteFunction,
								void *const pContext );
#endif // ! DPNBUILD_ONLYONEPROCESSOR
		
		BOOL	StopTimerJob( void *const pContext, const HRESULT hCommandResult );

		BOOL	ModifyTimerJobNextRetryTime( void *const pContext,
											DWORD const dwNextRetryTime );

		void	LockTimerData( void ) { DNEnterCriticalSection( &m_TimerDataLock ); }
		void	UnlockTimerData( void ) { DNLeaveCriticalSection( &m_TimerDataLock ); }

#ifndef DPNBUILD_ONLYONETHREAD
		HRESULT	SubmitBlockingJob( BLOCKING_JOB_CALLBACK *const pfnBlockingJobCallback,
									void *const pvContext );

		void	DoBlockingJobs( void );
#endif // ! DPNBUILD_ONLYONETHREAD


#ifndef DPNBUILD_NOSPUI		
		HRESULT	SpawnDialogThread( DIALOG_FUNCTION *const pDialogFunction,
								   void *const pDialogContext );

		static	DWORD WINAPI	DialogThreadProc( void *pParam );
#endif // ! DPNBUILD_NOSPUI

#ifndef DPNBUILD_ONLYONETHREAD
		LONG	GetIntendedThreadCount( void ) const { return m_iIntendedThreadCount; }
		void	SetIntendedThreadCount( const LONG iIntendedThreadCount ) { m_iIntendedThreadCount = iIntendedThreadCount; }
		HRESULT	GetIOThreadCount( LONG *const piThreadCount );
		HRESULT	SetIOThreadCount( const LONG iMaxThreadCount );
#endif // ! DPNBUILD_ONLYONETHREAD
		BOOL IsThreadCountReductionAllowed( void ) const { return m_fAllowThreadCountReduction; }
		HRESULT PreventThreadPoolReduction( void );
#if ((! defined(DPNBUILD_NOMULTICAST)) && (defined(WINNT)))
		BOOL EnsureMadcapLoaded( void );
#endif // ! DPNBUILD_MULTICAST and WINNT
#ifndef DPNBUILD_NONATHELP
		void EnsureNATHelpLoaded( void );
#endif // ! DPNBUILD_NONATHELP

		IDirectPlay8ThreadPoolWork* GetDPThreadPoolWork( void ) const { return m_pDPThreadPoolWork; }

#ifndef DPNBUILD_NONATHELP
		BOOL	IsNATHelpLoaded( void ) const { return m_fNATHelpLoaded; }
		BOOL	IsNATHelpTimerJobSubmitted( void ) const { return m_fNATHelpTimerJobSubmitted; }
		void	SetNATHelpTimerJobSubmitted( BOOL fValue ) { m_fNATHelpTimerJobSubmitted = fValue; }

		void	HandleNATHelpUpdate( DWORD * const pdwTimerInterval );

		static void	PerformSubsequentNATHelpGetCaps( void * const pvContext );
		static void	NATHelpTimerComplete( const HRESULT hResult, void * const pContext );
		static void	NATHelpTimerFunction( void * const pContext );
#endif // DPNBUILD_NONATHELP

#if ((defined(WINNT)) && (! defined(DPNBUILD_NOMULTICAST)))
		BOOL	IsMadcapLoaded( void ) const { return m_fMadcapLoaded; }
#endif // WINNT and not DPNBUILD_NOMULTICAST


	private:
		BYTE							m_Sig[4];							// debugging signature ('THPL')
		volatile LONG					m_iRefCount;						// reference count
		IDirectPlay8ThreadPoolWork *	m_pDPThreadPoolWork;				// pointer to DirectPlay Thread Pool Work interface
		BOOL							m_fAllowThreadCountReduction;		// boolean indicating that the thread count is locked from being reduced
#ifndef DPNBUILD_ONLYONETHREAD
		DNCRITICAL_SECTION				m_Lock;								// local object lock
		LONG							m_iIntendedThreadCount;				// how many threads will be started
		DNCRITICAL_SECTION				m_TimerDataLock;					// lock protecting timer data
#endif // ! DPNBUILD_ONLYONETHREAD
		CBilink							m_TimerJobList;						// list of current active timer jobs
#ifndef DPNBUILD_NONATHELP
		BOOL							m_fNATHelpLoaded;					// boolean indicating whether the NAT Help interface has been loaded
		BOOL							m_fNATHelpTimerJobSubmitted;		// whether the NAT Help refresh timer has been submitted or not
		DWORD							m_dwNATHelpUpdateThreadID;			// ID of current thread updating NAT Help status, or 0 if none
#endif // DPNBUILD_NONATHELP
#if ((defined(WINNT)) && (! defined(DPNBUILD_NOMULTICAST)))
		BOOL							m_fMadcapLoaded;					// boolean indicating whether the MADCAP API has been loaded
#endif // WINNT and not DPNBUILD_NOMULTICAST

#ifndef DPNBUILD_ONLYWINSOCK2
		UINT_PTR						m_uReservedSocketCount;				// count of sockets that are 'reserved' for use
		FD_SET							m_SocketSet;						// set of all sockets in use
		CSocketPort *					m_pSocketPorts[FD_SETSIZE];			// set of corresponding socket ports
		PVOID							m_pvTimerDataWinsock1IO;			// cancellable handle to Winsock 1 I/O poll timer
		UINT							m_uiTimerUniqueWinsock1IO;			// uniqueness value for Winsock 1 I/O poll timer
		BOOL							m_fCancelWinsock1IO;				// whether the Winsock 1 I/O poll timer should be cancelled or not
#endif // ! DPNBUILD_ONLYWINSOCK2

#ifndef DPNBUILD_ONLYONETHREAD
		DNCRITICAL_SECTION				m_csBlockingJobLock;				// lock protecting blocking job queue information
		CBilink							m_blBlockingJobQueue;					// queue of blocking jobs
		DNHANDLE						m_hBlockingJobThread;				// handle to blocking job thread
		DNHANDLE						m_hBlockingJobEvent;				// handle to event used to signal blocking job thread
#endif // ! DPNBUILD_ONLYONETHREAD
};




#undef DPF_MODNAME

#endif	// __THREAD_POOL_H__