#include <w32std.h>

#include <APGTASK.H>

#include <APGWGNAM.H>  

#include <memspy/engine/memspyengineobjectthreadinfocontainer.h>

#include <memspy/engine/memspyprocessdata.h>

#include <memspy/engine/memspythreaddata.h>

#include <memspy/engine/memspykernelobjectdata.h>

#include <memspy/engine/memspythreadinfoitemdata.h>

// ---------------------------------------------------------

// DoServiceL( const RMessage2& aMessage )

// ---------------------------------------------------------

//

void CMemSpyEngineSession::DoServiceL( const RMessage2& aMessage )

	{

	TInt function = aMessage.Function() & KMemSpyOpFlagsTypeMask;

	if (function >= EMemSpyClientServerOpMarkerUiFirst && 

		function < EMemSpyClientServerOpMarkerUiLast)

		DoUiServiceL(aMessage);

	else

		DoCmdServiceL(aMessage);

	}

// ---------------------------------------------------------

// DoUiServiceL( const RMessage2& aMessage )

// ---------------------------------------------------------

//

void CMemSpyEngineSession::DoUiServiceL( const RMessage2& aMessage )

    {

	switch (aMessage.Function() & KMemSpyOpFlagsTypeMask)

		{

		case EMemSpyClientServerOpGetProcessCount:

			{

			aMessage.WriteL(0, TPckgBuf<TInt>(iEngine.Container().Count()));

			break;

			}

		case EMemSpyClientServerOpGetProcesses:

			{

			CMemSpyEngineObjectContainer& list = iEngine.Container();

			TPckgBuf<TInt> a0;

			aMessage.ReadL(0, a0);

			TInt realCount = Min(a0(), list.Count());

			for(TInt i=0, offset = 0; i<realCount; i++, offset += sizeof(TMemSpyProcessData))

				{

				CMemSpyProcess& process = iEngine.Container().At(i);

				TMemSpyProcessData data;

				data.iId = process.Id();

				data.iName.Copy(process.Name());

				TPckgBuf<TMemSpyProcessData> buffer(data);

				aMessage.WriteL(1, buffer, offset);

				}

			a0 = list.Count();

			aMessage.WriteL(0, a0);

			break;

			}

		case EMemSpyClienServerOpGetProcessIdByName:

			{

			TFullName processName;

			aMessage.ReadL(0, processName);

			TBool found(EFalse);

			for (TInt i=0; i<iEngine.Container().Count(); i++)

				{

				CMemSpyProcess& process = iEngine.Container().At(i);

				if (process.Name().FindF(processName) >= 0)

					{

					found = ETrue;

					TPckgBuf<TProcessId> procId(process.Id());

					aMessage.WriteL(1, procId);

					}

				}

			if (!found)

				{

				User::Leave(KErrNotFound);

				}

			break;

			}

		case EMemSpyClientServerOpProcessSystemPermanentOrCritical:

			{

			TBool ret = EFalse;

			TPckgBuf<TProcessId> id;

			aMessage.ReadL( 0, id );

			CMemSpyEngineObjectContainer& container = iEngine.Container();

			CMemSpyProcess& process = container.ProcessByIdL( id() );

			process.Open();

			if  ( process.IsSystemPermanent() || process.IsSystemCritical() )

				{

				ret = ETrue;

				}

			TPckgBuf<TBool> retBuf( ret );

			aMessage.WriteL( 1, retBuf );

			break;

			}

		case EMemSpyClientServerOpEndProcess:

			{

			TPckgBuf<TProcessId> id;

			aMessage.ReadL( 0, id );

			TPckgBuf<TMemSpyEndType> type;

			aMessage.ReadL( 1, type );

			CMemSpyEngineObjectContainer& container = iEngine.Container();			

			CMemSpyProcess& process = container.ProcessByIdL( id() );

			switch ( type() )

				{

				case ETerminate:

					{

					process.TerminateL();

					break;

					}

				case EPanic:

					{

					process.PanicL();

					break;

					}

				case EKill:

					{

					process.KillL();

					break;

					}

				}																

			break;

			}

		case EMemSpyClientServerOpSwitchToProcess:

			{/*

			TInt wgCount;

			RWsSession wsSession;

			User::LeaveIfError( wsSession.Connect() );

			CleanupClosePushL( wsSession );

			User::LeaveIfError( wgCount = wsSession.NumWindowGroups() );

			RArray<RWsSession::TWindowGroupChainInfo> wgArray;

			CleanupClosePushL( wgArray );

			User::LeaveIfError( wsSession.WindowGroupList( &wgArray ) );

			TApaTask task( wsSession );

			TBool brought( EFalse );

			TInt wgId( KErrNotFound );

			TThreadId threadId;

			TPckgBuf<TProcessId> id;

			aMessage.ReadL( 0, id );

			CMemSpyEngineObjectContainer& container = iEngine.Container();

			CMemSpyProcess& process = container.ProcessByIdL( id() );

			// loop trough threads in a process

			for ( TInt i = 0; i < process.MdcaCount(); i++ )

				{

				TInt wgCountLocal = wgCount;

				// loop trough all window groups and see if a thread id matches

				while( !brought && wgCountLocal-- )

					{

					wgId = wgArray[wgCountLocal].iId;

					User::LeaveIfError( wsSession.GetWindowGroupClientThreadId( wgId, threadId ) );

					if ( threadId == process.At( i ).Id() )

						{

						CApaWindowGroupName* wgName = CApaWindowGroupName::NewLC( wsSession, wgId );

						task.SetWgId( wgId );

						if ( !wgName->Hidden() && task.Exists() )

							{

							task.BringToForeground();

							brought = ETrue;                        

							}

						CleanupStack::PopAndDestroy( wgName );

						}

					}

				}

			TPckgBuf<TBool> ret( brought );

			aMessage.WriteL( 1, ret );

			break;*/

			}

		case EMemSpyClientServerOpGetThreadCount:

			{

			TPckgBuf<TProcessId> pid;

			aMessage.ReadL(1, pid);

			CMemSpyProcess& process = iEngine.Container().ProcessByIdL(pid());

			process.Open();

			aMessage.WriteL(0, TPckgBuf<TInt>(process.Count()));

			process.Close();

			break;

			}

		case EMemSpyClientServerOpGetThreads:

			{

			TPckgBuf<TProcessId> pid;

			aMessage.ReadL(2, pid);

			CMemSpyProcess& list = iEngine.Container().ProcessByIdL(pid());

			list.Open();

			TPckgBuf<TInt> a0;

			aMessage.ReadL(0, a0);

			TInt realCount = Min(a0(), list.Count());

			for(TInt i=0, offset = 0; i<realCount; i++, offset += sizeof(TMemSpyThreadData))

				{

				CMemSpyThread& thread = list.At(i);

				thread.Open();

				TMemSpyThreadData data;

				data.iId = thread.Id();

				data.iName.Copy(thread.Name());

				data.iThreadPriority = thread.Priority();

				TPckgBuf<TMemSpyThreadData> buffer(data);

				aMessage.WriteL(1, buffer, offset);

				thread.Close();

				}

			a0 = list.Count();

			aMessage.WriteL(0, a0);

			list.Close();

			break;

			}

		case EMemSpyClientServerOpSetThreadPriority:

			{

			TPckgBuf<TThreadId> tid;

			TPckgBuf<TInt> priority;

			aMessage.ReadL(0, tid);

			aMessage.ReadL(1, priority);

			CMemSpyProcess* process = NULL;

			CMemSpyThread* thread = NULL; 

			User::LeaveIfError(iEngine.Container().ProcessAndThreadByThreadId(tid(), process, thread));

			if (thread)

				{				

				thread->Open();

				thread->SetPriorityL(static_cast<TThreadPriority>(priority()));				

				thread->Close();

				}					

			break;

			}

		case EMemSpyClientServerOpThreadSystemPermanentOrCritical:

			{

			TBool ret = EFalse;

			TPckgBuf<TThreadId> id;

			aMessage.ReadL( 0, id );

			CMemSpyEngineObjectContainer& container = iEngine.Container();            

			CMemSpyProcess* process = NULL;

			CMemSpyThread* thread = NULL; 

			User::LeaveIfError( container.ProcessAndThreadByThreadId( id(), process, thread ) );

			if ( thread )

				{				

				thread->Open();

				if  ( thread->IsSystemPermanent() || thread->IsSystemCritical() )

					{			

					ret = ETrue;					

					}

				thread->Close();

				}

			TPckgBuf<TBool> retBuf( ret );

			aMessage.WriteL( 1, retBuf );

			break;

			}

		case EMemSpyClientServerOpEndThread:

			{

			TPckgBuf<TThreadId> id;

			aMessage.ReadL( 0, id );

			TPckgBuf<TMemSpyEndType> type;

			aMessage.ReadL( 1, type );

			CMemSpyEngineObjectContainer& container = iEngine.Container();

			CMemSpyProcess* process = NULL;

			CMemSpyThread* thread = NULL; 

			User::LeaveIfError( container.ProcessAndThreadByThreadId( id(), process, thread ) );

			if( thread )

				{

				switch ( type() )

					{

					case ETerminate:

						{

						thread->TerminateL();

						break;

						}

					case EPanic:

						{

						thread->PanicL();

						break;

						}

					case EKill:

						{

						thread->KillL();

						break;

						}

					}				

				}			

			break;

			}

		case EMemSpyClientServerOpSwitchToThread:

			{

			TInt wgCount;

			RWsSession wsSession;

			User::LeaveIfError( wsSession.Connect() );

			CleanupClosePushL( wsSession );

			User::LeaveIfError( wgCount = wsSession.NumWindowGroups() );

			RArray<RWsSession::TWindowGroupChainInfo> wgArray;

			CleanupClosePushL( wgArray );

			User::LeaveIfError( wsSession.WindowGroupList( &wgArray ) );

			TApaTask task( wsSession );

			TBool brought( EFalse );

			TInt wgId( KErrNotFound );

			TThreadId threadId;

			TPckgBuf<TThreadId> id;

			aMessage.ReadL( 0, id );

			// loop trough all window groups and see if a thread id matches

			while( !brought && wgCount-- )

				{

				wgId = wgArray[wgCount].iId;

				User::LeaveIfError( wsSession.GetWindowGroupClientThreadId( wgId, threadId ) );

				if ( threadId == id() )

					{

					CApaWindowGroupName* wgName = CApaWindowGroupName::NewLC( wsSession, wgId );