// 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:

//

/**

 @file

*/

#include "ss_tiermanagerutils.h"

#include <comms-infras/ss_log.h>

#include <comms-infras/ss_metaconnprov.h>

#include <in_sock.h> //KAfInet

#include <es_connpref.h>

#include <commsdattypesv1_1.h> // CommsDat

#include <comms-infras/commsdatschema.h> // CommsDat

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <commsdattypesv1_1_partner.h>

#include <commsdattypesv1_1_internal.h>

#include <es_sock_internal.h>

#endif

#include <commdbconnpref.h> //TCommDbConnPref

#include <comms-infras/ss_thread.h>

#include <comms-infras/esock_params.h> //TConnAPPref

#include <comms-infras/ss_mcprnodemessages.h> //RConnPrefList

#include <agentdialog.h> //TConnectionPrefs

#include <elements/sd_std.h> //RTierThreadMap

#include "ss_tierthreadmap.h"

#ifdef _DEBUG

// Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module

// (if it could happen through user error then you should give it an explicit, documented, category + code)

_LIT(KSpecAssert_ESockSSockTrMngU, "ESockSSockTrMngU");

#endif

using namespace ESock;

using namespace CommsDat;

using namespace Den;

using namespace CommsFW;

/**

   TierManagerUtils panic category

*/

_LIT(KTierManagerUtils, "TierManagerUtils");

const TInt KEsockLinkFlag    =  0x80000000;

/** Panics generated by the Comms Channels

*/

enum TTierManagerUtilsPanics

	{

	EInvalidTierId          = 0,

	EInvalidAccessPointId   = 1,

	EInvalidCprId           = 2,

	EInvalidSCprId          = 3,

	EInvalidIapId           = 4,

	EInvalidProtocolId      = 5,

	EInvalidAPSelPolId      = 6

	};

//private, not exported, used with legacy implicit flows only

TUid TierManagerUtils::MapTierIdsForLegacyImplicitFlowsL(TUid aTierId, TUint aProtocol)

	{

	//If necessary, map the KAfInet to a default tier

	TUid mappedTier = MapTierIdsL(aTierId, aProtocol);

	//Now find the tier ID.

	CMDBSession* dbs = CMDBSession::NewLC(KCDVersion1_2);

	CCDTierRecord* tierRec = NULL;

	TRAP_IGNORE(tierRec = TierManagerUtils::LoadTierRecordL(mappedTier, *dbs));

	if(tierRec==NULL)

		{

		if(aTierId.iUid != KAfInet)

			{

			// In the absence of a trier record for this address family try using the KAfInet one

			// This covers the case of legacy protocols such as SMS which only need the top tier

			// The protocol argument is irrelevent for this.

			mappedTier = TierManagerUtils::MapTierIdsL(TUid::Uid(KAfInet), 0);

			tierRec = TierManagerUtils::LoadTierRecordL(mappedTier, *dbs);

			}

		else

			{

			User::Leave(KErrNotFound);

			}

		}

	delete tierRec;

	CleanupStack::PopAndDestroy(dbs);

	return mappedTier;

	}

//only called from functions which are returning AP fields.

TInt TierManagerUtils::ResolveDefAPtoTagL(TInt aElementId, CommsDat::CMDBSession& aDbs )

    {

    CMDBField<TInt>* iRecordTag = new (ELeave) CMDBField<TInt>(aElementId | KCDTIdRecordTag);

    CleanupStack::PushL(iRecordTag);

    iRecordTag->LoadL(aDbs);

	TInt temp = *iRecordTag;

	CleanupStack::PopAndDestroy(iRecordTag);

	return temp;

    }

//Here we have an AccessPoint record Id. Based on that the TagId of the record

//should be given back...

EXPORT_C TInt TierManagerUtils::ConvertSNAPPrefToTagIdL(TUint aSNAPPref, CommsDat::CMDBSession& aDbs)

	{

    CMDBField<TInt>* apTag = new (ELeave) CMDBField<TInt>(KCDTIdAccessPointRecord | KCDTIdRecordTag);

    CleanupStack::PushL(apTag);

    apTag->SetRecordId(aSNAPPref);

    apTag->LoadL(aDbs);

	TInt temp = *apTag;

	CleanupStack::PopAndDestroy(apTag);

	return temp;

	}

EXPORT_C TUid TierManagerUtils::MapElementIdToTagId(TUint aElementId, CommsDat::CMDBSession& aDbs)

    {

    CMDBField<TInt>* recordTag = new (ELeave) CMDBField<TInt>((aElementId & KCDMaskShowRecordType) |

                                                              (aElementId & KCDMaskShowRecordId) |

                                                              KCDTIdRecordTag);

    CleanupStack::PushL(recordTag);

    recordTag->LoadL(aDbs);

	TUid temp;

	temp.iUid = *recordTag;

	CleanupStack::PopAndDestroy(recordTag);

	return temp;

    }

//

//CTierManagerUtils - for commsdat manipulation

EXPORT_C TUid TierManagerUtils::MapTierIdsL(TUid aTierId, TUint /*aProtocol*/)

	{

	// Defined here to avoid a dependency on SIP headers(sipconnpref.h)

	const TUint KAFSip = 0x10000;

	const TUint KAFSipTierMgrFactoryImplementionUid = 0x200041F7;

	//Maps legacy or other thier ids (like the old address family) to new tier ids.

	switch (aTierId.iUid)

		{

		case KAFSip:

				return TUid::Uid(KAFSipTierMgrFactoryImplementionUid);

		}

	return aTierId;

	}

EXPORT_C CCDTierRecord* TierManagerUtils::LoadTierRecordL(TUid aTierId, CMDBSession& aDbs)

	{

	__ASSERT_ALWAYS(aTierId.iUid>0,User::Panic(KTierManagerUtils,EInvalidTierId));

    CCDTierRecord* tierRec = static_cast<CCDTierRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdTierRecord));

    CleanupStack::PushL(tierRec);

    tierRec->iRecordTag = aTierId.iUid;

	TBool found = tierRec->FindL(aDbs);

	if (!found)

    	{

    	User::Leave(KErrNotFound);

    	}

    if (static_cast<TInt>(tierRec->iDefaultAccessPoint)!=0)

        {

        TInt defTierElemId = ResolveDefAPtoTagL(static_cast<TInt>(tierRec->iDefaultAccessPoint), aDbs );

        tierRec->iDefaultAccessPoint = defTierElemId;

        }

	__ASSERT_DEBUG(tierRec->iTierManagerName.TypeId() == KCDTIdTierManagerName, User::Panic(KSpecAssert_ESockSSockTrMngU, 1)); // Panics if built against incorrect CommsDat.

	CleanupStack::Pop(tierRec);

	return tierRec;

	}

EXPORT_C CCDTierRecord* TierManagerUtils::LoadTierRecordL(CommsDat::TMDBElementId aTierId, CommsDat::CMDBSession& aDbs)

	{

	__ASSERT_ALWAYS(aTierId>0,User::Panic(KTierManagerUtils,EInvalidTierId));

    CCDTierRecord* tierRec = static_cast<CCDTierRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdTierRecord));

    CleanupStack::PushL(tierRec);

    tierRec->SetRecordId(aTierId);

	tierRec->LoadL(aDbs);

    if (static_cast<TInt>(tierRec->iDefaultAccessPoint)!=0)

        {

        TInt defTierElemId = ResolveDefAPtoTagL(static_cast<TInt>(tierRec->iDefaultAccessPoint), aDbs );

        tierRec->iDefaultAccessPoint = defTierElemId;

        }

	__ASSERT_DEBUG(tierRec->iTierManagerName.TypeId() == KCDTIdTierManagerName, User::Panic(KSpecAssert_ESockSSockTrMngU, 2)); // Panics if built against incorrect CommsDat.

	CleanupStack::Pop(tierRec);

	return tierRec;

	}

EXPORT_C CCDAPPrioritySelectionPolicyRecord* TierManagerUtils::LoadAPPrioritySelRecordL(CommsDat::TMDBElementId aApSelId, CommsDat::CMDBSession& aDbs)

	{

	__ASSERT_ALWAYS(aApSelId>0,User::Panic(KTierManagerUtils,EInvalidAPSelPolId));

    CCDAPPrioritySelectionPolicyRecord* apSelRec = static_cast<CCDAPPrioritySelectionPolicyRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdApPrioritySelectionPolicyRecord));

    CleanupStack::PushL(apSelRec);

    apSelRec->SetRecordId(aApSelId);

	apSelRec->LoadL(aDbs);

	CleanupStack::Pop(apSelRec);

	return apSelRec;

	}

EXPORT_C CCDAccessPointRecord* TierManagerUtils::LoadAccessPointRecordL(TUint aAccessPointId, CMDBSession& aDbs)

	{

	/**

	There are cases when ESock tries to load an access point record based on tag id but this id

	is got as a TUint parameter. The conversion is here.

	*/

	__ASSERT_ALWAYS(aAccessPointId>0,User::Panic(KTierManagerUtils,EInvalidAccessPointId));

	TUid temp;

	temp.iUid = aAccessPointId;

	return LoadAccessPointRecordL(temp, aDbs);

	}

EXPORT_C CCDAccessPointRecord* TierManagerUtils::LoadAccessPointRecordL(TUid aAccessPointId, CMDBSession& aDbs)

	{

	__ASSERT_ALWAYS(aAccessPointId.iUid>0,User::Panic(KTierManagerUtils,EInvalidAccessPointId));

    CCDAccessPointRecord* apRec = static_cast<CCDAccessPointRecord*>(CCDTierRecord::RecordFactoryL(KCDTIdAccessPointRecord));

	CleanupStack::PushL(apRec);

	apRec->iRecordTag = aAccessPointId.iUid;

	TBool found = apRec->FindL(aDbs);

	if (!found)

    	{

    	User::Leave(KErrNotFound);

    	}

	__ASSERT_DEBUG(apRec->iTier.TypeId() == KCDTIdTier, User::Panic(KSpecAssert_ESockSSockTrMngU, 3)); // Panics if built against incorrect CommsDat.

	CleanupStack::Pop(apRec);

	return apRec;

	}

EXPORT_C CCDAccessPointRecord* TierManagerUtils::LoadAccessPointRecordL(const TProviderInfo& aProviderInfo, CMDBSession& aDbs)

	{

	CCDAccessPointRecord* apRec = LoadAccessPointRecordL(aProviderInfo.APId(),aDbs);

	__ASSERT_DEBUG(aProviderInfo.TierId().iUid==apRec->iTier, User::Panic(KSpecAssert_ESockSSockTrMngU, 4));

	return apRec;

	}

EXPORT_C CMDBRecordSet<CCDAccessPointRecord>* TierManagerUtils::LoadAccessPointRecordsL(

							TUid aTierId, CMDBSession& aDbs)

	{

	__ASSERT_ALWAYS(aTierId.iUid>0,User::Panic(KTierManagerUtils,EInvalidTierId));

	//Load all AP records that belong to this tier.

	CMDBRecordSet<CCDAccessPointRecord>* apSet = new(ELeave) CMDBRecordSet<CCDAccessPointRecord>(KCDTIdAccessPointRecord);

    CleanupStack::PushL(apSet);

    //Create first record for priming

    CCDAccessPointRecord* apRec = static_cast<CCDAccessPointRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdAccessPointRecord));

    CleanupStack::PushL(apRec);

    //Add record to record set

    apRec->iTier = aTierId.iUid | KEsockLinkFlag;

    apSet->iRecords.AppendL(apRec);

    CleanupStack::Pop(apRec);

    //Load set

    TBool returned = apSet->FindL(aDbs);

	//Check if apRec has been overwritten

    if( ! returned )

        {

		User::Leave(KErrNotFound);

        }

    CleanupStack::Pop(apSet);

	return apSet;

	}

EXPORT_C CMDBRecordSet<CCDAccessPointRecord>* TierManagerUtils::LoadAccessPointRecordsL(

							TUid aTierId, const RArray<TAccessPointInfo>& aApIdsToMatch, CMDBSession& aDbs)

	{

	if(aApIdsToMatch.Count())

		{

		CMDBRecordSet<CCDAccessPointRecord>* apSet = new(ELeave) CMDBRecordSet<CCDAccessPointRecord>(KCDTIdAccessPointRecord);

	    CleanupStack::PushL(apSet);

		CCDAccessPointRecord* apRec = 0;

		TInt i=0;

		for( ; i<aApIdsToMatch.Count() ; ++i )

			{

			if(apRec == 0)

				{

				apRec = static_cast<CCDAccessPointRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdAccessPointRecord));

   				CleanupStack::PushL(apRec);

				}

  			apRec->iTier = aTierId.iUid | KEsockLinkFlag;

			apRec->iRecordTag = aApIdsToMatch[i].AccessPoint();

			TBool returned = apRec->FindL(aDbs);

			if(returned)

				{

			    apSet->iRecords.AppendL(apRec);

				CleanupStack::Pop(apRec);

				apRec = 0; // so a new one gets created on next iteration

				}

			}

		if(apRec)

			{

			CleanupStack::PopAndDestroy(apRec);

			}

		CleanupStack::Pop(apSet);

		return apSet;

		}

	else

		{

		// empty set means no filtering

		return LoadAccessPointRecordsL(aTierId,aDbs);

		}

	}

EXPORT_C CCDMCprRecord* TierManagerUtils::LoadMCprRecordL(TUint aMCprId, CMDBSession& aDbs)

	{

    CCDMCprRecord* mcprRec = static_cast<CCDMCprRecord*>(CCDMCprRecord::RecordFactoryL(KCDTIdMCprRecord));

	CleanupStack::PushL(mcprRec);

    mcprRec->SetRecordId(aMCprId);

	mcprRec->LoadL(aDbs);

	__ASSERT_DEBUG(mcprRec->iMCprUid.TypeId() == KCDTIdMCprUid, User::Panic(KSpecAssert_ESockSSockTrMngU, 5)); // Panics if built against incorrect CommsDat.

	CleanupStack::Pop(mcprRec);

	return mcprRec;

	}

EXPORT_C CCDMCprRecord* TierManagerUtils::LoadMCprRecordL(TUid aMCprFactoryUid, CMDBSession& aDbs)

	{

    CCDMCprRecord* mcprRec = static_cast<CCDMCprRecord*>(CCDMCprRecord::RecordFactoryL(KCDTIdMCprRecord));

	CleanupStack::PushL(mcprRec);

	mcprRec->iMCprUid = aMCprFactoryUid.iUid;

	TBool found = mcprRec->FindL(aDbs);

	if (!found)

    	{

    	User::Leave(KErrNotFound);

    	}

	__ASSERT_DEBUG(mcprRec->iMCprUid.TypeId() == KCDTIdMCprUid, User::Panic(KSpecAssert_ESockSSockTrMngU, 6)); // Panics if built against incorrect CommsDat.

	CleanupStack::Pop(mcprRec);

	return mcprRec;

	}

EXPORT_C CCDCprRecord* TierManagerUtils::LoadCprRecordL(TUint aCprId, CMDBSession& aDbs)

	{

	__ASSERT_ALWAYS(aCprId>0,User::Panic(KTierManagerUtils,EInvalidCprId));

    CCDCprRecord* cprRec = static_cast<CCDCprRecord*>(CCDCprRecord::RecordFactoryL(KCDTIdCprRecord));

	CleanupStack::PushL(cprRec);

    cprRec->SetRecordId(aCprId);

	cprRec->LoadL(aDbs);

	__ASSERT_DEBUG(cprRec->iCprUid.TypeId() == KCDTIdCprUid, User::Panic(KSpecAssert_ESockSSockTrMngU, 7)); // Panics if built against incorrect CommsDat.

	CleanupStack::Pop(cprRec);

	return cprRec;

	}

EXPORT_C CCDSCprRecord* TierManagerUtils::LoadSCprRecordL(TUint aSCprId, CMDBSession& aDbs)

	{

    __ASSERT_ALWAYS(aSCprId>0,User::Panic(KTierManagerUtils,EInvalidSCprId));

    CCDSCprRecord* scprRec = static_cast<CCDSCprRecord*>(CCDSCprRecord::RecordFactoryL(KCDTIdSCprRecord));

	CleanupStack::PushL(scprRec);

    scprRec->SetRecordId(aSCprId);

	scprRec->LoadL(aDbs);

	__ASSERT_DEBUG(scprRec->iSCprUid.TypeId() == KCDTIdSCprUid, User::Panic(KSpecAssert_ESockSSockTrMngU, 8)); // Panics if built against incorrect CommsDat.

	CleanupStack::Pop(scprRec);

	return scprRec;

	}

EXPORT_C CCDProtocolRecord* TierManagerUtils::LoadProtocolRecordL(TUint aProtocolId, CMDBSession& aDbs)

	{

	__ASSERT_ALWAYS(aProtocolId>0,User::Panic(KTierManagerUtils,EInvalidProtocolId));

    CCDProtocolRecord* prtRec = static_cast<CCDProtocolRecord*>(CCDTierRecord::RecordFactoryL(KCDTIdProtocolRecord));

	CleanupStack::PushL(prtRec);

	prtRec->SetRecordId(aProtocolId);

	prtRec->LoadL(aDbs);

	__ASSERT_DEBUG(prtRec->iProtocolUid.TypeId() == KCDTIdProtocolUid, User::Panic(KSpecAssert_ESockSSockTrMngU, 9)); // Panics if built against incorrect CommsDat.

	CleanupStack::Pop(prtRec);

	return prtRec;

	}

EXPORT_C CCDGlobalSettingsRecord* TierManagerUtils::LoadGlobalSettingsRecordL(CMDBSession& aDbs)

	{

	CCDGlobalSettingsRecord* gsRec = static_cast<CCDGlobalSettingsRecord*>(CCDGlobalSettingsRecord::RecordFactoryL(KCDTIdGlobalSettingsRecord));

	CleanupStack::PushL(gsRec);

	gsRec->SetRecordId(1);

	gsRec->LoadL(aDbs);

	__ASSERT_DEBUG(gsRec->iDefaultTier.TypeId() == KCDTIdDefaultTier, User::Panic(KSpecAssert_ESockSSockTrMngU, 10)); // Panics if built against incorrect CommsDat.

	CleanupStack::Pop(gsRec);

	return gsRec;

	}

EXPORT_C CCDIAPRecord* TierManagerUtils::LoadIapRecordL(TUint aIapId, CMDBSession& aDbs)

	{

	__ASSERT_ALWAYS(aIapId>0,User::Panic(KTierManagerUtils,EInvalidIapId));

	CCDIAPRecord* iapRec = static_cast<CCDIAPRecord*>(CCDIAPRecord::RecordFactoryL(KCDTIdIAPRecord));

	CleanupStack::PushL(iapRec);

	iapRec->SetRecordId(aIapId);

	iapRec->LoadL(aDbs);

	CleanupStack::Pop(iapRec);

	return iapRec;

	}

EXPORT_C CMDBRecordSet<CCDIAPRecord>* TierManagerUtils::LoadIapRecordsL(CMDBSession& aDbs)

	{

	//Load all IAP records

	CMDBRecordSet<CCDIAPRecord>* iapSet = new(ELeave) CMDBRecordSet<CCDIAPRecord>(KCDTIdIAPRecord);

    CleanupStack::PushL(iapSet);

    //Create first record for priming

	CCDIAPRecord* iapRec = static_cast<CCDIAPRecord*>(CCDIAPRecord::RecordFactoryL(KCDTIdIAPRecord));

	CleanupStack::PushL(iapRec);

    //Add record to record set

    iapSet->iRecords.AppendL(iapRec);

    CleanupStack::Pop(iapRec);

    //Load set

    TBool returned = iapSet->FindL(aDbs);

	//Check if apRec has been overwritten

    if( ! returned )

        {

		User::Leave(KErrNotFound);

        }

    CleanupStack::Pop(iapSet);

	return iapSet;

	}

EXPORT_C TUint TierManagerUtils::ReadDefaultAccessPointL(TUid aTierId, CMDBSession& aDbs)

	{

	CCDTierRecord* tierRec = TierManagerUtils::LoadTierRecordL(aTierId,aDbs);

	TUint accessPoint = tierRec->iDefaultAccessPoint;

	delete tierRec;

	return accessPoint;

	}

EXPORT_C TUid TierManagerUtils::ReadTierIdL(TUint aAccessPointId, CMDBSession& aDbs)

	{

	//it would be better to load 2 fields rather than load 2 record....

	__ASSERT_ALWAYS(aAccessPointId>0,User::Panic(KTierManagerUtils,EInvalidAccessPointId));

	CCDAccessPointRecord* apRec = TierManagerUtils::LoadAccessPointRecordL(aAccessPointId,aDbs);

	CleanupStack::PushL(apRec);

	//load the tag field for the given tier record

	CMDBField<TInt>* iRecordTag = new (ELeave) CMDBField<TInt>(static_cast<TInt>(apRec->iTier) | KCDTIdRecordTag);

    CleanupStack::PushL(iRecordTag);

    iRecordTag->LoadL(aDbs);

	TInt tempTag = *iRecordTag;

	CleanupStack::PopAndDestroy(iRecordTag);

	TUid tierId = TUid::Uid(tempTag);

	CleanupStack::PopAndDestroy(apRec);

	//delete apRec;

	User::LeaveIfError(tierId.iUid? KErrNone : KErrCorrupt);

	return tierId;

	}

EXPORT_C TUid TierManagerUtils::ReadMCprUidL(TUint aAccessPointId, CMDBSession& aDbs)

	{

	__ASSERT_ALWAYS(aAccessPointId>0,User::Panic(KTierManagerUtils,EInvalidAccessPointId));

	CCDAccessPointRecord* apRec = TierManagerUtils::LoadAccessPointRecordL(aAccessPointId,aDbs);

	CleanupStack::PushL(apRec);

	CCDMCprRecord* mcprRec = TierManagerUtils::LoadMCprRecordL(apRec->iMCpr,aDbs);

	TUid mCprUid = TUid::Uid(mcprRec->iMCprUid);

	delete mcprRec;

	CleanupStack::PopAndDestroy(apRec);

	return mCprUid;

	}

EXPORT_C TUint TierManagerUtils::ReadSelectionPolicyIdL(TUint aAccessPointId, CMDBSession& aDbs)

	{

	__ASSERT_ALWAYS(aAccessPointId>0,User::Panic(KTierManagerUtils,EInvalidAccessPointId));

	CCDAccessPointRecord* apRec = TierManagerUtils::LoadAccessPointRecordL(aAccessPointId,aDbs);

	TUint policyId = apRec->iSelectionPolicy;

	delete apRec;