/*
 * Copyright 2008 Stephen Liu
 * For license terms, see the file COPYING along with this library.
 */

#include <stdlib.h>

#include "spiocpevent.hpp"
#include "sputils.hpp"
#include "spsession.hpp"

SP_IocpEventHeap :: SP_IocpEventHeap()
{
	mEntries = NULL;
	mMaxCount = mCount = 0;
}

SP_IocpEventHeap :: ~SP_IocpEventHeap()
{
	if( NULL != mEntries ) free( mEntries );
	mEntries = NULL;
	mMaxCount = mCount = 0;
}

int SP_IocpEventHeap :: getCount()
{
	return mCount;
}

int SP_IocpEventHeap :: push( SP_IocpEvent_t * item )
{
	if( 0 != reserve( mCount + 1 ) ) return -1;

	shiftUp( mCount++, item );

	return 0;
}

SP_IocpEvent_t * SP_IocpEventHeap :: top()
{
	return mCount ? mEntries[ 0 ] : NULL;
}

SP_IocpEvent_t * SP_IocpEventHeap :: pop()
{
	if( mCount ) {
		SP_IocpEvent_t * ret = mEntries[ 0 ];
		shiftDown( 0, mEntries[ --mCount ] );
		ret->mHeapIndex = -1;

		return ret;
	}

	return NULL;
}

int SP_IocpEventHeap :: erase( SP_IocpEvent_t * item )
{
	if( -1 != item->mHeapIndex ) {
		shiftDown( item->mHeapIndex, mEntries[ -- mCount ] );
		item->mHeapIndex = -1;

		return 0;
	}

	return -1;
}

int SP_IocpEventHeap :: reserve( int count )
{
	if( mMaxCount < count ) {
		int maxCount = mMaxCount ? mMaxCount *  2 : 8;
		if( maxCount < count ) maxCount = count;

		SP_IocpEvent_t ** p = (SP_IocpEvent_t**)realloc( mEntries, maxCount * sizeof( SP_IocpEvent_t ) );
		if( NULL == p ) return -1;

		mEntries = p;
		mMaxCount = maxCount;
	}

	return 0;

}

int SP_IocpEventHeap :: isGreater( SP_IocpEvent_t * item1, SP_IocpEvent_t * item2 )
{
	if( item1->mTimeout.tv_sec == item2->mTimeout.tv_sec ) {
		return item1->mTimeout.tv_usec > item2->mTimeout.tv_usec;
	} else {
		return item1->mTimeout.tv_sec > item2->mTimeout.tv_sec;
	}
}

void SP_IocpEventHeap :: shiftUp( int index, SP_IocpEvent_t * item )
{
	int parent = ( index - 1 ) / 2;

	for( ; index && isGreater( mEntries[ parent ], item ); ) {
		mEntries[ index ] = mEntries[ parent ];
		mEntries[ index ]->mHeapIndex = index;
		index = parent;
		parent = ( index - 1 ) / 2;
	}
	mEntries[ index ] = item;
	item->mHeapIndex = index;
}

void SP_IocpEventHeap :: shiftDown( int index, SP_IocpEvent_t * item )
{
	int minChild = 2 * ( index + 1 );
	for( ; minChild <= mCount; ) {
		minChild -= ( minChild == mCount || isGreater( mEntries[ minChild ], mEntries[ minChild - 1 ] ) );
		if( ! isGreater( item, mEntries[ minChild ] ) ) break;

		mEntries[ index ] = mEntries[ minChild ];
		mEntries[ index ]->mHeapIndex = index;
		index = minChild;
		minChild = 2 * ( index + 1 );
	}
	shiftUp( index, item );
}

//===================================================================

SP_IocpMsgQueue :: SP_IocpMsgQueue( HANDLE completionPort,
		DWORD completionKey, QueueFunc_t func, void * arg )
{
	mCompletionPort = completionPort;
	mCompletionKey = completionKey;
	mFunc = func;
	mArg = arg;

	mMutex = CreateMutex( NULL, FALSE, NULL );
	mQueue = new SP_CircleQueue();
}

SP_IocpMsgQueue :: ~SP_IocpMsgQueue()
{
	CloseHandle( mMutex );
	delete mQueue;
	mQueue = NULL;
}

int SP_IocpMsgQueue :: push( void * queueData )
{
	WaitForSingleObject( mMutex, INFINITE );

	mQueue->push( queueData );
	if( 1 == mQueue->getLength() ) {
		PostQueuedCompletionStatus( mCompletionPort, 0, mCompletionKey, (OVERLAPPED*)this );
	}

	ReleaseMutex( mMutex );

	return 0;
}

int SP_IocpMsgQueue :: process()
{
	WaitForSingleObject( mMutex, INFINITE );

	for( ; mQueue->getLength() > 0; ) {
		void * queueData = mQueue->pop();

		ReleaseMutex( mMutex );

		mFunc( queueData, mArg );		

		WaitForSingleObject( mMutex, INFINITE );
	}

	ReleaseMutex( mMutex );

	return 0;
}

//===================================================================

SP_IocpEventArg :: SP_IocpEventArg( int timeout )
{
	mInputResultQueue = new SP_BlockingQueue();
	mOutputResultQueue = new SP_BlockingQueue();

	mResponseQueue = NULL;
	
	mSessionManager = new SP_SessionManager();

	mEventHeap = new SP_IocpEventHeap();

	mTimeout = timeout;

	mCompletionPort = CreateIoCompletionPort( INVALID_HANDLE_VALUE, NULL, 0, 0 );
	if( NULL == mCompletionPort ) {
		sp_syslog( LOG_ERR, "CreateIoCompletionPort failed, errno %d", WSAGetLastError() );
	}

	mDisconnectExFunc = NULL;
}

SP_IocpEventArg :: ~SP_IocpEventArg()
{
	if( NULL != mInputResultQueue ) delete mInputResultQueue;
	mInputResultQueue = NULL;

	if( NULL != mOutputResultQueue ) delete mOutputResultQueue;
	mOutputResultQueue = NULL;

	if( NULL != mEventHeap ) delete mEventHeap;
	mEventHeap = NULL;

	if( NULL != mResponseQueue ) delete mResponseQueue;
	mResponseQueue = NULL;

	if( NULL != mSessionManager ) delete mSessionManager;
	mSessionManager = NULL;
}

HANDLE SP_IocpEventArg :: getCompletionPort()
{
	return mCompletionPort;
}

SP_BlockingQueue * SP_IocpEventArg :: getInputResultQueue()
{
	return mInputResultQueue;
}
	
SP_BlockingQueue * SP_IocpEventArg :: getOutputResultQueue()
{
	return mOutputResultQueue;
}

void SP_IocpEventArg :: setResponseQueue( SP_IocpMsgQueue * responseQueue )
{
	mResponseQueue = responseQueue;
}

SP_IocpMsgQueue * SP_IocpEventArg :: getResponseQueue()
{
	return mResponseQueue;
}

SP_SessionManager * SP_IocpEventArg :: getSessionManager()
{
	return mSessionManager;
}

SP_IocpEventHeap * SP_IocpEventArg :: getEventHeap()
{
	return mEventHeap;
}

void SP_IocpEventArg :: setTimeout( int timeout )
{
	mTimeout = timeout;
}

int SP_IocpEventArg :: getTimeout()
{
	return mTimeout;
}

int SP_IocpEventArg :: loadDisconnectEx( SOCKET fd )
{
	LPFN_DISCONNECTEX fnDisConnectEx = NULL;
	GUID guidDisConnectEx = WSAID_DISCONNECTEX;
	DWORD dwByte;
	::WSAIoctl( fd, SIO_GET_EXTENSION_FUNCTION_POINTER,
			&guidDisConnectEx, sizeof(guidDisConnectEx),
			&fnDisConnectEx, sizeof(fnDisConnectEx),
			&dwByte, NULL, NULL); 

	mDisconnectExFunc = fnDisConnectEx;

	return NULL != mDisconnectExFunc ? 0 : -1;
}

BOOL SP_IocpEventArg :: disconnectEx( SOCKET fd, LPOVERLAPPED lpOverlapped,
		DWORD dwFlags, DWORD reserved )
{
	LPFN_DISCONNECTEX fnDisConnectEx = (LPFN_DISCONNECTEX)mDisconnectExFunc;
	if( NULL != fnDisConnectEx ) {
		return fnDisConnectEx( fd, lpOverlapped, dwFlags, reserved );
	}

	return FALSE;
}