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

/** 
* @file barscimpl.h
*
* @internalComponent
* @released
*/

#ifndef __BARSCIMPL_H__
#define __BARSCIMPL_H__

#include <string>
#include "commontypes.h"

//Forward declarations
struct SDictionaryCompressionData;
class RDictionaryCompressionBitStream;
/** 
Accesses a resource file and reads the resource data into a buffer.
It is the implementation class for CResourceFile class.
*/
class RResourceFileImpl
	{

public:
	RResourceFileImpl();
	~RResourceFileImpl();
	/** 
	Opens the resource file reader.
	The resource file reader must be opened before reading resources.
	@param aName name of the RSC file.
	@param aFileOffset RSC file offset 
	@param aFileSize RSC file size
	*/
	void OpenL(const std::string& aName, TUint32 aFileOffset=0, TInt aFileSize=0);
	/** 
	Reads a resource after allocating heap memory for it.
	Ownership of the allocated heap is passes to the caller who must 
	free it.	
	@param aResourceId The numeric id of the resource to be read.
	@return Pointer to the heap containing the resource.
	*/
	Ptr8* AllocReadL(const TInt& aResourceId);

	/** Initialises the offset value from the first resource.

	The function tests to catch cases where the first resource is not an RSS_SIGNATURE.
	It assumes that the first resource in the file consists of
	two 32-bit integers. The first integer contains the version number and
	the second is a self-referencing link whose value is the offset for
	the resources in the file, plus 1.This function must be called before
	calling Offset(), AllocReadL(), AllocReadLC() or ReadL().
	*/
	void ConfirmSignatureL();
	
	/** 
	Tests whether the resource file owns the specified resource id.
	@param aResourceId The resource id to test.
	@return True, if the resource file owns the id, false otherwise.
	*/
	TBool OwnsResourceId(const TInt& aResourceId) const;

	/** 
	Function to read specified bytes from the RSC file
	@param aPos Offset from where to begin reading
	@param aData Buffer to store read values
	@param aLength Length of the bytes to be read.
	@return Length of the bytes to be read.
	*/
	TInt ReadL(TInt aPos,TUint8* aData,const TInt& aLength);

	TUidType UidType() const;


private:
	struct SSigRecord
		{
		TInt signature;
		TInt offset;
		};
  enum
		{
		EFlagIsRomFile																=0x80000000,
		EFlagPotentiallyContainsCompressedUnicode									=0x40000000,
		EFlagDictionaryCompressed													=0x20000000,
		EFlagThirdUidIsOffset														=0x10000000,
		EFlagGenerate_RSS_SIGNATURE_ForFirstUserResource							=0x08000000,
		EFlagFirstResourceIsGeneratedBitArrayOfResourcesContainingCompressedUnicode	=0x04000000,
		EFlagCalypsoFileFormat														=0x02000000,
		EFlagIsBufferRscFile														=0x01000000,
		EAllFlags																	=0xff000000
		};
	enum
		{
		EOffsetBits	=0xfffff000,
		EIdBits		=0x00000fff
		};

	class TExtra;


private:	
	/** 
	Function to read specified bytes from the RSC file
	@param aFlags Integer conatainig no of resource and status flags.
	@param aPos Offset from where to begin reading
	@param aData Buffer to store read values
	@param aLength Length of the bytes to be read.
	@return Length of the bytes to be read.
	*/
	TInt ReadL(const TUint32& aFlags, TInt aPos, TUint8* aData, const TInt& aLength);

	/** @internalComponent
	@return The first resource record.
	@panic Some BAFL panic codes, if the file is corrupted.
	@leave KErrCorrupt The file is corrupted.
	Some other error codes are possible too.
	The method could panic or leave depending on the state of
	iAssertObj member of RResourceFileImpl::TExtra class. */
	SSigRecord FirstRecordL() const;

	
	/** 
	Function to retrieve the header and 
	resource index information of the RSC file.
	*/
	void ReadHeaderAndResourceIndexL();
	
	/** 
	The method will decomress the unicode data (aCompressedUnicode argument) and append
	the decompressed data to the end of aBuffer (aBuffer argument).

	@param aBuffer Destination buffer.
	@param aCompressedUnicode Pointer to compressed unicode data.
	@param aLengthOfCompressedUnicode Length of compressed unicode data.
	*/
	void AppendDecompressedUnicodeL(
								Ptr8* aBuffer,
								const TUint8*  aCompressedUnicode,
								const TInt& aLengthOfCompressedUnicode) const;
	/** 
	The method will decompress the unicode data (aInputResourceData argument), allocate enough
	memory from the heap for the decompressed data, copy the data there and return a pointer
	to the decompressed data.
	The method doesn't own the allocated heap memory for the decompressed data. It's a caller
	responsibility to deallocate the allocated memory.
	@param aInputResourceData Compressed data.
	@return Pointer to decompressed data 
	*/
	Ptr8* DecompressUnicodeL(const Ptr8* aInputResourceData) const;


	/**
	The method will decompress the dictionary compressed data, allocate enough
	memory from the heap for the decompressed data, copy the data there and return a pointer
	to the decompressed data.
	The method doesn't own the allocated heap memory for the decompressed data. It's a caller
	responsibility to deallocate the allocated memory.
	@pre OpenL() is called.
	@leave KErrCorrupt The file is corrupted.
	@leave KErrNoMemory There is not enough memory for the decompressed data.
	Some other error codes are possible too.
	*/
	Ptr8* DictionaryDecompressedResourceDataL(
								TInt aResourceIndex,
								TUint aFlags,
								const SDictionaryCompressionData& aDictionaryCompressionData,
								const Ptr16* aIndex) const;


	/** 
	The method will decomress the dictionary compressed data (aDictionaryCompressionData argument) and append
	the decompressed data to the end of std::vector<RDictionaryCompressionBitStream> 
	(aStackOfDictionaryCompressionBitStreams argument).
	*/
	void AppendDictionaryCompressionBitStreamL(
								std::vector<RDictionaryCompressionBitStream>& aStackOfDictionaryCompressionBitStreams,
								TUint aFlags,
								const SDictionaryCompressionData& aDictionaryCompressionData,
								TInt aStartOfBitData,
								TInt aStartOfIndex,
								TInt aIndexEntry) const;
	
	/**
	Get the two bytes(in Little Endian format) from the specified buffer
	@param aBuffer Buffer address from which 2-bytes are to be achieved.
	@param aIndexOfFirstByte Offset of the first byte to be retrieved from the
           buffer.
	@return 2-bytes read from the buffer.
	*/
	
	TInt LittleEndianTwoByteInteger(const TUint8* aBuffer,const TInt& aIndexOfFirstByte,TInt aLength) const;


private:
	std::ifstream* iResourceContents;	
	TInt iSizeOfLargestResourceWhenCompletelyUncompressed;
	//basically an array of (unsigned) 16-bit file-positions - 
	//this is only used for non-dictionary-compressed resource files
	Ptr16* iIndex; 

	//the position of this member in the class is exposed because RResourceFile::Offset() is 
	//an inline function accessing "iOffset". RResourceFileImpl is an implementation class for
	//RResourceFile class. The "iOffset" offset from the beginning of the class must be exactly
	//12 bytes.
	TInt iOffset; 
	TExtra* iExtra;
	TUint32 iFlagsAndNumberOfResources;
	};


struct SDictionaryCompressionData
	{
 	inline SDictionaryCompressionData() :
		iStartOfDictionaryData(0),
		iStartOfDictionaryIndex(0),
		iNumberOfDictionaryEntries(0),
		iStartOfResourceData(0),
		iStartOfResourceIndex(0),
		iNumberOfBitsUsedForDictionaryTokens(0), 
		iCachedDictionaryIndex(0),
		iCachedResourceBuffer(0)// = NULL;
		{
		}
	TInt iStartOfDictionaryData;
	TInt iStartOfDictionaryIndex;
	TInt iNumberOfDictionaryEntries;
	TInt iStartOfResourceData;
	TInt iStartOfResourceIndex;
	TInt iNumberOfBitsUsedForDictionaryTokens;
	TUint16* iCachedDictionaryIndex;
	TUint8* iCachedResourceBuffer;
	
	};


/** 
Stores the RSC filesize, offset and the bit-array 
representing resources containing compressed unicode.
*/
class RResourceFileImpl::TExtra
	{

public:
	TExtra();
	~TExtra();
	/**
	Finds whether the specified resource contain compressed unicode
	@param aRscIdx Resource Index
	@return Status of whether the resource is actually present or not.
	*/
	TInt32 ContainsCompressedUnicode(TInt& aRscIdx, TBool aFirstRscIsGen) const;

private:
	// Prevent default copy constructor
	TExtra(const TExtra&);
	// Prevent default "=" operator
	TExtra& operator=(const TExtra&);

public:
	// RSC file UID
	TUidType iUidType;
	// An array of bits, one for each resource in the resource file
	Ptr8* iBitArrayOfResourcesContainingCompressedUnicode;
	SDictionaryCompressionData iDictionaryCompressionData;
	// Offset of RSC chunk
	TInt iFileOffset;	
	// RSC file size 
	TUint32 iFileSize;		
	};


#endif//__BARSCIMPL_H__