/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 FILES

#include <etelmm.h>

#include <tisi.h>

#include <pn_const.h>

#include <ctsy/serviceapi/mmtsy_ipcdefs.h>

#include <etelmmerr.h>      // For error code

#include <ctsy/serviceapi/gsmerror.h>       // For error code

#include "tsylogger.h"

#include "cmmmessagerouter.h"

#include "cmmphonebookoperationwrite.h"

#include "cmmphonebookalphastring.h"

#include "osttracedefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmmphonebookoperationwritetraces.h"

#endif

// EXTERNAL DATA STRUCTURES

    // None

// EXTERNAL FUNCTION PROTOTYPES

    // None

// CONSTANTS

// MACROS

    // None

// LOCAL CONSTANTS AND MACROS

    // None

// MODULE DATA STRUCTURES

    // None

// LOCAL FUNCTION PROTOTYPES

    // None

// ==================== LOCAL FUNCTIONS =====================================

    // None

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

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

// CMmPhoneBookOperationWrite::CMmPhoneBookOperationWrite

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

// might leave.

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

//

CMmPhoneBookOperationWrite::CMmPhoneBookOperationWrite()

    {

TFLOGSTRING("TSY: CMmPhoneBookOperationWrite::\

        CMmPhoneBookOperationWrite");

OstTrace0( TRACE_NORMAL, CMMPHONEBOOKOPERATIONWRITE_CMMPHONEBOOKOPERATIONWRITE, "CMmPhoneBookOperationWrite::CMmPhoneBookOperationWrite" );

    iPhoneBookEntry = NULL;

    }

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

// CMmPhoneBookOperationWrite::~CMmPhoneBookOperationWrite

// C++ destructor.

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

//

CMmPhoneBookOperationWrite::~CMmPhoneBookOperationWrite()

    {

TFLOGSTRING("TSY: CMmPhoneBookOperationWrite::\

        ~CMmPhoneBookOperationWrite");

OstTrace0( TRACE_NORMAL, DUP1_CMMPHONEBOOKOPERATIONWRITE_CMMPHONEBOOKOPERATIONWRITE, "CMmPhoneBookOperationWrite::~CMmPhoneBookOperationWrite" );

    }

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

// CMmPhoneBookOperationWrite::NewL

// Creates a new CMmPhonebookOperationWrite object instance.

// Two-phased constructor.

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

CMmPhoneBookOperationWrite* CMmPhoneBookOperationWrite::NewL(

    CMmPhoneBookStoreMessHandler* aMmPhoneBookStoreMessHandler,

    const CMmDataPackage* aDataPackage ) // Data

    {

TFLOGSTRING("TSY: CMmPhoneBookOperationWrite::NewL");

OstTrace0( TRACE_NORMAL, CMMPHONEBOOKOPERATIONWRITE_NEWL, "CMmPhoneBookOperationWrite::NewL" );

    TName phonebookTypeName;

    CMmPhoneBookOperationWrite* mmPhoneBookOperationWrite =

        new( ELeave ) CMmPhoneBookOperationWrite();

    const CPhoneBookDataPackage* phoneBookData =

        static_cast<const CPhoneBookDataPackage*>( aDataPackage );

    phoneBookData->GetPhoneBookName( phonebookTypeName );

    // Store phonebook name 

    mmPhoneBookOperationWrite->iPhoneBookTypeName = phonebookTypeName;

    mmPhoneBookOperationWrite->iMmPhoneBookStoreMessHandler =

        aMmPhoneBookStoreMessHandler;

    return mmPhoneBookOperationWrite;

    }

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

// CMmPhoneBookOperationWrite::ConstructL

// Initialises object attributes.

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

//

void CMmPhoneBookOperationWrite::ConstructL()

    {

TFLOGSTRING("TSY: CMmPhoneBookOperationWrite::ConstructL");

OstTrace0( TRACE_NORMAL, CMMPHONEBOOKOPERATIONWRITE_CONSTRUCTL, "CMmPhoneBookOperationWrite::ConstructL" );

    }

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

// TInt CMmPhoneBookOperationWrite::CreateReq

// Separate request

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

//

TInt CMmPhoneBookOperationWrite::UICCCreateReq

        (

        TInt aIpc,

        const CMmDataPackage* aDataPackage,

        TUint8 aTransId

        )

    {

TFLOGSTRING2("TSY: CMmPhoneBookOperationWrite::UICCCreateReq Ipc: %d", aIpc);

OstTraceExt1( TRACE_NORMAL, DUP1_CMMPHONEBOOKOPERATIONWRITE_UICCCREATEREQ, "CMmPhoneBookOperationWrite::UICCCreateReq;aIpc=%hd", aIpc );

    TInt ret (KErrNone);

    const CPhoneBookDataPackage* phoneBookData =

        static_cast<const CPhoneBookDataPackage*>( aDataPackage );

        if( aIpc == EMmTsyPhoneBookStoreWriteIPC )

            {

                TInt16 index( 0 );

                // Store Entry to the operation which needs to be write in SIM

                phoneBookData->UnPackData( index, iPhoneBookEntry );

                if ( iPhoneBookEntry )

                    {

                    // get the index Number needs to be write

                    iPhoneBookEntry->iLocation = static_cast<TUint16>( index );

                    // Convert Phone Book name to file id

                    TUint16 fileIdExt ( UICC_ILLEGAL_FILE_ID );

                    TUint16 pbFileId = ConvertToPBfileId( iPhoneBookTypeName, fileIdExt );

                    TUint8 pbArrayIndex ( ConvertToConfArrayIndex( pbFileId ) );

                    if( PB_MBDN_FID == pbFileId )

                        {

                        // For MBDN PhoneBook first read MBI file 

                        // Check if the mailbox inidcation type is correct

                        if( index <= iMmPhoneBookStoreMessHandler->

                                iPBStoreConf[pbArrayIndex].iMbiRecLen )

                            {

                            iCurrentWritePhase = EPBWritePhase_Read_MBI_profile;

                            // read MBDN record number from MBI first record Profile number

                            ret = UiccPbReqReadMBI( index, aTransId );

                            }

                        else

                            {

                            ret = KErrArgument;

                            }

                        }

                    else

                        {

                        ret = UiccPbReqWriteL( aTransId, index, *iPhoneBookEntry );

                        }

                    }

            }

        else

            {

TFLOGSTRING2("TSY: CMmPhoneBookOperationWrite::UICCCreateReq Unknown Ipc: %d", aIpc);

OstTraceExt1( TRACE_NORMAL, DUP2_CMMPHONEBOOKOPERATIONWRITE_UICCCREATEREQ, "CMmPhoneBookOperationWrite::UICCCreateReq;Unknown aIpc =%hd", aIpc );

            }

    return ret;

    }

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

// CMmPhoneBookOperationWrite::UiccPbReqWriteL

// Constructs an ISI-message to read entry from SIM

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

//

TInt CMmPhoneBookOperationWrite::UiccPbReqWriteL(

        TUint8 aTransId,

        TInt16 aIndex,

        CPhoneBookStoreEntry& aDataToWrite )

    {

TFLOGSTRING3("TSY: CMmPhoneBookOperationWrite::SimPbReqWriteL, aTransId:%d,index:%d", aTransId,  aIndex);

OstTraceExt2( TRACE_NORMAL, CMMPHONEBOOKOPERATIONWRITE_UICCPBREQWRITEL, "CMmPhoneBookOperationWrite::UiccPbReqWriteL;aTransId=%hhu;aIndex=%hd", aTransId, aIndex );

    TInt ret( KErrNone );

    // Check for no of EXT records required for Writing this Entry

    TUint8 extRecordNo ( 0 ); 

    if( UICC_EF_FDN_NO_EXT_NUM_LEN < iPhoneBookEntry->iNumber->Length() )

        {

        extRecordNo++;

        TInt extDataLength = iPhoneBookEntry->iNumber->Length() - 

                             UICC_EF_FDN_NO_EXT_NUM_LEN;

        while ( extDataLength > UICC_EF_EXT_REC_NUM_LEN)

            {

            extRecordNo++;

            extDataLength = extDataLength - UICC_EF_EXT_REC_NUM_LEN;

            }

        }

    // reserve Space for ext record no

    iExtRecordArrayToBeWrite.ReserveL( extRecordNo );

    // File reserved memory with 0

    for( TInt count = 0; count < extRecordNo; count++ )

        {

        iExtRecordArrayToBeWrite.Insert( 0 , count );

        }

    // Convert Phone Book name to file id

    TUint16 fileIdExt ( UICC_ILLEGAL_FILE_ID );

    TUint16 pbFileId = ConvertToPBfileId( iPhoneBookTypeName, fileIdExt );

    if( UICC_ILLEGAL_FILE_ID != pbFileId )

        {

        TUint8 pbArrayIndex ( ConvertToConfArrayIndex( pbFileId ) );

        // Check if the index To read is valid

        if(  aIndex <= iMmPhoneBookStoreMessHandler->

                iPBStoreConf[pbArrayIndex].iNoOfRecords )

            {

            // if Entry present in list Store it locally

            TPBEntry entry;

            if( 0 < aIndex )

                {

                // Check for index present the store list

                if( iMmPhoneBookStoreMessHandler->IndexCheckInPBList(

                        aIndex,

                        pbArrayIndex,

                        entry ) )

                    {

                    // Check if Entry is present or not 

                    if( entry.iEntryPresent )

                        {

                        // Check if no if ext records are sufficient from previous Entry

                        if( extRecordNo  > entry.PBEntryExtRecord.Count() )

                            {

                            // Update old record number which needs to be updated by new entry

                            if( entry.PBEntryExtRecord.Count() > 0 )

                                {

                                for( TInt i=0; i <  entry.PBEntryExtRecord.Count(); i++ )

                                    {

                                    // Append record number to be write from old Entry

                                    iExtRecordArrayToBeWrite.Append( 

                                            entry.PBEntryExtRecord[i] );

                                    iExtRecordArrayToBeDelete.Append( 

                                            entry.PBEntryExtRecord[i] );

                                    }

                                }

                            // Search for more free records

                            iCurrentWritePhase = EPBWritePhase_Search_Ext_Entry;

                            // Send request to read first entry in Ext

                            iExtRecordNo = 1 ;

                            ret = UiccPbReqWriteReadExt(

                                    pbFileId,

                                    fileIdExt,

                                    iExtRecordNo,

                                    aTransId);

                            }

                        else  // when reocrds to be delete and write are 0 or to be write record less

                            {

                            // Check of both records are 0

                            if( ( extRecordNo == 0 ) && 

                                    ( entry.PBEntryExtRecord.Count() == 0 ))

                                {

                                // Start Writing Entry

                                iCurrentWritePhase = EPBWritePhase_Write_Entry;

                                ret = UiccPBReqWriteEntry( 

                                        pbFileId,

                                        aIndex,

                                        aTransId,

                                        aDataToWrite );

                                }

                            else

                                {

                                // Start copy Ext record number to be write array

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

                                    {

                                    // Append record number to be write from old Entry

                                    iExtRecordArrayToBeWrite.Append(

                                            entry.PBEntryExtRecord[i]);

                                    iExtRecordArrayToBeDelete.Append(

                                            entry.PBEntryExtRecord[i]);

                                    }

                                // Update records needs to be deleted

                                // From old Entry

                                for( TInt i=extRecordNo; i <  entry.PBEntryExtRecord.Count(); i++ )

                                    {

                                    // Append record number to be deleted from old Entry

                                    iExtRecordArrayToBeDelete.Append( 

                                            entry.PBEntryExtRecord[i]);

                                    }

                                // Start Deleting the EXT Records

                                iCurrentWritePhase = EPBWritePhase_Write_Ext_Entry;

                                iExtDeleteOperation = ETrue;

                                TUint8 index ( iExtRecordArrayToBeDelete[0] );

                                // Send request to Write main Entry

                                ret = UiccPbReqWriteExtDelete(

                                        pbFileId,

                                        fileIdExt,

                                        index,

                                        aTransId );

                                }

                            }

                        }

                    else

                        {

                        // If entry not present

                        // Check if EXT Records are needed for Entry to be written

                        if( 0 < extRecordNo )

                            {

                            // Search for free ext records 

                            iCurrentWritePhase = EPBWritePhase_Search_Ext_Entry;

                            // Send request To read First EXT record

                            iExtRecordNo = 1;

                            ret = UiccPbReqWriteReadExt(

                                    pbFileId,

                                    fileIdExt,

                                    iExtRecordNo,

                                    aTransId );

                            }

                        else

                            {

                            // Start Writting Entry

                            iCurrentWritePhase = EPBWritePhase_Write_Entry;

                            TUint8 indexToWrite = iPhoneBookEntry->iLocation;

                            ret = UiccPBReqWriteEntry(

                                    pbFileId,

                                    indexToWrite,

                                    aTransId,

                                    aDataToWrite );

                            }

                        }

                    }   // end of if Entry is present in the list

                else

                    {

                    // First Read that Entry from SIM and then delete that entry with EXT records if there are Any

                    iCurrentWritePhase = EPBWritePhase_Read_Entry;

                    ret = UiccPbReqWriteRead( pbFileId, aIndex, aTransId );

                    // read Main entry with given index number

                    }

                }

            else

                {

                // Start Serching For first free Entry in the Stored list

                TInt index = iMmPhoneBookStoreMessHandler->

                EmptyEntryCheckInPBList( pbArrayIndex );

                if( 0 < index )

                    {

                    //Check if EXT records Are needed or not

                    if( 0 < extRecordNo )

                        {

                        // Start Serching for EXT records

                        // Search for free ext records 

                        iCurrentWritePhase = EPBWritePhase_Search_Ext_Entry;

                        // Send request To read First EXT record

                        iExtRecordNo = 1;

                        ret = UiccPbReqWriteReadExt(

                                pbFileId,

                                fileIdExt,

                                iExtRecordNo,

                                aTransId );

                        }

                    else

                        {

                        // Start Writing Entry on given Index

                        // Start Writting Entry

                        iCurrentWritePhase = EPBWritePhase_Write_Entry;

                        ret = UiccPBReqWriteEntry(

                                pbFileId,

                                index,

                                aTransId,

                                aDataToWrite );

                        }

                    }

                else

                    {

                    // Start searching for first free Entry from SIM

                    iCurrentWritePhase = EPBWritePhase_Read_Entry;

                    iLocationSearch = ETrue;

                    iEntryToWrite = 1;

                    ret = UiccPbReqWriteRead(

                            pbFileId,

                            iEntryToWrite,

                            aTransId );

                    }

                }

            }

        else

            {

            ret = KErrArgument;

            }            

        }

    else

        {

        ret = KErrArgument;

        }

    return ret;

    }

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

// CMmPhoneBookOperationWrite::UiccPBReqWriteEntry

// Constructs an ISI-message to Write main Entry data

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

//

TInt CMmPhoneBookOperationWrite::UiccPBReqWriteEntry( TUint16 aFileId, TUint8 aIndex, TUint8 aTransId, CPhoneBookStoreEntry& aDataToWrite )

    {

TFLOGSTRING("TSY: CMmPhoneBookOperationWrite::UiccPBReqWriteEntry");

OstTrace0( TRACE_NORMAL, CMMPHONEBOOKOPERATIONWRITE_UICCPBREQWRITEENTRY, "CMmPhoneBookOperationWrite::UiccPBReqWriteEntry" );

    TInt ret( KErrNone );

    TUiccWriteLinearFixed cmdParams;

    cmdParams.messHandlerPtr  = static_cast<MUiccOperationBase*> 

                               ( iMmPhoneBookStoreMessHandler );

    cmdParams.filePath.Append( static_cast<TUint8>( MF_FILE >> 8 ));

    cmdParams.filePath.Append( static_cast<TUint8>( MF_FILE ));

    cmdParams.filePath.Append( APPL_FILE_ID>>8);

    cmdParams.filePath.Append( APPL_FILE_ID);

    cmdParams.filePath.Append( static_cast<TUint8>( DF_PHONEBOOK >> 8 ));

    cmdParams.filePath.Append( static_cast<TUint8>( DF_PHONEBOOK ));

    cmdParams.serviceType = UICC_APPL_UPDATE_LINEAR_FIXED;

    cmdParams.fileId = aFileId;

    cmdParams.trId = static_cast<TUiccTrId>( aTransId );

    // Check for valid record number

    TUint8 arrayIndex ( ConvertToConfArrayIndex( aFileId ) );

    if( aIndex <= iMmPhoneBookStoreMessHandler->iPBStoreConf[arrayIndex].iNoOfRecords )

        {

        cmdParams.record = aIndex;

        }

    else

        {

        ret = KErrArgument;

        }

    TBuf8<241>nameBuf;

    TPtr16 ptrToName = aDataToWrite.iText->Des();

    // Convert the Entry Name from ASCII format to UCS2

    CMmStaticUtility::ConvertUcs2ToGsmUcs2Data( ptrToName, nameBuf );

    if( nameBuf.Length() < iMmPhoneBookStoreMessHandler->

                           iPBStoreConf[ arrayIndex ].iAlphaStringlength )

        {

        // Fill rest of the Bytes 

        for( TInt count = nameBuf.Length(); count < ( iMmPhoneBookStoreMessHandler->

                      iPBStoreConf[ arrayIndex ].iAlphaStringlength ); count++ )

            {

            nameBuf.Append( KTagUnusedbyte );

            }

        }

    TBuf8<300>numberBuf;

    TPtr16 ptrToNumber = aDataToWrite.iNumber->Des();

    iMmPhoneBookStoreMessHandler->ConvertToBCDFromUCS2(

                                  ptrToNumber,

                                  numberBuf,

                                  aFileId );

    // Store number length

    TUint8 numLength ( numberBuf.Length() );

    if( numberBuf.Length() < UICC_EF_EXT_REC_NUM_LEN )

        {

        // fill  rest of the bytes

        for( TInt count = numberBuf.Length(); count < UICC_EF_EXT_REC_NUM_LEN; count++)

            {

            numberBuf.Append( KTagUnusedbyte );

            }

        }

    TBuf8<200>fileDataWrite;

    fileDataWrite.Append( nameBuf.Mid( 0, iMmPhoneBookStoreMessHandler->

                          iPBStoreConf[ arrayIndex ].iAlphaStringlength ) );

    fileDataWrite.Append( numLength );

    fileDataWrite.Append( numberBuf.Mid( 0, UICC_EF_EXT_REC_NUM_LEN ) );

    // Append Capability configuration byte as not used

    fileDataWrite.Append( KTagUnusedbyte );

    // Chekc for EXT Data is present or not

    if( 0 < iExtRecordArrayToBeWrite.Count() )

        {

        // Append Extension recorNo from iExtRecordArray to be write

        fileDataWrite.Append( iExtRecordArrayToBeWrite[0] );

        }

    else

        {

        // there is no EXT record

        fileDataWrite.Append( KTagUnusedbyte );

        }

    // Append 

    cmdParams.fileData.Append( fileDataWrite );

    if( KErrNone == ret )

        {

        ret = iMmPhoneBookStoreMessHandler->UiccMessHandler()->

            CreateUiccApplCmdReq( cmdParams );

TFLOGSTRING2("TSY: CreateUiccApplCmdReq returns %d", ret);

OstTraceExt1( TRACE_NORMAL, DUP1_CMMPHONEBOOKOPERATIONWRITE_UICCPBREQWRITEENTRY, "CMmPhoneBookOperationWrite::UiccPBReqWriteEntry;ret=%hd", ret );