// Copyright (c) 1996-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "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:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// f32\etshell\ts_clicomp.cpp
// 
//

#include "ts_clicomp.h"
#include "ts_std.h"

CCliCompleter::CCliCompleter()
	{	
	}
	
CCliCompleter* CCliCompleter::NewL()
	{
	CCliCompleter* self = new(ELeave) CCliCompleter();
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	
	return self;
	}
	
void CCliCompleter::ConstructL()
	{
	User::LeaveIfError(iFs.Connect());
	}

CCliCompleter::~CCliCompleter()
	{
	iFs.Close();
	}

void CCliCompleter::EstablishCompletionContext(TDesC& aBuf, TUint aPos, TDes& aKnownPart)
	{
	// Try and locate a double-quote to the left of the current cursor position
	TInt contextStart = aBuf.Mid(0, aPos).LocateReverse(TChar('"'));	
	TInt contextEnd;
	
	if(contextStart != KErrNotFound)
		{ // Double-quote found
		contextEnd = aPos - contextStart;
		// Grab a copy of the text we will be trying to complete
		aKnownPart = aBuf.Mid(contextStart, contextEnd);
		}
	else
		{ // Try from the last space character
		contextStart = aBuf.Mid(0, aPos).LocateReverse(TChar(' '));

		if(contextStart == KErrNotFound)
			{
			contextStart = 0;
			}
		else
			{
			contextStart += 1;
			}
			
		contextEnd = aPos - contextStart;

		aKnownPart = aBuf.Mid(contextStart, contextEnd);
		aKnownPart.Trim();
		}
	}

TBool CCliCompleter::AttemptCompletionL(TDes& aKnownPart, RPointerArray<HBufC>& aAlternatives)
	{
	// Turn the known part into something with a path
	TParse parsedKnownPart;

	// ShellFunction::GetFullPath() modifies the source path so create
	// a temporary buffer for a throwaway copy
	TBuf<KMaxPath> tmpKnownPart = aKnownPart;
	ShellFunction::StripQuotes(tmpKnownPart);
	tmpKnownPart.Append(KMatchAny);
	
	if(ShellFunction::GetFullPath(tmpKnownPart, parsedKnownPart) != KErrNone)
		{
		return EFalse;
		}
	
	CDir* entries;	
	if(iFs.GetDir(parsedKnownPart.FullName(), KEntryAttNormal | KEntryAttDir, ESortByName, entries) != KErrNone)
		{
		return EFalse;
		}

	CleanupStack::PushL(entries);

	TEntry entry;
	TBool result;

	if(entries->Count() == 1)
		{
		entry = (*entries)[0];
	
		TPtrC completedPart;	
		completedPart.Set(entry.iName.Mid(parsedKnownPart.NameAndExt().Length() - 1));
		aKnownPart.Append(completedPart);

		if(entry.IsDir()) aKnownPart.Append(KPathDelimiter);
		
		if(((TUint)aKnownPart[0] != TChar('"')) && 
			(aKnownPart.LocateF(TChar(' ')) != KErrNotFound))
			{
			aKnownPart.Insert(0, _L("\""));
			}
		
		result = ETrue;
		}
	else if(entries->Count() > 1)
		{
		TInt entryIdx;		
		
		// Find the smallest matching entry so as to not run off the end of
		// an index when trying to establish the greatest overlap between the
		// matches.  We're also caching the raw entries in a seperate array so
		// we can use them when displaying the ambiguous matches.
		TInt minLength = KMaxFileName;		
		
		for(entryIdx=0;entryIdx<entries->Count();entryIdx++)
			{
			entry = (*entries)[entryIdx];
			
			HBufC* buf = HBufC::NewLC(entry.iName.Length() + 100);
			*buf = entry.iName;
			if(entry.IsDir()) 
				{
				buf->Des().Append(KPathDelimiter);
				}
			aAlternatives.AppendL(buf);
			
			if(entry.iName.Length() < minLength)
				{
				minLength = entry.iName.Length();
				}
			}
		CleanupStack::Pop(entries->Count());
			
		// Find the greatest overlap between the matches.  Even though we can't
		// get a final match we can at least make a best-effort completion based 
		// on anything they've not told us but which matches anyway.
		
		// There's an asterisk on the end of the parsed filename that we want
		// to disregard when calculating the length of what we already know.
		TInt knownPartLength = parsedKnownPart.NameAndExt().Length() - 1;
		
		TInt matchLength = knownPartLength;
		TBool matching = ETrue;
		while(matching && matchLength < minLength)
			{			
			for(entryIdx=1;entryIdx<entries->Count();entryIdx++)
				{
				if(((*entries)[0].iName[matchLength]) != ((*entries)[entryIdx].iName[matchLength]))
					{
					matching = EFalse;
					}
				}
			if(matching) matchLength++;
			}

		if(matchLength > knownPartLength)
			{
			entry = (*entries)[0];
			
			TUint additionalKnownStart = knownPartLength;
			TUint additionalKnownLength = matchLength - knownPartLength;
			
			aKnownPart.Append(entry.iName.Mid(additionalKnownStart, additionalKnownLength));
			}

		result = EFalse;
		}
	else	
		{
		result = EFalse;
		}
	
	CleanupStack::PopAndDestroy(entries);
	
	return result;
	}


/*
	Note: method has the potential to modify the size of aAlternatives as 
	a side-effect of the call to ShellFunction::AlignTextIntoColumns().
*/
void CCliCompleter::DisplayAlternatives(RPointerArray<HBufC>& aAlternatives)
	{
	ShellFunction::AlignTextIntoColumns(aAlternatives);
	
	CShell::NewLine();
	for(TInt entryIdx=0;entryIdx<aAlternatives.Count();entryIdx++)
		{
		CShell::OutputStringToConsole(EFalse, *aAlternatives[entryIdx]);
		CShell::NewLine();
		}
	}