// 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 "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 "agsfileconverter.h"

#include <s32file.h>

#include <apparc.h>

#include <asshddefs.h>

#include <txtrich.h>

#include <vtzrules.h>

#include "agscategorylist.h"

#include "agsentrymanager.h"

#include "agmcontent.h"

#include "agmdate.h"

#include "agmentry.h"

#include "agsentrymodel.h"

#include "agsstreamidset.h"

#include "agmutil.h"

#include "agsver.h"

#include "agmcategory.h"

#include "agmattendee.h"

#include "agsfilemanager.h"

#include "agsmain.h"

#include "calcommonimpl.h"

#include "agstzruleindex.h"

const TInt KMajorVersionNumber = 1;

const TInt KMinorVersionNumber = 2;

const TInt KBuildNumber = 2;	// Build 1.2.2 is current build

const TInt KBuildCompatibleVersion = 1;

//

const TInt KOldMinorVersionNumber = 1;

const TInt KOldBuildV94 = 211;		// build 1.1.211 is v9.4 compacted version

const TInt KOldBuildV92 = 210;		// build 1.1.210 is v9.2

const TInt KOldBuildV91 = 209;		// build 1.1.209 is v9.1

									// build 1.1.208 is v8.0 and v8.1

									// build 1.1.207 is 6.0 & 6.1 (prior builds 204-206 were dev releases)

// ---------------------------- CalFileVersionUtils -------------------------

CAgnCalendarConverter* CalFileVersionUtils::CreateConverterL(const TAgnVersion& aFileVersion, CAgnServFile& aAgnServerFile)

/** @internalComponent */

	{

	CAgnCalendarConverter* converter = NULL;

	if (aFileVersion == TAgnVersion(TVersion(KMajorVersionNumber, KOldMinorVersionNumber, KOldBuildV91))) 

		{

		// file format 1.1.209 used in 9.1

		converter = CAgnCalendarConverter209::NewL(aAgnServerFile);

		}

	else if (aFileVersion == TAgnVersion(TVersion(KMajorVersionNumber, KOldMinorVersionNumber, KOldBuildV92))) 

		{

		// file format 1.1.210 used in 9.2

		converter = CAgnCalendarConverter210::NewL(aAgnServerFile);

		}

	else if (aFileVersion == TAgnVersion(TVersion(KMajorVersionNumber, KOldMinorVersionNumber, KOldBuildV94)))

		{

		// file format 1.1.211 used in 9.4 compacted file version

		converter = CAgnCalendarConverter211::NewL(aAgnServerFile);

		}

	else if (aFileVersion == CurrentFileVersion() )

		{

		converter = NULL;

		}

	else

		{

		User::Leave(KErrNotSupported);

		}

	return converter;

	}

void CalFileVersionUtils::FileVersionSupportedL(const TAgnVersion& aFileVersion, CalCommon::TCalFileVersionSupport& aStatus)

	{

	if ( aFileVersion == CurrentFileVersion() ||

			aFileVersion == TAgnVersion(TVersion(KMajorVersionNumber, KMinorVersionNumber, KBuildCompatibleVersion)))

		{

		// The the file was created by an agenda model

		// of the current version

		//

		aStatus = CalCommon::EFileIsCurrentVersion;

		}

	else

		{

		RArray<TAgnVersion> supportedFileVersions;

		CleanupClosePushL(supportedFileVersions);

		supportedFileVersions.AppendL(TAgnVersion(TVersion(KMajorVersionNumber, KOldMinorVersionNumber, KOldBuildV94)));

		supportedFileVersions.AppendL(TAgnVersion(TVersion(KMajorVersionNumber, KOldMinorVersionNumber, KOldBuildV92)));

		supportedFileVersions.AppendL(TAgnVersion(TVersion(KMajorVersionNumber, KOldMinorVersionNumber, KOldBuildV91)));

		// The file version is not current but if it is in the 

		// list of versions supported by this agenda model it can

		// be converted to current version.

		//

		aStatus = CalCommon::EUnsupportedFileVersion;

		for ( TInt i = 0; i < supportedFileVersions.Count(); ++i )

			{

			if ( supportedFileVersions[i] == aFileVersion )

				{

				aStatus = CalCommon::EFileNeedsConverting;

				break;

				}

			}

		CleanupStack::PopAndDestroy(&supportedFileVersions);

		}

	}

TAgnVersion CalFileVersionUtils::CurrentFileVersion()

	{ 

	return (TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildNumber));

	}

// ---------------------------- CAgnCalendarConverter -------------------------

CAgnCalendarConverter::CAgnCalendarConverter()

	{

	}

CAgnCalendarConverter::~CAgnCalendarConverter()

/** @internalComponent */

	{

	if(iOutputTzRuleIndex)

		{

		delete iOutputTzRuleIndex; 

		}

	delete iDictionary;

	delete iOutputStreamStore;

	delete iOutModelStreamIdSet;

	delete iOutEntryManager;

	}

void CAgnCalendarConverter::ConstructL(CAgnServFile& aAgnServerFile)

/** @internalComponent */

	{ 

	iOutModelStreamIdSet = CAgnModelStreamIdSet::NewL();

	iOutEntryManager = CAgnEntryManager::NewL();

	iAgnServerFile = &aAgnServerFile;

	// Get the original (old version) stream store from the CAgnServFile

	//

	iInputStreamStore = iAgnServerFile->StoreL();

	__ASSERT_ALWAYS(iInputStreamStore, User::Leave(KErrCorrupt));

	// Create the output stream store

	//

	TParsePtrC fullFileName(iAgnServerFile->FileName());

	HBufC* fileName = HBufC::NewLC(fullFileName.Drive().Length() + 

								   fullFileName.NameAndExt().Length() +

								   KUpdatedAgendaFileExtension().Length());

	TPtr fileNamePtr(fileName->Des());

	fileNamePtr.Append(fullFileName.Drive());

	fileNamePtr.Append(fullFileName.NameAndExt());

	fileNamePtr.Append(KUpdatedAgendaFileExtension);

	// Create the output stream store where converted information will be kept

	// This code copied from CAgnServerSession::CreateAgendaFileL() and CAgnEntryModel::CreateL(CStreamStore& aStore)

	//

	iOutputStreamStore = iAgnServerFile->Server().FileMgr()->CreateAgendaFileLC(fileNamePtr);

	CleanupStack::Pop(iOutputStreamStore);

	CleanupStack::PopAndDestroy(fileName);

	iOutputStreamStore->SetTypeL(TUidType(KPermanentFileStoreLayoutUid, KUidAppDllDoc, KUidAgnApp));

    iOutEntryManager->SetStore(*iOutputStreamStore);

	// Create the network of stream Ids needed by the model

	TStreamId headstreamId = iOutModelStreamIdSet->CreateL(*iOutputStreamStore, CalFileVersionUtils::CurrentFileVersion());

	// Create the stream dictionary for iOutputStreamStore and keep headstreamId in it

	//

	iDictionary = CStreamDictionary::NewL();

	iDictionary->AssignL(KUidAgnModel, headstreamId);

    // Set stream dictionary in stream store

	TApaAppIdentifier dummyApp(KUidAgnModel, KNullDesC());

	CApaProcess::WriteRootStreamL(*iOutputStreamStore,*iDictionary, dummyApp);

	iOutputTzRuleIndex = CAgnTzRuleIndex::NewL(*iDictionary, *iOutputStreamStore);

	}

CFileStore& CAgnCalendarConverter::InputStreamStore() const

	{

	return *iInputStreamStore;

	}

CFileStore& CAgnCalendarConverter::OutputStreamStore() const

	{

	return *iOutputStreamStore;

	}

CAgnServFile& CAgnCalendarConverter::AgnServerFile() const

	{

	return *iAgnServerFile;

	}

CStreamDictionary& CAgnCalendarConverter::Dictionary() const

	{

	return *iDictionary;

	}

void CAgnCalendarConverter::AddToIndexL(CAgnEntry& aEntry) const

	{

	iAgnServerFile->Model()->UpdateIndexL(aEntry, NULL, CAgnEntryModel::EAdd);

	}

void CAgnCalendarConverter::SetNextLocalUidValue(TInt aValue) const

	{

	iAgnServerFile->Model()->iNextLocalUidValue = aValue;

	}

void CAgnCalendarConverter::SetModelStreamIds(const TAgnVersion& aVersion,

											  const TStreamId& aEntrySetStreamId,

											  const TStreamId& aNextLocalUidValueStreamId,

											  const TStreamId& aEntryManagerStreamId,

											  const TStreamId& aFileInformationStreamId,

											  CAgnModelStreamIdSet& aModelStreamIdSet) const

	{

	aModelStreamIdSet.iVersion = aVersion;

	aModelStreamIdSet.iEntrySetStreamId = aEntrySetStreamId;

	aModelStreamIdSet.iNextLocalUidValueStreamId = aNextLocalUidValueStreamId;

	aModelStreamIdSet.iEntryManagerStreamId = aEntryManagerStreamId;

	aModelStreamIdSet.iFileInformationStreamId = aFileInformationStreamId;

	}

/**

This method is executed as the last step of a calendar file conversion.

Externalizes to the new file store the new CAgnEntryManager and CAgnModelStreamIdSet.

Calls ReplaceAgendaFile() to update the Model and its ServerFile with the products of the

conversion.

@internalComponent */

void CAgnCalendarConverter::CompleteConversionL()

	{

	// Copy iFileId and iNextUniqueIdValue to the Converter's output stream store

	//

	iAgnServerFile->Model()->ExternalizeFileIdL(*iOutputStreamStore, iOutModelStreamIdSet->FileInformationStreamId());

	iAgnServerFile->Model()->ExternalizeNextUidValuesL(*iOutputStreamStore, iOutModelStreamIdSet->NextLocalUidValueStreamId());

	iOutputStreamStore->CommitL();

	// Commit the streamIdSet and the EntryManager to the output store

	//

	RStoreWriteStream stream;

	stream.ReplaceLC(*iOutputStreamStore,iOutModelStreamIdSet->EntryManagerStreamId());

	stream << *iOutEntryManager;

	stream.CommitL();

	CleanupStack::PopAndDestroy();

	iOutModelStreamIdSet->CommitL(*iOutputStreamStore);

	iOutputStreamStore->CommitL();

	delete iDictionary;

	iDictionary = NULL;

	delete iOutputStreamStore;

	iOutputStreamStore = NULL;

	// Set new calendar file and dictionary in CAgnServFile

	// (this deletes the old file, and hands over the ownership of iOutputTzRuleIndex)

	//

	iAgnServerFile->ReplaceConvertedAgendaFileL(*iOutEntryManager, *iOutputTzRuleIndex);

	iOutputTzRuleIndex = NULL;

	}

/**

This method stores in CAgnCalendarConverter::iOutputStreamStore the entry that has been internalized

from an old version file. 

The persistence layer objects owned by the CAgnCalendarConverter (iOutEntryManager and iOutModelStreamIdSet)

will also be updated to register the new entry.

@internalComponent */

void CAgnCalendarConverter::SaveRestoredEntryL(CAgnEntry& aEntry) const

	{

	// Externalize outline attributes first

	TStreamId id = KNullStreamId;

	RStoreWriteStream out;

	id = WriteDescriptorToStreamL(aEntry.Description());

	aEntry.SetDescriptionStreamId(id);

	id = WriteDescriptorToStreamL(aEntry.Summary());

	aEntry.SetSummaryStreamId(id);

	if(aEntry.AlarmAction())

		{

		RStoreWriteStream out;

		id = out.CreateLC(*iOutputStreamStore);

		out << *aEntry.AlarmAction();

		out.CommitL();

		CleanupStack::PopAndDestroy(); //out

		aEntry.SetAlarmActionStreamId(id);

		}

	iOutputTzRuleIndex->AddTzRuleL(aEntry);

	TStreamId newStreamId = iOutEntryManager->AddEntryL(aEntry); // This changes the entry/instance ID

	if (newStreamId != KNullStreamId)

		{

		// This puts the stream id in the array but doesn't commit it

		// To reduce file acces, the ModelStreamIdSet is only commited when all

		// the entries have been converted.

		iOutModelStreamIdSet->EntryStreamIdSet().AddL(newStreamId);

		}

	}

TStreamId CAgnCalendarConverter::WriteDescriptorToStreamL(const TDesC& aString) const

/** @internalComponent */

	{

	if (aString.Length() > 0)

		{

		RStoreWriteStream out;

		TStreamId id = out.CreateLC(*iOutputStreamStore);

		out.WriteUint32L(aString.Length());

		out << aString;

		out.CommitL();

		CleanupStack::PopAndDestroy(); //out

		return id;

		}

	return KNullStreamId;

	}

// CAgnCalendarConverter209 //

CAgnCalendarConverter209::CAgnCalendarConverter209()

	{

	}

CAgnCalendarConverter209* CAgnCalendarConverter209::NewL(CAgnServFile& aAgnServerFile)

	{

	CAgnCalendarConverter209* converter = new (ELeave) CAgnCalendarConverter209();

	CleanupStack::PushL(converter);

	converter->ConstructL(aAgnServerFile);

	CleanupStack::Pop(converter);

	return converter;

	}

void CAgnCalendarConverter209::InternalizeEntriesL(RReadStream& aStream)

/** @internalComponent */

	{

	// The layout of the calendar file in 1.1.x puts a set of calendar entries first, followed by their 

	// extended data. For this reason, the entire set must be loaded into memory before they can be stored.

	RPointerArray<CAgnEntry> entryArray(TAgnEntryId::EMaxNumEntriesPerStream);

	CleanupResetAndDestroyPushL(entryArray);

	RArray<TBool> isExtendedArray;

	CleanupClosePushL(isExtendedArray);

	const TUint8 KCount = aStream.ReadUint8L();

	for ( TInt ii = 0; ii < KCount; ++ii )

		{

		// Read in entries

		TBool isExtended = EFalse;

		CAgnEntry* entry = InternalizeEntryL(aStream, isExtended);

		CleanupStack::PushL(entry);

		entryArray.AppendL(entry);

		CleanupStack::Pop(entry);

		isExtendedArray.AppendL(isExtended); // isExtended is set to ETrue if the entry has extended data (to be loaded later)

		}

	for ( TInt i = 0; i < KCount; ++i )

		{

		// Now read in the extended attributes if necessary

		if (isExtendedArray[i])

			{

			InternalizeExtendedEntryL(aStream, *entryArray[i]);

			}

		// The old aEntry has been internalized, so add it to the current version of the file

	    SaveRestoredEntryL(*entryArray[i]);

	    // add this entry to the index

	    AddToIndexL(*entryArray[i]);

		}

	CleanupStack::PopAndDestroy(&isExtendedArray);

	CleanupStack::PopAndDestroy(&entryArray);

	}

void CAgnCalendarConverter209::InternalizeNextUidValuesL(RReadStream& aStream)

	{

	SetNextLocalUidValue(aStream.ReadUint32L());

	}

/**

This method internalizes the CAgnModelStreamIdSet according to the file version.

It also copies to the Converter's own stream store the contents of 

aModelStreamIdSet's streams that must be preserved

during the conversion: iNextUniqueIdValue and iFileId.

(Currently, it works for both 9.1 and 9.2 to 9.3)

@internalComponent */

void CAgnCalendarConverter209::InternalizeModelStreamIdSetL(RReadStream& aStream, CAgnModelStreamIdSet& aModelStreamIdSet)

	{

	// 9.2/9.1 was:                                     9.3 is:

	// iVersion                                         iVersion

	// iTodoListListStreamId

	// iDeletedTodoListListStreamId

	// iEntrySetStreamId                                iEntrySetStreamId

	// iFormatLayerStreamId

	// iNextLocalUidValueStreamId                       iNextLocalUidValueStreamId

	// iObserverControllerStreamId

	// iLastSynchronizedDateStreamId

	// iEntryStoreStreamId                              iEntryManagerStreamId

	// iFileInformationStreamId                         iFileInformationStreamId

	// Get the 9.1/9.2 bytes. Those that exit in 9.3, set them in the CAgnModelStreamIdSet.

	// Skip the rest.

	TStreamId disposableStreamId;

	TAgnVersion version;

	aStream >> version;

	//Skip: iTodoListStreamId, iDeletedTodoListListStreamId

	aStream >> disposableStreamId;

	aStream >> disposableStreamId;

	TStreamId entrySetStreamId;

	aStream >> entrySetStreamId;

	//Skip: iFormatLayerStreamId

	aStream >> disposableStreamId;

	TStreamId nextLocalUidValueStreamId;

	aStream >> nextLocalUidValueStreamId;

	//Skip: iObserverControllerStreamId, iLastSynchronizedDateStreamId;

	aStream >> disposableStreamId;

	aStream >> disposableStreamId;

	TStreamId entryManagerStreamId;

	aStream >> entryManagerStreamId;

	TStreamId fileInformationStreamId;

	aStream >> fileInformationStreamId;

	SetModelStreamIds(version, entrySetStreamId, nextLocalUidValueStreamId, entryManagerStreamId, fileInformationStreamId, aModelStreamIdSet);

	}

/**

Categories have not changed from 9.1 to 9.3.

Just copy them from the original file to the new file.

@internalComponent */

void CAgnCalendarConverter209::InternalizeCategoriesL()

	{

	TStreamId streamId = AgnServerFile().WriteCategoryListL(OutputStreamStore());

	AgnServerFile().AddStreamToDictionaryL(KUidAgnCategoryList, streamId, Dictionary(), OutputStreamStore());

	}

CAgnEntry* CAgnCalendarConverter209::InternalizeEntryL(RReadStream& aStream, TBool& aHasExtended)

	{

	enum TAgnEntryTypeV9192 // the entry type enumeration in v9.1 and v9.2

		{

		EAgnAppt,

		EAgnTodo,

		EAgnEvent,

		EAgnAnniv

		};

	const TInt KAgnExtendedDataFlag = 0x80;

    // Remove 9.1's/9.2's KAgnExtendedDataFlag (0x80)

    // from the entry type

    //

    TUint8 typeData = aStream.ReadUint8L();

	if (typeData & KAgnExtendedDataFlag)

		{

		const TUint8 KVersion = aStream.ReadUint8L();

		__ASSERT_ALWAYS(KVersion !=0, User::Leave(KErrCorrupt));  //version mumbers started from 1

		if (KVersion > 1)

			{

			const TUint8 KLength = aStream.ReadUint8L();

			for (TInt i=0; i<KLength; ++i)

				{

				aStream.ReadUint8L(); //skip additional data becouse we don't support it yet

				}

			}

		typeData &= ~KAgnExtendedDataFlag;

		}

	const TAgnEntryTypeV9192 KV9192Type = static_cast<TAgnEntryTypeV9192>(typeData);

	CCalEntry::TType entryType = CCalEntry::EAppt;

	TAgnEntryId entryId;

	entryId.InternalizeL(aStream); //TUInt32 iId

	TUint16 attributes = aStream.ReadUint16L(); 

	switch (KV9192Type)

		{

		case EAgnAppt:

			if (attributes & EBit9)

				{

				entryType = CCalEntry::EReminder; // is a day note

				}

			else

				{

				entryType = CCalEntry::EAppt;

				}

			break;

		case EAgnAnniv:

			entryType = CCalEntry::EAnniv;

			break;

		case EAgnEvent:

			entryType = CCalEntry::EEvent;

			break;

		case EAgnTodo:

			entryType = CCalEntry::ETodo;

			break;

		default:

			User::Leave(KErrCorrupt);

		}

    if (attributes & EBit13)

    	{