// Copyright (c) 2007-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 "inputdata.h"

#if defined(__LIGHTLOGGER_ENABLED)
#include "lightlogger.h" 
#endif

/**Default constructor.
*/
EXPORT_C CInputData::CInputData(unsigned int aMinPackageSize)
{
	iMinPackageSize = aMinPackageSize;
}

/**Destructor.
*/
EXPORT_C CInputData::~CInputData()
{
}

/**Function creates new control data chunk (with EOL).

@param aCommand A pointer to command literal.
@param aCommandSize Size of data poitned by aCommand.
@return Pointer to ControlData type is returned when chunk was successfully created, otherwise NULL.
*/
EXPORT_C ControlData* CInputData::CreatePackage(void* aCommand, signed long aCommandSize)
{
	unsigned long trueSize = aCommandSize+SIZE_OF_EOL; 
	unsigned long size = trueSize;
	if(size<iMinPackageSize)
		size = iMinPackageSize;

	//create package
	ControlData *package = new ControlData[size]; //minimum package
	if(!package)
		return NULL;
	
	//add command 
	memcpy((void*)package, aCommand, aCommandSize);
	
	//apend padding character if necessary (between last string and EOL)
	long padd = 0;
	if(trueSize < iMinPackageSize)
	{
	padd = iMinPackageSize-trueSize;
		for(int i=0; i<padd; i++) //skip separator
			memcpy((void*)(package+aCommandSize+i), (void*)&DATA_SEPARATOR, 1);
	}
	
	//add EOL
	memcpy((void*)(package+aCommandSize+padd), (void*)&CD_EOL, SIZE_OF_EOL);
	
	return package;
}

//only for internal use
unsigned long CInputData::FindAvailablePlace(const ControlData *aDataPtr)
{
	unsigned long currentSize = this->GetSize(aDataPtr);
	unsigned long endPtr = 0;
	
	while(true)
	{
		if((*(aDataPtr+endPtr))==CD_CR)
			break;
		
		if((*(aDataPtr+endPtr)) == DATA_SEPARATOR)
			if(((*(aDataPtr+endPtr+1)) == CD_CR) || ((*(aDataPtr+endPtr+1)) == DATA_SEPARATOR))
				break; //offset
		++endPtr;
	}
	
	return endPtr+1;
}

//only for internal use
unsigned long CInputData::CalcNumberOfPaddingChars(const ControlData *aDataPtr)
{
	unsigned long padd = 0;
	int i=1;
	
	while(true)
	{
		if((*(aDataPtr+i))==DATA_SEPARATOR)
			if((*(aDataPtr+i+1))==DATA_SEPARATOR)
				++padd;
		if((*(aDataPtr+i))==CD_CR)
			break;
		++i;
	}
	
	return padd;
}

/**Function returns size of control data chunk given as an argument.
aDataPtr must be ended with EOL (end if line) sequence.

@param aDataPtr A poiter to existing control data.
@return Unsigned long number describing current size of control data.
*/
EXPORT_C unsigned long CInputData::GetSize(const ControlData *aDataPtr)
{
	long i=0;
	while(true)
		{
		if((*(aDataPtr+i)) == CD_CR)
			if((*(aDataPtr+i+1)) == CD_LF)
				return i+SIZE_OF_EOL;
		++i;
		}
}


/**Function returns number of chunks in current control data package.
 
@param aDataPtr A poiter to existing control data chunk.
@return Number of chunks in current control data.
*/
EXPORT_C unsigned long CInputData::GetChunksCount(const ControlData *aDataPtr)
{
	unsigned long counter = 0;
	unsigned long size = this->GetSize(aDataPtr);
	unsigned long tmp = 0;
	
	while(tmp < size-1)
	{
		if( (*(aDataPtr+tmp) != DATA_SEPARATOR) && (*(aDataPtr+tmp) != CD_CR) && (*(aDataPtr+tmp) != CD_LF) )
			if( (*(aDataPtr+tmp+1) == DATA_SEPARATOR) || (*(aDataPtr+tmp+1) == CD_CR) || (*(aDataPtr+tmp+1) == CD_LF) )
				++counter;
		++tmp;
	}	
	return counter;
}


/**Function parses control data chunk and returns pointer to data chunk described in aChunkNumber argument and update 
aChunkSize argument passed as a reference.
 
@param aDataPtr A poiter to existing control data.
@param aChunkNumber Number of desired data chunk.
@param aChunkSize Reference to unsigned long variable, where size of returned chunk will be written.
@return A pointer to data or NULL.
*/
EXPORT_C const void* CInputData::GetChunk(const ControlData* aDataPtr, unsigned long aChunkNumber, unsigned long &aChunkSize)
{
	aChunkSize = 0;
	unsigned long counter = 0;
	unsigned long size = this->GetSize(aDataPtr);
	unsigned long tmp = 0;
	
	while(tmp < size)
	{
		if(counter == aChunkNumber)
		{
			unsigned long chunkStart = tmp;
			while((*(aDataPtr+tmp)!=DATA_SEPARATOR) && (*(aDataPtr+tmp)!=CD_CR))
				{++tmp;}
			aChunkSize = tmp-chunkStart;
			const void* ret = aDataPtr+chunkStart;
			return ret;
		}
		else if(*(aDataPtr+tmp)==DATA_SEPARATOR)
				++counter;
		++tmp;
	}
	
	return NULL;
}

/**Functions appends data to existing control data. All operations, like updating size and appending separators, are done internally.

@param aDataPtr A reference to poiter to existing control data.
@param aAddData A pointer to data that should be appended to current payload.
@param aAddDataSize A size of data that should be appended.
@return A new size of control data chunk (size after 'append' operation).
*/
EXPORT_C unsigned long CInputData::AppendNewData(ControlData *&aDataPtr, const void *aAddData, unsigned long aAddDataSize)
{	
	unsigned long currentSize = this->GetSize(aDataPtr); //with EOL
	unsigned long nextPayOffest = this->FindAvailablePlace(aDataPtr);
	unsigned long paddChars = this->CalcNumberOfPaddingChars(aDataPtr);
	
	//calculate new size
	unsigned long newSize = 0;
	if(paddChars >= aAddDataSize)
		newSize = currentSize;	
		else
			newSize = currentSize+aAddDataSize+1; //1 char for separator

	//reallocate 
	ControlData *newPtr = new ControlData[newSize];
	if(newPtr == NULL)
		{
		delete [] aDataPtr;
		return NULL;
		}

	//fill with padding characters
	for(int i=0; i<newSize; i++)
		memcpy((void*)(newPtr+i), (void*)&DATA_SEPARATOR, 1);
	
	//copy old content to new location
	memcpy((void*)newPtr, (void*)aDataPtr, currentSize-SIZE_OF_EOL); //except EOL
	delete [] aDataPtr;
	
	//add new Data
	memcpy((void*)(newPtr+nextPayOffest), (void*)aAddData, aAddDataSize);
	
	//add EOL (end of package indicator)
	memcpy((void*)(newPtr+newSize-SIZE_OF_EOL), (void*)&CD_EOL, SIZE_OF_EOL);

	//assign new data
	aDataPtr = newPtr;
	
	return newSize;
}