// threadListboxdata.cpp
// 
// Copyright (c) 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 "KernLbxModel.h"
#include "Utils.h"
#include <fshell/clogger.h>
#include <fshell/memoryaccess.h>
#include <fshell/qr3dll.h>
#include "QResources3.hrh"
#include <fshell/heaputils.h>

CThreadsListBoxData::CThreadsListBoxData(CKernListBoxModel* aModel)
	: CKernListBoxData(aModel)
	{
	}

void CThreadsListBoxData::DoFormatL(TObjectKernelInfo* aInfo, RBuf& name, RBuf& more, TInt& itemId)
	{
	TThreadKernelInfo& info = *(TThreadKernelInfo*)aInfo;
	name.Copy(info.iFullName);
	PrettyName(iType, name);

	TUint tid = info.iThreadId;
	TExitType exitType = EExitPending;
	RThread thread;
	if (Model().MemAccess().RThreadForceOpen(thread, tid) == KErrNone)
		{
		exitType = thread.ExitType();
		}
	if (exitType == EExitPending)
		{
		more.Format(_L("Tid %i"), tid);
		}
	else
		{
		TExitCategoryName cat = thread.ExitCategory();
		more.Format(_L("Tid %i %S %i"), tid, &cat, thread.ExitReason());
		}
	thread.Close();
	itemId = tid;
	}

void CThreadsListBoxData::DumpToCloggerL(RClogger& clogger, TInt i, TInt /*count*/)
	{
	_LIT8(KThreadDesc,"Thread;FullName;Tid;Priority;(PriorityHumanReadable);ParentPid;StackSize;(StackSizeHumanReadable);HeapSize;(HeapSizeHumanReadable);MinHeapSize;(MinHumanReadable);UnusedPages;LostBytes;(LostBytesHumanReadable);ExitStatus;ExitCategory;ExitReason;KernObjAddr");
	_LIT8(KThreadFmt,"Thread;%S;%i;%i;(%S);%i;%i;(%S);%i;(%S);%i;(%S);%i;%i;(%S);%S;%S;%i;%x");
	//                                                    ^ HeapSizeHumanReadable
	if (i == 0) clogger.Log(KThreadDesc);
	TThreadKernelInfo& info = *(TThreadKernelInfo*)iInfo;

	TBuf<16> priority16 = ToString((TThreadPriority)info.iThreadPriority);
	TPtr8 priority = priority16.Collapse();
	
	LtkUtils::RProxyAllocatorHelper allocHelper;
	User::LeaveIfError(allocHelper.Open(Model().MemAccess(), info.iThreadId));
	TBuf8<16> heapSize, minHeap, lostBytes, stackSize;
	HR(heapSize, allocHelper.CommittedSize());
	HR(stackSize, info.iUserStackSize);
	HR(minHeap, allocHelper.MinCommittedSize());
	TInt lostBytesCount = allocHelper.CommittedFreeSpace();
	HR(lostBytes, lostBytesCount);
	TInt parentPid = 0; //TODO
	TPtrC exitStatus;
	TInt exitReason = 0;
	TExitCategoryName exitCategory;
	RThread handle;
	if (Model().MemAccess().RThreadForceOpen(handle, info.iThreadId) == KErrNone)
		{
		exitStatus.Set(ToString(handle.ExitType()));
		exitCategory = handle.ExitCategory();
		exitReason = handle.ExitReason();
		handle.Close();
		}
	TBuf8<16> exitStatus8;
	exitStatus8.Copy(exitStatus);
	TPtrC8 exitCategory8 = exitCategory.Collapse();
	clogger.Log(KThreadFmt, &info.iFullName, info.iThreadId, info.iThreadPriority, &priority, parentPid, info.iUserStackSize, &stackSize, allocHelper.CommittedSize(), &heapSize, allocHelper.MinCommittedSize(), &minHeap, allocHelper.CountUnusedPages(), lostBytesCount, &lostBytes, &exitStatus8, &exitCategory8, exitReason, info.iAddressOfKernelObject);
	allocHelper.Close();
	}

void CThreadsListBoxData::DoInfoForDialogL(RBuf& aTitle, RBuf& inf, TDes* aTemp)
	{
	TThreadKernelInfo& info = *(TThreadKernelInfo*)iInfo;
	RThread thread;
	RProcess process;
	TInt err = Model().MemAccess().RThreadForceOpen(thread, info.iThreadId);
	if (!err)
		{
		err = thread.Process(process);
		}
	TUint processId = err;
	if (!err)
		{
		processId = (TUint)process.Id();
		}
	CleanupClosePushL(thread);
	CleanupClosePushL(process);

	_LIT(KInfo, "Thread info");
	aTitle.Copy(KInfo);
	inf.Copy(iInfo->iFullName);
	inf.Append(Klflf);
	
	_LIT(KThread, "Tid: %d Pid: %d Kern Priority: %d\nPriority: %d (%S)\nProc Priority: %d (%S)");
	_LIT(KCritical, "\n%S");
	_LIT(KCreator, "\nCreator thread id: %d (%S)");
	_LIT(KKern, "\nKernel object address: 0x%08x");
	_LIT(KStack, "\n\nUser stack size: %S");
	_LIT(KHeap, "\nAllocator: 0x%08x\nHeap size: %S (%d)\nMin/Max: %S/%S\nUnused: %S Usable: %S");
	_LIT(KDied, "\n\nDied with: %S %S %i");

	TThreadPriority threadPriority = (TThreadPriority)err;
	TProcessPriority processPriority = (TProcessPriority)err;
	TPtrC priority = _L("?");
	TPtrC priorityP = _L("?");
	if (!err)
		{
		threadPriority = thread.Priority();
		priority.Set(ToString(threadPriority));
		processPriority = process.Priority();
		priorityP.Set(ToString(processPriority));
		}
	LtkUtils::RProxyAllocatorHelper allocHelper;
	User::LeaveIfError(allocHelper.Open(Model().MemAccess(), info.iThreadId));
	TBuf<16> heapSize, minHeap, maxHeap, unusedMem, reclaimableMem, stackSize;
	HR(heapSize, allocHelper.CommittedSize());
	HR(stackSize, info.iUserStackSize);
	HR(minHeap, allocHelper.MinCommittedSize());
	HR(maxHeap, allocHelper.MaxCommittedSize());
	HR(unusedMem, allocHelper.CommittedFreeSpace());
	HR(reclaimableMem, allocHelper.CountUnusedPages() * 4096);
	inf.AppendFormat(KThread, info.iThreadId, processId, info.iThreadPriority, threadPriority, &priority, processPriority, &priorityP);

	TUint creatorTid = Model().MemAccess().GetThreadCreatorId(info.iThreadId);
	if (creatorTid != 0)
		{
		RThread creator;
		TInt err = Model().MemAccess().RThreadForceOpen(creator, creatorTid);
		*aTemp = _L("?");
		if (err == KErrNone)
			{
			*aTemp = creator.FullName();
			PrettyName(iType, *aTemp);
			creator.Close();
			}
		inf.AppendFormat(KCreator, creatorTid, aTemp);
		}

	User::TCritical crit = User::ENotCritical;
	if (!err)
		{
		crit = User::Critical(thread);
		}
	if (crit != User::ENotCritical)
		{
		TPtrC critical = ToString(crit);
		inf.AppendFormat(KCritical, &critical);
		}
	inf.AppendFormat(KKern, info.iAddressOfKernelObject);

	inf.AppendFormat(KStack, &stackSize);
	inf.AppendFormat(KHeap, allocHelper.AllocatorAddress(), &heapSize, allocHelper.CommittedSize(), &minHeap, &maxHeap, &unusedMem, &reclaimableMem);
	allocHelper.Close();
	if (err == KErrNone && thread.ExitType() != EExitPending)
		{
		TPtrC exitStatus;
		TInt exitReason = 0;
		TExitCategoryName exitCategory;
		exitStatus.Set(ToString(thread.ExitType()));
		if (thread.ExitType() == EExitPanic)
			{
			exitCategory = thread.ExitCategory();
			}
		exitReason = thread.ExitReason();
		inf.AppendFormat(KDied, &exitStatus, &exitCategory, exitReason);
		}
	CleanupStack::PopAndDestroy(2, &thread);
	}

TBool CThreadsListBoxData::SupportsCommand(TInt aCommand)
	{
	switch (aCommand)
		{
		case ECmdHandleInfo:
		case ECmdKill:
		case ECmdDumpHeap:
		case ECmdSetCritical:
		case ECmdSetPriority:
		case ECmdPoll:
			return ETrue;
		default:
			return EFalse;
		}
	}