/*

* 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:  DS Settings Provisioning Adapter

*

*/

// INCLUDE FILES

#include <badesca.h>

#include <commdb.h>

#include <cdbcols.h>			 // CommsDB columname defs

#include <utf.h>

#include <stringresourcereader.h>

#include <barsread.h>

#include <NSmlDSProvisioningAdapter.rsg>

#include <bautils.h>

#include <barsc.h>

#include <cmconnectionmethoddef.h>

#include <cmmanagerext.h>

#include <nsmlconstants.h>

#include <nsmldebug.h>

#include <nsmldsconstants.h>

#include <CWPCharacteristic.h>

#include <CWPParameter.h>

#include <CWPEngine.h>

#include "NSmlDsProvisioningAdapter.h"

#include "implementationinformation.h"

#include "NSmlTransportHandler.h"

#include <WPAdapterUtil.h>

_LIT( KInternetString, "INTERNET" );

#include <data_caging_path_literals.hrh>

// ============================ MEMBER FUNCTIONS ===============================

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

// CNSmlDsProvisioningAdapter::CNSmlDsProvisioningAdapter

// C++ default constructor can NOT contain any code, that

// might leave.

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

CNSmlDsProvisioningAdapter::CNSmlDsProvisioningAdapter() :

    CWPAdapter(), iToNapIDInternetIndicator(EFalse)

	{

	}

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

// CNSmlDsProvisioningAdapter::ConstructL

// Symbian 2nd phase constructor can leave.

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

void CNSmlDsProvisioningAdapter::ConstructL()

	{

	iSession.OpenL();

	}

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

// CNSmlDsProvisioningAdapter::NewL

// Two-phased constructor.

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

CNSmlDsProvisioningAdapter* CNSmlDsProvisioningAdapter::NewL()

	{

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

	CNSmlDsProvisioningAdapter* self = new(ELeave) CNSmlDsProvisioningAdapter; 

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

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

	return self;

	}

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

// Destructor

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

CNSmlDsProvisioningAdapter::~CNSmlDsProvisioningAdapter()

	{

	iProfiles.ResetAndDestroy();

	iProfiles.Close();

	delete iTitle;

	iSession.Close();

	}

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

// Destructor

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

CNSmlDataProviderElement::~CNSmlDataProviderElement()

	{

	delete iRemoteDBUri;

	delete iLocalDBUri;

	}

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

// Destructor

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

CNSmlDsProfileElement::~CNSmlDsProfileElement()

	{

	iDataProvElement.ResetAndDestroy();

	iDataProvElement.Close();

	iVisitParameter = 0;

	delete iHostAddress;

	delete iPort;

	delete iHTTPUserName;

	delete iHTTPPassword;

	delete iDisplayName;		

	delete iServerId;

    delete iUsername;

	delete iPassword;

	}

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

// CNSmlDsProvisioningAdapter::CanSetAsDefault

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

TBool CNSmlDsProvisioningAdapter::CanSetAsDefault(TInt /*aItem*/) const

	{

	return EFalse;

	}

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

// CNSmlDsProvisioningAdapter::SetAsDefaultL

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

void CNSmlDsProvisioningAdapter::SetAsDefaultL(TInt /*aItem*/ )

	{

	}

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

// CNSmlDsProvisioningAdapter::ItemCount

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

TInt CNSmlDsProvisioningAdapter::ItemCount() const

	{

	return iProfiles.Count();

	}

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

// CNSmlDsProvisioningAdapter::SummaryTitle

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

const TDesC16& CNSmlDsProvisioningAdapter::SummaryTitle(TInt /*aIndex*/) const

	{

	return *iTitle;

	}

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

// CNSmlDsProvisioningAdapter::SummaryText

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

const TDesC16& CNSmlDsProvisioningAdapter::SummaryText(TInt aIndex) const

	{

	return *iProfiles[aIndex]->iDisplayName;

	}

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

// CNSmlDsProvisioningAdapter::SaveL

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

void CNSmlDsProvisioningAdapter::SaveL(TInt aItem)

	{

	_DBG_FILE("CNSmlDsProvisioningAdapter::SaveL(): begin");

	TPckgBuf<TUint32> uid;

	RSyncMLDataSyncProfile profile;

	TBool ret = EFalse;

	if(iProfiles[aItem]->iServerId != NULL)

	{

	RSyncMLDataSyncProfile ProfileToSearch;

	RArray<TSmlProfileId> arr;

    iSession.ListProfilesL( arr, ESmlDataSync );

    TInt ProfileId = KErrNotFound;

    CleanupClosePushL(arr);   	

	for ( TInt index = 0; index < arr.Count(); index++ )

		{

	    TRAPD( error, ProfileToSearch.OpenL(iSession, arr[index], ESmlOpenRead ) );

	    if ( error == KErrNone )

	        {	            	            	        

    	        if ( ( iProfiles[aItem]->iServerId->Des()).Compare(ProfileToSearch.ServerId() ) == 0 )

    	            {

                    ret = ETrue;                    

                    ProfileId = (TInt)arr[index];

                    ProfileToSearch.Close();

                    break;

                    }	            		    

	        }

	      ProfileToSearch.Close();  

		}

    CleanupStack::PopAndDestroy( &arr );

	if( ret )

		{

		profile.OpenL(iSession, ProfileId , ESmlOpenReadWrite );	

		}

	else

		{

	profile.CreateL( iSession );

		}

	CleanupClosePushL( profile );	

	}

	else

	{

		profile.CreateL( iSession );

		CleanupClosePushL( profile );	

	}

	// ui needs this to be set 0

	profile.SetCreatorId(0);//iProfiles[aItem]->iProfile.SetCreatorId(0);

	profile.SetSanUserInteractionL( iProfiles[aItem]->iServerAlertedAction );

	if ( iProfiles[aItem]->iDisplayName )

	    {

	    profile.SetDisplayNameL( iProfiles[aItem]->iDisplayName->Des() );    

	    }

	if ( iProfiles[aItem]->iServerId )

	    {

	    profile.SetServerIdL( iProfiles[aItem]->iServerId->Des() );    

	    }

	if ( iProfiles[aItem]->iUsername )   

	    {

	    profile.SetUserNameL( iProfiles[aItem]->iUsername->Des() );    

	    }

	if ( iProfiles[aItem]->iPassword )

	    {

	    profile.SetPasswordL( iProfiles[aItem]->iPassword->Des() );    

	    }

	// creates profile -> must be done before opening the connection

	profile.UpdateL();

	RSyncMLConnection connection;

	connection.OpenL( profile, KUidNSmlMediumTypeInternet.iUid );

	CleanupClosePushL( connection );

    if ( (iProfiles[aItem]->iVisitParameter

            && iProfiles[aItem]->iVisitParameter->Data().Length() == uid.MaxLength() )

            || iToNapIDInternetIndicator)

		{

        TUint apId = 0;

        TInt ERROR = KErrNone;

        TInt err1 = KErrNone;

        if (iToNapIDInternetIndicator)

            {

            //Get Access Point from DB or SNAP

            TRAP(err1, apId = WPAdapterUtil::GetAPIDL());

            }

        else

            {

            uid.Copy(iProfiles[aItem]->iVisitParameter->Data() );

            RCmManagerExt  cmmanagerExt;

		    cmmanagerExt.OpenL();

		    CleanupClosePushL(cmmanagerExt);

		    RCmConnectionMethodExt cm;

		    cm = cmmanagerExt.ConnectionMethodL( uid());

		    CleanupClosePushL( cm );

            TRAP( ERROR, apId = cm.GetIntAttributeL(CMManager::ECmIapId) );

            CleanupStack::PopAndDestroy(2); //cmmanager,cm

            }

        //Get default access point in failure of getting AP

        if (ERROR != KErrNone || err1 != KErrNone)

			{

			apId = GetDefaultIAPL();

			}

		HBufC8* iapBuf = HBufC8::NewLC( 8 );

		TPtr8 ptrBuf = iapBuf->Des();

		ptrBuf.Num( apId );

		connection.SetPropertyL( KNSmlIAPId, *iapBuf );

        CleanupStack::PopAndDestroy(); //iapBuf	

		}

	if( iProfiles[aItem]->iHostAddress )

		{

		// see if address contains also port

		TBool portFound = EFalse;

		TInt startPos(0);

		if(iProfiles[aItem]->iHostAddress->Find(KNSmlDsProvisioningHTTP)==0)

		    {

		    startPos=KNSmlDsProvisioningHTTP().Length();		    		    

		    }

		else if(iProfiles[aItem]->iHostAddress->Find(KNSmlDsProvisioningHTTPS)==0)

		    {

		    startPos=KNSmlDsProvisioningHTTPS().Length();		    		    

		    }

		TPtrC uriPtr = iProfiles[aItem]->iHostAddress->Mid(startPos);

		if(uriPtr.Locate(KNSmlDMColon)!=KErrNotFound)

		    {

			portFound = ETrue;

		    }

		if( portFound == EFalse )

			{

			HBufC *uri = 0;

			// port not found from URI -> see if it is given separately				

			if( iProfiles[aItem]->iPort )

				{

				// parse address and port into URI

				if( CombineURILC( iProfiles[aItem]->iHostAddress->Des(),

							  iProfiles[aItem]->iPort->Des(), uri ) == KErrNone )

					{

					if(iProfiles[aItem]->iHostAddress)

					{

						delete iProfiles[aItem]->iHostAddress;

						iProfiles[aItem]->iHostAddress = NULL;

					}

					iProfiles[aItem]->iHostAddress = uri->Des().AllocL();

					}

				CleanupStack::PopAndDestroy(); // uri		  

				}

			else

				{

				// use default port

				if( CombineURILC( iProfiles[aItem]->iHostAddress->Des(),

							  KNSmlDsDefaultPort(), uri ) == KErrNone )

					{

					if(iProfiles[aItem]->iHostAddress)

					{

						delete iProfiles[aItem]->iHostAddress;

						iProfiles[aItem]->iHostAddress = NULL;

					}

					iProfiles[aItem]->iHostAddress = uri->Des().AllocL();

					}

				CleanupStack::PopAndDestroy(); // uri		  

				}

			}

		connection.SetServerURIL( ConvertTo8LC( iProfiles[aItem]->iHostAddress->Des() ) );

		CleanupStack::PopAndDestroy(); // ConvertTo8LC

		}

	// set authtype, HTTPUserName, HTTPPassword

	if( iProfiles[aItem]->iHTTPUserName ||

	    iProfiles[aItem]->iHTTPPassword )

		{

		connection.SetPropertyL( KNSmlHTTPAuth, KNSmlTrueVal );

		if( iProfiles[aItem]->iHTTPUserName )

			{

			connection.SetPropertyL( KNSmlHTTPUsername, iProfiles[aItem]->iHTTPUserName->Des() );

			}

		if( iProfiles[aItem]->iHTTPPassword )

			{

			connection.SetPropertyL( KNSmlHTTPPassword, iProfiles[aItem]->iHTTPPassword->Des() );

			}

		}

	else

		{

		connection.SetPropertyL( KNSmlHTTPAuth, KNSmlFalseVal );

		}

	connection.UpdateL();

	CleanupStack::PopAndDestroy(); // connection

	if(iProfiles[aItem]->iProtocolVersion == ESmlVersion1_1_2 || 

			iProfiles[aItem]->iProtocolVersion == ESmlVersion1_2 )

	{

		profile.SetProtocolVersionL(iProfiles[aItem]->iProtocolVersion);

	}

	TInt iDataProvElementCount = iProfiles[aItem]->iDataProvElement.Count();

	_DBG_FILE("CNSmlDsProvisioningAdapter::SaveL(): Resource For loop: before Start");

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

		{

        _DBG_FILE(

                "CNSmlDsProvisioningAdapter::SaveL(): Resource For loop: In");

		RSyncMLDataProvider dataProvider;

        TRAPD(error, dataProvider.OpenL(iSession,

                iProfiles[aItem]->iDataProvElement[i]->iUid));

		if (!error)

		    {

		    CleanupClosePushL(dataProvider);

            if (ret)

                {

                RArray<TSmlTaskId> providers;

                profile.ListTasksL(providers);

                TInt dataprovcount = providers.Count();

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

                    {

                    TSmlTaskId taskID = providers[i];

                    RSyncMLTask task;

                    task.OpenL(profile, taskID);

                    CleanupClosePushL(task);

                    if (dataProvider.Identifier() == task.DataProvider())

                        {

                        profile.DeleteTaskL(taskID);

                        CleanupStack::PopAndDestroy();

                        break;

                        }

                    CleanupStack::PopAndDestroy();

                    }

                providers.Reset();

                providers.Close();

                }

            HBufC* localDB = dataProvider.DefaultDataStoreName().AllocLC();

            _DBG_FILE("CNSmlDsProvisioningAdapter::SaveL(): DB value");

            DBG_ARGS(

                    iProfiles[aItem]->iDataProvElement[i]->iRemoteDBUri->Des().Ptr());

            RSyncMLTask task;

            task.CreateL(

                    profile,

                    iProfiles[aItem]->iDataProvElement[i]->iUid,

                    iProfiles[aItem]->iDataProvElement[i]->iRemoteDBUri->Des(),

                    localDB->Des());

            CleanupClosePushL(task);

            TRAPD(err, task.UpdateL());

            if (err != KErrAlreadyExists && err != KErrNone)

                {

                User::Leave(err);

                }

            CleanupStack::PopAndDestroy(3); // task, localDB, dataProvider

		    }

		}

	_DBG_FILE("CNSmlDsProvisioningAdapter::SaveL(): Resource For loop: after End");

	profile.UpdateL();

	iProfiles[aItem]->iProfileId = profile.Identifier();

	CleanupStack::PopAndDestroy( &profile );

	_DBG_FILE("CNSmlDsProvisioningAdapter::SaveL(): end");

	}

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

// CNSmlDsProvisioningAdapter::Reserved_1

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

TInt CNSmlDsProvisioningAdapter::Reserved_1()

	{

	return KErrNotSupported;

	}

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

// CNSmlDsProvisioningAdapter::Reserved_2

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

TInt CNSmlDsProvisioningAdapter::Reserved_2()

	{

	return KErrNotSupported;

	}

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

// CNSmlDsProvisioningAdapter::VisitL

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

void CNSmlDsProvisioningAdapter::VisitL( CWPCharacteristic& aCharacteristic )

	{

	_DBG_FILE("CNSmlDsProvisioningAdapter::VisitL(CWPCharacteristic): begin");

	if(aCharacteristic.Type() == KWPApplication)

		{

		iState = CNSmlDsProvisioningAdapter::EStateApplication;

		}

	else if(aCharacteristic.Type() == KWPAppAuth)

		{

		iAuthLevel = CNSmlDsProvisioningAdapter::ENone;

		if(iState == CNSmlDsProvisioningAdapter::EStateDsSettings)

			{

			iState = CNSmlDsProvisioningAdapter::EStateAppAuth;

			}

		else

			{

			iState = CNSmlDsProvisioningAdapter::EStateNull;

			}

		}

	else if(aCharacteristic.Type() == KWPResource)

		{

		if(iState != CNSmlDsProvisioningAdapter::EStateNull )

			{

			iState = CNSmlDsProvisioningAdapter::EStateResource;

			}

		else

			{

			iState = CNSmlDsProvisioningAdapter::EStateNull;

			}

		}

	else if(aCharacteristic.Type() == KWPAppAddr || aCharacteristic.Type() == KWPPort)

		{

		if( iState != CNSmlDsProvisioningAdapter::EStateNull )

			{

			iState = CNSmlDsProvisioningAdapter::EStateDsSettings;

			}

		}

	else

		{

		iState = CNSmlDsProvisioningAdapter::EStateNull;

		}

	if(iState != CNSmlDsProvisioningAdapter::EStateNull)

		{

		aCharacteristic.AcceptL( *this );

		}

	_DBG_FILE("CNSmlDsProvisioningAdapter::VisitL(CWPCharacteristic): end");

	}