// cmdwindow.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 "cmdwindow.h"
#include <e32cons.h>
#include <BADESCA.H>

const TInt KInfoPrintTime = 2500000; // 2.5 seconds

CCommandWindow* CCommandWindow::NewL(RFs& aFs, CColorConsoleBase& aConsole)
	{
	CCommandWindow* self = new(ELeave) CCommandWindow(aFs, aConsole);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

CCommandWindow* CCommandWindow::NewL(RFs& aFs, CConsoleBase& aConsole)
	{
	CCommandWindow* self = new(ELeave) CCommandWindow(aFs, aConsole);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

CCommandWindow::CCommandWindow(RFs& aFs, CConsoleBase& aConsole)
	: iFs(aFs), iConsole(aConsole), iColorConsole(NULL), iConsoleAdapter(aConsole)
	{}

CCommandWindow::CCommandWindow(RFs& aFs, CColorConsoleBase& aConsole)
	: iFs(aFs), iConsole(aConsole), iColorConsole(&aConsole), iConsoleAdapter(aConsole)
	{}

void CCommandWindow::ConstructL()
	{
	iInfoPrintDismisser = CPeriodic::NewL(CActive::EPriorityStandard);
	TBuf<64> buf;

	User::LeaveIfError(iFs.PrivatePath(buf));
	buf.Insert(0, _L("c:"));
	buf.Append(_L("fed_filehistory"));
	iFileNameLineEditor = CLineEditor::NewL(iFs, iConsoleAdapter, *this, *this, buf);

	User::LeaveIfError(iFs.PrivatePath(buf));
	buf.Insert(0, _L("c:"));
	buf.Append(_L("fed_generalhistory"));
	iGeneralLineEditor = CLineEditor::NewL(iFs, iConsoleAdapter, *this, *this, buf);
	}

CCommandWindow::~CCommandWindow()
	{
	if (iInfoPrintDismisser) iInfoPrintDismisser->Cancel();
	delete iInfoPrintDismisser;
	delete iGeneralLineEditor;
	delete iFileNameLineEditor;
	}

CConsoleBase& CCommandWindow::Console()
	{
	return iConsole;
	}

CColorConsoleBase* CCommandWindow::ColorConsole()
	{
	return iColorConsole;
	}

class TOverflow16 : public TDes16Overflow
	{
public:
	void Overflow(TDes16 &) {}
	};

void CCommandWindow::WriteStatus(const TDesC& aNameToTruncate, TRefByValue<const TDesC> aFmt, ...)
	{
	TDes& buf = iLastStatus;
	buf.Zero();
	VA_LIST args;
	VA_START(args, aFmt);
	TOverflow16 overflow;
	buf.AppendFormatList(aFmt, args, &overflow);
	VA_END(args);

	const TInt availWidth = iWindow.iWidth - 1;
	buf.SetLength(Min(buf.Length(), availWidth));
	TInt widthForName = availWidth - buf.Length();
	buf.Insert(0, aNameToTruncate.Right(widthForName));
	if (buf.Length() < iWindow.iWidth) buf.Append(' ');
	buf.AppendFill('-', iWindow.iWidth - buf.Length() - 1); // Don't fill to edge of screen, that causes a wrap

	DoWriteLine(buf);
	}

void CCommandWindow::DoWriteLine(const TDesC& aLine, TInt aHighlightStart, TInt aHighlightLength)
	{
	TPoint cursor = iConsole.CursorPos();
	iConsole.SetCursorHeight(0);
	iConsole.SetPos(iWindow.iX, iWindow.iY);
	if (aHighlightLength && ColorConsole())
		{
		TPtrC left = aLine.Left(aHighlightStart);
		TPtrC mid = aLine.Mid(aHighlightStart, aHighlightLength);
		TPtrC right = aLine.Mid(aHighlightStart + aHighlightLength);
		ColorConsole()->Write(left);
		ColorConsole()->SetTextAttribute(ETextAttributeInverse);
		ColorConsole()->Write(mid);
		ColorConsole()->SetTextAttribute(ETextAttributeNormal);
		ColorConsole()->Write(right);
		}
	else
		{
		iConsole.Write(aLine);
		}
	iConsole.SetCursorPosAbs(cursor);
	iConsole.SetCursorHeight(20);
	}

void CCommandWindow::InfoPrint(TRefByValue<const TDesC> aFmt, ...)
	{
	iInfoPrintDismisser->Cancel(); // If there's already a print onscreen, we bin it straight away (same as how User::InfoPrint works)
	TBuf<256> buf;
	VA_LIST args;
	VA_START(args, aFmt);
	TOverflow16 overflow;
	buf.AppendFormatList(aFmt, args, &overflow);
	VA_END(args);

	buf.SetLength(Min(buf.Length(), iWindow.iWidth-5)); // 4 for -[ and ]-, and one more to avoid hitting the final column
	TInt highlightLen = buf.Length() + 2; // Highlight the [] as well
	buf.Insert(0, _L("-["));
	buf.Append(_L("]-"));
	TInt fillWidth = iWindow.iWidth - buf.Length() - 1;
	TInt left = fillWidth / 2;
	TInt highlightStart = left+1;
	TInt right = fillWidth - left;
	while(left--)
		{
		buf.Insert(0, _L("-"));
		}
	buf.AppendFill('-', right);
	DoWriteLine(buf, highlightStart, highlightLen);
	iInfoPrintDismisser->Start(KInfoPrintTime, KInfoPrintTime, TCallBack(&DismissInfoPrint, this));
	}

TInt CCommandWindow::DismissInfoPrint(TAny* aSelf)
	{
	CCommandWindow* self = static_cast<CCommandWindow*>(aSelf);
	// Restore previous status
	self->DoWriteLine(self->iLastStatus);
	self->iInfoPrintDismisser->Cancel();
	return 0;
	}

TKeyCode CCommandWindow::Query(const TDesC& aPrompt, const TDesC& aValidKeys)
	{
	TPoint cursor = iConsole.CursorPos();
	iQuery = aPrompt;
	iQuery.Append(_L("[ ]"));
	iQuery.AppendFill('-', iQuery.MaxLength() - iQuery.Length());
	iQuery.SetLength(iWindow.iWidth - 1);
	DoWriteLine(iQuery);
	iConsole.SetPos(iWindow.iX + aPrompt.Length()+1, iWindow.iY);
	iConsole.SetCursorHeight(20);
	TKeyCode res = EKeyNull;
	while (aValidKeys.Locate(res) == KErrNotFound)
		{
		res = iConsole.Getch();
		}
	// Print the key that the user entered, between the square brackets
	if (TChar(res).IsPrint())
		{
		TBuf<1> chbuf;
		chbuf.Append(res);
		iConsole.Write(chbuf);
		}
	iConsole.SetCursorPosAbs(cursor);
	// Async clear the query (in case we are called repeatedly)
	iInfoPrintDismisser->Cancel();
	iInfoPrintDismisser->Start(0, KInfoPrintTime, TCallBack(&DismissInfoPrint, this));
	return res;
	}

TBool CCommandWindow::QueryText(const TDesC& aPrompt, TDes& aText)
	{
	iLineEditor = iGeneralLineEditor;
	return DoQueryText(aPrompt, aText);
	}

TBool CCommandWindow::QueryFilename(const TDesC& aPrompt, TFileName& aFileName)
	{
	iLineEditor = iFileNameLineEditor;
	TBool res = DoQueryText(aPrompt, aFileName);
	if (res)
		{
		IoUtils::TFileName2 fn2(aFileName);
		TRAPD(err, fn2.MakeAbsoluteL(iFs));
		if (err) res = EFalse;
		aFileName.Copy(fn2);
		}
	return res;
	}

TBool CCommandWindow::DoQueryText(const TDesC& aPrompt, TDes& aText)
	{
	// Get cursor in right position
	TPoint cursor = iConsole.CursorPos();
	// Clear the way
	iConsole.SetPos(iWindow.iX, iWindow.iY);
	iQuery.Fill(' ', iWindow.iWidth-1);
	iConsole.Write(iQuery);
	iConsole.SetPos(iWindow.iX, iWindow.iY);
	// Start the line editor going
	iLineEditor->Start(aPrompt, aText);
	iLineEditor->ReinstatePromptAndUserInput();
	iFinished = EFalse;
	TBool result = ETrue;
	iResultForQuery = &aText;
	while (!iFinished)
		{
		TKeyCode ch = iConsole.Getch();
		if (ch == EKeyEscape) 
			{
			result = EFalse;
			break;
			}
		if (ch == EKeyEnter)
			{
			// Fool line editor by moving cursor up a line, so when it does its newline it doesn't screw us up
			iConsole.SetCursorPosRel(TPoint(0, -1));
			}
		iLineEditor->HandleKey(ch, iConsole.KeyModifiers());
		}
	iConsole.SetCursorPosAbs(cursor);
	// Async clear the query (in case of... something. Velociraptors maybe?)
	iInfoPrintDismisser->Cancel();
	iInfoPrintDismisser->Start(0, KInfoPrintTime, TCallBack(&DismissInfoPrint, this));
	return result;
	}

RFs& CCommandWindow::Fs()
	{
	return iFs;
	}

void CCommandWindow::LeoHandleLine(const TDesC& aLine)
	{
	iFinished = ETrue;
	*iResultForQuery = aLine.Left(iResultForQuery->MaxLength());
	}

_LIT(KFileNameSlash, "\\");
_LIT(KDriveColonSlash, ":\\");
_LIT(KTab, "\t");
_LIT(KSpace, " ");

// This code ripped from ptf
void CCommandWindow::LcCompleteLineL(TConsoleLine& aLine, const TChar& /*aEscapeChar*/)
	{
	if (iLineEditor != iFileNameLineEditor) return; // Don't autocomplete for anything that isn't a filename

	IoUtils::TFileName2 fileNameMatch;
	fileNameMatch.Copy(aLine.ContentsToCursor());
	
	CDesCArray* suggestions = new(ELeave) CDesC16ArrayFlat(16);
	CleanupStack::PushL(suggestions);

	if (fileNameMatch.Length()==0)
		{
		SuggestDrivesL(suggestions);
		}
	else if (fileNameMatch.Length() == 2 && TChar(fileNameMatch[0]).IsAlpha() && fileNameMatch[1] == ':')
		{
		fileNameMatch.Append(KFileNameSlash);
		}

	if (!fileNameMatch.IsAbsolute())
		{
		fileNameMatch.MakeAbsoluteL(iFs);
		}
	
	TPtrC relativeDir = aLine.ContentsToCursor();
	relativeDir.Set(relativeDir.Left(relativeDir.LocateReverse('\\')+1)); // Remove any name to the right of the last backslash
		
	fileNameMatch.Append('*');
	
	CDir* files = NULL;
	User::LeaveIfError(iFs.GetDir(fileNameMatch, KEntryAttNormal | KEntryAttDir, ESortByName, files));
	CleanupStack::PushL(files);
		
	TInt numFiles = files->Count();
	if (numFiles == 1)
		{
		fileNameMatch.SetLength(fileNameMatch.DriveAndPath().Length());
		fileNameMatch.AppendComponentL((*files)[0].iName);
		TEntry entry;
		User::LeaveIfError(iFs.Entry(fileNameMatch, entry));
		suggestions->AppendL(fileNameMatch.NameAndExt());
		CompleteL(aLine, *suggestions, &relativeDir, entry.IsDir() ? &KFileNameSlash : NULL);
		}
	else if (numFiles > 0)
		{
		for (TInt i=0; i<numFiles; ++i)
			{
			suggestions->AppendL((*files)[i].iName);
			}
		CompleteL(aLine, *suggestions, &relativeDir, NULL);
		}
	
	CleanupStack::PopAndDestroy(2, suggestions); // files, suggestions
	}

void CCommandWindow::SuggestDrivesL(CDesCArray* aSuggestions)
	{
	TDriveList drives;
	User::LeaveIfError(iFs.DriveList(drives));
	
	for (TInt i=0; i<drives.Length(); ++i)
		{
		if (drives[i])
			{
			TBuf<3> buf;
			
			TChar driveChar;
			User::LeaveIfError(iFs.DriveToChar(i, driveChar));
			
			buf.Append(driveChar);
			buf.Append(KDriveColonSlash);
			aSuggestions->AppendL(buf);						
			}
		}
	}
	
void CCommandWindow::CompleteL(TConsoleLine& aLine, const CDesCArray& aPossibilities, const TDesC* aPrefix, const TDesC* aSuffix)
	{
	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)
			{
			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]);
			}

		if (aPrefix)
			{
			completion->AppendL(*aPrefix);
			}
		completion->AppendL(commonChars);

		if ((numPossibilities == 1) && (aSuffix))
			{
			completion->AppendL(*aSuffix);
			}
			
		if ((numPossibilities == 1) && (!aSuffix))
			{
			completion->AppendL(KSpace);
			}
			
		if (completion->Descriptor().Length() > 0)
			{
			aLine.Replace(0, completion->Descriptor());
			}
		CleanupStack::PopAndDestroy(completion);
		}
	}