// Copyright (c) 2004-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:
// BSP2.CPP
//
#include "BSP.H"
#include "REGPSDLL.H"	// CRegisteredParserDll
#include "msvapi.h"		// CMsvEntry
#include <cbioasyncwaiter.h>

#include <msvuids.h>	// KUidMsvMessageEntry, KUidMsvServiceEntry
#include <msvids.h>
#include <biouids.h>
#include <biodb.h>
#include <mmsvattachmentmanager.h>
#include <mmsvattachmentmanagersync.h>
#include <cmsvattachment.h>
#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS 
#include "tmsvbioinfo.h"
#include <biomessageuids.h>
#include <bifchangeobserver.h>
#endif

// constants
const TInt KMaxStringLength = 1024;
const TInt KParsedFieldArrayGranularity = 16;
const TInt KReadBufSize = 256;

/** Constructor.

This is called by CBIOServerMtm to create a parser object.

@param aRegisteredParserDll Object that loaded the parser. It contains a reference 
counter of the use of the parser.
@param aEntry The message entry the parser should parse
@param aFs Connected file server handle 
*/
EXPORT_C CBaseScriptParser2::CBaseScriptParser2(CRegisteredParserDll& aRegisteredParserDll,CMsvEntry& aEntry, RFs& aFs) :
	CActive(EPriorityStandard), 
	iRegisteredParserDll(aRegisteredParserDll), 
	iEntry(aEntry), 
	iFs(aFs), 
	iEntryId(iEntry.Entry().Id())
	{
	}

/** Destructor.

This deletes iSettings and iReadBuffer and calls iRegisteredParserDll.ReleaseLibrary(). 
*/
EXPORT_C CBaseScriptParser2::~CBaseScriptParser2()
	{
	delete iReadBuffer;
	delete iSettings;
	iRegisteredParserDll.ReleaseLibrary();
	}

/** Utility function for unfolding Smart Messages.

Nokia protocol allows for folding of long fields (see Nokia Smart Messaging 
spec 2.0.0pre, 3-34 and RFC822, 3.1.1). This method unfolds the message by 
deleting any linefeed characters which are followed immediately by linear 
white space. It expects the buffer to be in iSmsBuf. 
*/
EXPORT_C void CBaseScriptParser2::UnfoldMessageL()
    {
    // Nokia protocol allows for folding of long fields (see Nokia Smart
    // Messaging spec 2.0.0pre, 3-34 and RFC822, 3.1.1). This method
    // unfolds the message by deleting any linefeed characters which are
    // followed immediately by linear white space.
    //   Note that the value returned by pBuf.Length() will change if
    // linefeeds are deleted. Hence this is called for each iteration to
    // avoid violating buffer bounds.

    TPtr pBuf(iSmsBuf->Des());				// Create modifiable pointer to HBufC

    for (TInt pos = 0; pos < (pBuf.Length() - 1); ++pos)
        {
        // Find linefeed followed by whitespace
        if (pBuf[pos] == KCharLineFeed  &&
            (pBuf[pos+1] == KCharSpace  ||  pBuf[pos+1] == KCharTab))
            {
            pBuf.Delete(pos, 1);
            }
        }
    iSmsBuf = iSmsBuf->ReAllocL(pBuf.Length());		// Reallocate iSmsBuf with new size.
    }

void CBaseScriptParser2::InternalizeL(RMsvReadStream& aReadStream)
	{
	ResetL();
	iParsedFieldArray = new(ELeave) CArrayPtrSeg<CParsedField>(KParsedFieldArrayGranularity);

	CParsedField* parsedField(NULL);
	TInt count = aReadStream.ReadUint8L();
	for (TInt i=0; i < count; ++i)
		{
		parsedField = new (ELeave) CParsedField();
		CleanupStack::PushL(parsedField);
		parsedField->InternalizeL(aReadStream);
		iParsedFieldArray->AppendL(parsedField);
		CleanupStack::Pop(parsedField); 
		}
	}

void CBaseScriptParser2::ExternalizeL(RMsvWriteStream& aStream) const
	{
	TInt count = iParsedFieldArray->Count();
	aStream.WriteInt8L(count);
	for (TInt number = 0; number<count; ++number) // must keep order, go forwards
		{
		aStream << *(*iParsedFieldArray)[number];
		}
	}

/** Stores the parsed fields array.

It stores the iParsedFieldArray array in the specified CMsvStore.

@param aMsvStore Store to write to 
*/
EXPORT_C void CBaseScriptParser2::StoreL(CMsvStore& aMsvStore) const
	{
	RMsvWriteStream out;
	out.AssignLC(aMsvStore, KUidMsvBIODataStream); // pushes 'out' to the stack
	ExternalizeL(out);
	out.CommitL();
	out.Close(); // make sure we close the file
	aMsvStore.CommitL();
	CleanupStack::PopAndDestroy(); // out
	}

/** Restores the parsed fields array.

It restores the iParsedFieldArray array from the specified CMsvStore.

@param aMessageStore Store to read from 
*/
EXPORT_C void CBaseScriptParser2::RestoreL(CMsvStore& aMessageStore)
	{
	RMsvReadStream in;
	in.OpenLC(aMessageStore, KUidMsvBIODataStream);
	InternalizeL(in);
	CleanupStack::PopAndDestroy(); // in
	}

/** Stores the message data in a specified file.

It stores iSettings in the specified file.
Write contents of Smart message to a file as attachment

@param aFileName File to write to 
*/
EXPORT_C void CBaseScriptParser2::StoreL(const TFileName& aFileName) const
	{
	// Get the data contents, stored as 8-bit
	TPtr dataContents = iSettings->Des();
	HBufC8* buf = HBufC8::NewLC(dataContents.Length());
	buf->Des().Copy(dataContents);
	
	// Create the attachment object and copy the data into the file
	CMsvStore* store = iEntry.EditStoreL();
	CleanupStack::PushL(store);
	
	
	MMsvAttachmentManager& manager = store->AttachmentManagerL();
	MMsvAttachmentManagerSync& managerSync = store->AttachmentManagerExtensionsL();
	
	// If an attachment already exists with the same filename then delete
	// the existing one so multiple files of the same name dont exist
	for( TInt ii=0; ii<manager.AttachmentCount(); ++ii )
		{
		CMsvAttachment* attachmentInfo = manager.GetAttachmentInfoL(ii);
		CleanupStack::PushL(attachmentInfo);
		if( attachmentInfo->AttachmentName().CompareF(aFileName) == 0 )
			{
			// We have a match, delete the attachment as we will have
			// to add it as new one
			managerSync.RemoveAttachmentL(ii);
			CleanupStack::PopAndDestroy(attachmentInfo);
			break;
			}
		CleanupStack::PopAndDestroy(attachmentInfo);
		}
		
	// Create and add as a new attachment	
	CMsvAttachment* attachment = CMsvAttachment::NewL(CMsvAttachment::EMsvFile);
	CleanupStack::PushL(attachment);
	attachment->SetSize(buf->Length());
	attachment->SetAttachmentNameL(aFileName);
		
	RFile file;
	managerSync.CreateAttachmentL(aFileName, file, attachment);
	CleanupStack::Pop(attachment); // ownership passed to manager
	CleanupClosePushL(file);
	User::LeaveIfError(file.Write(*buf));
	CleanupStack::PopAndDestroy(&file);
	
	// Commit the changes and cleanup
	store->CommitL();
	CleanupStack::PopAndDestroy(2, buf); // store, buf
	}


/** Restores the message data from a specified file.

It restores iSettings from the specified file.

@param aFileName File to read from 
*/
EXPORT_C void CBaseScriptParser2::RestoreL(const TFileName& aFileName)
	{
	// Find the attachment with the provided file name
	CMsvStore* store = iEntry.ReadStoreL();
	CleanupStack::PushL(store);
	MMsvAttachmentManager& manager = store->AttachmentManagerL();
	
	TInt foundIndex = KErrNotFound;	
	for( TInt ii=0; ii<manager.AttachmentCount(); ++ii )
		{
		CMsvAttachment* attachmentInfo = manager.GetAttachmentInfoL(ii);
		if( attachmentInfo->AttachmentName().CompareF(aFileName) == 0 )
			{
			// found the attachment
			foundIndex = ii;
			delete attachmentInfo;
			break;
			}
		delete attachmentInfo;
		}
	
	// Leave if the attachment file has not been found
	User::LeaveIfError(foundIndex);
	
	// Get the file attachment...
	RFile file = manager.GetAttachmentFileL(foundIndex);
	
	CleanupStack::PopAndDestroy(store);
	
	CleanupClosePushL(file);

	// read into descriptor resizing as we go
	iReadBuffer = HBufC8::NewL(KReadBufSize);
	TBuf8<KReadBufSize> fileChunk;
	TInt fileErr = KErrNone;
	while(fileErr==KErrNone)
		{
		fileErr = file.Read(fileChunk, fileChunk.MaxLength());
		if(fileChunk.Length()==0)
			break;
		// check if we need to resize
		TInt newLength = iReadBuffer->Des().Length() + fileChunk.Length();
		if( newLength > iReadBuffer->Des().MaxLength())
			{
			iReadBuffer = iReadBuffer->ReAllocL(newLength);
			}
		iReadBuffer->Des().Append(fileChunk);
		}
	// if it worked stream data to it
	// first copy data into 8-bit buffer (it's 8bit content anyway?)
	CleanupStack::PopAndDestroy(&file); // file
	User::LeaveIfError(fileErr);

	delete iSettings;
	iSettings = NULL;
	iSettings = HBufC::NewL(iReadBuffer->Length());
	iSettings->Des().Copy(iReadBuffer->Des());
	} 

/** Gets the UID of the BIO message type handled by the parser.

@return BIO message type UID 
*/
EXPORT_C TUid CBaseScriptParser2::ParserUid()
	{
	return (iRegisteredParserDll.UidType()[2]);
	}

/** Deletes the iParsedFieldArray parsed fields array and sets it to NULL. 
*/
EXPORT_C void CBaseScriptParser2::ResetL()
	{
	// delete previous array and create a new one
	if(iParsedFieldArray)
		{
		iParsedFieldArray->ResetAndDestroy();
		delete iParsedFieldArray;
		iParsedFieldArray=NULL;
		}
	}

//
// Class CParsed field container class for 
// data item extracted from smart message
//
/** Constructor. */
EXPORT_C CParsedField::CParsedField()
	{
	iFieldName =NULL;
	iFieldValue =NULL;
	iMandatoryField =ETrue;
	}

/** Destructor. */
EXPORT_C CParsedField::~CParsedField()
	{
	delete iFieldName;
	delete iFieldValue;
	}


/** Gets the field name.

@return Field name 
*/
EXPORT_C TPtrC CParsedField::FieldName() const
	{
	return iFieldName->Des();
	}


/** Sets the field name.

@param aFieldName Field name 
*/
EXPORT_C void CParsedField::SetFieldNameL(const TDesC& aFieldName)
	{
	HBufC* temp =aFieldName.AllocL();
	delete iFieldName;
	iFieldName = temp;	
	}


/** Gets the field value.

@return Field value 
*/
EXPORT_C TPtrC CParsedField::FieldValue() const 
	{
	return iFieldValue->Des();
	}


/** Sets the field value.

@param aFieldValue Field value 
*/
EXPORT_C void CParsedField::SetFieldValueL(const TDesC& aFieldValue)
	{
	HBufC* temp =aFieldValue.AllocL();
	delete iFieldValue;
	iFieldValue = temp;
	}


/** Tests if this is a mandatory field.

@return True if this is a mandatory field 
*/
EXPORT_C TBool CParsedField::MandatoryField() const 
	{
	return iMandatoryField;
	}


/** Sets/unsets this as a mandatory field.

@param aMandatoryField True if this is a mandatory field, false if not 
*/
EXPORT_C void CParsedField::SetMandatoryField(TBool aMandatoryField)
	{
	iMandatoryField = aMandatoryField;
	}

/** Internalises the object.

@param aStream Stream to read from 
*/
EXPORT_C void CParsedField::InternalizeL(RReadStream& aStream)
	{
	Reset();
	delete iFieldName;
	iFieldName = NULL;
	iFieldName = HBufC::NewL(aStream, KMaxStringLength);
	TInt fieldValueLength = aStream.ReadInt16L();
	delete iFieldValue;
	iFieldValue = NULL;
	iFieldValue = HBufC::NewL(aStream, fieldValueLength);
	iMandatoryField = aStream.ReadInt8L();
	}

/** Externalises the object.

@param aStream Stream to write to 
*/
EXPORT_C void CParsedField::ExternalizeL(RWriteStream& aStream) const
	{
	aStream << *iFieldName;
	aStream.WriteUint16L(iFieldValue->Length());
	aStream << *iFieldValue;
	aStream.WriteUint8L(iMandatoryField ? 1 : 0);
	}

//
// Reset contetnts of field
//
void CParsedField::Reset()
	{
	delete iFieldName;
	iFieldName = NULL;

	delete iFieldValue;
	iFieldValue = NULL;

	iMandatoryField= EFalse;
	}