// tail.cpp

// 

// Copyright (c) 2005 - 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 "character_converter.h"

#include "file_reader.h"

#include "tail.h"

const TInt KBlockSize = 512;

const TText KUnicodeParagraphSeparator = 0x2029;

const TText KUnicodeLineSeparator = 0x2028;

const TText KCarriageReturn = 0x000d;

const TText KLineFeed = 0x000a;

//

// CTrailingLineFinder.

//

class CTrailingLineFinder : public CBase, public MFileReaderObserver

	{

public:

	static CTrailingLineFinder* NewL(TInt aBlockSize, CCharacterConverter& aCharacterConverter);

	~CTrailingLineFinder();

	void Find(CFileReader& aFileReader, const TDesC& aFileName, TInt aNumLines, MTrailingLineFinderObserver& aObserver);

	void Cancel();

	const TDesC& operator[](TInt aIndex) const;

private:

	CTrailingLineFinder(CCharacterConverter& aCharacterConverter);

	void ConstructL(TInt aBlockSize);

	void HandleFileDataL(const TDesC8& aData, TReadType aType, TBool& aContinue);

	void FindNextLine(const TDesC& aData, TInt aOffset, TPtrC& aLine, TBool& aComplete);

	void AddLineL(const TDesC& aLine, TBool aComplete);

private:	// From MFileReaderObserver.

	virtual void HandleFileData(const TDesC8& aData, TReadType aType, TBool& aContinue);

	virtual void HandleFileReadError(TInt aError);

private:

	CFileReader* iFileReader;

	CCharacterConverter& iCharacterConverter;

	MTrailingLineFinderObserver* iObserver;

	HBufC8* iBuf;

	TPtr8 iPtr;

	RPointerArray<HBufC> iTrailingLines;

	TInt iCurrentLineIndex;

	TInt iNumLinesToFind;

	TInt iNumCompleteLinesFound;

	TInt iFilePos;

	TBool iPossiblySplitCrLf;

	TBool iLastLineNotComplete;

	};

CTrailingLineFinder* CTrailingLineFinder::NewL(TInt aBlockSize, CCharacterConverter& aCharacterConverter)

	{

	CTrailingLineFinder* self = new(ELeave) CTrailingLineFinder(aCharacterConverter);

	CleanupStack::PushL(self);

	self->ConstructL(aBlockSize);

	CleanupStack::Pop(self);

	return self;

	}

CTrailingLineFinder::~CTrailingLineFinder()

	{

	delete iBuf;

	iTrailingLines.ResetAndDestroy();

	}

void CTrailingLineFinder::Find(CFileReader& aFileReader, const TDesC& aFileName, TInt aNumLines, MTrailingLineFinderObserver& aObserver)

	{

	ASSERT(!iFileReader);

	iTrailingLines.ResetAndDestroy();

	iFileReader = &aFileReader;

	iObserver = &aObserver;

	iNumLinesToFind = aNumLines;

	iNumCompleteLinesFound = 0;

	iCurrentLineIndex = -1;

	iPossiblySplitCrLf = EFalse;

	iFileReader->Read(aFileName, *this);

	}

void CTrailingLineFinder::Cancel()

	{

	if (iFileReader)

		{

		iFileReader->Cancel();

		}

	}

const TDesC& CTrailingLineFinder::operator[](TInt aIndex) const

	{

	return *iTrailingLines[aIndex];

	}

void CTrailingLineFinder::HandleFileDataL(const TDesC8& aData, TReadType aType, TBool& aContinue)

	{

	iFilePos += aData.Length();

	aContinue = ETrue;

	const TDesC* convertedData = NULL;

	switch (aType)

		{

		case MFileReaderObserver::EFirst:

			{

			convertedData = &iCharacterConverter.ConvertChunkL(aData, CCharacterConverter::EFirst);

			break;

			}

		case MFileReaderObserver::EMiddle:

			{

			convertedData = &iCharacterConverter.ConvertChunkL(aData, CCharacterConverter::EMiddle);

			break;

			}

		case MFileReaderObserver::ELast:

			{

			convertedData = &iCharacterConverter.ConvertChunkL(aData, CCharacterConverter::ELast);

			break;

			}

		default:

			{

			ASSERT(FALSE);

			}

		}

	if (convertedData->Length() > 0)

		{

		TInt offset = 0;

		FOREVER

			{

			TPtrC linePtr;

			TBool completeLine;

			FindNextLine(*convertedData, offset, linePtr, completeLine);

			AddLineL(linePtr, completeLine);

			if (!completeLine)

				{

				break;

				}

			offset += linePtr.Length();

			}

		}

	if (aType == MFileReaderObserver::ELast)

		{

		iFileReader = NULL;

		iObserver->HandleTrailingLines(iCurrentLineIndex + 1, iFilePos);

		}

	}

void CTrailingLineFinder::AddLineL(const TDesC& aLine, TBool aComplete)

	{

	if (iLastLineNotComplete)

		{

		HBufC*& buf = iTrailingLines[iCurrentLineIndex];

		buf = buf->ReAllocL(buf->Length() + aLine.Length());

		buf->Des() += aLine;

		}

	else

		{

		HBufC* line = aLine.AllocLC();

		if (iNumCompleteLinesFound <= iNumLinesToFind)

			{

			++iCurrentLineIndex;

			User::LeaveIfError(iTrailingLines.Append(line));

			}

		else

			{

			delete iTrailingLines[0];

			iTrailingLines.Remove(0);

			iTrailingLines.Append(line); // Will always succeed due to the above removal.

			}

		CleanupStack::Pop(line);

		}

	iLastLineNotComplete = !aComplete;

	if (aComplete)

		{

		++iNumCompleteLinesFound;

		}

	}

CTrailingLineFinder::CTrailingLineFinder(CCharacterConverter& aCharacterConverter)

	: iCharacterConverter(aCharacterConverter), iPtr(NULL, 0)

	{

	}

void CTrailingLineFinder::ConstructL(TInt aBlockSize)

	{

	iBuf = HBufC8::NewL(aBlockSize);

	iPtr.Set(iBuf->Des());

	}

void CTrailingLineFinder::FindNextLine(const TDesC& aData, TInt aOffset, TPtrC& aLine, TBool& aComplete)

	{

	const TText* first = aData.Ptr() + aOffset;

	const TText* p = first;

	const TText* last = first + aData.Length() - aOffset - 1;

	aComplete = EFalse;

	TBool foundLineBreak = EFalse;

	while ((p <= last) && !foundLineBreak)

		{

		if (iPossiblySplitCrLf)

			{

			iPossiblySplitCrLf = EFalse;

			if (*p == KLineFeed)

				{

				aComplete = ETrue;

				foundLineBreak = ETrue;

				}

			}

		else if ((*p == KUnicodeParagraphSeparator) || (*p == KUnicodeLineSeparator) || (*p == KLineFeed))

			{

			aComplete = ETrue;

			foundLineBreak = ETrue;

			}

		else if (*p == KCarriageReturn)

			{

			if (p == last)

				{

				iPossiblySplitCrLf = ETrue;

				}

			else if (*(p + 1) == KLineFeed)

				{

				aComplete = ETrue;

				foundLineBreak = ETrue;

				++p;

				}

			else

				{

				aComplete = ETrue;

				foundLineBreak = ETrue;

				}

			}

		++p;

		}

	aLine.Set(first, p - first);

	}

void CTrailingLineFinder::HandleFileData(const TDesC8& aData, TReadType aType, TBool& aContinue)

	{

	TRAPD(err, HandleFileDataL(aData, aType, aContinue));

	if (err)

		{

		iObserver->HandleTrailingLineError(err);

		}

	}

void CTrailingLineFinder::HandleFileReadError(TInt aError)

	{

	iObserver->HandleTrailingLineError(aError);

	}

//

// CFileWatcher.

//

class CFileWatcher : public CActive

	{

public:

	static CFileWatcher* NewL(RFs& aFs);

	~CFileWatcher();

	void Start(const TDesC& aFileName, MFileChangeObserver& aObserver);

private:

	CFileWatcher(RFs& aFs);

	void Queue();

private:	// From CActive.

	virtual void DoCancel();

	virtual void RunL();

private:

	RFs& iFs;

	TFileName iFileName;

	MFileChangeObserver* iObserver;

	};

CFileWatcher* CFileWatcher::NewL(RFs& aFs)

	{

	return new(ELeave) CFileWatcher(aFs);

	}

CFileWatcher::~CFileWatcher()

	{

	Cancel();

	}

void CFileWatcher::Start(const TDesC& aFileName, MFileChangeObserver& aObserver)

	{

	ASSERT(!IsActive());

	iFileName = aFileName;

	iObserver = &aObserver;

	Queue();

	}

CFileWatcher::CFileWatcher(RFs& aFs)

	: CActive(CActive::EPriorityStandard), iFs(aFs)

	{

	CActiveScheduler::Add(this);

	}

void CFileWatcher::Queue()

	{

	ASSERT(!IsActive());

	iFs.NotifyChange(ENotifyWrite, iStatus, iFileName);

	SetActive();

	}

void CFileWatcher::DoCancel()

	{

	iFs.NotifyChangeCancel(iStatus);

	}

void CFileWatcher::RunL()

	{

	Queue();

	iObserver->HandleFileChange(iFileName);

	}

//

// CCmdTail.

//

CCommandBase* CCmdTail::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CCmdTail::~CCmdTail()

	{

	delete iCharacterConverter;

	delete iTrailingLineFinder;

	delete iFileWatcher;

	delete iFileReader;

	}

CCmdTail::CCmdTail()

	: CCommandBase(EManualComplete), iNumLines(10)

	{

	}

void CCmdTail::ConstructL()

	{

	BaseConstructL();

	}

void CCmdTail::WriteChunkToConsoleL(const TDesC8& aData, TReadType aType)

	{

	switch (aType)

		{

		case MFileReaderObserver::EFirst:

			{

			Write(iCharacterConverter->ConvertChunkL(aData, CCharacterConverter::EFirst));

			break;

			}

		case MFileReaderObserver::EMiddle: // Treat "middle" and "last" to same as with tailing it's not possible to know if "last" is really last.

		case MFileReaderObserver::ELast:

			{

			Write(iCharacterConverter->ConvertChunkL(aData, CCharacterConverter::EMiddle));

			break;

			}

		default:

			{

			ASSERT(FALSE);

			}

		}

	}

const TDesC& CCmdTail::Name() const

	{

	_LIT(KName, "tail");

	return KName;

	}

void CCmdTail::DoRunL()

	{

	iCharacterConverter = CCharacterConverter::NewL(KBlockSize, FsL());

	iTrailingLineFinder = CTrailingLineFinder::NewL(KBlockSize, *iCharacterConverter);

	iFileWatcher = CFileWatcher::NewL(Fs());

	iFileReader = CFileReader::NewL(KBlockSize, Fs(), ETrue);

	iTrailingLineFinder->Find(*iFileReader, iFileName, iNumLines, *this);

	}

void CCmdTail::OptionsL(RCommandOptionList& aOptions)

	{

	_LIT(KOptFollow, "follow");

	_LIT(KOptNumLines, "lines");

	aOptions.AppendBoolL(iFollow, KOptFollow);

	aOptions.AppendIntL(iNumLines, KOptNumLines);

	}

void CCmdTail::ArgumentsL(RCommandArgumentList& aArguments)

	{

	_LIT(KArgFileName, "file_name");

	aArguments.AppendFileNameL(iFileName, KArgFileName);

	}

void CCmdTail::HandleTrailingLines(TInt aNumLinesFound, TInt aEndFilePos)

	{

	if (iFollow)

		{

		iFilePos = aEndFilePos;

		iFileWatcher->Start(iFileName, *this);

		}

	for (TInt i = 0; i < aNumLinesFound; ++i)

		{

		Write((*iTrailingLineFinder)[i]);

		}

	if (!iFollow)

		{

		Complete();

		}

	}

void CCmdTail::HandleTrailingLineError(TInt aError)

	{

	PrintError(aError, _L("Problem finding trailing %d lines in %S: %d"), iNumLines, &iFileName, aError);

	Complete(aError);

	}

void CCmdTail::HandleFileChange(const TDesC& /*aFileName*/)

	{

	if (!iFileReader->IsActive())

		{

		iFileReader->Read(iFileName, iFilePos, *this);

		}

	}

void CCmdTail::HandleFileData(const TDesC8& aData, TReadType aType, TBool& aContinue)

	{

	aContinue = ETrue;

	iFilePos += aData.Length();

	TRAPD(err, WriteChunkToConsoleL(aData, aType));

	if (err)

		{

		aContinue = EFalse;

		PrintError(err, _L("Problem writing chunk of %S to console: %d"), &iFileName, err);

		}

	}

void CCmdTail::HandleFileReadError(TInt aError)

	{

	PrintWarning(_L("Problem reading %S: %d"), &iFileName, aError);

	}

#ifdef EXE_BUILD

EXE_BOILER_PLATE(CCmdTail)

#endif