/*

* Copyright (c) 2006-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: 

* Class receives tree structured directory and file information. And 

* prepares the cluster versus content MAP by traversing through the same. 

* Later all the prepared clusters are written into image file.

* @internalComponent

* @released

*

*/

#include "dirregion.h"

/**

Constructor:

1.Get the instance of class CCluster

2.Intializes the Cluster pointer

3.Intialize the flags and other variables

@internalComponent

@released

@param aNodeList - Root node placed in this list

@param aFileSystemPtr - CFileSystem class pointer

*/

CDirRegion::CDirRegion(EntryList aNodeList,

					   CFileSystem * aFileSystemPtr):

					   iCurrentDirEntry(false),

					   iParentDirEntry(false),

					   iFirstCluster(true),

   					   iNodeList(aNodeList)

{

	iClusterSize = aFileSystemPtr->GetClusterSize();

	iRootDirSizeInBytes = (aFileSystemPtr->GetRootDirSectors () * 

						   aFileSystemPtr->GetBytesPerSector());

	int totalClusters = aFileSystemPtr->GetTotalCluster();

	iClusterPtr = CCluster::Instance(iClusterSize,totalClusters);

	if(iClusterPtr == NULL)

	{

		throw ErrorHandler(CLUSTERERROR,"Instance creation error",__FILE__,__LINE__);

	}

	iClusterSize = iClusterPtr->GetClusterSize();

}

/**

Destructor: 

1. Clean the Node List 

2. Clean the instance of Cluster object 

3. Clean the Cluster MAP.

4. Invokes the DestroyShortEntryList to clear the contents of static GShortEntryList.

@internalComponent

@released

*/

CDirRegion::~CDirRegion()

{

	if(iNodeList.size() > 0)

	{

		//Delete the root node

		delete iNodeList.front();

	}

	if(iClusterPtr != NULL)

	{

		delete iClusterPtr;

		iClusterPtr = NULL;

	}

	iClusterMap.clear();

	ClongName::DestroyShortEntryList();

}

/**

Function to return Clusters per entry map(input for FAT table generator function) 

container

@internalComponent

@released

@return - returns clusters per entry map container

*/

TClustersPerEntryMap* CDirRegion::GetClustersPerEntryMap() const

{

	return iClusterPtr->GetClustersPerEntryMap();

}

/**

Function responsible to write all the clusters available in iClusterMap

into file. 

@internalComponent

@released

@param aOutPutStream - output file stream to write clusters in it

*/

void CDirRegion::WriteClustersIntoFile(OfStream& aOutPutStream)

{

	StringMap::iterator mapBeginIter = iClusterMap.begin();

	StringMap::iterator mapEndIter= iClusterMap.end();

	//MAPs are sorted associative containers, so no need to sort

	String tempString;

	while(mapBeginIter != mapEndIter)

	{

		tempString = (*mapBeginIter++).second;

		aOutPutStream.write(tempString.c_str(),tempString.length());

	}

	aOutPutStream.flush();

	if(aOutPutStream.bad())

	{

		throw ErrorHandler(FILEWRITEERROR,__FILE__,__LINE__);

	}

}

/**

Function takes the full entry name and formats it as per FAT spec requirement

Requirement:

1. All the names should be of 11 characters length.

2. Name occupies 8 characters and the extension occupies 3 characters.

3. If the name length is less than 8 characters, padd remaining characters with '0x20' 

4. If the extension length is less than 3 characters, padd remaining characters with '0x20' 

5. If the Name or extension exceeds from its actual length then it is treated as long name.

@internalComponent

@released

@param aString - the String needs to be formatted

@param aAttrValue - the entry attribute

*/

void CDirRegion::FormatName(String& aString, char aAttrValue)

{

	if(!aString.empty())

	{

		if((*aString.begin()) != KDot)

		{

			//Get the file extension start index

			int extensionStartIndex = aString.find_last_of (KDot);

			if(aAttrValue != EAttrDirectory && extensionStartIndex != -1)

			{

				//Erase the dot, because it is not required to be written in the FAT image

				aString.erase(extensionStartIndex,1);

				//Apply Space padding for the Name

				aString.insert (extensionStartIndex,(ENameLength - extensionStartIndex), KSpace);

				int totalStringLength = aString.length();

				//Apply Space padding for the  Extension

				if(totalStringLength < ENameLengthWithExtension)

				{

					aString.insert(totalStringLength,(ENameLengthWithExtension - totalStringLength), KSpace);

					return;

				}

			}

			else

			{

				int nameEndIndex = aString.length();

				//Apply Space padding for the directory Name

				aString.insert(nameEndIndex,(ENameLengthWithExtension - nameEndIndex),KSpace);

				return;

			}

		}

		else

		{	//Apply Space padding for either '.' or ".."

			aString.append((ENameLengthWithExtension - aString.length()),KSpace);

			return;

		}

	}

	else

	{

		throw ErrorHandler(EMPTYFILENAME,__FILE__,__LINE__);

	}

}

/**

Function responsible to classify the entry name as long name or regular name.

@internalComponent

@released

@param aEntry - the directory entry

@return - returns true if it is long name else false.

*/

bool CDirRegion::IsLongEntry(CDirectory* aEntry) const

{

	String entryName = aEntry->GetEntryName();

	unsigned int receivedNameLength = entryName.length();

	unsigned int firstDotLocation = entryName.find_first_of(KDot);

	unsigned int lastDotLocation = entryName.find_last_of(KDot);

	if(firstDotLocation == lastDotLocation)

	{

		if(aEntry->GetEntryAttribute() == EAttrDirectory)

		{

			// If the directory name length is more than 8 characters, then it is a long name

			if(receivedNameLength > ENameLength)

			{

				return true;

			}

		}

		else

		{

			int extensionIndex = lastDotLocation;

			unsigned int fileExtensionLength = receivedNameLength - extensionIndex - 1;

			/*Either the full name length is greater than 11 or the extension 

			 *length is greater than 3, then it is considered as long name.

			 */

			if((receivedNameLength > ENameLengthWithExtension) 

			   || (fileExtensionLength > EExtensionLength))

			{

				return true;

			}

		}

		return false;

	}

	else

	{

		//If the name contains multiple dots, then it is a long name.

		return true;	

	}

}

/**

Function responsible to 

1. Invoke long name class

2. Invoke the methods to create long and short entries

3. Receive the string filled with long entries

@internalComponent

@released

@param aEntry - the entry

@param aDirString - long name entry appended to this string

*/

void CDirRegion::CreateLongEntries(CDirectory* aEntry,String& aDirString)

{

	ClongName aLongNameObject(iClusterPtr,aEntry);

	String tempString = aLongNameObject.CreateLongEntries();

	if(tempString.length() == 0)

	{

		tempString.erase();

		throw ErrorHandler(EMPTYFILENAME,__FILE__,__LINE__);

	}

	else

	{

		aDirString.append(tempString.c_str(),tempString.length());

		tempString.erase();

		WriteEntryToString(aLongNameObject.CreateShortEntry(aEntry),aDirString);

	}

}

/**

Function takes a single entry and writes its attributes into tempString.

Later this string is appended with the string received in the argument

@internalComponent

@released

@param aEntry - the entry which attributes are needs to be written into aString

@param aString - entry attributes appended into this string

*/

void CDirRegion::WriteEntryToString(CDirectory* aEntry,String& aString)

{

	String tempString;

	String entryName = aEntry->GetEntryName();

	tempString.append(ToUpper(entryName));

	//appends the attributes only once

	tempString.append(KWriteOnce, aEntry->GetEntryAttribute());

	tempString.append(KWriteOnce, aEntry->GetNtReservedByte());

	tempString.append(KWriteOnce, aEntry->GetCreationTimeMsecs());

	unsigned short int createdTime = aEntry->GetCreatedTime();

	tempString.append(ToString(createdTime));

	unsigned short int creationDate = aEntry->GetCreationDate();

	tempString.append(ToString(creationDate));

	unsigned short int lastAccessDate = aEntry->GetLastAccessDate();

	tempString.append(ToString(lastAccessDate));

	unsigned short int clusterNumberHi = aEntry->GetClusterNumberHi();

	tempString.append(ToString(clusterNumberHi));

	unsigned short int lastWriteTime = aEntry->GetLastWriteTime();

	tempString.append(ToString(lastWriteTime));

	unsigned short int lastWriteDate = aEntry->GetLastWriteDate();

	tempString.append(ToString(lastWriteDate));

	unsigned short int clusterNumberLow = aEntry->GetClusterNumberLow();

	tempString.append(ToString(clusterNumberLow));

	unsigned int fileSize = aEntry->GetFileSize();

	tempString.append(ToString(fileSize));

	aString.append(tempString.c_str(),KDirectoryEntrySize);

	tempString.erase();

}

/**

Function responsible to 

1. Read the file content and write into string.

2. Invoke the function to push data clusters into cluster Map

@internalComponent

@released

@param aEntry - the directory entry node

*/

void CDirRegion::WriteFileDataInToCluster(CDirectory* aEntry)

{

	iInputStream.open(aEntry->GetFilePath().c_str(),Ios::binary);

	if(iInputStream.fail() == true )

	{

		throw ErrorHandler(FILEOPENERROR,aEntry->GetFilePath().c_str(),

			__FILE__,__LINE__);

	}

	else

	{

		iInputStream.seekg (0,Ios::end);

		Long64 fileSize = iInputStream.tellg(); 

		iInputStream.seekg(0,Ios::beg);

		char* dataBuffer = (char*)malloc((unsigned int)fileSize);

		if(dataBuffer == 0)

		{

			throw ErrorHandler(MEMORYALLOCATIONERROR,__FILE__,__LINE__);

		}

		//Read the whole file in one short

		iInputStream.read (dataBuffer,fileSize);

		Long64 bytesRead = (unsigned int)iInputStream.tellg();

		if((iInputStream.bad()) || (bytesRead != fileSize))

		{

			throw ErrorHandler(FILEREADERROR,aEntry->GetFilePath().c_str(),

				__FILE__, __LINE__);

		}

		String clusterData(dataBuffer,(unsigned int)bytesRead);

		PushStringIntoClusterMap(iClusterPtr->GetCurrentClusterNumber(),clusterData,iClusterSize,aEntry->GetEntryAttribute());

	}

	iInputStream.close();

}

/**

Function invokes 

1. CheckEntry function, to identify whether the received entry list is proper or not.

2. Invokes CreateDirEntry, to create directory and data portion of FAT image.

@internalComponent

@released

*/

void CDirRegion::Execute()

{

	CheckEntry(iNodeList);

	CreateDirEntry(iNodeList.front(),KParentDirClusterNumber);

}

/**

Function is to initialize the Parent directory entry with parent cluster number

and appends all the attributes into the string (aString).

@internalComponent

@released

@param aParDirClusterNumber - parent directory cluster number

@param aString - parent directory entry attributes appended to this string

*/

void CDirRegion::CreateAndWriteParentDirEntry(unsigned int aParDirClusterNumber,String& aString)

{

	const char* parentDirName = ".."; //Indicates parent directory entry name

	CDirectory* parentDirectory = new CDirectory((char*)parentDirName);

	parentDirectory->SetEntryAttribute(EAttrDirectory);

	parentDirectory->SetClusterNumberLow((unsigned short) (aParDirClusterNumber & KHighWordMask));

	parentDirectory->SetClusterNumberHi((unsigned short) (aParDirClusterNumber >> KBitShift16));

	String tempString(parentDirectory->GetEntryName());

	FormatName(tempString,EAttrDirectory);

	parentDirectory->SetEntryName(tempString);

	tempString.erase();

	WriteEntryToString(parentDirectory,aString);

	iParentDirEntry = true;

	delete parentDirectory;

	parentDirectory = NULL;

}

/**

Function responsible to 

1. Initialize the Current directory entry attribute

2. Write the entry attributes into received string

@internalComponent

@released

@param aCurDirClusterNumber - Current directory Cluster number

@param aString - the entry attributes should be appended to this string

*/

void CDirRegion::CreateAndWriteCurrentDirEntry(unsigned int aCurClusterNumber,String& aString)

{

	const char* currentDirName = "."; //Indicates Current Directory entry name

	iCurEntryClusterNumber = aCurClusterNumber;

	CDirectory* currentDirectory = new CDirectory((char*)currentDirName);

	currentDirectory->SetEntryAttribute(EAttrDirectory);

	currentDirectory->SetClusterNumberLow((unsigned short) (iCurEntryClusterNumber & KHighWordMask));

	currentDirectory->SetClusterNumberHi((unsigned short) (iCurEntryClusterNumber >> KBitShift16));

	String tempString(currentDirectory->GetEntryName());

	FormatName(tempString,EAttrDirectory);

	currentDirectory->SetEntryName(tempString);

	tempString.erase();

	WriteEntryToString(currentDirectory,aString);

	iCurrentDirEntry = true;

	delete currentDirectory;

	currentDirectory = NULL;

}

/**

Function responsible to push the directory entry clusters into cluster MAP only if the

directory entry string size is greater than the cluster size.

@internalComponent

@released

@param aNumber - is the Cluster Key used to insert the cluster into cluster map

@param aString - is the directory entry string

@param aClustersRequired - No of clusters required to hold this string

*/

void CDirRegion::PushDirectoryEntryString(unsigned int aNumber,String& aString,int aClustersRequired)

{

	int clusterCount = 0;

	int clusterKey = aNumber;

	iClusterPtr->CreateMap(aNumber,clusterKey);

	iClusterMap[clusterKey] =	aString.substr(clusterCount*iClusterSize,iClusterSize);

	++clusterCount;

	String clusterSizeString;

	for(; clusterCount < aClustersRequired; ++clusterCount)

	{

		clusterKey = iClusterPtr->GetCurrentClusterNumber();

		clusterSizeString = aString.substr(clusterCount*iClusterSize,iClusterSize);

		clusterSizeString.append((iClusterSize - clusterSizeString.length()),0);

		iClusterMap[clusterKey] = clusterSizeString;

		iClusterPtr->CreateMap(aNumber,clusterKey);

		iClusterPtr->UpdateNextAvailableClusterNumber();

	}

}

/**Function responsible to 

1. Convert the string into equal size clusters of cluster size

2. Insert the clusters into Cluster MAP

@internalComponent

@released

@param aNumber - cluster number, used to map the cluster

@param aString - reference of input string

@param aClusterSize - used to split the string

@param aAttribute - current entry attribute

*/

void CDirRegion::PushStringIntoClusterMap(unsigned int aNumber, String& aString, unsigned long int aClusterSize,char aAttribute)

{

	int receivedStringLength = aString.length();

	/* Precaution, once the map is initialized with specific cluster number don't over write

	 * it once again. Look for the cluster number within the existing MAP and then proceed with 

	 * filling in the cluster.

	 */

	StringMap::iterator iter= iClusterMap.find(aNumber);

	if(iter == iClusterMap.end())

	{

		/* The length of the cluster content (aString) can be more or less than the cluster size, 

		 * hence, calculate the total number of clusters required.

		 */

		int clustersRequired = receivedStringLength / aClusterSize;

		if((receivedStringLength % aClusterSize) > 0)

		{

			++clustersRequired;

		}

		if((clustersRequired > 1) && (aAttribute == EAttrDirectory))

		{

			PushDirectoryEntryString(aNumber,aString,clustersRequired);

			return;

		}

		int updatedClusterNumber = aNumber;

		String clusterSizeString;

		for(short int clusterCount = 0; clusterCount < clustersRequired; ++clusterCount)

		{

			/* In case of the contents occupying more than one cluster, break the contents into

			 * multiple parts, each one measuring as that of the cluster size.

			 */

			clusterSizeString = aString.substr(clusterCount * aClusterSize,aClusterSize);

			iClusterPtr->CreateMap(aNumber,updatedClusterNumber);

			if(clusterSizeString.length() < aClusterSize)

			{

				/* Copied string size is less than cluster size, fill the remaining space

				 * with zero

				 */

				clusterSizeString.append((aClusterSize - clusterSizeString.length()),0);

			}

			// Insert the String into ClusterMap	

			iClusterMap[updatedClusterNumber] = clusterSizeString;

			iClusterPtr->UpdateNextAvailableClusterNumber();

			updatedClusterNumber = iClusterPtr->GetCurrentClusterNumber ();

		}

		/* In the above loop, cluster number is incremented to point to the next entry.

		 * However, before writing a directory or a volume id entry, it is always ensured 

		 * to get the next cluster number. Hence in this case, it is required to decrement

		 * the cluster number, so that the pointer points to the end of the cluster occupied.

		 */

		if(aAttribute == EAttrDirectory || aAttribute == EAttrVolumeId)

		{

			iClusterPtr->DecrementCurrentClusterNumber ();

		}

	}

}

/**

Function is responsible to take in the tree structured directory 

information and to initialize the starting cluster in the Cluster Map.