// wsp_session.cpp
// 
// Copyright (c) 2002 - 2010 Accenture. All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
// 
// Initial Contributors:
// Accenture - Initial contribution
//


#include "wsp_session.h"
#include "wsp_factory.h"
#include "wsp_request.h"
#include "wsp_panic.h"
#include "wsp_log.h"


//
// Constants.
//

_LIT(KWspThreadName, "WinSockPrtThread");
_LIT(KWspThreadNameWhilstWaitingForDeath, "WinSockPrtThread_WaitingForDeath_%Ld");
_LIT(KWspThreadStartSemaphoreName, "WinSockPrtThreadStartSemaphore");
const TInt KWspThreadStackSize = KDefaultStackSize;
const TInt KWspThreadMinHeapSize = 0x4000;		// 16 kb
const TInt KWspThreadMaxHeapSize = 0x40000;		// 256 kb


//
// RWin32Session.
//

TInt RWin32Session::Open()
	{
	return CreateThread();
	}

void RWin32Session::Close()
	{
	if (iThread.Handle())
		{
		iWin32Message.Set(CWin32Session::EClose);
		iRequest.MakeRequest(iWin32Message);
		iThread.Close();
		}
	}

TInt RWin32Session::MakeRequest(TWin32Message& aMessage)
	{
	return iRequest.MakeRequest(aMessage);
	}

TInt RWin32Session::CreateThread()
	{
	WSP_LOG(WspLog::Write(_L("RWin32Session::CreateThread")));
#ifdef _DEBUG
	TFindThread findThread(KWspThreadName);
	TFullName name;
	__ASSERT_DEBUG(findThread.Next(name)==KErrNotFound, Panic(EWinSockPrtThreadAlreadyExists));
#endif
	
	RSemaphore threadStartSemaphore;
	TInt err = threadStartSemaphore.CreateGlobal(KWspThreadStartSemaphoreName, 0, EOwnerThread);
	if (err)
		{
		return err;
		}

	err = iThread.Create(KWspThreadName, WinSockPrtThreadStart, KWspThreadStackSize, KWspThreadMinHeapSize, KWspThreadMaxHeapSize, &iRequest, EOwnerThread);
	if (err == KErrNone)
		{
		err = iRequest.DuplicateParentThreadHandle(iThread);
		if (err)
			{
			iThread.Close();
			threadStartSemaphore.Close();
			return err;
			}
		//iThread.SetPriority(EPriorityAbsoluteVeryLow); // Hack to prevent the thread from blocking all threads lower than the default priority. Should really be using a raw Win32 thread rather than a Symbian one.
		iThread.Resume();
		threadStartSemaphore.Wait();
		threadStartSemaphore.Close();
		}
	else
		{
		threadStartSemaphore.Close();
		}
	return err;
	}


//
// Thread start functions.
//

GLDEF_C TInt WinSockPrtThreadStart(TAny* aPtr)
	{
	__UHEAP_MARK;
	CTrapCleanup* trapCleanup = CTrapCleanup::New();
	if (trapCleanup == NULL)
		{
		return KErrNoMemory;
		}
	TRAPD(err, InitialiseAndRunThreadL(aPtr));
	WSP_LOG(WspLog::Close());
	delete trapCleanup;
	__UHEAP_MARKEND;
	return err;
	}

GLDEF_C void InitialiseAndRunThreadL(TAny* aPtr)
	{
	WSP_LOG(User::LeaveIfError(WspLog::Open()));
	CWin32Scheduler* win32Scheduler = CWin32Scheduler::NewL();
	CleanupStack::PushL(win32Scheduler);
	TWin32Request* request = static_cast<TWin32Request*>(aPtr);
	CWin32Factory* win32Factory = CWin32Factory::NewL(*request, *win32Scheduler);
	CleanupStack::PushL(win32Factory);

	RSemaphore threadStartSemaphore;
	User::LeaveIfError(threadStartSemaphore.OpenGlobal(KWspThreadStartSemaphoreName, EOwnerThread));
	threadStartSemaphore.Signal();
	threadStartSemaphore.Close();
	
	win32Scheduler->Start();

	CleanupStack::PopAndDestroy(2, win32Scheduler);
	}


//
// CWin32Session.
//

void CWin32Session::AddSubSessionL(CWin32SubSession* aSubSession)
	{
	TInt subSessionHandle = reinterpret_cast<TInt>(aSubSession);
	TPckg<TInt> subSessionHandlePckg(subSessionHandle);
	iRequest.Message().WriteBuffer().Copy(subSessionHandlePckg);
	CleanupStack::PushL(aSubSession);
	User::LeaveIfError(iSubSessions.Append(aSubSession));
	CleanupStack::Pop(aSubSession);
	}

CWin32Session::~CWin32Session()
	{
	__ASSERT_DEBUG(iSubSessions.Count() == 0, Panic(EWinSockPrtSubSessionListNotEmpty));
	iSubSessions.Close();
	}

CWin32Session::CWin32Session(TWin32Request& aRequest, CWin32Scheduler& aScheduler)
	: CWin32ActiveObject(aScheduler), iRequest(aRequest)
	{
	}

void CWin32Session::ConstructL()
	{
	CWin32ActiveObject::ConstructL();
	iRequest.SetEventHandle(iEvent);
	}

void CWin32Session::Run()
	{
	TInt err = KErrNone;

	CWin32SubSession* subSession = reinterpret_cast<CWin32SubSession*>(iRequest.SubSession());
	TWin32Message& message = iRequest.Message();
	if (subSession == NULL)
		{
		switch (message.OppCode())
			{
			case EClose:
				{
				Close();
				break;
				}
			case ECloseSubSession:
				{
				CloseSubSession();
				break;
				}
			default:
				{
				// Pass on to sub-class.
				TRAP(err, ServiceL(message));
				}
			}
		}
	else
		{
		TRAP(err, subSession->ServiceL(message));
		}

	iRequest.Requested(err);
	}

void CWin32Session::Close()
	{
	// This thread could take a while to die, so give it a different name so that subsequent client attempt to create another one don't fail with KErrInUse.
	TTime time;
	time.UniversalTime();
	const TInt64& int64 = time.Int64();
	TBuf<64> newThreadName;
	newThreadName.Format(KWspThreadNameWhilstWaitingForDeath(), int64);
	User::RenameThread(newThreadName); // Throw away error code.
	iScheduler.Stop();
	}

void CWin32Session::CloseSubSession()
	{
	TInt handle;
	TPckg<TInt> handlePckg(handle);
	handlePckg.Copy(iRequest.Message().ReadBuffer());
	CWin32SubSession* subSessionToClose = reinterpret_cast<CWin32SubSession*>(handle);
	TInt pos = iSubSessions.Find(subSessionToClose);
	__ASSERT_DEBUG(pos >= 0, Panic(EWinSockPrtUnableToFindSubSession));
	delete subSessionToClose;
	iSubSessions.Remove(pos);
	}