// Copyright (c) 2005-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:
// CR99QoSConversion.cpp
// Contains methods for converting R97 QoS parameters to R99/R4 parameters
// 
//

/**
 @file
 @internalComponent
*/

#include <e32cons.h>
#include <e32std.h>
#include <bacline.h>
#include "ceddumper.h"
#include "R99QoSConversion.h"
#include "ceddumpglobals.h"
#include "dbdef.h"
#include <etelpckt.h>
#include <etelqos.h>
#include <faxdefn.h>
#include <networking/panroles.h>

/**
Creates new class instance
*/
CR99QoSConversion* CR99QoSConversion::NewL()
	{
		CR99QoSConversion *self = new (ELeave) CR99QoSConversion();
		CleanupStack::PushL(self);
		self->ConstructL();
		CleanupStack::Pop(self);
		return self;		
	}

/**
Constructes, initialises the object
*/
void CR99QoSConversion::ConstructL()
	{
	iNext = NULL;
	iId = 1;
	iModificationFlag = EFalse;
	
	// Initialize the values. 
	// the remaing, unitialised values are set to '0' by CBase
	iGPRSReqTrafficClass                    = RPacketQoS::ETrafficClassUnspecified;
	iGPRSMinTrafficClass                    = RPacketQoS::ETrafficClassUnspecified;
	iGPRSReqDeliveryOrder                   = RPacketQoS::EDeliveryOrderUnspecified;
	iGPRSMinDeliveryOrder                   = RPacketQoS::EDeliveryOrderUnspecified;
	iGPRSReqDeliverErroneousSDU             = RPacketQoS::EErroneousSDUDeliveryUnspecified;
	iGPRSMinDeliverErroneousSDU             = RPacketQoS::EErroneousSDUDeliveryUnspecified;
	iGPRSReqBER                             = RPacketQoS::EBERUnspecified;
	iGPRSMaxBER                             = RPacketQoS::EBERUnspecified;
	iGPRSReqSDUErrorRatio                   = RPacketQoS::ESDUErrorRatioUnspecified;
	iGPRSMaxSDUErrorRatio                   = RPacketQoS::ESDUErrorRatioUnspecified;
	iGPRSReqTrafficHandlingPriority         = RPacketQoS::ETrafficPriorityUnspecified;
	iGPRSMinTrafficHandlingPriority         = RPacketQoS::ETrafficPriorityUnspecified;
	iGPRSSignallingIndication               = EFalse;
	iGPRS_ImCnSignallingIndication          = EFalse;
	
	//Fixed Value
	iGPRSReqMaxSDUSize                      = 1500;
	iGPRSMinAcceptableMaxSDUSize            = 1500;
	
	iGPRSReqDeliveryOrder                   = RPacketQoS::EDeliveryOrderRequired;
	
	}
	
/**
Deletes object
*/
CR99QoSConversion::~CR99QoSConversion()
	{
	delete iNext;
	}

/**
Check if given column is not deprecated within incoming/outgoing GPRS table. 
Additionally converts the setting to new R99 GPRS QoS values if necessary. 
Assumes setting is given as R97/98 GPRS QoS parameter. 

@param aColumn A reference to a descriptor containing the name of a column in the current record. 
@param aSetting The setting
@return CR99QoSConversion::TConvRecordType
*/
CR99QoSConversion::TConvRecordType CR99QoSConversion::CheckAndConvert(TPtrC& aColumn, TPtrC& aSetting )
	{
	
	TLex temp(aSetting);
	TInt number;
	
	temp.Val(number);
	
	if (aColumn.Compare(TPtrC(GPRS_REQ_PRECEDENCE)) == 0)
		{
		switch (number)
			{
			case (RPacketQoS::EPriorityHighPrecedence) :
			  iGPRSReqTrafficHandlingPriority   = RPacketQoS::ETrafficPriority1;
			  break;
			case (RPacketQoS::EPriorityMediumPrecedence) :
			  iGPRSReqTrafficHandlingPriority   = RPacketQoS::ETrafficPriority2;
			  break;
			case (RPacketQoS::EPriorityLowPrecedence) :
			  iGPRSReqTrafficHandlingPriority   = RPacketQoS::ETrafficPriority3;
			  break;
			default : break;
			}
		iModificationFlag = ETrue;
		return CR99QoSConversion::EDeprecatedRecord;
		}
	else if (aColumn.Compare(TPtrC(GPRS_REQ_DELAY)) == 0)
		{
		switch (number)
			{
			case (RPacketQoS::EDelayClass1):
			   iGPRSReqTrafficClass = RPacketQoS::ETrafficClassInteractive;
			   iGPRSReqTrafficHandlingPriority   = RPacketQoS::ETrafficPriority1;
			   break;
			case (RPacketQoS::EDelayClass2):
			   iGPRSReqTrafficClass = RPacketQoS::ETrafficClassInteractive;
			   iGPRSReqTrafficHandlingPriority   = RPacketQoS::ETrafficPriority2;
			   break;
			case (RPacketQoS::EDelayClass3):
			   iGPRSReqTrafficClass = RPacketQoS::ETrafficClassInteractive;
			   iGPRSReqTrafficHandlingPriority   = RPacketQoS::ETrafficPriority3;
			   break;
			case (RPacketQoS::EDelayClass4):
			   iGPRSReqTrafficClass = RPacketQoS::ETrafficClassBackground;
			   break;
			default :
			   break;
			}
		iModificationFlag = ETrue;
		return CR99QoSConversion::EDeprecatedRecord;
		}
	else if (aColumn.Compare(TPtrC(GPRS_REQ_RELIABILITY)) == 0)
		{
		switch (number)
			{
			case (RPacketQoS::EReliabilityClass1) :
			    iGPRSReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerMillion;
			    iGPRSReqBER           = RPacketQoS::EBEROnePerHundredThousand;
			    iGPRSReqDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryNotRequired;
			    break;
			case (RPacketQoS::EReliabilityClass2) :
			    iGPRSReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerMillion;
			    iGPRSReqBER           = RPacketQoS::EBEROnePerHundredThousand;
			    iGPRSReqDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryNotRequired;
			    break;
			case (RPacketQoS::EReliabilityClass3) :
			    iGPRSReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerTenThousand;
			    iGPRSReqBER           = RPacketQoS::EBEROnePerHundredThousand;
			    iGPRSReqDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryNotRequired;
			    break;
			case (RPacketQoS::EReliabilityClass4) :
			    iGPRSReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerThousand;
			    iGPRSReqBER           = RPacketQoS::EBEROnePerHundredThousand;
			    iGPRSReqDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryNotRequired;
			    break;
			case (RPacketQoS::EReliabilityClass5) :
			    iGPRSReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerThousand;
			    iGPRSReqBER           = RPacketQoS::EBERFourPerThousand;
			    iGPRSReqDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryRequired;
			    break;
			default: break;
			}
		iModificationFlag = ETrue;		
		return CR99QoSConversion::EDeprecatedRecord;
		}
	else if (aColumn.Compare(TPtrC(GPRS_REQ_PEAK_THROUGHPUT)) == 0)
		{
		switch (number)
			{
			case (RPacketQoS::EPeakThroughput1000) :
			     iGPRSReqMaxUplinkRate     = 8;
			     iGPRSReqMaxDownlinkRate       = 8;
			     break;
			 case (RPacketQoS::EPeakThroughput2000) :
			     iGPRSReqMaxUplinkRate    = 16;
			     iGPRSReqMaxDownlinkRate       = 16;
			     break;
			 case (RPacketQoS::EPeakThroughput4000) :
			     iGPRSReqMaxUplinkRate     = 32;
			     iGPRSReqMaxDownlinkRate       = 32;
			     break;
			 case (RPacketQoS::EPeakThroughput8000) :
			     iGPRSReqMaxUplinkRate    = 64;
			     iGPRSReqMaxDownlinkRate       = 64;
			     break;
			 case (RPacketQoS::EPeakThroughput16000) :
			     iGPRSReqMaxUplinkRate     = 128;
			     iGPRSReqMaxDownlinkRate       = 128;
			     break;
			 case (RPacketQoS::EPeakThroughput32000) :
			     iGPRSReqMaxUplinkRate     = 256;
			     iGPRSReqMaxDownlinkRate       = 256;
			     break;
			 case (RPacketQoS::EPeakThroughput64000) :
			     iGPRSReqMaxUplinkRate    = 512;
			     iGPRSReqMaxDownlinkRate       = 512;
			     break;
			 case (RPacketQoS::EPeakThroughput128000) :
			     iGPRSReqMaxUplinkRate     = 1024;
			     iGPRSReqMaxDownlinkRate      = 1024;
			     break;
			 case (RPacketQoS::EPeakThroughput256000) :
			     iGPRSReqMaxUplinkRate    = 2048;
			     iGPRSReqMaxDownlinkRate       = 2048;
			     break;
			 default : break;
			 }
		iModificationFlag = ETrue;		
		return CR99QoSConversion::EDeprecatedRecord;
		}
	else if (aColumn.Compare(TPtrC(GPRS_REQ_MEAN_THROUGHPUT)) == 0)
		{
		iModificationFlag = ETrue;
		return CR99QoSConversion::EDeprecatedRecord;
		}
	else if (aColumn.Compare(TPtrC(GPRS_MIN_PRECEDENCE)) == 0)
		{
		switch (number)
			{
			case (RPacketQoS::EPriorityHighPrecedence) :
			  iGPRSMinTrafficHandlingPriority   = RPacketQoS::ETrafficPriority1;
			  break;
			case (RPacketQoS::EPriorityMediumPrecedence) :
			  iGPRSMinTrafficHandlingPriority   = RPacketQoS::ETrafficPriority2;
			  break;
			case (RPacketQoS::EPriorityLowPrecedence) :
			  iGPRSMinTrafficHandlingPriority   = RPacketQoS::ETrafficPriority3;
			  break;
			default : break;
			}
		iModificationFlag = ETrue;
		return CR99QoSConversion::EDeprecatedRecord;
		}
	else if (aColumn.Compare(TPtrC(GPRS_MIN_DELAY)) == 0)
		{
		switch (number)
			{
			case (RPacketQoS::EDelayClass1):
			   iGPRSMinTrafficClass = RPacketQoS::ETrafficClassInteractive;
			   iGPRSMinTrafficHandlingPriority   = RPacketQoS::ETrafficPriority1;
			   break;
			case (RPacketQoS::EDelayClass2):
			   iGPRSMinTrafficClass = RPacketQoS::ETrafficClassInteractive;
			   iGPRSMinTrafficHandlingPriority   = RPacketQoS::ETrafficPriority2;
			   break;
			case (RPacketQoS::EDelayClass3):
			   iGPRSMinTrafficClass = RPacketQoS::ETrafficClassInteractive;
			   iGPRSMinTrafficHandlingPriority   = RPacketQoS::ETrafficPriority3;
			   break;
			case (RPacketQoS::EDelayClass4):
			   iGPRSMinTrafficClass = RPacketQoS::ETrafficClassBackground;
			   break;
			default :
			   break;
			}
		iModificationFlag = ETrue;
		return CR99QoSConversion::EDeprecatedRecord;
		}
	else if (aColumn.Compare(TPtrC(GPRS_MIN_RELIABILITY))== 0)
		{
		switch (number)
			{
			case (RPacketQoS::EReliabilityClass1) :
			    iGPRSMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerMillion;
			    iGPRSMaxBER           = RPacketQoS::EBEROnePerHundredThousand;
			    iGPRSMinDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryNotRequired;
			    break;
			case (RPacketQoS::EReliabilityClass2) :
			    iGPRSMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerMillion;
			    iGPRSMaxBER           = RPacketQoS::EBEROnePerHundredThousand;
			    iGPRSMinDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryNotRequired;
			    break;
			case (RPacketQoS::EReliabilityClass3) :
			    iGPRSMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerTenThousand;
			    iGPRSMaxBER           = RPacketQoS::EBEROnePerHundredThousand;
			    iGPRSMinDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryNotRequired;
			    break;
			case (RPacketQoS::EReliabilityClass4) :
			    iGPRSMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerThousand;
			    iGPRSMaxBER           = RPacketQoS::EBEROnePerHundredThousand;
			    iGPRSMinDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryNotRequired;
			    break;
			case (RPacketQoS::EReliabilityClass5) :
			    iGPRSMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerThousand;
			    iGPRSMaxBER           = RPacketQoS::EBERFourPerThousand;
			    iGPRSMinDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryRequired;
			    break;
			default: break;
			}
		iModificationFlag = ETrue;
		return CR99QoSConversion::EDeprecatedRecord;
		}
	else if (aColumn.Compare(TPtrC(GPRS_MIN_PEAK_THROUGHPUT)) == 0)
		{
		switch (number)
			{
			case (RPacketQoS::EPeakThroughput1000) :
			     iGPRSReqMinUplinkRate     = 8;
			     iGPRSReqMinDownlinkRate       = 8;
			     break;
			 case (RPacketQoS::EPeakThroughput2000) :
			     iGPRSReqMinUplinkRate    = 16;
			     iGPRSReqMinDownlinkRate       = 16;
			     break;
			 case (RPacketQoS::EPeakThroughput4000) :
			     iGPRSReqMinUplinkRate     = 32;
			     iGPRSReqMinDownlinkRate       = 32;
			     break;
			 case (RPacketQoS::EPeakThroughput8000) :
			     iGPRSReqMinUplinkRate    = 64;
			     iGPRSReqMinDownlinkRate       = 64;
			     break;
			 case (RPacketQoS::EPeakThroughput16000) :
			     iGPRSReqMinUplinkRate     = 128;
			     iGPRSReqMinDownlinkRate       = 128;
			     break;
			 case (RPacketQoS::EPeakThroughput32000) :
			     iGPRSReqMinUplinkRate     = 256;
			     iGPRSReqMinDownlinkRate       = 256;
			     break;
			 case (RPacketQoS::EPeakThroughput64000) :
			     iGPRSReqMinUplinkRate    = 512;
			     iGPRSReqMinDownlinkRate       = 512;
			     break;
			 case (RPacketQoS::EPeakThroughput128000) :
			     iGPRSReqMinUplinkRate     = 1024;
			     iGPRSReqMinDownlinkRate      = 1024;
			     break;
			 case (RPacketQoS::EPeakThroughput256000) :
			     iGPRSReqMinUplinkRate    = 2048;
			     iGPRSReqMinDownlinkRate       = 2048;
			     break;
			 default : break;
			 }
		iModificationFlag = ETrue;
		return CR99QoSConversion::EDeprecatedRecord;
		}
	else if (aColumn.Compare(TPtrC(GPRS_MIN_MEAN_THROUGHPUT)) == 0)
		{
		iModificationFlag = ETrue;
		return CR99QoSConversion::EDeprecatedRecord;
		}
	else
		{
		return CR99QoSConversion::EValidRecord;
		}
	}


/**
Set iNext to the next CR99QoSConversion object in the list.

@param aNext handle to CR99QoSConversion object
*/
void CR99QoSConversion::SetNext(CR99QoSConversion* aNext)
	{
	iNext = aNext;
	aNext->SetId(iId + 1);
	}

/**
Retrieves iNext values

@return iNext handle to next CR99QoSConversion object in the list
*/
CR99QoSConversion* CR99QoSConversion::GetNext()
	{
	return iNext;
	}

/**
Retrieves identification number

@return iId object's identification number
*/
TInt CR99QoSConversion::GetId()
	{
	return iId;
	}

/**
Set object identification number 

@param aId identification number
*/
void CR99QoSConversion::SetId(TInt aId)
	{
	iId = aId;
	}

/**
Prints out all R99 values in particular format

@param aFileDumper handle to the object responsible for writing to the output file
*/
void CR99QoSConversion::PrintValues(CFileDump* aFileDumper)
	{
	TBuf<MAX_BUFFER_LEN> buf;
	TPtrC column;
	TPtrC setting;
	
	ASSERT(aFileDumper);
	
	aFileDumper->WriteSectionHeader(iId);
	
	buf.Copy(TPtrC(QOS_UMTS_R99_AND_ON_TABLE));
	buf.AppendNum(iId);
	column.Set(TPtrC(COMMDB_NAME));
	setting.Set(buf);
	aFileDumper->WriteColumnValue(column, setting);
	
	PrintLine(aFileDumper, TPtrC(GPRS_QOS_REQ_TRAFFIC_CLASS), iGPRSReqTrafficClass);
	PrintLine(aFileDumper, TPtrC(GPRS_QOS_MIN_TRAFFIC_CLASS), iGPRSMinTrafficClass);
	PrintLine(aFileDumper, TPtrC(GPRS_QOS_REQ_DELIVERY_ORDER),iGPRSReqDeliveryOrder);
	PrintLine(aFileDumper, TPtrC(GPRS_QOS_MIN_DELIVERY_ORDER),iGPRSMinDeliveryOrder);
	PrintLine(aFileDumper, TPtrC(GPRS_QOS_REQ_DELIVER_ERRONEOUS_SDU),iGPRSReqDeliverErroneousSDU); 
	PrintLine(aFileDumper, TPtrC(GPRS_QOS_MIN_DELIVER_ERRONEOUS_SDU),iGPRSMinDeliverErroneousSDU);
	PrintLine(aFileDumper, TPtrC(GPRS_QOS_REQ_MAX_SDUSIZE),iGPRSReqMaxSDUSize);
	PrintLine(aFileDumper, TPtrC(GPRS_QOS_MIN_ACCEPTABLE_MAX_SDU_SIZE),iGPRSMinAcceptableMaxSDUSize);
	PrintLine(aFileDumper, TPtrC(GPRS_QOS_REQ_MAX_UPLINK_RATE),iGPRSReqMaxUplinkRate);
	PrintLine(aFileDumper, TPtrC(GPRS_QOS_REQ_MIN_UPLINK_RATE),iGPRSReqMinUplinkRate);
	PrintLine(aFileDumper, TPtrC(GPRS_QOS_REQ_MAX_DOWNLINK_RATE),iGPRSReqMaxDownlinkRate);
	PrintLine(aFileDumper, TPtrC(GPRS_QOS_REQ_MIN_DOWNLINK_RATE),iGPRSReqMinDownlinkRate);
	PrintLine(aFileDumper, TPtrC(GPRS_QOS_REQ_BER),iGPRSReqBER);
	PrintLine(aFileDumper, TPtrC(GPRS_QOS_MAX_BER),iGPRSMaxBER);
	PrintLine(aFileDumper, TPtrC(GPRS_QOS_REQ_SDU_ERROR_RATIO),iGPRSReqSDUErrorRatio);
	PrintLine(aFileDumper, TPtrC(GPRS_QOS_MAX_SDU_ERROR_RATIO),iGPRSMaxSDUErrorRatio);
	PrintLine(aFileDumper, TPtrC(GPRS_QOS_REQ_TRAFFIC_HANDLING_PRIORITY),iGPRSReqTrafficHandlingPriority);
	PrintLine(aFileDumper, TPtrC(GPRS_QOS_MIN_TRAFFIC_HANDLING_PRIORITY),iGPRSMinTrafficHandlingPriority);
	PrintLine(aFileDumper, TPtrC(GPRS_QOS_REQ_TRANSFER_DELAY),iGPRSReqTransferDelay);
	PrintLine(aFileDumper, TPtrC(GPRS_QOS_MAX_TRANSFER_DELAY),iGPRSMaxTransferDelay);
	PrintLine(aFileDumper, TPtrC(GPRS_QOS_REQ_GUARANTEED_UPLINK_RATE),iGPRSReqGuaranteedUplinkRate);
	PrintLine(aFileDumper, TPtrC(GPRS_QOS_MIN_GUARANTEED_UPLINK_RATE),iGPRSMinGuaranteedUplinkRate);
	PrintLine(aFileDumper, TPtrC(GPRS_QOS_REQ_GUARANTEED_DOWNLINK_RATE),iGPRSReqGuaranteedDownlinkRate);
	PrintLine(aFileDumper, TPtrC(GPRS_QOS_MIN_GUARANTEED_DOWNLINK_RATE),iGPRSMinGuaranteedDownlinkRate);
	PrintLine(aFileDumper, TPtrC(GPRS_QOS_SIGNALLING_INDICATION),(iGPRSSignallingIndication == RPacketQoS::EDeliveryOrderRequired)?TPtrC(_S("TRUE")):TPtrC(_S("FALSE")));
	PrintLine(aFileDumper, TPtrC(GPRS_QOS_IM_CN_SIGNALLING_INDICATOR),(iGPRS_ImCnSignallingIndication == RPacketQoS::EDeliveryOrderRequired)?TPtrC(_S("TRUE")):TPtrC(_S("FALSE")));
	PrintLine(aFileDumper, TPtrC(GPRS_QOS_SOURCE_STATISTICS_DESCRIPTOR),iGPRSSourceStatisticsDescriptor);

	aFileDumper->WriteFieldCount(27);
	aFileDumper->WriteSectionFooter(iId);
	}

/**
Prints out the line to the output file

@param aFileDumper handle to the object responsible for writing to the output file
@param aCol name of the column to print out
@param aSetting intiger column's value to print out
*/
void CR99QoSConversion::PrintLine(CFileDump* aFileDumper, TPtrC aCol, TInt aSetting)
	{
	TBuf<MAX_BUFFER_LEN> buf;
	TPtrC column;
	TPtrC setting;
	
	column.Set(aCol);
	buf.Num(aSetting);
	setting.Set(buf);
	aFileDumper->WriteColumnValue(column, setting);
	}

/**
Prints out all R99 values in particular format

@param aFileDumper handle to the object responsible for writing to the output file
@param aCol name of the column to print out
@param aSetting pointer to string to print out as a column's value
*/
void CR99QoSConversion::PrintLine(CFileDump* aFileDumper, TPtrC aCol, TPtrC aSetting)
	{
	TPtrC column;
	TPtrC setting;
	column.Set(aCol);
	setting.Set(aSetting);
	aFileDumper->WriteColumnValue(column, setting);
	}

/**
Retrieves modification flag

@return iModificationFlag modification flag
*/	
TBool CR99QoSConversion::GetModificationFlag()
	{
	return iModificationFlag;
	}