// Copyright (c) 2001-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:
//

#include <e32std.h>
#include <e32std_private.h>
#include "sr_rofs.h"
#include <rofs.h>


CDirectoryCache::CDirectoryCache( CRofsMountCB& aMount, CProxyDrive& aLocalDrive, const TRofsHeader& aHeader )
	: iMount( aMount ), iLocalDrive( aLocalDrive ), 
	iTreeMediaOffset( aHeader.iDirTreeOffset ),
	iTreeSize( aHeader.iDirTreeSize ),
	iFilesMediaOffset( aHeader.iDirFileEntriesOffset ),
	iFilesSize( aHeader.iDirFileEntriesSize )
	{
	}

CDirectoryCache::~CDirectoryCache()
	{
	delete iTreeBuffer;
	delete iFilesBuffer;
	}
	
void CDirectoryCache::ConstructL()
	{
	iTreeBuffer = HBufC8::NewL( iTreeSize );
	iFilesBuffer = HBufC8::NewL( iFilesSize );

	TPtr8 ptr = iTreeBuffer->Des();
	User::LeaveIfError( iLocalDrive.Read( iTreeMediaOffset, iTreeSize, ptr) );
	TPtr8 ptr2 = iFilesBuffer->Des();
	User::LeaveIfError( iLocalDrive.Read( iFilesMediaOffset, iFilesSize, ptr2) );
	}


void CDirectoryCache::FindLeafDirL(const TDesC& aName, const TRofsDir*& aDir) const
//
// Navigate the path to find the leaf directory, starting at aDir.
//
	{

	TLex lex(aName);
	TInt r;
	FOREVER
		{
		lex.Inc(); // Skip the file separator
		lex.Mark();
		r=lex.Remainder().Locate(KPathDelimiter);
		
		if ( KErrNotFound == r )
			{
			r=lex.Remainder().Length();
			}
		if ( 0 == r ) // End of the path
			{
			break;
			}

		lex.Inc(r); // Set the token length
		
		const TRofsEntry* subDirEntry = NULL;
		TInt r = DoBinaryFindSubDir(lex.MarkedToken(), KEntryAttDir|KEntryAttMatchExclusive, aDir, subDirEntry );
		if( KErrNone != r )
			{
			User::Leave( KErrPathNotFound );
			}
		__ASSERT_DEBUG( 0 != (subDirEntry->iAtt & KEntryAttDir ), CRofs::Panic( CRofs::EPanicEntryNotDir ));
		aDir = RofsDirFromSubDirEntry( subDirEntry );
		}
	}

TInt CDirectoryCache::DoBinaryFindSubDir(const TDesC& aName, TUint aAtt, const TRofsDir* aDir, const TRofsEntry*& aSubDirEntry ) const
	//
	// Scan the directory aDir looking for subdirectory aName using binary search.
	// aName cannot contain wildcards and aSubDirEntry should always be NULL.
	// If a matching entry is found writes pointer to the entry into aSubDirEntry
	// and returns KErrNone.
	//
	{

	if (aSubDirEntry != NULL)
		{
		return DoFindSubDir(aName, aAtt, aDir, aSubDirEntry);
		}

	TInt numDirs=GetDirCount(aDir);
	TInt topIndex=numDirs-1;
	TInt bottomIndex=0;

	TBool bFound=EFalse;
	TInt retVal=KErrNotFound;
	if(topIndex>=0)
		{
		TUint16* offsets = (TUint16*) ((TUint8*) aDir + aDir->iStructSize);
		offsets += 2; //to skip file and dir counts

		while((!bFound) && (topIndex>=bottomIndex))
		{
			TInt32 middleIndex;
			const TRofsEntry* pCurrentEntry=NULL;
			middleIndex=(topIndex+bottomIndex)>>1;

			//Offsets for directories are relative to the start of the
			//directory block
			TUint8* ptr = (TUint8*) aDir + (offsets[middleIndex] << 2);
			pCurrentEntry = (TRofsEntry*)  ptr;

			TPtrC currName=TPtrC((const TText*)&pCurrentEntry->iName[0],pCurrentEntry->iNameLength);

			TInt result=Compare(aName,currName);
			if(result<0)
				topIndex=middleIndex-1;
			else if(result>0)
				bottomIndex=middleIndex+1;
			else
				{
				bFound=ETrue;	// exit loop
				if (iMount.MatchEntryAtt(pCurrentEntry->iAtt, aAtt))
					{
					aSubDirEntry=pCurrentEntry;
					retVal=KErrNone;
					}
				}
			}
		}
	return retVal;
	}

TInt CDirectoryCache::DoFindSubDir(const TDesC& aName, TUint aAtt, const TRofsDir* aDir, const TRofsEntry*& aSubDirEntry ) const
	//
	// Scan the directory aDir looking for subdirectory aName. If aSubDirEntry is
	// not NULL the search starts from the entry AFTER aSubDirEntry.
	// If a matching entry is found writes pointer to the entry into aSubDirEntry
	// and returns KErrNone.
	//
	{
	const TRofsEntry* pEntry = aSubDirEntry;	// which entry
	const TRofsEntry* const pEnd = (TRofsEntry*)EndOfDirPlusOne( aDir );

	if( !pEntry )
		{
		pEntry = FirstSubDirEntryFromDir( aDir );
		}
	else
		{
		// move to next entry
		__ASSERT_DEBUG( pEntry >= FirstSubDirEntryFromDir( aDir ), CRofs::Panic( CRofs::EPanicEntryBeforeDirectory ));
		__ASSERT_DEBUG( pEntry < pEnd, CRofs::Panic( CRofs::EPanicEntryAfterDirectory ));
		pEntry = NextEntry( pEntry );
		}

	while ( pEntry < pEnd )
		{
		TPtrC name( NameAddress( pEntry ), pEntry->iNameLength);
		if ( KErrNotFound != name.MatchF(aName) && iMount.MatchEntryAtt(pEntry->iAtt, aAtt) )
			{
			aSubDirEntry = pEntry;
			return KErrNone;
			}
		
		pEntry = NextEntry( pEntry );
		}
	return KErrNotFound;
	}

TInt CDirectoryCache::GetDirCount(const TRofsDir* aDir) const
//
//Return the number of directory entries contained in aDir
//
	{
	TUint16* dirCount = (TUint16*) ((TUint8*) aDir + aDir->iStructSize);
	return *dirCount;
	}

TInt CDirectoryCache::GetFileCount(const TRofsDir* aDir) const
//
//Return the number of file entries contained in aDir
//
	{
	TUint16* fileCount = (TUint16*) ((TUint8*) aDir + aDir->iStructSize);
	fileCount++; //jump over the dir count
	return *fileCount;
	}

TInt CDirectoryCache::Compare(const TDesC& aLeft, const TDesC& aRight) const
//
//Compares two filenames.  Folds ASCII characters to uppercase
//
	{

	TInt len=Min(aLeft.Length(),aRight.Length());
	const TText* leftString = aLeft.Ptr();
	const TText* rightString = aRight.Ptr();
	while (len--)
		{
		TText leftChar=*leftString++;
		TText rightChar=*rightString++;
		if (leftChar<='Z' && leftChar>='A')
			leftChar +='a'-'A';     // covert to UPPERCASE
		if (rightChar<='Z' && rightChar>='A')
			rightChar +='a'-'A';    // covert to UPPERCASE
		TInt result=leftChar-rightChar;
		if (result != 0)
			return result;
		}
		// match up to end of shorter string, now compare lengths
		return aLeft.Length()-aRight.Length();
	}

TInt CDirectoryCache::ExtractMangleInfo(const TDesC& searchName, TUint8 &MountId, TUint8 &ReservedId) const
{
	#define HexToInt(x) ( x.IsDigit()? (TUint8)(x-(TUint)'0') : 0x0a+(TUint8)((x>='A' && x<='Z')? x-(TUint)'A':x-(TUint)'a') )
	const TInt KOpenBraceRevPos = 7;
	const TInt KHyphenRevPos = 4;
	const TInt KCloseBraceRevPos = 1;

	TInt openBraceRevPos = searchName.LocateReverse('[');
	TInt closeBraceRevPos = searchName.LocateReverse(']');
	TInt hyphenRevPos = searchName.LocateReverse('-');
	TInt searchNameLen = searchName.Length();

	if(openBraceRevPos==KErrNotFound || closeBraceRevPos==KErrNotFound || hyphenRevPos==KErrNotFound)
		return KErrNotFound;

	openBraceRevPos = searchNameLen - openBraceRevPos;
	closeBraceRevPos = searchNameLen - closeBraceRevPos;
	hyphenRevPos = searchNameLen - hyphenRevPos;
	if(openBraceRevPos!=KOpenBraceRevPos || hyphenRevPos!=KHyphenRevPos || closeBraceRevPos!=KCloseBraceRevPos)
		return KErrNotFound;

	const TText* nameString = searchName.Ptr();
	TInt MountIdPos = searchNameLen - KOpenBraceRevPos + 1;
	TInt ReservedIdPos = searchNameLen - KHyphenRevPos + 1;

	TChar MountIdHNibble = *(nameString+MountIdPos);
	TChar MountIdLNibble = *(nameString+MountIdPos+1);

	TChar ReservedIdHNibble = *(nameString+ReservedIdPos);
	TChar ReservedIdLNibble = *(nameString+ReservedIdPos+1);

	if(MountIdHNibble.IsHexDigit() && MountIdLNibble.IsHexDigit() &&
			ReservedIdHNibble.IsHexDigit() && ReservedIdLNibble.IsHexDigit())
	{
		MountId = (TUint8)((HexToInt(MountIdHNibble) << 4) | HexToInt(MountIdLNibble));
		ReservedId = (TUint8)((HexToInt(ReservedIdHNibble) << 4) | HexToInt(ReservedIdLNibble));
		return KErrNone;
	}
	return KErrNotFound;
}

TInt CDirectoryCache::DoBinaryFindFile(const TDesC& aName, TUint aAtt, const TRofsDir* aDir, const TRofsEntry*& aEntry ) const
//
// Scan from aDir looking for file aName using binary search.
// aName cannot contain wildcards and aEntry should always be NULL.
// If found return the result in aEntry.
//
	{
	if (aEntry != NULL)
		{
		return DoFindFile(aName, aAtt, aDir, aEntry);
		}

	TInt numFiles=GetFileCount(aDir);
	TInt topIndex=numFiles-1;
	TInt bottomIndex=0;
	TInt result;
	TBool doNameMangle = ETrue;
	TBuf<KMaxFileName> searchName;

	TBool bFound=EFalse;
	TInt retVal=KErrNotFound;

	searchName.Copy((const TText*)aName.Ptr(), aName.Length());

	if(topIndex>=0)
		{
		TUint16* offsets = (TUint16*) ((TUint8*) aDir + aDir->iStructSize);
		offsets += 2;                 //to skip file and dir counts
		offsets += GetDirCount(aDir); //skip directory offsets

		while((!bFound) && (topIndex>=bottomIndex))
			{
			TInt32 middleIndex;
			const TRofsEntry* pCurrentEntry=NULL;
			TBuf<KMaxFileName> currName;

			middleIndex=(topIndex+bottomIndex)>>1;

			//Offsets for files are relative to the start of the
			//file block
			TInt bufferOffset = (offsets[middleIndex]<<2) - iFilesMediaOffset + 4;
			bufferOffset += aDir->iFileBlockAddress;

			TUint8* ptr = (TUint8*) &iFilesBuffer[0];

			pCurrentEntry=(TRofsEntry*) &ptr[bufferOffset];

			currName.Copy(((const TText*)&pCurrentEntry->iName[0]), pCurrentEntry->iNameLength);

			if(doNameMangle && ((~pCurrentEntry->iAttExtra & (KEntryAttUnique >> 23)) != 0))
				currName.AppendFormat(_L("[%02x-00]"),iMount.iMountId);

			result=Compare(searchName,currName);

			if(result<0)
				topIndex=middleIndex-1;
			else if(result>0)
				bottomIndex=middleIndex+1;
			else
				{
				bFound=ETrue;	// exit loop
				if (iMount.MatchEntryAtt(pCurrentEntry->iAtt, aAtt))
					{
					aEntry=pCurrentEntry;
					retVal = (pCurrentEntry->iFileAddress == KFileHidden) ? KErrHidden : KErrNone;
					}
				/* If we have found a file and we are in second pass of binary search without nameMangle 
					check whether it is unique file */
				if(!doNameMangle)
					{
					/* If it is not a unique file then the file does not exist */
					if((~pCurrentEntry->iAttExtra & (KEntryAttUnique >> 23)) == 0)
						{
						retVal = KErrNotFound;
						aEntry = NULL;
						}
					}
				}

			/* If we are going to return and we are searching for the unique file,there is a possiblity
			   that the binary search would have missed it (since the file entries were sorted without 
			   namemangle).*/
			if((!bFound) && (topIndex<bottomIndex) && doNameMangle)
				{
					TUint8 MountId;
					TUint8 ReservedId;

					if(ExtractMangleInfo(searchName,MountId,ReservedId) != KErrNone)
						break;

					if(MountId != iMount.iMountId || ReservedId != 0)
						break;

					/* If the aNameLength is equal to the mangle name length, we cant proceed our search 
						with null strings */
					if((TUint)(aName.Length()) == KRofsMangleNameLength)
						break;

					searchName.Copy((const TText*)aName.Ptr(), aName.Length()-KRofsMangleNameLength);

					/* The next level of search is sufficient enough to start on the top portion of the list.
						Thus resetting the bottomIndex to 0 is sufficient */
					bottomIndex=0;
					doNameMangle = EFalse;
				}
			}
		}
	return retVal;
	}

TInt CDirectoryCache::DoFindFile(const TDesC& aName, TUint aAtt, const TRofsDir* aDir, const TRofsEntry*& aEntry ) const
//
// Scan from aDir looking for file aName.
// The search starts at the entry after aEntry, unless aEntry is NULL, in which
// case the srach starts from the beginning of the file block.
// If found return the result in aEntry.
//
	{
	__ASSERT_DEBUG( aDir != NULL, CRofs::Panic( CRofs::EPanicNullSubDir ));
	
	if( aDir->iFileBlockAddress )
		{
		const TRofsEntry* pEntry;
		if( !aEntry )
			{
			pEntry = FirstFileEntryFromDir( aDir );
			}
		else
			{
			pEntry = NextEntry( aEntry );
			}
		const TAny* const pEnd = EndOfFileBlockPlusOne( aDir );
		
		while ( pEntry < pEnd )
			{
			TBuf<KMaxFileName> fileName;

			fileName.Copy(NameAddress( pEntry ), pEntry->iNameLength);
			if((~pEntry->iAttExtra & (KEntryAttUnique >> 23)) != 0)
				fileName.AppendFormat(_L("[%02x-00]"),iMount.iMountId);

			if ( KErrNotFound != fileName.MatchF(aName) && iMount.MatchEntryAtt(pEntry->iAtt, aAtt)  )
				{
				aEntry = pEntry;
				return(( pEntry->iFileAddress == KFileHidden ) ? KErrHidden : KErrNone);
				}
			
			pEntry = NextEntry( pEntry );
			}
		}
	return KErrNotFound;
	}


void CDirectoryCache::FindFileEntryL(const TDesC& aName, const TRofsEntry*& aEntry) const
//
// Locate an entry from its full path name.
//
	{
	TInt namePos=aName.LocateReverse(KPathDelimiter)+1; // There is always a path delimiter
	const TRofsDir* dir = RootDirectory();
	FindLeafDirL(aName.Left(namePos), dir);

	aEntry=0;
	TInt r = DoBinaryFindFile(aName.Mid(namePos), KEntryAttDir|KEntryAttMatchExclude, dir, aEntry);
	if (r!=KErrNone)
		User::Leave(r);
	}

void CDirectoryCache::FindDirectoryEntryL(const TDesC& aName, const TRofsDir*& aDir) const
//
// Locate an entry from its full path name.
//
	{
	aDir = RootDirectory();
	FindLeafDirL(aName,aDir);
	}


void CDirectoryCache::GetNextMatchingL(const TDesC& aName, TUint aAtt, const TRofsDir*& aDir, const TRofsEntry*& aEntry, TInt aError, TBool bUseBinarySearch) const
	//
	// Retrieves the next directory or file entry from aDir that matches the pattern in aName
	// (which should be the entry name only, not the full path)
	// The search starts at the entry after aEntry
	//
	{
	__ASSERT_DEBUG( aName.LocateReverse(KPathDelimiter) == KErrNotFound, CRofs::Panic( CRofs::EPanicBadMatchName ));

	TInt r = KErrGeneral;
	const TRofsEntry* entry = aEntry;
	TBool searchFiles = EFalse;
	if( entry && (entry < FirstSubDirEntryFromDir(aDir) || entry >= EndOfDirPlusOne(aDir)) )
		{
		searchFiles = ETrue;
		}
	else
		{
		// searching the directory list
		if (!bUseBinarySearch)
			{
			r = DoFindSubDir( aName, aAtt, aDir, entry );
			}
		else
			{
			r = DoBinaryFindSubDir(aName, aAtt, aDir, entry);
			}
		if( KErrNotFound == r )
			{
			// start looking through the file list
			entry = NULL;	// start at beginning of list
			searchFiles = ETrue;
			}
		}


	if( searchFiles )
		{
		if (!bUseBinarySearch)
			{
			r = DoFindFile( aName, aAtt, aDir, entry );
			}
		else
			{
			r = DoBinaryFindFile(aName, aAtt, aDir, entry);
			}
		}

/*
	if( aEntry >= FirstFileEntryFromDir( aDir ) 
		&& aDir->iFileBlockAddress )
		{
		// we are searching the file list
		r = DoFindFile( aName, aAtt, aDir, aEntry );
		}
	else
		{
		// searching the directory list
		r = DoFindSubDir( aName, aAtt, aDir, aEntry );
		if( KErrNotFound == r )
			{
			// start looking through the file list
			TRofsEntry* entry = NULL;	// start at beginning of list
			r = DoFindFile( aName, aAtt, aDir, entry );
			if( KErrNone == r )
				{
				aEntry = entry;
				}
			}
		}
*/

	if( r == KErrNone || r == KErrHidden)
		{
		// Move onto the next entry (this is valid even for hidden entries so
		// that we can move onto the next entry, which may not be hidden)
		aEntry = entry;
		if(r == KErrNone)
			{
			return;
			}
		}

	User::Leave(r == KErrHidden ? r : aError);
	}

void CDirectoryCache::FindGeneralEntryL(const TDesC& aName, TUint aAtt, const TRofsDir*& aDir, const TRofsEntry*& aEntry ) const
	{
	TInt namePos=aName.LocateReverse(KPathDelimiter)+1; // There is always a path delimiter
	aDir = RootDirectory();
	FindLeafDirL(aName.Left(namePos), aDir);
	GetNextMatchingL( aName.Mid(namePos), aAtt, aDir, aEntry, KErrNotFound, ETrue );
	}

TUint8 CDirectoryCache::GetMountId( void )
	{
	return (TUint8)(iMount.iMountId);
	};