// pod_formatter.cpp
// 
// Copyright (c) 2009 - 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 "pod_formatter.h"

const TInt KGap = 2;

_LIT(KPartialCommandStart, "\r\n=");
_LIT(KCommandStart, "\r\n\r\n=");
_LIT(KBlankLine, "\r\n\r\n");
_LIT(KNewLine, "\r\n");

using namespace IoUtils;


TPodFormatter::TPodFormatter(CTextFormatter& aFormatter)
	: iFormatter(aFormatter)
	{
	}

void TPodFormatter::FormatL(const TDesC& aPod)
	{
	iPodLex = aPod;
	while (!iPodLex.Eos())
		{
		TPtrC command(NextCommand());
		if (command == _L("pod"))
			{
			SkipToNextBlankLine();
			}
		else if ((command == _L("head1")) || (command == _L("head2")))
			{
			iPodLex.SkipSpaceAndMark();
			SkipToLineEnd();
			iFormatter.SetAttributesL(ConsoleAttributes::EBold | ConsoleAttributes::EUnderscore);
			iFormatter.WrapL(0, iPodLex.MarkedToken());
			iFormatter.SetAttributesL(ConsoleAttributes::ENone);
			iFormatter.AppendL(KBlankLine);
			}
		else if (command == _L("cut"))
			{
			SkipToNextBlankLine();
			break;
			}
		else if (command == _L("begin"))
			{
			TPtrC nextCommand;
			do
				{
				nextCommand.Set(NextCommand());
				}
				while ((nextCommand.Length() > 0) && (nextCommand != _L("end")));

			SkipToNextBlankLine();
			}
		else if (command == _L("for"))
			{
			SkipToNextBlankLine();
			}
		else if (command == _L("over"))
			{
			iPodLex.SkipSpace();
			TUint indent;
			User::LeaveIfError(iPodLex.Val(indent));
			OverL(indent);
			}

		FormatToNextCommandL();
		}
	}

void TPodFormatter::OverL(TInt aIndent)
	{
	CTextBuffer* buffer = CTextBuffer::NewLC(0x100);

	while (!iPodLex.Eos())
		{
		FormatToNextCommandL(aIndent);

		TPtrC command(NextCommand());
		if (command == _L("item"))
			{
			iPodLex.SkipSpaceAndMark();
			SkipToLineEnd();
			buffer->AppendL(iPodLex.MarkedToken());
			iPodLex.SkipSpace();
			//buffer->AppendL('\t');
			//buffer->AppendL(TextToNextCommand());
			// Need to split the text up putting a tab in front of every paragraph of text, in case the item description is multi-paragraph.
			// If we don't, the next paragraph will end up in column one which will break the column formatter.
			// If there's a neater way of doing this, someone feel free! -TomS
			TPtrC text(TextToNextCommand());
			while(text.Length())
				{
				TInt nextNewLine = text.Find(KNewLine);
				if (nextNewLine == KErrNotFound) nextNewLine = text.Length();
				TPtrC line(text.Left(nextNewLine+KNewLine().Length()));
				buffer->AppendL('\t');
				buffer->AppendL(line);
				text.Set(text.Mid(line.Length()));
				}
			buffer->AppendL(KNewLine);
			}
		else if (command == _L("back"))
			{
			break;
			}
		else if (command == _L("over"))
			{
			if (buffer->Descriptor().Length() > 0)
				{
				iFormatter.TabulateL(aIndent, KGap, buffer->Descriptor(), EWrapLastColumn);
				iFormatter.AppendL(KNewLine);
				buffer->Zero();
				}
			iPodLex.SkipSpace();
			TUint indent;
			User::LeaveIfError(iPodLex.Val(indent));
			OverL(indent + aIndent);
			}
		}

	if (buffer->Descriptor().Length() > 0)
		{
		iFormatter.TabulateL(aIndent, KGap, buffer->Descriptor(), EWrapLastColumn);
		iFormatter.AppendL(KNewLine);
		}

	CleanupStack::PopAndDestroy(buffer);
	}

void TPodFormatter::FormatToNextCommandL(TInt aIndent)
	{
	FOREVER
		{
		TPtrC paragraph(NextParagraph());
		if (paragraph.Length() > 0)
			{
			if (TChar(paragraph[0]).IsSpace())
				{
				iFormatter.AppendL(paragraph);
				}
			else
				{
				iFormatter.WrapL(aIndent, paragraph);
				}
			iFormatter.AppendL(KNewLine);
			}
		else
			{
			break;
			}
		}
	}

TPtrC TPodFormatter::NextCommand()
	{
	TPtrC command;
	if (SkipToNextCommand() == KErrNone)
		{
		iPodLex.Mark();
		iPodLex.SkipCharacters();
		command.Set(iPodLex.MarkedToken());
		}
	return command;
	}

TPtrC TPodFormatter::NextParagraph()
	{
	// Consume leading new line characters.
	while (iPodLex.Remainder().Find(KNewLine) == 0)
		{
		if (AtCommandStart())
			{
			return TPtrC();
			}
		iPodLex.Inc(KNewLine().Length());
		}
	
	iPodLex.Mark();

	if (iPodLex.Peek().IsSpace())
		{
		// This line has leading white space - treat everything up to the next blank line as a single paragraph.
		if (SkipToNextBlankLine() != KErrNone)
			{
			SkipToLineEnd();
			}
		}
	else if (SkipToNextLine() != KErrNone)
		{
		SkipToLineEnd();
		}

	return iPodLex.MarkedToken();
	}

TPtrC TPodFormatter::TextToNextCommand()
	{
	TInt initialOffset = iPodLex.Offset();
	iPodLex.Mark();

	if (SkipToNextCommand() == KErrNone)
		{
		if (iPodLex.Offset() >= KCommandStart().Length())
			{
			iPodLex.Inc(-(KCommandStart().Length()));
			}
		else
			{
			iPodLex.Inc(-(iPodLex.Remainder().Length()));
			}
		}
	else
		{
		iPodLex.Inc(iPodLex.Remainder().Length());
		}

	if (initialOffset < iPodLex.Offset())
		{
		return iPodLex.MarkedToken();
		}
	else
		{
		return TPtrC(NULL, 0);
		}
	}

void TPodFormatter::SkipToLineEnd()
	{
	if (SkipTo(KNewLine) != KErrNone)
		{
		iPodLex.Inc(iPodLex.Remainder().Length());
		}
	}

TInt TPodFormatter::SkipToNextLine()
	{
	TInt ret = SkipTo(KNewLine);
	if (ret == KErrNone)
		{
		iPodLex.Inc(KNewLine().Length());
		}
	return ret;
	}

TInt TPodFormatter::SkipToNextCommand()
	{
	if (iPodLex.Remainder().Find(KPartialCommandStart) == 0)
		{
		if (iPodLex.Offset() == 0)
			{
			iPodLex.Inc(KPartialCommandStart().Length());
			return KErrNone;
			}
		else
			{
			iPodLex.Inc(-2);
			if (iPodLex.Remainder().Find(KCommandStart) == 0)
				{
				iPodLex.Inc(KCommandStart().Length());
				return KErrNone;
				}
			else
				{
				iPodLex.Inc(2);
				}
			}
		}

	TInt ret = SkipTo(KCommandStart);
	if (ret == KErrNone)
		{
		iPodLex.Inc(KCommandStart().Length());
		}
	return ret;
	}

TInt TPodFormatter::SkipToNextBlankLine()
	{
	TInt ret = SkipTo(KBlankLine);
	if (ret == KErrNone)
		{
		iPodLex.Inc(2);
		}
	return ret;
	}

TInt TPodFormatter::SkipTo(const TDesC& aDes)
	{
	TInt ret = iPodLex.Remainder().Find(aDes);
	if (ret >= 0)
		{
		iPodLex.Inc(ret);
		return KErrNone;
		}
	return KErrNotFound;
	}

TBool TPodFormatter::AtCommandStart()
	{
	return ((iPodLex.Remainder().Find(KCommandStart) == 0) || (iPodLex.Remainder().Find(KPartialCommandStart) == 0));
	}