// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "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 <barsc2.h>
#include "BaArchiveImpl.h"
#include <baflpan.h>
#include <bautils.h>

/** TCleanupItem function.
@internalComponent
*/
LOCAL_C void CloseAndDeleteFile(TAny* aFile)
	{
	RFile* const file=static_cast<RFile*>(aFile);
	if (file!=NULL)
		{
		file->Close();
		delete file;
		}
	}

/** TCleanupItem function.
@internalComponent
*/
LOCAL_C void CloseAndDeleteChunk(TAny* aChunk)
	{
	RChunk* const rchunk=static_cast<RChunk*>(aChunk);
	if (rchunk!=NULL)
		{
		rchunk->Close();
		delete rchunk;
		}
	}

/** Default Constructor
@internalComponent
*/
CResourceArchiveImpl::CResourceArchiveImpl() :
	iCurrentIndex(0),
	iSpiFileType(KNullUid)
	{}

/** Class destructor
@internalComponent 
*/
CResourceArchiveImpl::~CResourceArchiveImpl()
	{
	iRscList.Close();
	
	for(TInt i=0; i<iSpiChunkBufferArray.Count(); i++)
		{
		RChunk* const chunk = iSpiChunkBufferArray[i];                     
		chunk->Close();
		delete chunk;
		}
	
	iSpiChunkBufferArray.Reset();
	iSpiChunkBufferArray.Close();

	iSpiBufferArray.ResetAndDestroy();
	iSpiBufferArray.Close();
	iCurrentIndex=0;
	iSpiFileType=KNullUid;
#ifdef __BASPITEST__
	iSpiFileNameArray.Reset();
	iSpiFileNameArray.Close();
#endif	
	}

/** Creates a CResourceArchiveImpl instance to read a single spi file
@internalComponent
*/
CResourceArchiveImpl* CResourceArchiveImpl::NewL(RFs& aFs,const TDesC& aName)
	{
	CResourceArchiveImpl* self=new (ELeave) CResourceArchiveImpl;
	CleanupStack::PushL(self);
	self->ConstructL(aFs,aName);
	CleanupStack::Pop();
	return self;
	}

/** Creates a CResourceArchiveImpl instance to read a set of spi files
@internalComponent
*/	
CResourceArchiveImpl* CResourceArchiveImpl::NewL(RFs& aFs,const TDesC& aPath,const TDesC& aPattern)
	{
	CResourceArchiveImpl* self=new (ELeave) CResourceArchiveImpl;
	CleanupStack::PushL(self);
	self->ConstructL(aFs,aPath,aPattern);
	CleanupStack::Pop();
	return self;	
	}

/** ConstructL method of CResourceArchiveImpl
@internalComponent
*/
void CResourceArchiveImpl::ConstructL(RFs& aFs,const TDesC& aName)
	{
	RArray<TPtrC8> hiddenRscList;
	CleanupClosePushL(hiddenRscList);
	//Open the file and initialise the buffer pointer
	TPtr8 bufferPtr(NULL,0,0);
	OpenFileL(aFs,aName,bufferPtr);
	//Now validate the header
	ValidateHeaderL(bufferPtr);
	//Process all the rsc entry
	ProcessEntryL(bufferPtr,hiddenRscList);	
	CleanupStack::PopAndDestroy();
	}
	

/** Function to get the string representation of a language code
assume language code has max N digits currently equal to ELangMaximum
note that the minimum suffix required is NN so TLang(0-9) needs to have a 0
e.g s01...s09, s10, s100 etc
@internalComponent
*/
static void GetLangCodeStringRep(TLanguage lang,TDes& aStringRep)
{
	aStringRep.Zero();
	//special case for 0-9 where you need the 0 appended, langcode min two digit
	if (lang<10)
		aStringRep.AppendNumFixedWidthUC(lang,EDecimal,2);
	else
		aStringRep.AppendFormat(_L("%d"),lang);
}

/**
Open the file and initialise the aBufferPtr to point at the buffer
@internalComponent
*/
void CResourceArchiveImpl::OpenFileL(RFs& aFs,const TDesC& aName,TPtr8& aBufferPtr)
	{
	#ifdef __WINS__
	TUint8* romAddress=NULL;
	#else // ! __WINS__
	TUint8* romAddress=aFs.IsFileInRom(aName);
	#endif // ! __WINS__
	
	RFile* const file=new(ELeave) RFile;
	CleanupStack::PushL(TCleanupItem(CloseAndDeleteFile,file));
	User::LeaveIfError(file->Open(aFs, aName, EFileStream | EFileRead | EFileShareReadersOnly));
	TInt fileSize=0;
	User::LeaveIfError(file->Size(fileSize));						
	if (romAddress)
		{	
		aBufferPtr.Set(romAddress,fileSize,fileSize);
		}
	else
		{
		RChunk* rchunk = new(ELeave) RChunk;
		
		CleanupStack::PushL(TCleanupItem(CloseAndDeleteChunk,rchunk));
		
		TInt createRet = rchunk->CreateDisconnectedLocal(0, 0, fileSize);
		TInt commitRet = rchunk->Commit(0, fileSize);
		
		// Create a chunk to store the large file contents of which is closed and destroyed in destructor...
		if(createRet==KErrNone && commitRet==KErrNone)
			{
			TUint8* chunkBase = (TUint8*)rchunk->Base();
			TPtr8 tempBuffer(chunkBase, fileSize);
			User::LeaveIfError(file->Read(0, tempBuffer, fileSize));
			aBufferPtr.Set(tempBuffer);
			iSpiChunkBufferArray.AppendL(rchunk);
			
			CleanupStack::Pop(rchunk);
			}
		else	// Unable to create a chunk so use heap memory...
			{
			HBufC8* fileBuffer=HBufC8::NewMaxLC(fileSize);
			aBufferPtr.Set(fileBuffer->Des());
			User::LeaveIfError(file->Read(0,aBufferPtr,fileSize));
			iSpiBufferArray.AppendL(fileBuffer);
			
			CleanupStack::Pop(fileBuffer);
			CleanupStack::PopAndDestroy(rchunk);
			}
		}
	//can close the file now
	CleanupStack::PopAndDestroy(file);
#ifdef __BASPITEST__
	iSpiFileNameArray.AppendL(aName);
#endif		
	}

/**
Validate the spi header in the file buffer
On return it will update the bufferPtr to point to start of the first
rsc entry
@internalComponent
*/
void CResourceArchiveImpl::ValidateHeaderL(TPtr8& aBufferPtr)
	{
	//Getting the 32 bytes header information. At the moment maybe we should just buffer 16 bytes
	//of the header as the remaining 16 bytes are padding bytes
	TUidType uidType=TCheckedUid(aBufferPtr.Left(16)).UidType();			
	if (uidType[0]!=KSpiFileUid)
		User::Leave(KErrCorrupt);
	//now get the spi file type
	TUid spiFileType=TUid::Uid(uidType[1].iUid);
	if (iSpiFileType==KNullUid)
		iSpiFileType=spiFileType;
	//also check consistency with previous spi files
	__ASSERT_DEBUG(iSpiFileType==spiFileType,::Panic(EBafPanicBadResourceFileFormat));							

	//update the bufferPtr to point to start of first rsc entry
	aBufferPtr.Set(aBufferPtr.MidTPtr(KSpiFirstRscOffset));	
	}

/**
Process all the entry found in the buffer and update the internal rscList
@internalComponent
*/
void CResourceArchiveImpl::ProcessEntryL(TPtr8& aBufferPtr,RArray<TPtrC8>& aHiddenList)
	{
	//now traverse content of the spi file and build up the hidden list and the TRscEntry array
	TRscEntry rscEntry;
	while (aBufferPtr.Length()>0)
		{
		//length(first 4 bytes) and the actual rsc file size(second 4 bytes)
		//Retrieving the rscfilename length
		TUint32 rscFileNameLength=LittleEndianFourByteInteger(aBufferPtr,0);
		TUint32 rscFileSize=LittleEndianFourByteInteger(aBufferPtr,4);
		TUint32 paddingbyte=(4-((rscFileNameLength+rscFileSize)%4))%4;
		__ASSERT_DEBUG((rscFileNameLength+rscFileSize+paddingbyte)%4==0,::Panic(EBafPanicFileSize));
		//construct the TRscEntry				
		rscEntry.iRscName.Set(aBufferPtr.Mid(8,rscFileNameLength));
		rscEntry.iRscData.Set(aBufferPtr.Mid(8+rscFileNameLength,rscFileSize));
#ifdef __BASPITEST__
		rscEntry.iFileNamePtr.Set(iSpiFileNameArray[iSpiFileNameArray.Count()-1].Mid(0));
#endif				
		//update the buffer pointer
		aBufferPtr.Set(aBufferPtr.MidTPtr(8+rscFileNameLength+rscFileSize+paddingbyte));

		//process the TRscEntry
		if (rscEntry.iRscData.Length()==0)
			aHiddenList.AppendL(rscEntry.iRscName);
		else
			{
			//if can find a matching resource name entry in the hidden list ignore this entry
			TIdentityRelation<TPtrC8> identity(MatchDescriptor);
			if (aHiddenList.Find(rscEntry.iRscName,identity)==KErrNotFound)
				{
				//note no duplicate entry, this implies the lastly mounted resource
				//entry is preferred over earlier mounted resource entry.(REPLACING)
				TInt ret=iRscList.InsertInOrder(rscEntry,EntryOrder);
				if (ret!=KErrNone && ret!=KErrAlreadyExists)
					User::Leave(ret);
				}		
			}
		}//end while loop	
	}
	
/** ConstructL method that accepts a spi path and a matching pattern
aPath here must end with \\ as well e.g. z:\\private\\10009d8f\\ 
aPattern should be the spi file withou rom image id and extension
@internalComponent
*/
void CResourceArchiveImpl::ConstructL(RFs& aFs,const TDesC& aPath,const TDesC& aPattern)
	{
	//Get the downgradepath
	RArray<TLanguage> downgradeList;
	BaflUtils::GetDowngradePathL(aFs,User::Language(),downgradeList);
	CleanupClosePushL(downgradeList);
	
	//used to check if there is any matching pattern and leave with KErrNotFound if
	//no matching spi
	TInt spiDiscovered=0;
	
	//sort out the language specific spi first
	for (int i=0;i<=downgradeList.Count();i++)	
		{
		//list all the files in the directory that matches this language
		TFileName matchPattern;
		TBuf<5> langExtension;
		if (i<downgradeList.Count())
			GetLangCodeStringRep(downgradeList[i],langExtension);
		else
			{
			//process the default spi lastly
			langExtension.Append(_L("pi"));			
			}
		matchPattern.AppendFormat(_L("%S%S-*-*.s%S"),&aPath,&aPattern,&langExtension);

		//Get all the spis that match the language pattern
		CDir* spiList=NULL;
		User::LeaveIfError(aFs.GetDir(matchPattern,KEntryAttReadOnly | KEntryAttHidden | KEntryAttSystem | KEntryAttArchive,ESortByName,spiList));
		CleanupStack::PushL(spiList);

		//the hidden list is only a temporary variable for each language
		RArray<TPtrC8> hiddenRscList;
		CleanupClosePushL(hiddenRscList);
		
		//reverse processing
		for (TInt i=spiList->Count()-1;i>=0;i--)
			{
			//reuse the matchPattern buffer to hold the full path of the spi file name
			matchPattern.Zero();
			matchPattern.Append(aPath);
			matchPattern.Append((*spiList)[i].iName);

			//Open the file and initialise the buffer pointer
			TPtr8 bufferPtr(NULL,0,0);
			OpenFileL(aFs,matchPattern,bufferPtr);
	
			//Now validate the header
			ValidateHeaderL(bufferPtr);
	
			//Process all the rsc entry
			ProcessEntryL(bufferPtr,hiddenRscList);
			}//end for loop
		spiDiscovered+=spiList->Count();
		CleanupStack::PopAndDestroy(2);				//hiddenRscList and spiList
		}//end for loop
	//if no spi files are discovered at all leave with KErrNotFound
	if (spiDiscovered==0)
		User::Leave(KErrNotFound);
	CleanupStack::PopAndDestroy(&downgradeList);
	}

/** Create the next CResourceFile that correponds to the next resource file
in the resource archive(SPI) file
@internalComponent
*/
CResourceFile* CResourceArchiveImpl::NextL(HBufC*& aRscFileName)
	{
	//if end of list return nothing
	if (iCurrentIndex==iRscList.Count())
		return NULL;
	//Construct the resource file name buffer
	TRscEntry currentEntry=iRscList[iCurrentIndex];
	HBufC* rscFileName=HBufC::NewLC(currentEntry.iRscName.Length());
	TPtr modifiable(rscFileName->Des());
	modifiable.Copy(currentEntry.iRscName);
	//Construct the CResourceFile object	
	CResourceFile* resourceFile=CResourceFile::NewL(currentEntry.iRscData);
	CleanupStack::Pop(rscFileName);
	//update the index
	iCurrentIndex++;
	aRscFileName=rscFileName;
	return resourceFile;
	}

/** Reset the archive reader to start reading from the first resource
@internalComponent 
*/
void CResourceArchiveImpl::Reset()
	{
	iCurrentIndex=0;
	}

/** Return the type of the resource archive(SPI) file being read
@internalComponent 
*/
TUid CResourceArchiveImpl::Type()
	{
	return iSpiFileType;
	}

/** Function to look ahead whether next resource exists in the resource archive
@internalComponent
*/
TBool CResourceArchiveImpl::NextResourceExist() const
	{
	return (iCurrentIndex<iRscList.Count());
	}

/** Function used to retrieve a 4 bytes signed integer stored in Little Endian Format
@internalComponent
*/
TInt32 CResourceArchiveImpl::LittleEndianFourByteInteger(const TDesC8& aBuffer,TInt aIndexOfFirstByte) const
	{
	__ASSERT_DEBUG((aIndexOfFirstByte + 3) < aBuffer.Length(), ::Panic(EBafPanicBadIndex));
	return aBuffer[aIndexOfFirstByte] | (aBuffer[aIndexOfFirstByte+1]<<8) | (aBuffer[aIndexOfFirstByte+2]<<16) | (aBuffer[aIndexOfFirstByte+3]<<24);
	}