/*

* Copyright (c) 2004 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:    DM Email Settings Adapter

 *

*/

#include <implementationproxy.h> // For TImplementationProxy definition

#include <utf.h>

#include <iapprefs.h>

#include <smtpset.h>

#include <pop3set.h>

#include <imapset.h>

#include <sysutil.h>

#include <etelmm.h>

#include <cemailaccounts.h>

#include "nsmldmimpluids.h"

#include "nsmldmemailadapter.h"

#include "nsmldebug.h"

#include "nsmlconstants.h"

#include "nsmldmconst.h"

#include "nsmldmiapmatcher.h"

#ifndef __WINS__

// This lowers the unnecessary compiler warning (armv5) to remark.

// "Warning:  #174-D: expression has no effect..." is caused by 

// DBG_ARGS8 macro in no-debug builds.

#pragma diag_remark 174

#endif

// -----------------------------------------------------------------------------

// CNSmlDmEmailAdapter* CNSmlDmEmailAdapter::NewL( )

// -----------------------------------------------------------------------------

CNSmlDmEmailAdapter* CNSmlDmEmailAdapter::NewL(MSmlDmCallback* aDmCallback )

    {

    _DBG_FILE("CNSmlDmEmailAdapter::NewL(): begin");

    CNSmlDmEmailAdapter* self = new (ELeave) CNSmlDmEmailAdapter(aDmCallback);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    _DBG_FILE("CNSmlDmEmailAdapter::NewL(): end");

    return self;

    }

// -----------------------------------------------------------------------------

// CNSmlDmEmailAdapter::CNSmlDmEmailAdapter()

// -----------------------------------------------------------------------------

CNSmlDmEmailAdapter::CNSmlDmEmailAdapter( MSmlDmCallback* aDmCallback )

    : CSmlDmAdapter(aDmCallback)

    {

    _DBG_FILE("CNSmlDmEmailAdapter::CNSmlDmEmailAdapter(): begin");

    iMsvSession = NULL;

    _DBG_FILE("CNSmlDmEmailAdapter::CNSmlDmEmailAdapter(): end");

    }

// -----------------------------------------------------------------------------

// CNSmlDmEmailAdapter::ConstructL()

// -----------------------------------------------------------------------------

void CNSmlDmEmailAdapter::ConstructL()

    {

    iBuffer = new (ELeave) CArrayFixFlat <TNSmlEmailSettingsElement> 

        (KNSmlDmEmailGranularity);

    }

// -----------------------------------------------------------------------------

// CNSmlDmEmailAdapter::~CNSmlDmEmailAdapter()

// -----------------------------------------------------------------------------

CNSmlDmEmailAdapter::~CNSmlDmEmailAdapter()

    {

    _DBG_FILE("CNSmlDmEmailAdapter::~CNSmlDmEmailAdapter(): begin");

    delete iMsvSession;

    if(iBuffer)

        {

        for(TInt i=0;i<iBuffer->Count();i++)

            {

            delete iBuffer->At(i).iMappingName;

            delete iBuffer->At(i).iName;

            delete iBuffer->At(i).iSmtpSettings;

            delete iBuffer->At(i).iPop3Settings;

            delete iBuffer->At(i).iImap4Settings;

            delete iBuffer->At(i).iIapPref;

            delete iBuffer->At(i).iSmtpIapPref;

            if(iBuffer->At(i).iNodeBuf)

                {

                for(TInt j=0;j<iBuffer->At(i).iNodeBuf->Count();j++)

                    {

                    delete iBuffer->At(i).iNodeBuf->At(j).iLastUriSeg;

                    delete iBuffer->At(i).iNodeBuf->At(j).iData;

                    }

                iBuffer->At(i).iNodeBuf->Reset();

                delete iBuffer->At(i).iNodeBuf;

                }

            }

        iBuffer->Reset();

        delete iBuffer;

        }

    _DBG_FILE("CNSmlDmEmailAdapter::~CNSmlDmEmailAdapter(): end");

    }

// -----------------------------------------------------------------------------

//  CNSmlDmEmailAdapter::DDFVersionL()

// -----------------------------------------------------------------------------

void CNSmlDmEmailAdapter::DDFVersionL(CBufBase& aDDFVersion)

    {

    _DBG_FILE("CNSmlDmEmailAdapter::DDFVersionL(TDes& aDDFVersion): begin");

    aDDFVersion.InsertL(0,KNSmlDMEmailDDFVersion);

    _DBG_FILE("CNSmlDmEmailAdapter::DDFVersionL(TDes& aDDFVersion): end");

    }

// -----------------------------------------------------------------------------

//  CNSmlDmEmailAdapter::DDFStructureL()

//

// -----------------------------------------------------------------------------

void CNSmlDmEmailAdapter::DDFStructureL(MSmlDmDDFObject& aDDF)

    {

    _DBG_FILE("CNSmlDmEmailAdapter::DDFStructureL(): begin");

    TSmlDmAccessTypes accessTypesNode;

    accessTypesNode.SetGet();

    // Email

    MSmlDmDDFObject& email = aDDF.AddChildObjectL(KNSmlDMEmailNodeName);

    FillNodeInfoL(email,accessTypesNode,MSmlDmDDFObject::EOne,

                  MSmlDmDDFObject::EPermanent,

                  MSmlDmDDFObject::ENode,KNSmlDMEmailDescription);

    accessTypesNode.SetAdd();

    accessTypesNode.SetDelete();

    accessTypesNode.SetReplace();

    MSmlDmDDFObject& rtNode = email.AddChildObjectGroupL();

    FillNodeInfoL(rtNode,accessTypesNode,MSmlDmDDFObject::EZeroOrMore,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::ENode,

                  KNSmlDMDynamicNodeDescription);

    TSmlDmAccessTypes accessTypes;

    accessTypes.SetGet();

    accessTypes.SetAdd();

    accessTypes.SetReplace();

    //displayable account name

    MSmlDmDDFObject& name = rtNode.AddChildObjectL(KNSmlDMEmailName);

    FillNodeInfoL(name,accessTypes,MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

                  KNSmlDMNameDescription);

    //user id for email account

    MSmlDmDDFObject& uid = rtNode.AddChildObjectL(KNSmlDMEmailUID);

    FillNodeInfoL(uid,accessTypes,MSmlDmDDFObject::EOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

                  KNSmlDMUIDDescription);

    //password for email account

    TSmlDmAccessTypes accessTypesPw;

    accessTypesPw.SetAdd();

    accessTypesPw.SetReplace();

    MSmlDmDDFObject& pw = rtNode.AddChildObjectL(KNSmlDMEmailPW);

    FillNodeInfoL(pw,accessTypesPw,MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

                  KNSmlDMPWDescription);

    //user's email address

    MSmlDmDDFObject& uaddr = rtNode.AddChildObjectL(KNSmlDMEmailUAddr);

    FillNodeInfoL(uaddr,accessTypes,MSmlDmDDFObject::EOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

                  KNSmlDMUAddrDescription);

    //Displayable name for the user

    MSmlDmDDFObject& uname = rtNode.AddChildObjectL(KNSmlDMEmailUName);

    FillNodeInfoL(uname,accessTypes,MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

                  KNSmlDMUNameDescription);

    //Host name for the receiving server

    MSmlDmDDFObject& mrcv = rtNode.AddChildObjectL(KNSmlDMEmailMrcv);

    FillNodeInfoL(mrcv,accessTypes,MSmlDmDDFObject::EOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

                  KNSmlDMMrcvDescription);

    //Host name for the sending server

    MSmlDmDDFObject& msnd = rtNode.AddChildObjectL(KNSmlDMEmailMsnd);

    FillNodeInfoL(msnd,accessTypes,MSmlDmDDFObject::EOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

                  KNSmlDMMsndDescription);

    //Remote mailbox protocol

    MSmlDmDDFObject& mpro = rtNode.AddChildObjectL(KNSmlDMEmailMpro);

    FillNodeInfoL(mpro,accessTypes,MSmlDmDDFObject::EOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

                  KNSmlDMMproDescription);

    //Use secure connection

    MSmlDmDDFObject& useSecCon = rtNode.AddChildObjectL(KNSmlDMEmailUseSecCon);

    FillNodeInfoL(useSecCon,accessTypes,MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EBool,

                  KNSmlDMUseSecConDescription);

    //Use APop

    MSmlDmDDFObject& useAPOP = rtNode.AddChildObjectL(KNSmlDMEmailUseAPOP);

    FillNodeInfoL(useAPOP, accessTypes, MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EBool,

                  KNSmlDMUseAPOPDescription );

    //Use smtp authentication

    MSmlDmDDFObject& useSauth = rtNode.AddChildObjectL(KNSmlDMEmailUseSauth);

    FillNodeInfoL(useSauth,accessTypes,MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EBool,

                  KNSmlDMUseSauthDescription);

    //smtp authentication user id

    MSmlDmDDFObject& sauthUid = rtNode.AddChildObjectL(KNSmlDMEmailSauthUID);

    FillNodeInfoL(sauthUid,accessTypes,MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

                  KNSmlDMSauthUIDDescription);

    //Use smtp authentication

    MSmlDmDDFObject& sauthPw = rtNode.AddChildObjectL(KNSmlDMEmailSauthPW);

    FillNodeInfoL(sauthPw,accessTypesPw,MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

                  KNSmlDMSauthPWDescription);

    //Use smtp authentication

    MSmlDmDDFObject& ptxtSAuth = rtNode.AddChildObjectL(KNSmlDMEmailPtxtSAuth);

    FillNodeInfoL(ptxtSAuth,accessTypes,MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EBool,

                  KNSmlDMPtxtSAuthDescription);

    //Link to IAP

    MSmlDmDDFObject& toNapId = rtNode.AddChildObjectL(KNSmlDMEmailToNapID);

    FillNodeInfoL(toNapId,accessTypes,MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

                  KNSmlDMToNapIDDescription);

    //Link to IAP for SMTP

    MSmlDmDDFObject& sToNapId = rtNode.AddChildObjectL(KNSmlDMEmailSToNapID);

    FillNodeInfoL(sToNapId,accessTypes,MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

                  KNSmlDMSToNapIDDescription);

    //SSL/TLS used in SMTP

    MSmlDmDDFObject& sUseSecCon = rtNode.

        AddChildObjectL(KNSmlDMEmailSUseSecCon);

    FillNodeInfoL(sUseSecCon,accessTypes,MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EBool,

                  KNSmlDMSUseSecConDescription);

    //StartTLS used in IMAP/POP

    MSmlDmDDFObject& useStartTls = rtNode.

        AddChildObjectL(KNSmlDMEmailUseStartTLS);

    FillNodeInfoL(useStartTls,accessTypes,MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EBool,

                  KNSmlDMUseStartTLSDescription);

    //StartTLS used in SMTP

    MSmlDmDDFObject& sUseStartTls = rtNode.

        AddChildObjectL(KNSmlDMEmailSUseStartTLS);

    FillNodeInfoL(sUseStartTls,accessTypes,MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EBool,

                  KNSmlDMSUseStartTLSDescription);

    //port of IMAP/POP server

    MSmlDmDDFObject& mrcvPort = rtNode.AddChildObjectL(KNSmlDMEmailMrcvPort);

    FillNodeInfoL(mrcvPort,accessTypes,MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EInt,

                  KNSmlDMMrcvPortDescription);

    //port of SMTP server

    MSmlDmDDFObject& msndPort = rtNode.AddChildObjectL(KNSmlDMEmailMsndPort);

    FillNodeInfoL(msndPort,accessTypes,MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EInt,

                  KNSmlDMMsndPortDescription);

    //IMAP folder path

    MSmlDmDDFObject& folderPath = rtNode.

        AddChildObjectL(KNSmlDMEmailFolderPath);

    FillNodeInfoL(folderPath,accessTypes,MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

                  KNSmlDMFolderPathDescription);

    _DBG_FILE("CNSmlDmEmailAdapter::DDFStructureL(): end");

    }

// -----------------------------------------------------------------------------

//  CNSmlDmEmailAdapter::UpdateLeafObjectL()

// -----------------------------------------------------------------------------

void CNSmlDmEmailAdapter::UpdateLeafObjectL( const TDesC8& aURI, 

                                             const TDesC8& aLUID,

                                             const TDesC8& aObject,

                                             const TDesC8& /*aType*/,

                                             const TInt aStatusRef )

    {

    _DBG_FILE("CNSmlDmEmailAdapter::UpdateLeafObjectL(): begin");

    TInt index = -1;

    TBool firstAdd = EFalse;

    for(TInt i = 0; i<iBuffer->Count(); i++)

        {

        TPtrC8 parentUri = RemoveLastURISeg(aURI);

        //Check Node from buffer if match

        if(iBuffer->At(i).iMappingName->Compare(parentUri) == 0 )

            {

            firstAdd = ETrue;

            index = i;

            break;

            }

        }

 	TInt luid = DesToInt(aLUID);

    if(aLUID.Length()==0 && index<0)

        {

        	luid = ConstructTreeL(aURI);

        	if(luid == -1)        	

        	{

        		Callback().SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);

        		_DBG_FILE("CNSmlDmEmailAdapter::UpdateLeafObjectL(): end");

        		return;

        	}

        }

    if( OpenSessionL() != KErrNone )

        {

        Callback().SetStatusL(aStatusRef, CSmlDmAdapter::EError);

        _DBG_FILE("CNSmlDmEmailAdapter::UpdateLeafObjectL(): end");

        return;

        }

    if(!firstAdd)

        {

        if(LastURISeg(aURI).Compare(KNSmlDMEmailMpro)==0)

            {

            Callback().SetStatusL(aStatusRef, CSmlDmAdapter::EError);

            _DBG_FILE("CNSmlDmEmailAdapter::UpdateLeafObjectL(): end");

            return;

            }

        index = -1;

        for(TInt i=0;i<iBuffer->Count();i++)

            {

            if(iBuffer->At(i).iLuid == luid)

                {

                index = i;

                break;

                }

            }

        if(index<0)

            {

            TNSmlEmailSettingsElement newNode;

            newNode.iImap4Settings = NULL;

            newNode.iPop3Settings = NULL;

            newNode.iSmtpSettings = NULL;

            newNode.iIapPref = NULL;

            newNode.iSmtpIapPref = NULL;

            newNode.iLuid = luid;

            newNode.iMappingName = aURI.AllocLC();

            newNode.iName = HBufC::NewLC(0);

            newNode.iNodeBuf = new (ELeave) CArrayFixFlat 

                <TNSmlEmailCommandElement> (KNSmlDmEmailGranularity);

            newNode.iExecuted = ETrue;

            GetIdByLuid(newNode.iAccType, newNode.iAccId, luid); 

            iBuffer->AppendL(newNode);

            index = iBuffer->Count() - 1;

            TInt err = DoRestoreSettingsL(index);

            if(err!=KErrNone)

                {

                CleanupStack::PopAndDestroy(2); //newNode.iMappingName,newNode.iName

                newNode.iMappingName = NULL;

                newNode.iName = NULL;

                iBuffer->At(index).iNodeBuf->Reset();

                delete iBuffer->At(index).iNodeBuf;

                iBuffer->Delete(index);

                }

            if(err==KErrNotFound)

                {

                Callback().SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);

                _DBG_FILE("CNSmlDmEmailAdapter::UpdateLeafObjectL(): end");

                return;

                }

            else if(err!=KErrNone)

                {

                Callback().SetStatusL(aStatusRef, CSmlDmAdapter::EError);

                _DBG_FILE("CNSmlDmEmailAdapter::UpdateLeafObjectL(): end");

                return;

                }

            CleanupStack::Pop(2); //newNode.iMappingName,newNode.iName

            }

        TNSmlEmailCommandElement newCommand;

        newCommand.iLastUriSeg = LastURISeg(aURI).AllocLC();

        newCommand.iData = NULL;

        newCommand.iStatusRef = aStatusRef;

        newCommand.iLeaf = ETrue;

        newCommand.iStatus = CSmlDmAdapter::EOk;

        iBuffer->At(index).iNodeBuf->AppendL(newCommand);

        CleanupStack::Pop(); //newCommand.iLastUriSeg

        iBuffer->At(index).iJustFetch=EFalse;

        DoAddLeafObjectL(newCommand.iLastUriSeg->Des(),aObject,index,

                         iBuffer->At(index).iNodeBuf->Count()-1);

        }

    else

        {

        FirstAddLeafL(aURI,aObject,aStatusRef,index);

        }

    _DBG_FILE("CNSmlDmEmailAdapter::UpdateLeafObjectL(): end");

    }

// -----------------------------------------------------------------------------

// CNSmlDmEmailAdapter::DeleteObjectL( const TDesC8& aURI,

//                                         const TDesC8& aLUID,

//                                         const TInt aStatusRef )

// -----------------------------------------------------------------------------

void CNSmlDmEmailAdapter::DeleteObjectL( const TDesC8& aURI,

                                         const TDesC8& aLUID,

                                         const TInt aStatusRef )

    {

    _DBG_FILE("CNSmlDmEmailAdapter::DeleteLeafObjectL( ): begin");

    if(NumOfURISegs(aURI)==2)

        {

        if(aLUID.Length()==0)

            {

            Callback().SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);

            _DBG_FILE("CNSmlDmEmailAdapter::DeleteLeafObjectL( ): ENotFound end");

            return;

            }

        TInt luid = DesToInt(aLUID);

        TInt err = OpenSessionL();

        if(err!=KErrNone)

            {

            Callback().SetStatusL(aStatusRef, CSmlDmAdapter::EError);

            _DBG_FILE("CNSmlDmEmailAdapter::DeleteLeafObjectL( ): EError end");

            return;

            }

        CEmailAccounts* emailAccs = CEmailAccounts::NewLC();

        TNSmlEmailAccountType accType;

        TInt id;

        GetIdByLuid(accType, id, luid );

        if( AccountExistsL( emailAccs, accType, id, -1 ) )

            {

            switch ( accType )

                {

            case EImap:

                {

                RArray<TImapAccount> imap4Accs;

                CleanupClosePushL( imap4Accs );

                emailAccs->GetImapAccountsL( imap4Accs );

                for (TInt i(0); i < imap4Accs.Count(); i++)

                    {

                    if ( imap4Accs[i].iImapAccountId == id  ) 

                        {

                        // Delete also related Smtp account

                        TSmtpAccount relatedSmtp;

                        emailAccs->GetSmtpAccountL( imap4Accs[i].iSmtpService, relatedSmtp );

                        emailAccs->DeleteImapAccountL( imap4Accs[i] );

                        emailAccs->DeleteSmtpAccountL( relatedSmtp );                       

                        //The only email a/c in phone gettiong deleted , so delete the default sntp a/c                     

                        if( imap4Accs.Count() == 1 )

	                        {

	                        TInt deferr = KErrNone;

                        	TRAP(deferr, emailAccs->DeleteDefaultSmtpAccountL());

                        	DBG_ARGS(_S16("CNSmlDmEmailAdapter::DeleteLeafObjectL( ): Delete default smtp account Error code %d"),deferr);

    	                    }

                        break;   

                        }

                    }

                CleanupStack::PopAndDestroy(&imap4Accs); //imap4Accs

                // If the default account was just deleted,

                // new one needs to be set.

                // 

	            TSmtpAccount defaultSmtp;

	            TInt retVal = emailAccs->DefaultSmtpAccountL( defaultSmtp );

	            if (  retVal != KErrNone )

	                {

                    RArray<TImapAccount> imapAccs;

                    CleanupClosePushL( imapAccs );

                    emailAccs->GetImapAccountsL( imapAccs );

                    if ( imapAccs.Count() > 0 )

                        {

                        TSmtpAccount relatedSmtp;

                        emailAccs->GetSmtpAccountL( imapAccs[0].iSmtpService, relatedSmtp );

	                    emailAccs->SetDefaultSmtpAccountL( relatedSmtp );

                        }

                    CleanupStack::PopAndDestroy( &imapAccs );

                    RArray<TPopAccount> popAccounts;

                    CleanupClosePushL( popAccounts );

                    emailAccs->GetPopAccountsL( popAccounts );

                    if ( popAccounts.Count() > 0 )

                        {

                        TSmtpAccount relatedSmtp;

                        emailAccs->GetSmtpAccountL( popAccounts[0].iSmtpService, relatedSmtp );

	                    emailAccs->SetDefaultSmtpAccountL( relatedSmtp );

                        }

                    CleanupStack::PopAndDestroy( &popAccounts );

	                }	                

                break;    

                }

            case EPop:

                {

                RArray<TPopAccount> popAccs;

                CleanupClosePushL( popAccs );

                emailAccs->GetPopAccountsL( popAccs );