/*

* All rights reserved.

* This component and the accompanying materials are made available

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

* cpackageinfo.cpp

* This file provides implementation for CIoHandler class

* CIoHandler: This class handles all the I/O activities like reading from

* console, writing to a log file, etc.

* @internalComponent

*

*/

#include <e32cons.h> 		// ConsoleBase

// User includes

#include "ciohandler.h"

#include "clogger.h"

#include "cpreferencehandler.h"

#include "swiconsoleerrors.h"

// Constants and literals

const TInt KProgressBarFactor	= 3;

const TInt KCursorOffset		= 2;

const TInt KProgressOffset		= 1;

const TInt KDateAdjustment		= 1;

const TInt KAllocationBlock		= 50;

_LIT(KCurProgressSymbol, "#");

_LIT(KCompleteProgressSymbol, "-");

_LIT(KDateFormatString, "%d/%d/%d");

_LIT(KConsoleName, "SwiConsole");

CIoHandler::CIoHandler():

			iIsLoggingEnabled(EFalse),

			iIsProgressBarEnabled(EFalse)

	{

	}

CIoHandler::~CIoHandler()

	{

	iResourceFile.Close();

	iFileSession.Close();

	delete iLogger;

	delete iConsole;

	}

// Second phase constructor

void CIoHandler::ConstructL()

	{

	iConsole = Console::NewL(KConsoleName,TSize(KConsFullScreen,KConsFullScreen));

	iProgressBarLen = iConsole->ScreenSize().iWidth;

	iProgressBarLen -= iProgressBarLen/KProgressBarFactor;

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

	_LIT(KResourceFile, "swiconsole.rsc"); 

	TFileName privatePath;

	iFileSession.PrivatePath(privatePath);

	TFileName resourceFilename(_L("Z:"));

	resourceFilename.Append(privatePath);

	resourceFilename.Append(KResourceFile());

	iResourceFile.OpenL(iFileSession, resourceFilename);

	}

CIoHandler* CIoHandler::NewL()

	{

	CIoHandler* self = NewLC();

	CleanupStack::Pop(self);

	return self;

	}

CIoHandler* CIoHandler::NewLC()

	{

	CIoHandler* self = new (ELeave) CIoHandler();

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

HBufC* CIoHandler::GetStringFromResourceLC(TInt aStringUid) const

	{

	HBufC8* dataBuffer = iResourceFile.AllocReadLC(aStringUid);

    TResourceReader resourceReader;

    resourceReader.SetBuffer(dataBuffer);

    TInt bufferLength = dataBuffer->Length();

	HBufC* stringBuffer = HBufC::NewL(bufferLength);

	TPtr ptrString = stringBuffer->Des();

	ptrString.Copy(resourceReader.ReadTPtrC());

    // clean up data buffer

    CleanupStack::PopAndDestroy(); // finished with dataBuffer

    CleanupStack::PushL(stringBuffer);

    return stringBuffer;

	}

void CIoHandler::GetStringFromResourceL(TDes& aString, TInt aStringUid) const

	{

	HBufC8* dataBuffer = iResourceFile.AllocReadLC(aStringUid);

    TResourceReader resourceReader;

    resourceReader.SetBuffer(dataBuffer);

    __ASSERT_DEBUG(resourceReader.ReadTPtrC().Length() < aString.MaxLength(), 

    				User::Panic(KGeneralPanicString, KInvalidArgument));

	aString.Copy(resourceReader.ReadTPtrC());

    // clean up data buffer

    CleanupStack::PopAndDestroy(); // finished with dataBuffer

	}

void CIoHandler::WriteToConsoleL(const TDesC& aString) const

	{

	if(	iIsProgressBarEnabled)

		{

		// This piece of code is used to redraw progress bar

		TSize screenSize = iConsole->ScreenSize();

		if(iConsole->WhereY() == screenSize.iHeight - KProgressOffset)

			{

			// Clear the current progress bar

			ClearLine();

			// write the string

			iConsole->Printf(aString);

			// Save the cursor position

			TPoint curPos = iConsole->CursorPos();

			// If the string passed is not a line breaker

			// then add line breaker

			if(aString.Compare(KLineBreaker))

				{

				iConsole->Printf(KLineBreaker);

				--curPos.iY;

				}

			RedrawProgressBarL();

			iConsole->SetPos(curPos.iX, curPos.iY);

			return;

			}

		}

	iConsole->Printf(aString);

	}	

void CIoHandler::WriteL(const TDesC& aString, TIoType aIoType) const

	{

	switch(aIoType)

		{

		case EIoBoth:

		case EIoConsoleType:

			{

			WriteToConsoleL(aString);

			if(EIoBoth != aIoType)

				{

				break;

				}

			}

		case EIoLogType:

			{

			if(!iIsLoggingEnabled)

				{

				break;

				}

			if(!aString.Compare(KLineBreaker))

				{

				iLogger->FlushLog();

				break;

				}

			iLogger->WriteL(aString);

			break;

			}

		default:

			{

			User::Leave(KSwiInvalidSwitchCase);

			}

		}

	}

void CIoHandler::WriteLineL(const TDesC& aString, TIoType aIoType) const

	{

	switch(aIoType)

		{

		case EIoBoth:

		case EIoConsoleType:

			{

			WriteToConsoleL(aString);

			WriteToConsoleL(KLineBreaker);

			if(EIoBoth != aIoType)

				{

				break;

				}

			}

		case EIoLogType:

			{

			if(!iIsLoggingEnabled)

				{

				break;

				}

			iLogger->WriteAndFlushL(aString);

			break;

			}

		default:

			{

			User::Leave(KSwiInvalidSwitchCase);

			}

		}

	}

void CIoHandler::WriteToPageL(const TDesC& aString, TBool aInsertLineBreak) const

	{

	TSize screenSize = iConsole->ScreenSize();

	if(iConsole->WhereY() >= screenSize.iHeight - KCursorOffset)

		{

		iConsole->Printf(KLineBreaker);

		if(!iPreferenceHandler || ESwiNormalMode == iPreferenceHandler->GetOperationMode())

			{

			PauseScreenL();

			}

		ClearConsoleL();

		}

	WriteToConsoleL(aString);

	if(aInsertLineBreak)

		{

		WriteToConsoleL(KLineBreaker);

		}

	}

void CIoHandler::WriteL(TInt aResourceID, TIoType aIoType) const

	{

	HBufC *string = GetStringFromResourceLC(aResourceID);

	WriteL(*string, aIoType);

	CleanupStack::PopAndDestroy(string);

	}

void CIoHandler::WriteLineL(TInt aResourceID, TIoType aIoType) const

	{

	HBufC *string = GetStringFromResourceLC(aResourceID);

	WriteLineL(*string, aIoType);

	CleanupStack::PopAndDestroy(string);

	}

void CIoHandler::WriteToPageL(TInt aResourceID, TBool aInsertLineBreak) const

	{

	TSize screenSize = iConsole->ScreenSize();

	if(iConsole->WhereY() >= screenSize.iHeight - KCursorOffset)

		{

		if(!iPreferenceHandler || ESwiNormalMode == iPreferenceHandler->GetOperationMode())

			{

			PauseScreenL();

			}

		ClearConsoleL();

		}

	HBufC *string = GetStringFromResourceLC(aResourceID);

	WriteToConsoleL(*string);

	if(aInsertLineBreak)

		{

		WriteToConsoleL(KLineBreaker);

		}

	CleanupStack::PopAndDestroy(string);

	}

void CIoHandler::WriteL(const TDateTime& aDate, TIoType aIoType) const

	{

	TBuf<KDateStringLen> dateString;

	dateString.Format(KDateFormatString, aDate.Day() + KDateAdjustment, aDate.Month() + KDateAdjustment, aDate.Year());

	WriteL(dateString, aIoType);

	}

void CIoHandler::WriteLineL(const TDateTime& aDate, TIoType aIoType) const

	{

	TBuf<KDateStringLen> dateString;

	dateString.Format(KDateFormatString, aDate.Day() + KDateAdjustment, aDate.Month() + KDateAdjustment, aDate.Year());

	WriteLineL(dateString, aIoType);

	}

void CIoHandler::WriteErrorMsgL(const TDesC& aString) const

	{

	ClearLine();

	iConsole->Printf(aString);

	TInt initialPos = iConsole->WhereY();

	iConsole->Printf(KLineBreaker);

	TInt finalPos = iConsole->WhereY();

	ClearLine();

	HBufC *string = GetStringFromResourceLC(R_PRESS_ANY_KEY_MSG);

	iConsole->Printf(*string);

	CleanupStack::PopAndDestroy(string);

	iConsole->Getch();

	if(initialPos == finalPos)

		{

		--initialPos;

		}

	ClearLine();

	RedrawProgressBarL();

	iConsole->SetPos(0, initialPos);

	ClearLine();

	}

void CIoHandler::WriteErrorMsgL(TInt aResourceID) const

	{

	HBufC *string = GetStringFromResourceLC(aResourceID);

	WriteErrorMsgL(*string);

	CleanupStack::PopAndDestroy(string);

	}

TBool CIoHandler::ReadStringFromConsoleL(TDes& aString, TBool aLimitedLength)

	{

	// This infinte loop terminates when user hits an "enter" key

	// Or the maximum size of the buffer is hit

	FOREVER

		{

		// Get a key(character) from the console

		TKeyCode ch = iConsole->Getch();

		switch(ch)

			{

			case EKeyEnter:

				{

				return EFalse;

				}

			case EKeyBackspace:

				{

				if(0 != aString.Length())

					{

					// Back-space only takes the cursor one position back

					// So to delete a character blank-space is inserted at

					// that position and later cursor is again adjusted.

					iConsole->Printf(_L("%c%c%c"), EKeyBackspace, 

												   EKeySpace, 

												   EKeyBackspace);

					// Delete the character from the target string also. 

					aString.Delete(aString.Length() - 1, 1);

					}

				break;

				}

			case EKeyEscape:

				{

					User::Leave(KErrCancel);

				}

			default:

				{

				// IsCharacterKey will return true if ch is a displayable

				// character else it will return false.

				if(IsCharacterKey(ch))

					{

					TInt maxBufferLength = aString.MaxLength();

					if(aString.Length() == maxBufferLength)

						{

						continue;

						}

					iConsole->Printf(_L("%c"), ch);

					aString.Append(ch);

					if(aString.Length() == maxBufferLength && !aLimitedLength)

						{

						return ETrue;

						}

					}

				}

			}

		}

	}

void CIoHandler::ReadStringL(TDes& aString)

	{

	aString.Zero();

	ReadStringFromConsoleL(aString);

	}

void CIoHandler::ReadStringL(RBuf& aString)

	{

	aString.Zero();

	while(ReadStringFromConsoleL(aString, EFalse))

		{

		aString.ReAllocL(aString.MaxLength() + KAllocationBlock);

		}

	}

TInt CIoHandler::ReadIntL(TInt& aValue)

	{

	TBuf<KIntStringLen> string;

	ReadStringL(string);

	TLex lexObj(string);

	return lexObj.Val(aValue);

	}

void CIoHandler::ReadIntArrayL(RArray<TInt>& aIntArr, TBool aAllowDuplicates)

	{

	RBuf string;

	string.Create(KIntArrayStringLen);

	CleanupClosePushL(string);

	ReadStringL(string);

	string.TrimLeft();

	if(0 == string.Length())

		{

		return;

		}

	TBool bFlag = ETrue;

	do

		{

		TInt pos = string.Find(_L(" "));

		if(KErrNotFound == pos)

			{

			pos = string.Length();

			bFlag = EFalse;

			}

		TInt number = 0;

		TLex lexObj(string);

		User::LeaveIfError(lexObj.Val(number));

		if(aAllowDuplicates)

			{

			}

		else

			{

			}

		string.Delete(0, pos);

		string.TrimLeft();

		}while(bFlag && string.Length() > 0);

	CleanupStack::PopAndDestroy(&string);

	}

void CIoHandler::InitLoggingL(TDesC& aLogFile)

	{

	__ASSERT_DEBUG(!iIsLoggingEnabled, User::Panic(KGeneralPanicString, KErrArgument));

	iIsLoggingEnabled = ETrue;

	iLogger = CLogger::NewL(aLogFile);

	HBufC *string = GetStringFromResourceLC(R_LOG_LINE_MSG);

	iLogger->WriteAndFlushL(*string);

	CleanupStack::PopAndDestroy(string);

	}

void CIoHandler::SetLoggingState(TBool aEnableLogging)

	{

	iIsLoggingEnabled = aEnableLogging;

	}

void CIoHandler::ClearConsoleL() const

	{

	iConsole->ClearScreen();

	RedrawProgressBarL();

	}

void CIoHandler::ClearLine() const

	{

	iConsole->SetPos(0);

	iConsole->ClearToEndOfLine();

	}

void CIoHandler::PauseScreenL() const

	{

	HBufC *string = GetStringFromResourceLC(R_PRESS_ANY_KEY_MSG);

	WriteL(*string, EIoConsoleType);

	CleanupStack::PopAndDestroy(string);

	iConsole->Getch();

	iConsole->Printf(KLineBreaker);

	}

TInt CIoHandler::ProgressBarLength() const

	{

	return (iCurProgressValue * iProgressBarLen)/iFinalProgressValue;

	}

void CIoHandler::SetFinalProgressValueL(TInt aFinalValue)

	{

	if(0 == aFinalValue)

		{

		return;

		}

	iFinalProgressValue = aFinalValue;

	iCurProgressValue = iProgressCursor = 0;

	iIsProgressBarEnabled = ETrue;

	TPoint curPos = iConsole->CursorPos();

	TSize screenSize = iConsole->ScreenSize();

	iConsole->SetPos(0, screenSize.iHeight - KProgressOffset);

	HBufC *string = GetStringFromResourceLC(R_PROGRESS_INFO);

	iConsole->Printf(*string);

	CleanupStack::PopAndDestroy(string);

	iProgressStartPos = iConsole->WhereX();

	for(TInt i = iProgressBarLen; i >= 0; --i)

		{

		iConsole->Printf(KCompleteProgressSymbol);

		}

	iConsole->SetPos(curPos.iX, curPos.iY);

	}

void CIoHandler::UpdateProgressBar(TInt aUpdateValue)

	{

	if(!iIsProgressBarEnabled)

		{

		return;

		}

	TPoint curPos = iConsole->CursorPos();

	TSize screenSize = iConsole->ScreenSize();