/*
* 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 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: 
* Note: This file may contain code to generate corrupt files for test purposes.
* Such code is excluded from production builds by use of compiler defines;
* it is recommended that such code should be removed if this code is ever published publicly.
*
*/


/**
 @file 
 @internalComponent
 @released
*/

#include "sisstring.h"
#include "utility.h"
#include "exception.h"
#include "utils.h"
#include "utf8.h"

// we cannot write or read a string directly from a file, because we don't know what format the
// MS implementation of STL will use for the std::string. So we need to go via an intemediate buffer.
// But strings can be variable size, including very big indeed, so that buffer will have to be
// allocated as need be. Buffer allocation and deletion is expensive. It is sensible to allocate
// a common buffer, and only change its size when necessary. To reduce the frequency of file size
// changes, the actual allocation oversteps the mark, so the next time something requests a slightly
// bigger string, no allocation is required (usually). These variables could be private static members of our
// string class, but that would mean some minor change to this code would require the entire
// product to be recompiled.

static TUint8* gBuffer = NULL;
static unsigned long gBufferLength = 0;
static const unsigned long gChunk = 512;



void VerifyBufferSize (const unsigned long aSize)
	{
	if (aSize == 0)
		{
		return;
		}
	if (aSize > gBufferLength)
		{
		delete [] gBuffer;
		gBufferLength = aSize + gChunk;
		gBuffer = new TUint8 [gBufferLength];
		}
	}


void CSISString::ExitInstance ()
	{
	delete [] gBuffer;
	gBuffer = NULL;
	gBufferLength = 0;
	}


void CSISString::Read (TSISStream& aFile, const TFieldSize& aContainerSize, const CSISFieldRoot::TFieldType aArrayType)
	{
	CSISHeader header (CSISFieldRoot::ESISString);
	if (IsDataThere (aFile, header, aArrayType))
		{
		if (header.DataSize () == 0)
			{
			iData.erase ();
			}
		else
			{
				unsigned int dataSize = header.DataSize();
				VerifyBufferSize (dataSize);
				dataSize = AlignedSize(dataSize);
				aFile.read (gBuffer, dataSize);

				if(sizeof(WCHAR) != 2)
					{
					int targetLength = dataSize*sizeof(wchar_t);
					wchar_t *ptrUCS4 = new wchar_t [dataSize];
					UTF16* sourceStart = reinterpret_cast<UTF16*>(gBuffer);
					UTF16* sourceEnd = sourceStart + dataSize;
					UCS4* targetStart = reinterpret_cast<UCS4*>(ptrUCS4);
					UCS4* targetEnd = targetStart + dataSize*2;
					ConvertUTF16toUCS4(&sourceStart, sourceEnd, &targetStart, targetEnd);
					iData.assign ((ptrUCS4), static_cast <std::wstring::size_type> (dataSize / 2));
					}
				else
					{
					iData.assign (	reinterpret_cast <wchar_t*> (gBuffer), 
  							static_cast <std::wstring::size_type> (header.DataSize () / sizeof (wchar_t)));
					}
			}

		}
	}


void CSISString::Write (TSISStream& aFile, const bool aIsArrayElement) const
	{
	if (! WasteOfSpace ())
		{
#ifdef GENERATE_ERRORS
		if (CSISFieldRoot::IsBugToBeCreated (CSISFieldRoot::EBugInsaneString))
			{
			CSISHeader (CSISFieldRoot::ESISString, rand ()).Write (aFile, aIsArrayElement);
			}
		else
#endif // GENERATE_ERRORS
			{
			CSISHeader (CSISFieldRoot::ESISString, ByteCount (aIsArrayElement)).Write (aFile, aIsArrayElement);
			}
		
		// SIS file format only supports UCS-2 format , so need conversion here if wchar is 4 bytes (Linux OS)
		if(sizeof(WCHAR) != 2)
			{
			int targetLength = iData.size()*2;
			UTF16 *ptrUtf16 = new UTF16[targetLength + 1];
			UCS4* sourceStart = reinterpret_cast<UCS4*>(const_cast<wchar_t*>(iData.c_str()));
			UCS4* sourceEnd = sourceStart + (iData.size()*sizeof(WCHAR));
			UTF16* targetStart = reinterpret_cast<UTF16*>(ptrUtf16);
			UTF16* targetEnd = targetStart + targetLength;
			ConvertUCS4toUTF16(&sourceStart, sourceEnd, &targetStart, targetEnd);
			int endOffset = (UTF16*)targetStart - ptrUtf16;
			targetStart = reinterpret_cast<UTF16*>(ptrUtf16) + endOffset;
			*targetStart = 0;
			aFile.write (reinterpret_cast <const TUint8*> (ptrUtf16),targetLength);
			}
		else
			{
			aFile.write (reinterpret_cast <const TUint8*> (iData.c_str ()), ByteCount (aIsArrayElement));
			}
		WriteFiller (aFile);
		}
	}


void CSISString::Dump (std::ostream& aStream, const int aLevel) const
	{
	aStream << "\"" << wstring2string (iData) << "\"";
	}


void CSISString::CalculateCrc (TCRC& aCRC, const bool aIsArrayElement) const
	{
	if(!WasteOfSpace())
		{
		CSISHeader (CSISFieldRoot::ESISString, ByteCount (false)).CalculateCrc (aCRC, aIsArrayElement);
		CSISFieldRoot::DoPaddedCrc(aCRC, reinterpret_cast <const TUint8*> (iData.c_str ()), ByteCount (aIsArrayElement));
		}
	}


CSISFieldRoot::TFieldSize CSISString::ByteCount (const bool aInsideArray) const
	{
	if(sizeof(wchar_t) != 2)
		return static_cast <CSISFieldRoot::TFieldSize> (iData.size () * sizeof (wchar_t)/2);
	else
		return static_cast <CSISFieldRoot::TFieldSize> (iData.size () * sizeof (wchar_t));
	}


bool CSISString::WasteOfSpace () const
	{
	return ! Required () && iData.empty ();
	}