/*
* Copyright (c) 2002-2005 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: 
* handler class for im client.
*
*/

// INCLUDE FILES
#include <e32std.h>
#include <imcvcodc.h>
#include "impsimcli.h"
#include "impsimhandler.h"
#include "impsfields.h"
#include "impsservercommon.h"
#include "impserrors.h"
#include "impsutils.h"
#include "impsdataaccessor.h"
#include "impscdatautils.h"
#include "impsliterals.h"  

// MACROS
#ifndef _DEBUG
#define _NO_IMPS_LOGGING_
#endif

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

// ----------------------------------------------------------------------------
// CImpsImHandler2::CImpsImHandler2
// ----------------------------------------------------------------------------
CImpsImHandler2::CImpsImHandler2( 
    TInt aPriority, 
    RImpsImClient2& aClient ) :
    // The base class adds this to the scheduler
    CImpsHandler2( aPriority, aClient )
    {
    }

// ----------------------------------------------------------------------------
// CImpsImHandler2::NewL
// ----------------------------------------------------------------------------
CImpsImHandler2* CImpsImHandler2::NewL( 
     RImpsImClient2& aClient,
     TInt aPriority )
     {

      // Perform the construction.
      CImpsImHandler2* self = new (ELeave)
            CImpsImHandler2( aPriority, aClient);

      CleanupStack::PushL( self );
      self->ConstructL();
      CleanupStack::Pop( self );

      return self;
     }
       
// ----------------------------------------------------------------------------
// CImpsImHandler2::~CImpsImHandler2()
// ----------------------------------------------------------------------------
 CImpsImHandler2::~CImpsImHandler2()
     {

     }

// ----------------------------------------------------------------------------
// CImpsImHandler2::ConstructL
// ----------------------------------------------------------------------------
void CImpsImHandler2::ConstructL()
    {
    CImpsHandler2::ConstructL();
    }

// ----------------------------------------------------------------------------
// CImpsImHandler2::HandleEventL()
// ----------------------------------------------------------------------------

void CImpsImHandler2::HandleEventL( CImpsFields* aErrorFields )
    {
    // get the event data from server thread.
    SImpsEventData* event = (SImpsEventData*)iEventData.Ptr();

#ifndef _NO_IMPS_LOGGING_
     CImpsClientLogger::Log(_L("CImpsImHandler2::HandleEventL opid=%d cli=%d"), 
         event->iOpCode, (TInt)&iClient );
#endif

    if ( event->iStatus != ( Imps_ERROR_BASE - 200 ) &&
             event->iStatus != KErrNone )
        {
        HandleErrorEventL( event->iOpCode, event->iStatus, aErrorFields );
        }
        // Call regular observer
        // iStatus is error code or message size
     else if ( iStatus >= 0 )
        {
        HandleImEventL( ); 
        }
    }

// ----------------------------------------------------------------------------
// CImpsImHandler2::HandleImEventL()
// ----------------------------------------------------------------------------
void CImpsImHandler2::HandleImEventL( )
    {
    SImpsEventData* event = (SImpsEventData*)iEventData.Ptr();
    RImpsImClient2& client = (RImpsImClient2&)iClient;
    MImpsImHandler2* imhandler = client.Handler();
    MImpsBlockingHandler2* blockhandler = client.BlockHandler();

    TInt err( KErrNone );
	
    // Check incoming message type
    TInt myType = event->iMessageType;

    CImpsDataAccessor* myAccess = CImpsDataAccessor::NewLC( iFields ); // << 
    CImpsKey* myKey = CImpsKey::NewLC();      // <<< myKey

    switch ( myType )
        {
        case EImpsNewMessage:
            {
            if ( !imhandler )
                {
                break;
                }
                
            // get messageID
            TPtrC msgId = TPtrC( KNullDesC );
            (void)TImpsCDataUtils::GetNewMessageIdL( 
                myKey, myAccess, msgId );

            myKey->Reset();

            // arrays
            // notice: optimize creation of arrays
            CPtrC16Array* users = new ( ELeave )CPtrC16Array( 4 );
            CleanupStack::PushL( users );   // <<< users
            CPtrC16Array* sns = new ( ELeave )CPtrC16Array( 4 );
            CleanupStack::PushL( sns );     //  <<< sns 
            CPtrC16Array* grs = new ( ELeave )CPtrC16Array( 4 );
            CleanupStack::PushL( grs );     // <<< grs 
            CPtrC16Array* sng = new (ELeave) CPtrC16Array(5);
            CleanupStack::PushL( sng );     // <<< grs 
            
            TImpsCDataUtils::AddValuesFromArrayL( 
                myKey, 
                KNewMessageElements, 
                sizeof( KNewMessageElements ) /
                sizeof( KNewMessageElements[0] ) );
            myKey->AddL( CREATEKEY( EImpsKeyMessageInfo, 0 ) );
            TPtrC mySender;
            TPtrC myGroup;
            TImpsCDataUtils::GetSenderL( myKey, myAccess, 
                mySender, myGroup );
            TImpsCDataUtils::GetRecipientsL( myKey, myAccess, 
                grs, users, sng, sns );

            myKey->PopL();

            TPtrC myType;
            TImpsCDataUtils::GetContentTypeL( myAccess, myType );
            
            // !!!! Fix for JKIO-6PAGQ3 !!!!
            // Check whether the content type starts with "text/plain"
            if ( !myType.Left(KImpsContentType().Length()).CompareF( KImpsContentType ) || myType.Length()  == 0 )
                {
            TPtrC myContent;
            TImpsCDataUtils::GetContentDataL( myKey, myAccess, myContent );
            
            // Call API observer method
#ifndef _NO_IMPS_LOGGING_
     CImpsClientLogger::Log(_L("CImpsImHandler2::call HandleNewTextMessageL opid=%d"), event->iOpCode );
#endif
            TRAP( err, imhandler->HandleNewTextMessageL(
                event->iOpCode, 
                msgId,
                mySender,
                myGroup,  
                *users,
                *sns,
                myContent,
                *iClient.CspIdentifier() ));
                }
            else
                {
                TPtrC8 myContent;
                TInt inCleanup(0);
                TDesC8* content;
                myKey->Reset();
                TImpsCDataUtils::AddValuesFromArrayL( 
                    myKey, 
                    KNewMessageElements, 
                    sizeof( KNewMessageElements ) /
                    sizeof( KNewMessageElements[0] ) );

                myKey->AddL( CREATEKEY( EImpsKeyContentData, 0 ) );
                if ( myAccess->RestoreDesc8L( myKey, content ) )
                    {
                    TInt encoding (-1);
                    TImpsCDataUtils::GetContentEncodingL( myAccess, encoding);
                    if ( encoding == EImpsBASE64 )
                        {           
                        // allocate buffer for decoding
                        HBufC8* contentBuf = HBufC8::NewLC( content->Length() ); // << contentBuf
                        inCleanup++;
                        // BASE64 decoding
                        TImCodecB64 codec;
                        codec.Initialise();
                        TPtr8 ptr( contentBuf->Des() );
                        codec.Decode( *content , ptr );
                        myContent.Set(*contentBuf);
                        }
                    else
                        {
                        myContent.Set( *content );
                        }
                    }
                else
                    {
                    myContent.Set( KNullDesC8 );                                    
                    }
                    // Call API observer method
#ifndef _NO_IMPS_LOGGING_
     CImpsClientLogger::Log(_L("CImpsImHandler2::HandleNewContentMessageL opid=%d length=%d"), event->iOpCode, myContent.Length() );
                    
#endif
                    TRAP( err, imhandler->HandleNewContentMessageL(
                        event->iOpCode, 
                        msgId,
                        mySender,
                        myGroup,  
                        *users,
                        *sns,
                        myType,
                        myContent,
                        *iClient.CspIdentifier() ));
                    if ( inCleanup > 0 )
                        {
                        CleanupStack::PopAndDestroy( inCleanup ); //  >>> contentBuf
                        }
                    myKey->PopL();
                
                }              
            CleanupStack::PopAndDestroy(4); // >>> users, sns, grs, sng
            }
            break;

	case EImpsDeliveryReportReq:
	    {
            if ( !imhandler )
                {
                break;
                }
		TImpsCDataUtils::AddValuesFromArrayL( 
                myKey, 
                KTransContentElements, 
                sizeof( KTransContentElements ) /
                sizeof( KTransContentElements[0] ) );
            myKey->AddL( CREATEKEY( EImpsKeyDeliveryReport_Request, 0 ) );    
            myKey->AddL( CREATEKEY( EImpsKeyMessageInfo, 0 ) );
            myKey->AddL( CREATEKEY( EImpsKeyMessageID, 0 ) );
            TDesC* msgId;
            myAccess->RestoreDescL( myKey, msgId );
            myKey->PopL( 2 );

            myKey->AddL( CREATEKEY( EImpsKeyResult, 0 ) );
            myKey->AddL( CREATEKEY( EImpsKeyCode, 0 ) );
            TInt result( 0 );
            myAccess->RestoreIntegerL( myKey, result );
            myKey->PopL();
            
            myKey->AddL( CREATEKEY( EImpsKeyDescription, 0 ) );
            TDesC* description;
            myAccess->RestoreDescL( myKey, description );
            
            TRAP( err, imhandler->HandleDeliveryReportL(
            	*msgId, result, description, *iClient.CspIdentifier() ) );
            
            // myKey->ResetL( );
            }
		break;		
		
        case EImpsGetBlockedListRes:
            if ( blockhandler )
                {

                TBool blockedInUse( EFalse );
                TBool grantedInUse( EFalse );

                CPtrC16Array* blockedList = new ( ELeave )CPtrC16Array( 4 );
                CleanupStack::PushL( blockedList  );   // <<< blockedList 

                CPtrC16Array* grantedList = new ( ELeave )CPtrC16Array( 4 );
                CleanupStack::PushL( grantedList  );   // <<< grantedList 

                // Get data from internal data format to API method
                TImpsCDataUtils::GetBlockedListResponseL(
                    myKey, myAccess,
                    blockedList,
                    blockedInUse,
                    grantedList,
                    grantedInUse );

#ifndef _NO_IMPS_LOGGING_
     CImpsClientLogger::Log(_L("CImpsImHandler2::call GetBlockedListResponseL opid=%d"), event->iOpCode );
#endif
                // Call API observer method
                TRAP( err, blockhandler->GetBlockedListResponseL(
                    blockedList,
                    blockedInUse,
                    grantedList,
                    grantedInUse,
                    *client.CspIdentifier() ) );

                CleanupStack::PopAndDestroy(2); // >> blockedList, grantedlist

                }
            break;
                   

        default: // responses
            if ( event->iReqMesType == EImpsBlockEntityReq && blockhandler)
                {
#ifndef _NO_IMPS_LOGGING_
     CImpsClientLogger::Log(_L("CImpsImHandler2::call HandleCompleteL opid=%d"), event->iOpCode );
#endif
                TRAP( err, blockhandler->HandleCompleteL( event->iOpCode, /*event->iStatus,*/ *iClient.CspIdentifierL() ));
                }
            else if ( event->iReqMesType == EImpsSendMessageReq && imhandler)
                {
#ifndef _NO_IMPS_LOGGING_
     CImpsClientLogger::Log(_L("CImpsImHandler2::call HandleSendCompleteL opid=%d"), event->iOpCode );
#endif
                TRAP( err, imhandler->HandleSendCompleteL(
                    event->iOpCode, EFalse, *iClient.CspIdentifier())); 
                }
            else 
                {
#ifndef _NO_IMPS_LOGGING_
     CImpsClientLogger::Log(_L("CImpsImHandler2:: ERROR CORRUPTED ***** opid=%d"), event->iOpCode );
#endif
                __ASSERT_DEBUG( 0 == 1,
                                User::Panic( KImpsPanicCategory,
                                            EImpsCorrupted ) ); 
                User::Leave( KErrNotSupported );
                }
            break;
        }  // switch

        CleanupStack::PopAndDestroy(2); // myKey, myAccess

    }

//  End of File