// 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 <msvuids.h>

#include <msvids.h>

#include <centralrepository.h>

#include <s32mem.h>

#include "POP3SET.H"

#include "IMAPSET.H"

#include "SMTPSET.H"

#include <iapprefs.h>

#include <cemailaccounts.h>

#include "MIUTSET.H"

#include "cimapsyncdownloadrules.h"

#include "cimaptransportbuffersizes.h"

#include "cimsmtpmobilitysettings.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS  

#include "msvconsts.h"

#endif

const TUint32 KNullId = 0x00000000;

const TUint32 KIncrementAccount = 0x00100000;

const TUint32 KInitialiseSettings = 0x00000000; // Initial settings are in account 0

const TInt KMaxAccount = 2048;

const TUint32 KDefaultAccountId = 0x80000000; // set top bit

const TInt KNullSmtpMobilityAccountEntryPos = -1;

const TInt KMaxIAPChoices = 4096;

const TInt KShiftAccountId = 20;

const TInt KPOPSettingsVersion = 2;

const TInt KIMAPSettingsVersion = 2;

const TInt KSMTPSettingsVersion = 3;

const TInt KIAPPrefSettingsVersion = 2;

const TInt KImapSyncDownloadRulesVersion = 1;

const TInt KImapTransportBufferSizesVersion = 1;

const TInt KSmtpMobilityAccountsListVersion = 1;

const TInt KSmtpLinkedMobilityAccountsListVersion = 1;

/** 

Allocates and constructs an Email accounts object.

Initialises all member data to their default values.

@return

The newly constructed Email accounts object.

*/

EXPORT_C CEmailAccounts* CEmailAccounts::NewL()

	{

	CEmailAccounts* self = new (ELeave) CEmailAccounts();

	return self;

	}

/** 

Allocates and constructs an Email accounts object.

Initialises all member data to their default values.

@return

The newly constructed Email accounts object.

*/

EXPORT_C CEmailAccounts* CEmailAccounts::NewLC()

	{

	CEmailAccounts* self = new (ELeave) CEmailAccounts();

	CleanupStack::PushL(self);

	return self;

	}

/**

Constructor.

*/

CEmailAccounts::CEmailAccounts()

	{

	}

/** 

Destructor. 

*/

EXPORT_C CEmailAccounts::~CEmailAccounts()

	{

	delete iIMAPRepository;

	delete iSMTPRepository;

	delete iPOPRepository;

	delete iMsvSession;

	}

/**

Creates a POP Account:

1. Creates a POP service entry in the message store

2. Creates settings in CenRep with values from the supplied objects

3. Returns a POP account ID

@param	aAccountName

Account Name

@param	aPopSettings

POP Service Settings

@param	aPopIAP

POP IAP preferences

@param	aReadOnly

Specify ETrue if it is a read-only account. 

Note: Read-only accounts should not be modified, however we don't enforce it.

@return

POP account ID of the new account

@leave

KErrOverflow if the account name is longer than 256 characters.

KErrArgument if settings fields contained non-ascii printable characters.

*/

EXPORT_C TPopAccount CEmailAccounts::CreatePopAccountL(const TDesC& aAccountName, const CImPop3Settings& aPopSettings,

	const CImIAPPreferences& aPopIAP, TBool aReadOnly)

	{

	// Check the incoming account name, if its too long then leave with KErrOverflow

	if(aAccountName.Length() > KEmailAccountNameSize)

		{

		User::Leave(KErrOverflow);

		}

	// Check for alpha numerics for the various strings

	if(!IsUnicodePrintable(aAccountName) ||

		!IsAsciiPrintable(aPopSettings.ServerAddress()) ||

	   	!IsAsciiPrintable(aPopSettings.Password()) ||

		!IsAsciiPrintable(aPopSettings.LoginName()))

		{

		User::Leave(KErrArgument);

		}

#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

	// Create  POP header table .

	CreateHeaderStoreL(KUidMsgTypePOP3);

#endif	

	// Create POP service entry in the message store

	TMsvId popService = KMsvNullIndexEntryId;

	CMsvEntry* msvEntry = SessionL().GetEntryL(KMsvRootIndexEntryId);

    CleanupStack::PushL(msvEntry);		

	popService = CreateEmailServiceL(*msvEntry, aAccountName, KUidMsgTypePOP3, ETrue);

	// Save settings to CenRep

	TUint32 popAccountId = 0;

	TRAPD(error, popAccountId = DoCreatePopAccountL(aAccountName, aPopSettings, aPopIAP, popService, 0, aReadOnly));

	if (error != KErrNone)

		{

		// saving settings to CenRep failed, so delete pop service and leave

		DeleteServiceEntryL(*msvEntry, popService);		

		User::Leave(error);

		}

	// Create account Id

	TPopAccount account;

	account.iPopAccountId = popAccountId >> KShiftAccountId; 

	account.iPopAccountName = aAccountName; 							

	account.iPopService = popService;

	account.iSmtpService = KMsvNullIndexEntryId; // Related smtp service not created yet 

	// settings saved, so un-set InPreparation Flags	

	UnSetInPreparationFlagsL(*msvEntry, popService, account.iPopAccountId);

	CleanupStack::PopAndDestroy(msvEntry);	

	return account;				

	}

TUint32 CEmailAccounts::DoCreatePopAccountL(const TDesC& aAccountName, const CImPop3Settings& aPopSettings, 

		const CImIAPPreferences& aPopIAP, const TMsvId aPopService, TMsvId aRelatedService, TBool aReadOnly)

	{

	CRepository& popRepository = PopRepositoryL();

	TUint32 popAccountId = GetNextEmptyAccountSlotL(popRepository);

	User::LeaveIfError(popRepository.StartTransaction(CRepository::EReadWriteTransaction));					

	popRepository.CleanupRollbackTransactionPushL();

	popRepository.Set(popAccountId + EPOPServiceId, static_cast<TInt>(aPopService)); 

	popRepository.Set(popAccountId + EPOPAccountNameId, aAccountName);

	popRepository.Set(popAccountId + EPOPRelatedSMTPServiceId, static_cast<TInt>(aRelatedService));

	popRepository.Set(popAccountId + EPOPReadOnlyAccountId, static_cast<TInt>(aReadOnly));

 	DoSavePopSettingsL(popAccountId, aPopSettings);

	SaveIAPPrefSettingsL(popAccountId, aPopIAP, popRepository);

	CleanupStack::Pop();

	TUint32 errorId = 0;	

	User::LeaveIfError(popRepository.CommitTransaction(errorId));	

	return popAccountId;

	}

TMsvId CEmailAccounts::CreateEmailServiceL(CMsvEntry& aMsvEntry, const TDesC& aAccountName, TUid aMTMType, TBool aVisible)

    {

	TMsvEntry entry;

	entry.iMtm = aMTMType;

	entry.iType = KUidMsvServiceEntry;

    entry.iServiceId = KMsvNullIndexEntryId;

	entry.SetReadOnly(EFalse);

	entry.SetVisible(aVisible);	

    entry.iDate.UniversalTime();

	entry.iDetails.Set(aAccountName);

	entry.iDescription.Set(KNullDesC);

	entry.SetInPreparation(ETrue);

	aMsvEntry.SetEntryL(KMsvRootIndexEntryId);

	aMsvEntry.CreateL(entry);

	return (entry.Id());

	}

void CEmailAccounts::SetRelatedIdL(CMsvEntry& aMsvEntry, TMsvId aId, TMsvId aRelatedId)

	{	

	aMsvEntry.SetEntryL(aId);	

	TMsvEntry entry(aMsvEntry.Entry());

	entry.iRelatedId = aRelatedId;	

	aMsvEntry.ChangeL(entry);

	}

void CEmailAccounts::SetEntryDetailsL(TMsvId aId, const TDesC& aAccountName)

	{	

	CMsvEntry* msvEntry = SessionL().GetEntryL(aId);

    CleanupStack::PushL(msvEntry);

	TMsvEntry entry(msvEntry->Entry());

	entry.iDetails.Set(aAccountName);	

	msvEntry->ChangeL(entry);

	CleanupStack::PopAndDestroy(msvEntry);	

	}

void CEmailAccounts::UnSetInPreparationFlagsL(CMsvEntry& aMsvEntry, TMsvId aId, TInt aAccountId)

	{

	aMsvEntry.SetEntryL(aId);	

	TMsvEntry entry = aMsvEntry.Entry();

	entry.SetMtmData2(aAccountId);

	entry.SetInPreparation(EFalse);	

	aMsvEntry.ChangeL(entry);

	}

void CEmailAccounts::DeleteServiceEntryL(CMsvEntry& aMsvEntry, TMsvId aId)

	{

	aMsvEntry.SetEntryL(KMsvRootIndexEntryId);	

	TRAPD (error, aMsvEntry.DeleteL(aId));

	if (error != KErrNotFound)

		{

		User::LeaveIfError(error);		

		}

	}

/**

Creates an IMAP Account:

1. Creates an IMAP service entry in the message store

2. Creates settings in CenRep with values from the supplied objects

3. Returns an IMAP account ID

@param	aAccountName

Account Name

@param	aImapSettings

IMAP Service Settings

@param	aImapIAP

IMAP IAP preferences

@param	aReadOnly

Specify ETrue if it is a read-only account

Note: Read-only accounts should not be modified, however we don't enforce it.

@return

IMAP account ID

@leave

KErrOverflow if the account name is longer than 256 characters.

KErrArgument if settings fields contained non-ascii printable characters.

*/

EXPORT_C TImapAccount CEmailAccounts::CreateImapAccountL(const TDesC& aAccountName,

	const CImImap4Settings& aImapSettings, const CImIAPPreferences& aImapIAP, TBool aReadOnly)

	{

	return CreateImapAccountL(aAccountName, aImapSettings, aImapIAP, NULL, aReadOnly);

	}

/**

Creates an IMAP Account:

1. Creates an IMAP service entry in the message store

2. Creates settings in CenRep with values from the supplied objects

3. Returns an IMAP account ID

@param	aAccountName

Account Name

@param	aImapSettings

IMAP Service Settings

@param	aImapIAP

IMAP IAP preferences

@param	aSyncDownloadRules

IMAP synchronisation download rules

@param	aReadOnly

Specify ETrue if it is a read-only account

Note: Read-only accounts should not be modified, however we don't enforce it.

@return

IMAP account ID

@publishedPartner

*/	

EXPORT_C TImapAccount CEmailAccounts::CreateImapAccountL(const TDesC& aAccountName,

	const CImImap4Settings& aImapSettings, const CImIAPPreferences& aImapIAP,

	const CImapSyncDownloadRules& aSyncDownloadRules, TBool aReadOnly)

	{

	return CreateImapAccountL(aAccountName, aImapSettings, aImapIAP, &aSyncDownloadRules, aReadOnly);

	}

/**

Creates an IMAP Account:

1. Creates an IMAP service entry in the message store

2. Creates settings in CenRep with values from the supplied objects

3. Returns an IMAP account ID

@param	aAccountName

Account Name

@param	aImapSettings

IMAP Service Settings

@param	aImapIAP

IMAP IAP preferences

@param	aReadOnly

Specify ETrue if it is a read-only account

Note: Read-only accounts should not be modified, however we don't enforce it.

@param	aSyncDownloadRules

Synchronisation download rules (can be NULL)

@return

IMAP account ID

*/	

TImapAccount CEmailAccounts::CreateImapAccountL(const TDesC& aAccountName,

	const CImImap4Settings& aImapSettings, const CImIAPPreferences& aImapIAP,

	const CImapSyncDownloadRules* aSyncDownloadRules, TBool aReadOnly)

	{

	// Check the incoming account name, if its too long then leave with KErrOverflow

	if(aAccountName.Length() > KEmailAccountNameSize)

		{

		User::Leave(KErrOverflow);

		}

	// Check for alpha numerics for the various strings

	if(!IsUnicodePrintable(aAccountName) ||

	   !IsAsciiPrintable(aImapSettings.ServerAddress()) ||

	   !IsAsciiPrintable(aImapSettings.FolderPath()))

		{

		User::Leave(KErrArgument);

		}

#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

	// Create  IMAP header table .

	CreateHeaderStoreL(KUidMsgTypeIMAP4);

#endif

	// Create IMAP service entry in the message store

	TMsvId imapService = KMsvNullIndexEntryId;

	CMsvEntry* msvEntry = SessionL().GetEntryL(KMsvRootIndexEntryId);

	CleanupStack::PushL(msvEntry);		

	imapService = CreateEmailServiceL(*msvEntry, aAccountName, KUidMsgTypeIMAP4, ETrue);

	// Save settings to CenRep

	TUint32 imapAccountId = 0;

	TRAPD(error, imapAccountId = DoCreateImapAccountL(aAccountName, aImapSettings, aImapIAP, aSyncDownloadRules, imapService, 0, aReadOnly));

	if (error != KErrNone)

		{

		// saving settings to CenRep failed, so delete imap service and leave

		DeleteServiceEntryL(*msvEntry, imapService);	

		User::Leave(error);

		}

	TImapAccount account;

	account.iImapAccountId = imapAccountId >> KShiftAccountId;

	account.iImapAccountName = aAccountName; 				

	account.iImapService = imapService; 

	account.iSmtpService = KMsvNullIndexEntryId; 	// Related smtp service not created yet		

	// settings saved, so un-set InPreparation Flags	

	UnSetInPreparationFlagsL(*msvEntry, imapService, account.iImapAccountId);

	CleanupStack::PopAndDestroy(msvEntry);	

	return account;				

	}

TUint32 CEmailAccounts::DoCreateImapAccountL(const TDesC& aAccountName,

	const CImImap4Settings& aImapSettings, const CImIAPPreferences& aImapIAP,

	const CImapSyncDownloadRules* aSyncDownloadRules, TMsvId aImapService,

	TMsvId aRelatedService, TBool aReadOnly)

	{

	CRepository& imapRepository = ImapRepositoryL();

	TUint32 imapAccountId = GetNextEmptyAccountSlotL(imapRepository);

	User::LeaveIfError(imapRepository.StartTransaction(CRepository::EReadWriteTransaction));						

	imapRepository.CleanupRollbackTransactionPushL();

	imapRepository.Set(imapAccountId + EIMAPServiceId, static_cast<TInt>(aImapService));

	imapRepository.Set(imapAccountId + EIMAPAccountNameId, aAccountName);

	imapRepository.Set(imapAccountId + EIMAPRelatedSMTPServiceId, static_cast<TInt>(aRelatedService));

	imapRepository.Set(imapAccountId + EIMAPReadOnlyAccountId, static_cast<TInt>(aReadOnly));

	DoSaveImapSettingsL(imapAccountId, aImapSettings);

	if (aSyncDownloadRules)

		{

		DoSaveImapSyncDownloadRulesL(imapAccountId, *aSyncDownloadRules, imapRepository);

		}

	SaveIAPPrefSettingsL(imapAccountId, aImapIAP, imapRepository);

	CleanupStack::Pop();

	TUint32 errorId = 0;	

	User::LeaveIfError(imapRepository.CommitTransaction(errorId));

	return imapAccountId;			

	}

/**

Creates a SMTP Account:

1. Creates a SMTP service entry in the message store

2. Creates settings in CenRep with values from the supplied objects

3. Relates this account with the supplied POP account

4. Returns a SMTP account ID

@param	aPopAccount

POP Account Id

@param	aSmtpSettings

SMTP Service Settings

@param	aSmtpIAP

SMTP IAP preferences

@param	aReadOnly

Specify ETrue if it is a read-only account

Note: Read-only accounts should not be modified, however we don't enforce it.

@return

SMTP account ID

@leave

KErrArgument if settings fields contained non-ascii printable characters.

*/

EXPORT_C TSmtpAccount CEmailAccounts::CreateSmtpAccountL(TPopAccount& aPopAccount, const CImSmtpSettings& aSmtpSettings,

		const CImIAPPreferences& aSmtpIAP, TBool aReadOnly)

	{

 	// Check for alpha numerics for the various strings

 	if(!IsAsciiPrintable(aSmtpSettings.Password()) ||

 	   !IsAsciiPrintable(aSmtpSettings.LoginName())||

 	   !IsAsciiPrintable(aSmtpSettings.ServerAddress()))

 		{

 		User::Leave(KErrArgument);

 		}

#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

 	// Create  SMTP header table .

 	CreateHeaderStoreL(KUidMsgTypeSMTP);

#endif

	// Create SMTP service entries in the message store

	TMsvId smtpService = KMsvNullIndexEntryId;

	CMsvEntry* msvEntry = SessionL().GetEntryL(KMsvRootIndexEntryId);

    CleanupStack::PushL(msvEntry);		

	smtpService = CreateEmailServiceL(*msvEntry, aPopAccount.iPopAccountName, KUidMsgTypeSMTP, EFalse);		

	// Save settings to CenRep

	TUint32 smtpAccountId = 0;

	TUint32 popAccountId = aPopAccount.iPopAccountId << KShiftAccountId;

	TRAPD(error, smtpAccountId = DoCreateSmtpAccountL(aPopAccount, aSmtpSettings, 

			aSmtpIAP, smtpService, *msvEntry, popAccountId, aReadOnly));

	if (error != KErrNone)

		{

		// saving settings to CenRep failed, so delete smtp service and leave

		PopRepositoryL().Set(popAccountId + EPOPRelatedSMTPServiceId, 0);

		SetRelatedIdL(*msvEntry, aPopAccount.iPopService, 0);				

		DeleteServiceEntryL(*msvEntry, smtpService);

		User::Leave(error);

		}

	aPopAccount.iSmtpService = smtpService;

	TSmtpAccount account;

	account.iSmtpAccountId = smtpAccountId >> KShiftAccountId;

	account.iSmtpAccountName = aPopAccount.iPopAccountName; 				

	account.iSmtpService = smtpService; 

	account.iRelatedService = aPopAccount.iPopService;	

	// settings saved, so un-set InPreparation Flags

	UnSetInPreparationFlagsL(*msvEntry, smtpService, account.iSmtpAccountId);

	CleanupStack::PopAndDestroy(msvEntry);	

	return account;				

	}

TUint32 CEmailAccounts::DoCreateSmtpAccountL(TPopAccount& aPopAccount, const CImSmtpSettings& aSmtpSettings, 

		const CImIAPPreferences& aSmtpIAP, TMsvId aSmtpService, CMsvEntry& aMsvEntry, TUint32& aPopAccountId, TBool aReadOnly)

	{

	// set related smtp service

	SetRelatedIdL(aMsvEntry, aSmtpService, aPopAccount.iPopService);

	// update pop account

	SetRelatedIdL(aMsvEntry, aPopAccount.iPopService, aSmtpService);		

	User::LeaveIfError(PopRepositoryL().Set(aPopAccountId + EPOPRelatedSMTPServiceId, static_cast<TInt>(aSmtpService)));

	return DoCreateSmtpAccountL(aPopAccount.iPopAccountName, aSmtpSettings, aSmtpIAP, aSmtpService, aPopAccount.iPopService, aReadOnly);

	}

/**

Creates a SMTP Account:

1. Creates a SMTP service entry in the message store