/*
* Copyright (c) 1997-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 <e32std.h>
#include <e32base.h>

#include <s32strm.h>
#include <s32stor.h>

#include "FLDDEF.H"
#include "FLDSET.H"
#include "FLDARRAY.H"

#include "FLDSTD.H"



EXPORT_C TFieldMapExternalizer::TFieldMapExternalizer(const CStoreMap& aMap)
	: iMap(&aMap)
	{}

EXPORT_C void TFieldMapExternalizer::ExternalizeL(const TStreamRef& aRef,RWriteStream& aStream) const
// Write the stream id bound to aRef to aStream. If not bound, write KNullStreamId
//
	{
	TSwizzleC<TAny> swizzle=aRef;
	aStream<<iMap->At(swizzle);
	}


EXPORT_C TStreamId CTextFieldSet::StoreL(CStreamStore& aStore)const
// Save the fields and the fieldSet in their own streams
// Encapsulates the storing of its components.
//
	{
	CStoreMap* map=CStoreMap::NewLC(aStore);
	StoreFieldsL(aStore,*map);  // binds id's to swizzles
//
	// create custom externalizer over the map
	TFieldMapExternalizer fMap(*map);
	RStoreWriteStream stream(fMap);
	TStreamId id=stream.CreateLC(aStore);
	stream<< *this;
	stream.CommitL();
	CleanupStack::PopAndDestroy();  // stream
//
	map->Reset();
	CleanupStack::PopAndDestroy();  // map
	return id;
	}


EXPORT_C void CTextFieldSet::StoreFieldsL(CStreamStore& aStore,CStoreMap& aMap)const
// Stores all fields in the set
//
	{StoreFieldsL(aStore,aMap,iFieldArray);}


void CTextFieldSet::StoreFieldsL(CStreamStore& aStore,CStoreMap& aMap,CArrayFixSeg<TTextFieldEntry>* aArray)const
// Stores all fields contained in the set provided
//
	{
	__TEST_INVARIANT;

	for (TInt i=0 ; i<(aArray->Count()-1) ; i++)
		{
		TStreamId id=(*aArray)[i].iFieldHeader.iField->StoreL(aStore);
		if (id!=KNullStreamId)
			aMap.BindL((*aArray)[i].iFieldHeader.iField,id);
		}
	}


EXPORT_C void CTextFieldSet::ExternalizeL(RWriteStream& aStream)const
	{
	__TEST_INVARIANT;

	ExternalizeL(aStream,iFieldArray);
	}


void CTextFieldSet::ExternalizeL(RWriteStream& aStream,CArrayFixSeg<TTextFieldEntry>* aArray)const
	{
	TInt numFieldEntries = aArray->Count();
	aStream.WriteInt32L(numFieldEntries);
	// write out fields
	for (TInt i=0 ; i<numFieldEntries-1 ; i++)
		aStream<< (*aArray)[i];
	// write out last entry in array: the bit after the last field
	aStream.WriteInt32L((*aArray)[numFieldEntries-1].iPreFieldLen);
	}


EXPORT_C void CTextFieldSet::RestoreL(const CStreamStore& aFieldStore,TStreamId aStreamId)
	{
	// reset the array and stream into it
	Reset();
	DoRestoreL(aFieldStore,aStreamId);
	}


EXPORT_C void CTextFieldSet::RestoreFieldsL(const CStreamStore& aFieldStore)
	{
	DoRestoreFieldsL(iFieldArray,aFieldStore); // restore the fields individually from their own streams
	}


void CTextFieldSet::DoRestoreL(const CStreamStore& aFieldStore,TStreamId aStreamId)
// Restores a field set and its associated fields from the store provded.
// 
	{
	__ASSERT_ALWAYS(iFieldArray->Count()==1,Panic(EArrayNotEmptyOnRestore)); // array must be empty
	__ASSERT_ALWAYS((*iFieldArray)[0].iPreFieldLen==0,Panic(EArrayNotEmptyOnRestore));

	// retrieve the headstream from the store
	RStoreReadStream stream;
	stream.OpenLC(aFieldStore,aStreamId);
	// restore the set, then the individual fields
	stream>> *this;  // internalize the field set (the headers)
	CleanupStack::PopAndDestroy(); // stream
	DoRestoreFieldsL(iFieldArray,aFieldStore); // restore the fields individually from their own streams
	}


EXPORT_C void CTextFieldSet::InternalizeL(RReadStream& aStream)
	{
	InternalizeL(iFieldArray,aStream);

	__TEST_INVARIANT;
	}


void CTextFieldSet::InternalizeL(CArrayFixSeg<TTextFieldEntry>* aArray,RReadStream& aStream)
	{// assume the array is empty
	TInt numFieldEntries = aStream.ReadInt32L();
	// read in the fields
	TTextFieldEntry entry;
	for (TInt i=0 ; i<numFieldEntries-1 ; i++)
		{
		aStream>> entry;
		InsertEntryL(i,entry,aArray); // insert new entry
		}
	// read in the last entry: the bit after the last field. This will not contain a field
	(*aArray)[numFieldEntries-1].iPreFieldLen = aStream.ReadInt32L();
	}


void CTextFieldSet::DoRestoreFieldsL(CArrayFixSeg<TTextFieldEntry>* aArray,const CStreamStore& aFieldStore,TInt aStartIndex)
// This fn is called after all FieldHeaders have been internalized - the Swizzles hold the stream id's.
// One by one the fields are created (with the factory) and then have their settings streamed in from the store.
// If no factory exists all fields are converted to text.
//
	{
	TInt ii=aArray->Count()-2;  // -2 because we skip the last (empty) entry
	while (ii>=aStartIndex)
		{
		if ((*aArray)[ii].iFieldHeader.iField.IsId()) 
			{// restore the field only if it isn't the very last (dummy) entry
			if (iFieldFactory==NULL)
				// no factory - convert the field to text
				DeleteFieldEntry(aArray,ii);
			else
				{
				TStreamId id = (*aArray)[ii].iFieldHeader.iField.AsId();
				(*aArray)[ii].iFieldHeader.iField = iFieldFactory->NewFieldL((*aArray)[ii].iFieldHeader.iFieldType);
				if ((*aArray)[ii].iFieldHeader.iField!=NULL)
					(*aArray)[ii].iFieldHeader.iField->RestoreL(aFieldStore,id);
				else
					DeleteFieldEntry(aArray,ii); // handle "field type not recognised" by converting field to text
				}
			}
		ii--;
		}
	}


/***************************************** cut & paste *******************************************/


EXPORT_C TStreamId CTextFieldSet::CopyToStoreL(CStreamStore& aStore,TInt aPos,TInt aLength)const
// Copy any fields in the selected region to the specified store, returning the id of the head-stream.
//
	{
	__TEST_INVARIANT;
	__ASSERT_ALWAYS(aPos>=0,Panic(EPosOutOfRange));
	__ASSERT_ALWAYS(aLength>=0,Panic(ENegativeRange));
	__ASSERT_DEBUG((aPos+aLength)<=CharCount(),Panic(EPosOutOfRange));

	// Create a store map and store the fields themselves
	CStoreMap* map=CStoreMap::NewLC(aStore);
	CopyComponentsL(aStore,*map,aPos,aLength);

	// Create a head-stream in which to store the field entries and do so
	RStoreWriteStream stream(*map);
	TStreamId id=stream.CreateLC(aStore);
	CopyToStreamL(stream,aPos,aLength);

	// tidy up
	stream.CommitL();
	map->Reset();
	CleanupStack::PopAndDestroy(2); // map, stream
	return id;
	}


EXPORT_C void CTextFieldSet::CopyComponentsL(CStreamStore& aStore,CStoreMap& aMap,TInt aPos,TInt aLength)const
// Stores all fields in the set
//
	{
	__TEST_INVARIANT;
	__ASSERT_ALWAYS(aPos>=0,Panic(EPosOutOfRange));
	__ASSERT_ALWAYS(aLength>=0,Panic(ENegativeRange));
	__ASSERT_DEBUG((aPos+aLength)<=CharCount(),Panic(EPosOutOfRange));

	// Create an array of the fields to be cut/copied
	CArrayFixSeg<TTextFieldEntry>* tempArray = new(ELeave) CArrayFixSeg<TTextFieldEntry>(KFieldArrayGranularity);
	CleanupStack::PushL(tempArray);
	CopyToArrayL(tempArray,aPos,aLength);

	// stream the required fields in their own streams
	StoreFieldsL(aStore,aMap,tempArray);
	CleanupStack::PopAndDestroy(); // tempArray
	}


EXPORT_C void CTextFieldSet::CopyToStreamL(RWriteStream& aStream,TInt aPos,TInt aLength)const
// Stores all fields in the set
//
	{
	__TEST_INVARIANT;
	__ASSERT_ALWAYS(aPos>=0,Panic(EPosOutOfRange));
	__ASSERT_ALWAYS(aLength>=0,Panic(ENegativeRange));
	__ASSERT_DEBUG((aPos+aLength)<=CharCount(),Panic(EPosOutOfRange));

	// Create an array of the fields to be cut/copied
	CArrayFixSeg<TTextFieldEntry>* tempArray = new(ELeave) CArrayFixSeg<TTextFieldEntry>(KFieldArrayGranularity);
	CleanupStack::PushL(tempArray);
	CopyToArrayL(tempArray,aPos,aLength);

	// stream the field entries in the temp array
	ExternalizeL(aStream,tempArray);
	CleanupStack::PopAndDestroy(); // tempArray
	}


void CTextFieldSet::CopyToArrayL(CArrayFixSeg<TTextFieldEntry>* aArray,TInt aPos,TInt aLength)const
	{
	TInt index; TInt offset;
	if (InField(aPos,index,offset))
		offset += (*iFieldArray)[index].iPreFieldLen; // make offset relative to start of entry
	// split first entry in range
	TTextFieldEntry entry = SplitEntry(index,offset,aLength);
	index++;
	TInt charsCopied=EntryLen(entry);
	// split second if neccessary
	if ((!entry.iFieldHeader.iField)&&(charsCopied<aLength))
		{
		TInt preFieldLen = entry.iPreFieldLen;
		entry = SplitEntry(index,0,aLength-preFieldLen);
		entry.iPreFieldLen += preFieldLen;
		charsCopied = EntryLen(entry);
		index++;
		}
	((CTextFieldSet*)this)->AppendEntryL(entry,aArray); // append the first entry to the storage array
	// write out all whole entries
	while (charsCopied<aLength)
		{
		if ((charsCopied+EntryLen(index))<=aLength)
			((CTextFieldSet*)this)->AppendEntryL((*iFieldArray)[index],aArray); 
		charsCopied += EntryLen(index);
		index++;
		}
	// split last entry if neccessary
	if (charsCopied>aLength)
		{// The last entry needs to be split
		// first get back to the beginning of the entry
		index--;
		charsCopied -= EntryLen(index);
		entry = SplitEntry(index,0,aLength-charsCopied); // split up the last entry as required
		((CTextFieldSet*)this)->AppendEntryL(entry,aArray); // append the last entry to the storage array
		}
	// add an empty last entry if neccessary
	TInt numFieldEntries = aArray->Count();
	if (((*aArray)[numFieldEntries-1].iFieldHeader.iField) || ((*aArray)[numFieldEntries-1].iFieldValueLen!=0))
		{
		entry.iPreFieldLen = 0;
		entry.iFieldValueLen = 0;
		entry.iFieldHeader.iFieldType = KNullUid;
		entry.iFieldHeader.iField = NULL;
		((CTextFieldSet*)this)->AppendEntryL(entry,aArray);
		numFieldEntries++;
		}
	}


EXPORT_C void CTextFieldSet::PasteFromStoreL(const CStreamStore& aFieldStore,TStreamId aStreamId,TInt aPos,TInt aMaxLen)
// Paste from aStore into the document at insert position aPos.
// Optionally the pasted text can be clipped to a maximum length aMaxLen.
//
	{
	__ASSERT_ALWAYS(aPos>=0,Panic(EPosOutOfRange));
	__ASSERT_DEBUG(aPos<=CharCount(),Panic(EPosOutOfRange));

	// retrieve the headstream from the store
	RStoreReadStream stream;
	stream.OpenLC(aFieldStore,aStreamId);

	// restore the set...
	PasteFromStreamL(stream,aPos,aMaxLen); // internalize the field set (the headers)
	CleanupStack::PopAndDestroy(); // stream

	// ...then the individual fields
	PasteComponentsL(aFieldStore,aPos); // restore the fields individually from their own streams
	}


EXPORT_C void CTextFieldSet::PasteFromStreamL(RReadStream& aStream,TInt aPos,TInt aMaxLen)
// streams the field entries into a temporary array, which is returned. 
// PasteComponents() must be called after this to actually carry out the paste...
	{
	// create a temporary array to stream in to, inserting the first entry
	CArrayFixSeg<TTextFieldEntry>* tempFieldArray = new(ELeave) CArrayFixSeg<TTextFieldEntry>(KFieldArrayGranularity);
	CleanupStack::PushL(tempFieldArray);
	AddInitialFieldEntryL(tempFieldArray,0);

	// internalize the field entries
	InternalizeL(tempFieldArray,aStream);

	// trim off any entries that lie beyond aMaxLength
	if (aMaxLen!=ENoPasteLimit)
		{// if aMaxLen is not ENoPasteLimit discard the excess fields
		__ASSERT_ALWAYS(aMaxLen>=0,Panic(ELengthOutOfRange));
		//
		TInt length=0;
		TInt i=0;
		for (i=0 ; (length<aMaxLen)&&(i<tempFieldArray->Count()) ; i++)
			length += EntryLen((*tempFieldArray)[i]);
		if (aMaxLen==0)
			{// make first entry zero len, delete all others
			i++;
			(*tempFieldArray)[i-1].iPreFieldLen = 0;
			}
		else if (length>aMaxLen)
			// truncate the last field in range
			(*tempFieldArray)[i-1].iPreFieldLen += (*tempFieldArray)[i-1].iFieldValueLen-(length-aMaxLen);
		else if ((length==aMaxLen) && ((*tempFieldArray)[i-1].iFieldHeader.iField!=NULL))
			{// if the terminating entry has a field add a zero length entry, the mandatory last entry
			i++;
			(*tempFieldArray)[i-1].iPreFieldLen = 0;
			}
		// ensure the last entry is of the correct format
		(*tempFieldArray)[i-1].iFieldValueLen = 0;
		(*tempFieldArray)[i-1].iFieldHeader.iFieldType = KNullUid;
		(*tempFieldArray)[i-1].iFieldHeader.iField = NULL;
		// delete all the fields wholely out of range
		for (TInt index=i ; index<tempFieldArray->Count() ; index++)
			(*tempFieldArray)[index].iFieldHeader.iField = NULL;
		tempFieldArray->Delete(i,tempFieldArray->Count()-i); // pos,count
		}

	DoPasteL(tempFieldArray,aPos);
	CleanupStack::PopAndDestroy(); // tempFieldArray
	}


EXPORT_C void CTextFieldSet::PasteComponentsL(const CStreamStore& aFieldStore,TInt aPos)
	{
	// Restore the fields individually from their own streams
	TInt index; TInt offset;
	// We don't need to make any difference between in and not in field situation here
	// all we need is the index
	TBool isInField = InField(aPos,index,offset);
	DoRestoreFieldsL(iFieldArray,aFieldStore,index); 
	}


void CTextFieldSet::DoPasteL(CArrayFixSeg<TTextFieldEntry>* aSourceArray,TInt aPos)
// Insert into this instance, at character position aPos, the entire (field entry) contents of the field array aSourceArray.
// All iField objects in aSourceArray are ID's at this time.
//
	{
	// are we inserting into a field?
	TInt numFieldEntries = aSourceArray->Count();
	TInt index; TInt offset;
	
	TBool inField = InField(aPos,index,offset);
	// record the rollback info
	RecordRollbackInfoL(index);
	if ((inField)&&(offset!=0))
		{// everything we insert will become text - no chance of leaving
		// insert all but last entry
		TInt i=0;
		for (; i<numFieldEntries-1 ; i++)
			{// copy text (no need to delete field)
			(*iFieldArray)[index].iFieldValueLen += EntryLen((*aSourceArray)[i]);
			}
		// read in the last entry (has no field attached)
		(*iFieldArray)[index].iFieldValueLen += (*aSourceArray)[i].iPreFieldLen;
		}
	else
		{// else split the entry we are going to bisect - this may leave
		if (inField)
			offset = (*iFieldArray)[index].iPreFieldLen; // must be at start of field
		if (numFieldEntries>1)
			{// read 1st field & carry out split.
			InsertEntryL(index,(*aSourceArray)[0]); // if this leaves the model will be intact
			(*iFieldArray)[index].iPreFieldLen += offset;
			(*iFieldArray)[index+1].iPreFieldLen -= offset;
			index++;
			}
		// insert all other fields except last.
		for (TInt i=1 ; i<numFieldEntries-1 ; i++)
			{
			TRAPD(ret,\
				InsertEntryL(index,(*aSourceArray)[i]));
			if (ret!=KErrNone)
				{// do rollback, then propagate leave
				RollbackPaste();
				User::Leave(ret);
				}
			index++;
			}
		// join last field up to successor
		(*iFieldArray)[index].iPreFieldLen += (*aSourceArray)[numFieldEntries-1].iPreFieldLen;
		}

	__TEST_INVARIANT;
	}


void CTextFieldSet::RecordRollbackInfoL(TInt aIndex)
	{
	delete iRollbackInfo;
	iRollbackInfo = new(ELeave) TRollbackInfo();
	iRollbackInfo->iEntryNum = aIndex;
	iRollbackInfo->iPreFieldLen = (*iFieldArray)[aIndex].iPreFieldLen;
	iRollbackInfo->iFieldValueLen = (*iFieldArray)[aIndex].iFieldValueLen;
	iRollbackInfo->iTotalEntries = iFieldArray->Count();
	}


EXPORT_C void CTextFieldSet::RollbackPaste()
// Carries out rollback from a paste function
// This will only have an effect after a PasteFromStream() has been called
// nb it would be distasterous if this were called at random some time after a paste!
//
	{
	if (!iRollbackInfo)
		return; // nothing to do
	// remove added entries from array
	TInt entriesToRemove=iFieldArray->Count()-iRollbackInfo->iTotalEntries;
	TInt i=0;
	for (i=iRollbackInfo->iEntryNum ; i<iRollbackInfo->iEntryNum+entriesToRemove ; i++)
		{
		if ((*iFieldArray)[i].iFieldHeader.iField.IsPtr())
			delete (*iFieldArray)[i].iFieldHeader.iField.AsPtr(); // Delete the textField object
		iFieldArray->Delete(i);
		}
	// now right num entries, but wrong length - use backup info to correct length
	(*iFieldArray)[i].iPreFieldLen = iRollbackInfo->iPreFieldLen;
	(*iFieldArray)[i].iFieldValueLen = iRollbackInfo->iFieldValueLen;

	__ASSERT_DEBUG(iFieldArray->Count()==iRollbackInfo->iTotalEntries,Panic(EDebug));
	delete iRollbackInfo;
	}