// line_completer.cpp

// 

// Copyright (c) 2006 - 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 <f32file.h>

#include <fshell/ltkutils.h>

#include "lexer.h"

#include "command_factory.h"

#include "line_completer.h"

_LIT(KTab, "\t");

_LIT(KWild, "*");

_LIT(KDoubleQuote, "\"");

_LIT(KSpace, " ");

_LIT(KFileNameSlash, "\\");

_LIT(KPipe, "|");

_LIT(KDoublePipe, "||");

_LIT(KAmpersand, "&");

_LIT(KDoubleAmpersand, "&&");

_LIT(KAmpersandPipe, "&|");

_LIT(KSemicolon, ";");

_LIT(KDollar, "$");

_LIT(KDashDash, "--");

_LIT(KDash, "-");

CLineCompleter* CLineCompleter::NewL(RFs& aFs, CCommandFactory& aCommandFactory, IoUtils::CEnvironment& aEnv)

	{

	CLineCompleter* self = new(ELeave) CLineCompleter(aFs, aCommandFactory, aEnv);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CLineCompleter::~CLineCompleter()

	{

	delete iLexer;

	delete iLastUsedCif;

	}

void CLineCompleter::LcCompleteLineL(TConsoleLine& aLine, const TChar& aEscapeChar)

	{

	iLexer->Set(aLine.ContentsToCursor(), aEscapeChar);

	TToken token(iLexer->NextToken());

	TToken firstToken = token;

	TToken prevToken(TToken::EString, KNullDesC, aLine.ContentsToCursor().Length());

	TInt lastTokenIdx = 0;

	while (iLexer->More())

		{

		// More than one token - skip to last.

		prevToken = token;

		token = iLexer->NextToken();

		lastTokenIdx++;

		}

	switch (prevToken.Type())

		{

		case TToken::EPipe:

		case TToken::EAmpersand:

		case TToken::ESemicolon:

		case TToken::EDoublePipe:

		case TToken::EDoubleAmpersand:

		case TToken::EAmpersandPipe:

			CompleteCommandNameL(aLine, token, aEscapeChar);

			break;

		default:

			if (token.Position() + token.String().Length() < aLine.ContentsToCursor().Length())

				{

				// Looks like there's whitespace after this token, so consider it to be completing the empty token.

				token = TToken(TToken::EString, KNullDesC, aLine.ContentsToCursor().Length());

				}

			else if (lastTokenIdx == 0)

				{

				CompleteCommandNameL(aLine, token, aEscapeChar);

				break;

				}

			if (token.String().Left(1) == KDollar)

				{

				CompleteEnvVarL(aLine, token, aEscapeChar);

				}

			else if (token.String() == KDash || token.String().Left(2) == KDashDash)

				{

				// Check the CIF is loaded and it's the right one

				if (iLastUsedCif && iLastUsedCif->Name().CompareF(firstToken.String()) != 0)

					{

					delete iLastUsedCif;

					iLastUsedCif = NULL;

					}

				TInt err = KErrNone;

				if (iLastUsedCif == NULL)

					{

					// We need to supress StaticLeaveIfErrs from CCommandInfoFile::NewL causing a PrintError if there's no CIF for this command,

					// hence the use of TRAP_QUIETLY.

					TRAP_QUIETLY(err, iLastUsedCif = IoUtils::CCommandInfoFile::NewL(iFs, iEnv, firstToken.String()));

					}

				if (err == KErrNone)

					{

					CompleteOptionL(aLine, token, aEscapeChar);

					}

				}

			else

				{

				CompleteFileNameL(aLine, token, aEscapeChar);

				}

			break;

		}

	}

CLineCompleter::CLineCompleter(RFs& aFs, CCommandFactory& aCommandFactory, IoUtils::CEnvironment& aEnv)

	: iFs(aFs), iCommandFactory(aCommandFactory), iEnv(aEnv)

	{

	}

void CLineCompleter::ConstructL()

	{

	iLexer = CLexer::NewL();

	iLexer->DefineTokenTypeL(TToken::EPipe, KPipe);

	iLexer->DefineTokenTypeL(TToken::EAmpersand, KAmpersand);

	iLexer->DefineTokenTypeL(TToken::ESemicolon, KSemicolon);

	iLexer->DefineTokenTypeL(TToken::EDoublePipe, KDoublePipe);

	iLexer->DefineTokenTypeL(TToken::EDoubleAmpersand, KDoubleAmpersand);

	iLexer->DefineTokenTypeL(TToken::EAmpersandPipe, KAmpersandPipe);

	}

HBufC* SimplifyStringLC(const TDesC& aString, const TChar& aEscapeChar)

	{

	HBufC* buf = HBufC::NewLC(aString.Length());

	TPtr bufPtr(buf->Des());

	TLex lex(aString);

	while (!lex.Eos())

		{

		TChar c = lex.Get();

		if (c == aEscapeChar)

			{

			if (!lex.Eos())

				{

				bufPtr.Append(lex.Get());

				}

			}

		else if (c == '\'')

			{

			while (!lex.Eos())

				{

				c = lex.Get();

				if (c == '\'')

					{

					break;

					}

				else

					{

					bufPtr.Append(c);

					}

				}

			}

		else if (c == '"')

			{

			while (!lex.Eos())

				{

				c = lex.Get();

				if (c == aEscapeChar)

					{

					bufPtr.Append(lex.Get());

					}

				else if (c == '"')

					{

					break;

					}

				else

					{

					bufPtr.Append(c);

					}

				}

			}

		else

			{

			bufPtr.Append(c);

			}

		}

	return buf;

	}

void CLineCompleter::CompleteCommandNameL(TConsoleLine& aLine, const TToken& aToken, const TChar& aEscapeChar) const

	{

	RArray<TPtrC> commands;

	CleanupClosePushL(commands);

	iCommandFactory.ListCommandsL(commands);

	HBufC* commandBuf = SimplifyStringLC(aToken.String(), aEscapeChar);

	// Remove commands that don't match aLine.

	TInt i;

	for (i = (commands.Count() - 1); i >= 0; --i)

		{

		if (commands[i].Find(*commandBuf) != 0)

			{

			commands.Remove(i);

			}

		}

	if (commands.Count() > 0)

		{

		CompleteL(aLine, aToken, commands, NULL, NULL);

		}

	else

		{

		CompleteFileNameL(aLine, aToken, aEscapeChar);

		}

	CleanupStack::PopAndDestroy(2, &commands);

	}

void RemovePartialElement(HBufC*& aBuf)

	{

	TPtr ptr(aBuf->Des());

	while (ptr.Length() > 0)

		{

		if (ptr[ptr.Length() - 1] == KPathDelimiter)

			{

			break;

			}

		else

			{

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

			}

		}

	}

void CLineCompleter::CompleteFileNameL(TConsoleLine& aLine, const TToken& aToken, const TChar& aEscapeChar) const

	{

	HBufC* fileNameBuf = SimplifyStringLC(aToken.String(), aEscapeChar);

	IoUtils::TFileName2 absFileName(*fileNameBuf);

	RemovePartialElement(fileNameBuf);

	absFileName.Append(KWild);

	absFileName.MakeAbsoluteL(iEnv.Pwd());

	CDir* files;

	User::LeaveIfError(iFs.GetDir(absFileName, KEntryAttNormal | KEntryAttDir, ESortByName, files));

	CleanupStack::PushL(files);

	RArray<TPtrC> fileNames;

	CleanupClosePushL(fileNames);

	const TInt numFiles = files->Count();

	if (numFiles == 1)

		{

		absFileName = absFileName.DriveAndPath();

		absFileName.AppendComponentL((*files)[0].iName);

		TEntry entry;

		User::LeaveIfError(iFs.Entry(absFileName, entry));

		User::LeaveIfError(fileNames.Append(absFileName.NameAndExt()));

		CompleteL(aLine, aToken, fileNames, fileNameBuf, entry.IsDir() ? &KFileNameSlash : NULL);

		}

	else if (numFiles > 1)

		{

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

			{

			User::LeaveIfError(fileNames.Append(TPtrC((*files)[i].iName)));

			}

		CompleteL(aLine, aToken, fileNames, fileNameBuf, NULL);

		}

	CleanupStack::PopAndDestroy(3, fileNameBuf);

	}

TBool NeedsQuoting(const TDesC& aDes)

	{

	return ((aDes.Locate(TChar(' ')) >= 0) || aDes.Locate(TChar('\'')) >= 0);

	}

void CLineCompleter::CompleteL(TConsoleLine& aLine, const TToken& aToken, const RArray<TPtrC> aPossibilities, const TDesC* aPrefix, const TDesC* aSuffix, TBool aPrefixIsPartOfToken) const

	{

	const TInt numPossibilities = aPossibilities.Count();

	if (numPossibilities > 1)

		{

		// Fill out possibilities buffer.

		IoUtils::CTextBuffer* possibilities = IoUtils::CTextBuffer::NewLC(0x100);

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

			{

			if (aPrefixIsPartOfToken) possibilities->AppendL(*aPrefix);

			possibilities->AppendL(aPossibilities[i]);

			if (i != (numPossibilities - 1))

				{

				possibilities->AppendL(KTab);

				}

			}

		aLine.PrintCompletionPossibilitiesL(possibilities->Descriptor());

		CleanupStack::PopAndDestroy(possibilities);

		}

	if (numPossibilities > 0)

		{

		IoUtils::CTextBuffer* completion = IoUtils::CTextBuffer::NewLC(0x100);

		TPtrC commonChars(NULL, 0);

		if (numPossibilities > 1)

			{

			// Find common leading characters of the possibilities.

			TInt commonCharPos = -1;

			TBool finished(EFalse);

			do

				{

				++commonCharPos;

				TChar character(0);

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

					{

					if (commonCharPos >= aPossibilities[i].Length())

						{

						finished = ETrue;

						break;

						}

					else if (i == 0)

						{

						character = aPossibilities[0][commonCharPos];

						character.Fold();

						}

					else

						{

						TChar c(aPossibilities[i][commonCharPos]);

						c.Fold();

						if (c != character)

							{

							finished = ETrue;

							break;

							}

						}

					}

				}

				while (!finished);

			commonChars.Set(aPossibilities[0].Mid(0, commonCharPos));

			}

		else

			{

			commonChars.Set(aPossibilities[0]);

			}

		TBool quote(EFalse);

		if ((aPrefix && NeedsQuoting(*aPrefix)) || NeedsQuoting(commonChars) || (aSuffix && NeedsQuoting(*aSuffix)))

			{

			quote = ETrue;

			}

		if (quote)

			{

			completion->AppendL(KDoubleQuote);

			}

		if (aPrefix)

			{

			completion->AppendL(*aPrefix);

			}

		completion->AppendL(commonChars);

		if ((numPossibilities == 1) && quote)

			{

			completion->AppendL(KDoubleQuote);

			}

		if (numPossibilities == 1)

			{

			if (aSuffix)

				{

				completion->AppendL(*aSuffix);

				}

			else

				{

				completion->AppendL(KSpace);

				}

			}

		if (completion->Descriptor().Length() > 0)

			{

			aLine.Replace(aToken.Position(), completion->Descriptor());

			}

		CleanupStack::PopAndDestroy(completion);

		}

	}

void CLineCompleter::CompleteEnvVarL(TConsoleLine& aLine, const TToken& aToken, const TChar& /*aEscapeChar*/) const

	{

	RArray<TPtrC> matchingVars;

	CleanupClosePushL(matchingVars);

	TPtrC envVar = aToken.String().Mid(1); // Lose the $

	RPointerArray<HBufC> keys;

	LtkUtils::CleanupResetAndDestroyPushL(keys);

	iEnv.GetKeysL(keys);

	const TInt count = keys.Count();

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

		{

		const TDesC& key = *keys[i];

		if (key.Left(envVar.Length()) == envVar)

			{

			matchingVars.AppendL(TPtrC(key));

			}

		}

	CompleteL(aLine, aToken, matchingVars, &KDollar, NULL, ETrue);

	CleanupStack::PopAndDestroy(2, &matchingVars); // keys, matchingVars

	}

void CLineCompleter::CompleteOptionL(TConsoleLine& aLine, const TToken& aToken, const TChar& /*aEscapeChar*/) const

	{

	RArray<TPtrC> matchingOptions;

	CleanupClosePushL(matchingOptions);

	TPtrC optFrag = aToken.String();

	if (optFrag.Length() >= 2) optFrag.Set(optFrag.Mid(2)); // Lose the --

	else if (optFrag.Length() == 1) optFrag.Set(TPtrC()); // single dash gets dropped completely

	const IoUtils::RCommandOptionList& options = iLastUsedCif->Options();

	const TInt count = options.Count();

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

		{

		const TDesC& optName = options[i].Name();;

		if (optName.Left(optFrag.Length()) == optFrag)

			{

			matchingOptions.AppendL(TPtrC(optName));

			}

		}

	CompleteL(aLine, aToken, matchingOptions, &KDashDash, NULL, ETrue);

	CleanupStack::PopAndDestroy(&matchingOptions);

	}