/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:

* Nokia Corporation - initial contribution.

*

* Contributors:

* 

* Description: This module contains the implementation of 

* CAtsLogger class member functions.

*

*/

// INCLUDE FILES

#include "atslogger.h"

CAtsLogger::CAtsLogger(const TDesC& aName) :

	iReportStage(EUninitialized),

	iName(aName),

	iIndentLevel(0),

	iRawLog(EFalse),

	iXmlLog(EFalse),

	iValid(EFalse),

	iLineFeedDone(EFalse),

	iInTestCase(EFalse),

	iClosed(EFalse),

	iFullReportingMode(ETrue),

	iDoDebugOutput(EFalse),

	iDoIndentation(ETrue)

	{

	}

void CAtsLogger::ConstructL( TBool aAfterReboot )

	{

	TChar xmlDrive;

	iXmlLog = CheckDirectoryL(KAtsLoggerXmlDirectory, xmlDrive);

	TChar rawDrive;

	iRawLog = CheckDirectoryL(KAtsLoggerRawDirectory, rawDrive);

	if (iXmlLog)

		{

		iXmlLogFileName.Copy(_L("?:"));		

		iXmlLogFileName.Append(KAtsLoggerXmlDirectory);

		iXmlLogFileName.Append(iName);

		iXmlLogFileName.Append(KAtsLoggerXmlSuffix);

		iXmlLogFileName[0] = (TUint8)xmlDrive;

		if( aAfterReboot )

		    {

		    User::LeaveIfError(OpenExistingFileL(iXmlLogFileName));

		    }

		else

		    {

		    User::LeaveIfError(ReplaceFileL(iXmlLogFileName));

		    }

		iValid = ETrue;

		}

	else

		{

		iValid = EFalse;

		}

	if (iRawLog)

		{

		iRawLogFileName.Copy(_L("?:"));		

		iRawLogFileName.Append(KAtsLoggerRawDirectory);

		iRawLogFileName.Append(iName);

		iRawLogFileName.Append(KAtsLoggerRawSuffix);

		iRawLogFileName[0] = (TUint8)rawDrive;

		if( aAfterReboot )

		    {

		    User::LeaveIfError(OpenExistingFileL(iRawLogFileName));

		    }

		else

		    {

		    User::LeaveIfError(ReplaceFileL(iRawLogFileName));

		    }

		}

	iXmlBuffer = CBufSeg::NewL(KAtsLoggerBufferSegmentGranularity);

	iXmlBufferLength = 0;

	}

TBool CAtsLogger::CheckDirectoryL(const TDesC& aDirName, TChar& aDrive)

	{

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

	TDriveList driveList;

	iRfs.DriveList(driveList);

	TBool dirFound = EFalse;

	TFileName dir;

	for (TInt i = 0; i < driveList.Length() && !dirFound; i++)

		{

		TChar drive;

		if (driveList[i] != 0)

			{

			iRfs.DriveToChar(i, drive);

			dir.Copy(_L("?:"));

			dir.Append(aDirName);

			dir[0] = (TUint8)drive;

			RDir rDir;

			TInt error = rDir.Open(iRfs, dir, KEntryAttNormal);

			if (error == KErrNone)

				{

				dirFound = ETrue;

				aDrive = drive;

				}

			else 

				{

				dirFound = EFalse;

				aDrive = '?';

				}

			rDir.Close();

			}

		}

	iRfs.Close();

	return dirFound;

	}

TInt CAtsLogger::ReplaceFileL(const TDesC& aFileName)

	{

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

	RFile file;

	TInt err = file.Replace(iRfs, aFileName, EFileWrite | EFileShareAny);

	file.Close();

	iRfs.Close();

	return err;

	}

TInt CAtsLogger::OpenExistingFileL(const TDesC& aFileName)

	{

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

	RFile file;

	TInt err = file.Open(iRfs, aFileName, EFileWrite | EFileShareAny);

	file.Close();

	iRfs.Close();

	return err;

	}

EXPORT_C CAtsLogger::~CAtsLogger()

	{

	if (!iClosed)

		{

		CloseL();

		}

	if (iXmlBuffer)

		{

		delete iXmlBuffer;

		iXmlBuffer = NULL;

		}

	}

EXPORT_C void CAtsLogger::CloseL()

	{

	if (iClosed)

		{

		return;

		}

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

	if (iXmlLog)

		{

		RFile file;

		TInt err = file.Open(iRfs, iXmlLogFileName, EFileWrite | EFileShareAny);

		if (err == KErrNone)

			{

			TInt fileSize = 0;

			file.Size(fileSize);

			file.Close();

			if (fileSize == 0)

				{

				iRfs.Delete(iXmlLogFileName);

				}

			}

		}

	if (iRawLog)

		{

		RFile file;

		TInt err = file.Open(iRfs, iRawLogFileName, EFileWrite | EFileShareAny);

		if (err == KErrNone)

			{

			TInt fileSize = 0;

			file.Size(fileSize);

			file.Close();

			if (fileSize == 0)

				{

				iRfs.Delete(iRawLogFileName);

				}

			}

		}

	iRfs.Close();

	iClosed = ETrue;

	}

EXPORT_C CAtsLogger* CAtsLogger::NewL( const TDesC& aName,

                                       TBool aAfterReboot )

	{

	__ASSERT_ALWAYS(aName.Length() > 0, User::Leave(KErrBadName));

	RFs rfs;

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

	__ASSERT_ALWAYS(rfs.IsValidName(aName), User::Leave(KErrBadName));

	rfs.Close();

	CAtsLogger* self = new (ELeave) CAtsLogger(aName);

	CleanupStack::PushL(self);

	self->ConstructL( aAfterReboot );

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C TBool CAtsLogger::IsValid()

	{

	return iValid;

	}

EXPORT_C void CAtsLogger::BeginTestReportL()

	{

	if (iFullReportingMode)

		{

		if (!IsTransitionLegal(EBeginTestReport))

			{

			User::Leave(EBeginTestReport);

			}

		iReportStage = EBeginTestReport;

		OpenTagIndentL(KAtsLoggerTagTestReport());

		}

	else

		{

		//iTestSet.iStartTime = TTime();

		iTestSet.iStartTime.HomeTime();

		}

	}

EXPORT_C void CAtsLogger::EndTestReportL()

	{

	if (iFullReportingMode)

		{

		if (!IsTransitionLegal(EEndTestReport))

			{

			User::Leave(EEndTestReport);

			}

		iReportStage = EEndTestReport;

		CloseTagIndentL(KAtsLoggerTagTestReport());

		}

	if (iDoDebugOutput)

		{

		WriteBufferToDebugPortL(iXmlBuffer);

		}

	if (iXmlLog && !iInTestCase && iXmlBufferLength > 0)

		{

		WriteBufferToFileL(iXmlBuffer, iXmlLogFileName);

		}

	iXmlBuffer->Reset();

	iXmlBufferLength = 0;

	}

EXPORT_C void CAtsLogger::BeginTestSetL(const TDesC& aFactory,

									    const TDesC& aComponent,

									    const TDesC& aVersion,

									    const TDesC& aDescription)

	{

	if (iFullReportingMode)

		{

		if (!IsTransitionLegal(EBeginTestSet))

			{

			User::Leave(EBeginTestSet);

			}

		iReportStage = EBeginTestSet;

		//iTestSet.iStartTime = TTime();

		iTestSet.iStartTime.HomeTime();

		TDateTime date(iTestSet.iStartTime.DateTime());

		OpenTagIndentL(KAtsLoggerTagTestSet());

		OpenTagIndentL(KAtsLoggerTagTestSetInit());

		TagL(KAtsLoggerTagDescription(), aDescription);

		HBufC* stamp;

		stamp = FormatDateLC(date);

		TagL(KAtsLoggerTagDate(), *stamp);

		CleanupStack::PopAndDestroy(stamp);

		TagL(KAtsLoggerTagFactory(), aFactory);

		OpenTagIndentL(KAtsLoggerTagComponent());

		TagL(KAtsLoggerTagName(), aComponent);

		TagL(KAtsLoggerTagVersion(), aVersion);

		CloseTagIndentL(KAtsLoggerTagComponent());

		CloseTagIndentL(KAtsLoggerTagTestSetInit());

		}

	}

EXPORT_C void CAtsLogger::SaveForRebootL()

	{

	if (iFullReportingMode)

		{

		iReportStage = EEndTestReport;

		}

	if (iDoDebugOutput)

		{

		WriteBufferToDebugPortL(iXmlBuffer);

		}

	if (iXmlLog && !iInTestCase && iXmlBufferLength > 0)

		{

		WriteBufferToFileL(iXmlBuffer, iXmlLogFileName);

		}

	iXmlBuffer->Reset();

	iXmlBufferLength = 0;

	}

EXPORT_C void CAtsLogger::ContinueAfterRebootL()

	{

	if (iFullReportingMode)

		{

		iIndentLevel += 2;

		iLineFeedDone = ETrue;

		iReportStage = EBeginTestSet;

		//iTestSet.iStartTime = TTime();

		iTestSet.iStartTime.HomeTime();

		}

	}

EXPORT_C void CAtsLogger::EndTestSetL()

	{

	if (iFullReportingMode)

		{

		if (!IsTransitionLegal(EEndTestSet))

			{

			User::Leave(EEndTestSet);

			}

		iReportStage = EEndTestSet;

		OpenTagIndentL(KAtsLoggerTagTestSetResult());

		TTime current;

		current.HomeTime();

		HBufC* time;

		time = FormatTimeLC(current.MicroSecondsFrom(iTestSet.iStartTime));

		TagL(KAtsLoggerTagRunTime(), *time);

		CleanupStack::PopAndDestroy(time);

		CloseTagIndentL(KAtsLoggerTagTestSetResult());

		CloseTagIndentL(KAtsLoggerTagTestSet());

		}

	}

EXPORT_C void CAtsLogger::BeginTestCaseL(const TDesC& aId,

									     const TDesC& aExpected,

								    	 const TDesC& aInfo,

										 const TDesC& aVersion)

	{

	TTime current;

	current.HomeTime();	

	BeginTestCaseReportL( aId, aExpected, current, aInfo, aVersion );

	}

EXPORT_C void CAtsLogger::BeginTestCaseL(const TDesC& aId,

										 const TInt aExpected,

										 const TDesC& aInfo,

										 const TDesC& aVersion)

	{

		TBuf<16> res;

		res.Format(_L("%d"), aExpected);

		BeginTestCaseL(aId, res, aInfo, aVersion);

	}

EXPORT_C void CAtsLogger::BeginTestCaseReportL( const TDesC& aId,

										        const TDesC& aExpected,

										        const TTime& aStartTime,

										        const TDesC& aInfo,

										        const TDesC& aVersion )

	{

	if (iFullReportingMode)

		{

		if (!IsTransitionLegal(EBeginTestCase))

			{

			User::Leave(EBeginTestCase);

			}

		iReportStage = EBeginTestCase;

	}		

	iTestCase.iStartTime = aStartTime;

	HBufC* time;

	time = FormatTimeLC(aStartTime.MicroSecondsFrom(iTestSet.iStartTime));

	OpenTagIndentL(KAtsLoggerTagTestCase(), KAtsLoggerTimeStamp(), *time);

	CleanupStack::PopAndDestroy(time);

	OpenTagIndentL(KAtsLoggerTagTestCaseInit());

	TagL(KAtsLoggerTagVersion, aVersion);

	TagL(KAtsLoggerTagId(), aId);

	TagL(KAtsLoggerTagExpected(), aExpected, KAtsLoggerTagDescription(), aInfo);

	CloseTagIndentL(KAtsLoggerTagTestCaseInit());

	iTestCase.iStatus.Set(KAtsLoggerNa());

	iInTestCase = ETrue;

	}

EXPORT_C void CAtsLogger::BeginTestCaseReportL( const TDesC& aId,

										        const TInt aExpected,

										        const TTime& aStartTime,

										        const TDesC& aInfo,

										        const TDesC& aVersion )

	{

	TBuf<16> res;

	res.Format(_L("%d"), aExpected);

	BeginTestCaseReportL( aId, res, aStartTime, aInfo, aVersion );

    }

EXPORT_C void CAtsLogger::EndTestCaseL()

	{

	if (iFullReportingMode)

		{

		if (!IsTransitionLegal(EEndTestCase))

			{

			User::Leave(EEndTestCase);

			}

		iReportStage = EEndTestCase;

	}

	TTime current;

	current.HomeTime();

	OpenTagIndentL(KAtsLoggerTagTestCaseResult(), KAtsLoggerTagStatus(), iTestCase.iStatus);

	if (iTestCase.iResult)

		{

		TagL(KAtsLoggerTagActual(), *iTestCase.iResult);

		delete iTestCase.iResult;

		iTestCase.iResult = NULL;

		}

	else

		{

		TagL(KAtsLoggerTagActual(), KAtsLoggerEmpty());

		}

	HBufC* time;

	time = FormatTimeLC(current.MicroSecondsFrom(iTestCase.iStartTime));

	TagL(KAtsLoggerTagRunTime(), *time);

	CleanupStack::PopAndDestroy(time);

	CloseTagIndentL(KAtsLoggerTagTestCaseResult());	

	CloseTagIndentL(KAtsLoggerTagTestCase());

	iInTestCase = EFalse;

	if (iDoDebugOutput)

		{

		WriteBufferToDebugPortL(iXmlBuffer);

		}

	if (iXmlLog)

		{

		WriteBufferToFileL(iXmlBuffer, iXmlLogFileName);

		}

	iXmlBuffer->Reset();

	iXmlBufferLength = 0;

	}

EXPORT_C void CAtsLogger::TestCasePassed()

	{

	if (iFullReportingMode)

		{

		if (!IsTransitionLegal(ESetTestCaseVerdict))

			{

			User::Leave(ESetTestCaseVerdict);

			}

		iReportStage = ESetTestCaseVerdict;

	}

	iTestCase.iStatus.Set(KAtsLoggerPassed());

	}

EXPORT_C void CAtsLogger::TestCaseFailed()

	{

	if (iFullReportingMode)

		{

		if (!IsTransitionLegal(ESetTestCaseVerdict))

			{

			User::Leave(ESetTestCaseVerdict);

			}

		iReportStage = ESetTestCaseVerdict;

	}

	iTestCase.iStatus.Set(KAtsLoggerFailed());

	}

EXPORT_C void CAtsLogger::TestCaseNa()

	{

	if (iFullReportingMode)

		{

		if (!IsTransitionLegal(ESetTestCaseVerdict))

			{

			User::Leave(ESetTestCaseVerdict);

			}

		iReportStage = ESetTestCaseVerdict;

	}

	iTestCase.iStatus.Set(KAtsLoggerNa());

	}

EXPORT_C void CAtsLogger::TestCaseSkipped()

	{

	if (iFullReportingMode)

		{

		if (!IsTransitionLegal(ESetTestCaseVerdict))

			{

			User::Leave(ESetTestCaseVerdict);

			}

		iReportStage = ESetTestCaseVerdict;

	}

	iTestCase.iStatus.Set(KAtsLoggerSkipped());

	}

EXPORT_C void CAtsLogger::SetTestCaseResultL(const TDesC& aResult)

	{

	if (iTestCase.iResult)

		{

		delete iTestCase.iResult;

		iTestCase.iResult = NULL;

		}

	HBufC* newResult = HBufC::NewL(aResult.Length());

	CleanupStack::PushL(newResult);

	TPtr ptr(newResult->Des());

	ptr.Copy(aResult);

	CleanupStack::Pop(newResult);

	iTestCase.iResult = newResult;

	}

EXPORT_C void CAtsLogger::SetTestCaseResultL(const TInt aResult)

	{

	if (iTestCase.iResult)

		{

		delete iTestCase.iResult;

		iTestCase.iResult = NULL;

		}

	HBufC* newResult = HBufC::NewL(16);

	CleanupStack::PushL(newResult);

	TPtr ptr(newResult->Des());

	ptr.Format(_L("%d"), aResult);

	CleanupStack::Pop(newResult);

	iTestCase.iResult = newResult;

	}