// cat.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 "cat.h"

const TInt KDefaultBlockSize = 512;


CCommandBase* CCmdCat::NewLC()
	{
	CCmdCat* self = new(ELeave) CCmdCat();
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}

CCmdCat::~CCmdCat()
	{
	iFiles.Close();
	iBuf16.Close();
	delete iCharacterConverter;
	delete iFileReader;
	}

CCmdCat::CCmdCat()
	: CCommandBase(EManualComplete), iBlockSize(KDefaultBlockSize)
	{
	}

void CCmdCat::ConstructL()
	{
	BaseConstructL();
	}

void CCmdCat::ReadNextFile()
	{
	if (iFiles.Count() > 0)
		{
		iFileReader->Read(iFiles[0], *this);
		}
	else
		{
		Complete();
		}
	}

void CCmdCat::RemoveCurrentFileName()
	{
	iFiles.Remove(0);
	}

void CCmdCat::WriteChunkToConsoleL(const TDesC8& aData, TReadType aType)
	{
	if (iEncoding == EBinary)
		{
		iBuf16.Copy(aData);
		Write(iBuf16);
		if (aType == MFileReaderObserver::ELast)
			{
			RemoveCurrentFileName();
			ReadNextFile();
			}
		}
	else if (iEncoding == ELtkUtf8)
		{
		iBuf16.Zero();
		iBuf16.AppendUtf8L(aData);
		Write(iBuf16);
		if (aType == MFileReaderObserver::ELast)
			{
			TInt firstBad;
			iBuf16.FinalizeUtf8(firstBad);
			if (firstBad != KErrNotFound) PrintWarning(_L("Found bad UTF-8 sequence in %S at byte offset %d"), &iFiles[0], firstBad);

			RemoveCurrentFileName();
			ReadNextFile();
			}
		}
	else
		{
		switch (aType)
			{
			case MFileReaderObserver::EFirst:
				{
				Write(iCharacterConverter->ConvertChunkL(aData, CCharacterConverter::EFirst));
				break;
				}
			case MFileReaderObserver::EMiddle:
				{
				Write(iCharacterConverter->ConvertChunkL(aData, CCharacterConverter::EMiddle));
				break;
				}
			case MFileReaderObserver::ELast:
				{
				Write(iCharacterConverter->ConvertChunkL(aData, CCharacterConverter::ELast));
				RemoveCurrentFileName();
				ReadNextFile();
				break;
				}
			default:
				{
				ASSERT(FALSE);
				}
			}
		}
	}

const TDesC& CCmdCat::Name() const
	{
	_LIT(KName, "cat");
	return KName;
	}

void CCmdCat::DoRunL()
	{
	if (iBinary)
		{
		if (iOptions.IsPresent(&iEncoding))
			{
			PrintWarning(_L("--encoding overrides legacy --binary option"));
			}
		else
			{
			iEncoding = EBinary;
			}
		}

	if (iEncoding == EBinary || iEncoding == ELtkUtf8 || iFiles.Count() == 0)
		{
		iBuf16.CreateL(iBlockSize);
		}
	else
		{
		TUint charset;
		switch (iEncoding)
			{
			case EUtf8:
				charset = KCharacterSetIdentifierUtf8;
				break;
			case ELatin1:
				charset = KCharacterSetIdentifierIso88591;
				break;
			case EAuto:
			default:
				charset = 0;
				break;

			}
		TRAPL(iCharacterConverter = CCharacterConverter::NewL(iBlockSize, FsL(), charset), _L("Couldn't load charconv - try using --binary mode"));
		}
	iFileReader = CFileReader::NewL(iBlockSize, FsL(), iForce);

	if (iFiles.Count() > 0)
		{
		ReadNextFile();
		}
	else
		{
		TInt err = KErrNone;
		while (err == KErrNone)
			{
			err = Stdin().Read(iBuf16);
			if (err == KErrNone)
				{
				Write(iBuf16);
				}
			}
		if (err == KErrEof)
			{
			err = KErrNone;
			}
		Complete(err);
		}
	}

void CCmdCat::OptionsL(RCommandOptionList& aOptions)
	{
	_LIT(KOptForce, "force");
	_LIT(KOptBinary, "binary");
	_LIT(KOptEncoding, "encoding");
	_LIT(KOptBlockSize, "block-size");

	aOptions.AppendBoolL(iForce, KOptForce);
	aOptions.AppendEnumL((TInt&)iEncoding, KOptEncoding);
	aOptions.AppendIntL(iBlockSize, KOptBlockSize);
	aOptions.AppendBoolL(iBinary, KOptBinary);
	}

void CCmdCat::ArgumentsL(RCommandArgumentList& aArguments)
	{
	_LIT(KArgFiles, "file_name");
	aArguments.AppendFileNameL(iFiles, KArgFiles);
	}

CCommandBase& CCmdCat::Command()
	{
	return *this;
	}

void CCmdCat::HandleFileData(const TDesC8& aData, TReadType aType, TBool& aContinue)
	{
	aContinue = ETrue;
	TRAPD(err, WriteChunkToConsoleL(aData, aType));
	if (err)
		{
		aContinue = EFalse;
		PrintWarning(_L("Problem writing chunk of %S to console: %d"), &iFiles[0], err);
		RemoveCurrentFileName();
		ReadNextFile();
		}
	}

void CCmdCat::HandleFileReadError(TInt aError)
	{
	PrintWarning(_L("Problem reading %S: %d"), &iFiles[0], aError);
	RemoveCurrentFileName();
	ReadNextFile();
	}


#ifdef EXE_BUILD
EXE_BOILER_PLATE(CCmdCat)
#endif