/*
* 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 imps fundemental feature.
*
*/


// INCLUDE FILES
#include "impsfundcli.h"
#include "impsfundhandler.h"
#include "impsutils.h"
#include "impscdatautils.h"
#include "impserrors.h"
#include "impscommonenums.h"

// MACROS
#ifndef _DEBUG
#define _NO_IMPS_LOGGING_
#endif

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

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

// ----------------------------------------------------------------------------
// CImpsFundHandler2::NewL
// ----------------------------------------------------------------------------
CImpsFundHandler2* CImpsFundHandler2::NewL( RImpsFundClient2& aClient,
                                          TInt aPriority )
     {
     CImpsFundHandler2* self = new (ELeave) CImpsFundHandler2( aPriority , 
                                                             aClient);
     CleanupStack::PushL( self );
     self->ConstructL();
     CleanupStack::Pop( self );
     return self;
     }

// ----------------------------------------------------------------------------
// CImpsFundHandler2::~CImpsFundHandler2
// ----------------------------------------------------------------------------
CImpsFundHandler2::~CImpsFundHandler2()
     {
     delete iDataAccessor;
     delete iKey;
     }

// ----------------------------------------------------------------------------
// CImpsFundHandler2::HandleEventL
// ----------------------------------------------------------------------------
void CImpsFundHandler2::HandleEventL( CImpsFields* aErrorFields )
    {
    // get the event data from server thread.
    SImpsEventData* event = (SImpsEventData*)iEventData.Ptr();
#ifndef _NO_IMPS_LOGGING_
     CImpsClientLogger::Log(_L("CImpsFundHandler2::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 )
        {
        HandleFundamentalEventL( ); 
        }
    }

// ----------------------------------------------------------------------------
// CImpsFundHandler2::HandleFundamentalEventL
// ----------------------------------------------------------------------------
void CImpsFundHandler2::HandleFundamentalEventL( )
    {
    // get the event data from server thread.

    MImpsSearchHandler2* searchhandler = NULL; 
    SImpsEventData* event = ( SImpsEventData* )iEventData.Ptr();
    TInt err( KErrNone );    
    //This must be a "response" to search stop
    if( event->iMessageType == EImpsStatus &&
        event->iRequestType == EImpsServFundSearch )
        {
        searchhandler = iClient.SearchHandler();
        //Notice: Status message does not include a search ID, which is the 
        //third parameter in HandleSearchStoppedL() method. In future, it
        //might be a good idea to expand the event structure so that a
        //response could always be mapped to the correct request regardless
        //of the message type. For now, just send a meaningless magic number 0.
        if( searchhandler != NULL )
            {
#ifndef _NO_IMPS_LOGGING_
            CImpsClientLogger::Log( _L( "CImpsFundHandler2:: calls HandleSearchStoppedL opid=%d"), 
                event->iOpCode );
#endif
            TRAP( err, searchhandler->HandleSearchStoppedL( event->iOpCode, 
                                          /*event->iStatus,*/ KErrNone, *iClient.CspIdentifier() ));
            }
        else
            {
            #ifndef _NO_IMPS_LOGGING_
                CImpsClientLogger::Log(_L("Search handler not instantiated!"));
            #endif
            return;
            }
        }
    else
        {
        MImpsInviteHandler2* invitehandler = iClient.InviteHandler();
        switch( event->iMessageType )
            {
            case EImpsSearchRes:
                HandleSearchResponseL( event->iOpCode );
                break;
            case EImpsInviteUserReq:
                HandleInviteRequestL();
                break;
            case EImpsInviteRes:
                HandleInviteResponseL();
                break;
            case EImpsCancelInviteUserReq:
                HandleInviteCancelL();
                break;
            default:
                if( invitehandler != NULL)
                {
#ifndef _NO_IMPS_LOGGING_
            CImpsClientLogger::Log( _L( "CImpsFundHandler2:: calls HandleCompleteL opid=%d"), 
                event->iOpCode );
#endif
                    TRAP( err, invitehandler->HandleCompleteL( event->iOpCode, /*event->iStatus,*/ *iClient.CspIdentifier() ));
                }
                else
                    {
                    #ifndef _NO_IMPS_LOGGING_
                        CImpsClientLogger::Log
                            ( _L( "Invite handler not instantiated!" ) );
                    #endif
                    return;
                    }
                break;
            }
        iKey->Reset();
        }
    #ifndef _NO_IMPS_LOGGING_
        CImpsClientLogger::Log( _L( "CImpsFundHandler2::HandleFundamentalEventL ends" ) );
    #endif
    }

// ----------------------------------------------------------------------------
// CImpsFundHandler2::HandleSearchResponseL
// ----------------------------------------------------------------------------
void CImpsFundHandler2::HandleSearchResponseL( const TInt aOpId )
    {
    #ifndef _NO_IMPS_LOGGING_
        CImpsClientLogger::Log
                ( _L( "CImpsFundHandler2::HandleSearchResponseL()" ) );
    #endif
    MImpsSearchHandler2* search = iClient.SearchHandler();
    if( search != NULL )
        {
        TImpsSearchResultType resultType = EImpsUserResult;
        const TImpsContent* content = KSearchResponseElements;
        TImpsDataUtils::AddValuesFromArrayL( iKey, content,
                                        sizeof( KSearchResponseElements ) /
                                        sizeof( KSearchResponseElements[0] ) );
        TInt searchId = IntegerElementL( EImpsKeySearchID, 0 ); //search ID
        TInt index = IntegerElementL( EImpsKeySearchIndex, 0 );
        TInt results = IntegerElementL( EImpsKeySearchFindings, 0 );
        TBool complete = BooleanElementL( EImpsKeyCompletionFlag, 0 );
        CPtrC16Array* resultArray = results > 0 ? SearchResultsLC( resultType ) : NULL;

       	TInt err( KErrNone );
        TRAP( err, search->HandleSearchL( aOpId, 
                               searchId, index,
                               results, complete,
                               resultType, resultArray, *iClient.CspIdentifier() ));
        if( resultArray != NULL )
            CleanupStack::PopAndDestroy();  //resultArray
        }
    else
        {
        #ifndef _NO_IMPS_LOGGING_
            CImpsClientLogger::Log( _L( " Search handler not instantiated!" ) );
        #endif
        }
    }

// ----------------------------------------------------------------------------
// CImpsFundHandler2::HandleInviteRequestL
// ----------------------------------------------------------------------------
void CImpsFundHandler2::HandleInviteRequestL()
    {
    #ifndef _NO_IMPS_LOGGING_
        CImpsClientLogger::Log
            ( _L( "CImpsFundHandler2::HandleInviteRequestL()" ) );
    #endif
    MImpsInviteHandler2* invite = iClient.InviteHandler();
    if( invite != NULL )
        {
		TInt err( KErrNone );

        const TImpsContent* content = KInviteUserRequestElements;
        TImpsDataUtils::AddValuesFromArrayL( iKey, content,
                                    sizeof( KInviteUserRequestElements ) /
                                    sizeof( KInviteUserRequestElements[0] ) );
      
        TInt inviteType = IntegerElementL( EImpsKeyInviteType, 0 );
        TPtrC inviteID = DescriptorElementL( EImpsKeyInviteID, 0 );
        TPtrC reason = DescriptorElementL( EImpsKeyInviteNote, 0 );
        TInt validity = IntegerElementL( EImpsKeyValidity, 0 );
        TPtrC groupName;
        groupName.Set( DescriptorElementL( EImpsKeyGroupID, 0 ) );//gr   
            
        iKey->AddL( CREATEKEY( EImpsKeySender, 0 ) );           
        iKey->AddL( CREATEKEY( EImpsKeyUser, 0 ) );            
        TPtrC userID = DescriptorElementL( EImpsKeyUserID, 0 );
        if ( inviteType == EImpsGR )
            {
            TPtrC sName;
            if( userID.Length() == 0 )
                {
                iKey->PopL();                                       //user
                iKey->AddL( CREATEKEY( EImpsKeyGroup, 0 ) );        // group
                iKey->AddL( CREATEKEY( EImpsKeyScreenName, 0 ) );   // ScreenName //gr
                sName.Set( DescriptorElementL( EImpsKeySName, 0 ) );
                groupName.Set( DescriptorElementL( EImpsKeyGroupID, 0 ) );
                }
	        TRAP( err, invite->HandleGroupInviteL( inviteID, userID, sName, groupName,
                                    reason, validity, 
	                                    *iClient.CspIdentifier() ) );  
        }
            else if ( inviteType == EImpsIM )
                {
                invite->HandleImInviteL( inviteID, userID, reason, 
                                         validity, *iClient.CspIdentifier());
                }
            else if ( inviteType == EImpsSC )
                {
                CDesCArrayFlat* urlList = new ( ELeave ) CDesCArrayFlat( 4 );
                CleanupStack::PushL( urlList );
                TImpsCDataUtils::GetUrlListL( iDataAccessor, urlList );
                TRAP( err, invite->HandleContentInviteL( inviteID, userID, urlList,
                                          reason, validity, *iClient.CspIdentifier()));
                CleanupStack::PopAndDestroy();
                }
            else
                {
#ifndef _NO_IMPS_LOGGING_
        CImpsClientLogger::Log( _L( "CImpsFundHandler2: ERROR Unknown invite type %d" ), inviteType );
#endif
                User::Leave( KErrCorrupt );
                }
        

        }
    else
        {
        #ifndef _NO_IMPS_LOGGING_
            CImpsClientLogger::Log( _L( "Invite handler not instantiated!" ) );
        #endif
        }
    }

// ----------------------------------------------------------------------------
// CImpsFundHandler2::HandleInviteResponseL
// ----------------------------------------------------------------------------
void CImpsFundHandler2::HandleInviteResponseL()
    {
    #ifndef _NO_IMPS_LOGGING_
        CImpsClientLogger::Log
            ( _L( "CImpsFundHandler2::HandleInviteResponseL()" ) );
    #endif
    MImpsInviteHandler2* invite = iClient.InviteHandler();
    if( invite != NULL )
        {
        TPtrC sName;
        TPtrC groupName;
        const TImpsContent* content = KInviteResponseElements;
        TImpsDataUtils::AddValuesFromArrayL( iKey, content,
                                        sizeof( KInviteResponseElements ) /
                                        sizeof( KInviteResponseElements[0] ) );
        TPtrC inviteID = DescriptorElementL( EImpsKeyInviteID, 0 );
        TBool accept = BooleanElementL( EImpsKeyAcceptance, 0 );
        TPtrC response = DescriptorElementL( EImpsKeyResponseNote, 0 );
        iKey->AddL( CREATEKEY( EImpsKeySender, 0 ) );           // sender
        iKey->AddL( CREATEKEY( EImpsKeyUser, 0 ) );             // user
        TPtrC userID = DescriptorElementL( EImpsKeyUserID, 0 );
        if( userID.Length() == 0 )
            {
            iKey->PopL();                                      //user
            iKey->AddL( CREATEKEY( EImpsKeyGroup, 0 ) );       // group
            iKey->AddL( CREATEKEY( EImpsKeyScreenName, 0 ) );  //screenName
            sName.Set( DescriptorElementL( EImpsKeySName, 0 ) );
            groupName.Set( DescriptorElementL( EImpsKeyGroupID, 0 ) );
            } 
        TInt err( KErrNone );
        TRAP( err, invite->HandleInviteResponseL( inviteID, accept, userID, 
                                       sName, groupName, response, *iClient.CspIdentifier() ));
        }
    else
        {
        #ifndef _NO_IMPS_LOGGING_
            CImpsClientLogger::Log( _L( "Invite handler not instantiated!" ) );
        #endif
        }
    }

// ----------------------------------------------------------------------------
// CImpsFundHandler2::HandleInviteCancelL
// ----------------------------------------------------------------------------
void CImpsFundHandler2::HandleInviteCancelL()
    {
    #ifndef _NO_IMPS_LOGGING_
        CImpsClientLogger::Log
            ( _L( "CImpsFundHandler2::HandleInviteCancelL()" ) );
    #endif
    MImpsInviteHandler2* invite = iClient.InviteHandler();
    if( invite != NULL )
        {
        TPtrC sName;
        TPtrC groupName;
        const TImpsContent* content = KInviteCancelUserRequestElements;
        TImpsDataUtils::AddValuesFromArrayL( iKey, content,
                                sizeof( KInviteCancelUserRequestElements ) /
                                sizeof( KInviteCancelUserRequestElements[0] ) );
        TPtrC inviteID = DescriptorElementL( EImpsKeyInviteID, 0 );
        TPtrC response = DescriptorElementL( EImpsKeyInviteNote, 0 );
        iKey->AddL( CREATEKEY( EImpsKeySender, 0 ) );           // sender 
        iKey->AddL( CREATEKEY( EImpsKeyUser, 0 ) );             // user
        TPtrC userID = DescriptorElementL( EImpsKeyUserID, 0 );
        if( userID.Length() == 0 )
            {
            iKey->PopL();                                      //user
            iKey->AddL( CREATEKEY( EImpsKeyGroup, 0 ) );       //group
            iKey->AddL( CREATEKEY( EImpsKeyScreenName, 0 ) );  //screenName
            sName.Set( DescriptorElementL( EImpsKeyGroupID, 0 ) );
            //screenName, group
            groupName.Set( DescriptorElementL( EImpsKeySName, 0 ) );    
            }
        TInt err( KErrNone );    
        TRAP( err, invite->HandleInviteCancelL( inviteID, userID, sName, 
                                     groupName, response,
                                     *iClient.CspIdentifier() ));  
        }
    else
        {
        #ifndef _NO_IMPS_LOGGING_
            CImpsClientLogger::Log( _L( "Invite handler not instantiated!" ) );
        #endif
        }
    }

// ----------------------------------------------------------------------------
// CImpsFundHandler2::SearchResultsLC
// ----------------------------------------------------------------------------
CPtrC16Array* CImpsFundHandler2::SearchResultsLC( 
                                        TImpsSearchResultType& aResultType )
    {
    #ifndef _NO_IMPS_LOGGING_
        CImpsClientLogger::Log( _L( "   CImpsFundHandler2::SearchResultsLC()" ) );
    #endif
    TBool moreResults = ETrue;
    const TInt KArraySize = 5;
    CPtrC16Array* results = new ( ELeave ) CPtrC16Array( KArraySize );
    CleanupStack::PushL( results );
    iKey->AddL( CREATEKEY( EImpsKeySearchResult, 0 ) );     //*** search result
    iKey->AddL( CREATEKEY( EImpsKeyUserList, 0 ) );         //*** user list
    if( iDataAccessor->CheckBranchExistenceL( iKey ) )
        {
        aResultType = EImpsUserResult;
        for( TInt i = 0;moreResults;i++ )
            {
            iKey->AddL( CREATEKEY( EImpsKeyUser, i ) );     //*** user
            TPtrC userId = DescriptorElementL( EImpsKeyUserID, 0 );
            if( userId.Length() > 0 )
                {
                results->AppendL( userId );
                #ifndef _NO_IMPS_LOGGING_
                    CImpsClientLogger::Log( _L( "        Result no. %d: \"%S\"" ), i, &userId );
                #endif
                }
            else
                {
                moreResults = EFalse;
                }
            iKey->PopL();                                   //user
            }
        iKey->PopL( 2 );                                    //user list, search result
        }
    else
        {
        aResultType = EImpsGroupResult;
        iKey->PopL();                                       //user list
        iKey->AddL( CREATEKEY( EImpsKeyGroupList, 0 ) );    //*** group list
        for( TInt i(0); moreResults; ++i )
            {
            TPtrC groupId = DescriptorElementL( EImpsKeyGroupID, i );
            if( groupId.Length() > 0 )
                {
                results->AppendL( groupId );
                #ifndef _NO_IMPS_LOGGING_
                    CImpsClientLogger::Log( _L( "        Result no. %d: \"%S\"" ), i, &groupId );
                #endif
                }
            else
                {
                moreResults = EFalse;
                }
            }
        iKey->PopL( 2 );                                    //group list, search result
        }
    return results;
    }

// ----------------------------------------------------------------------------
// CImpsFundHandler2::DescriptorElementL
// ----------------------------------------------------------------------------
TPtrC CImpsFundHandler2::DescriptorElementL( const TImpsContent aContent,
                                            const TInt aIndex )
    {
    TDesC* ret = NULL;
    iKey->AddL( CREATEKEY( aContent, aIndex ) );
    iDataAccessor->RestoreDescL( iKey, ret );
    iKey->PopL();
    return ret != NULL ? TPtrC( *ret ) : TPtrC();
    }

// ----------------------------------------------------------------------------
// CImpsFundHandler2::BooleanElementL
// ----------------------------------------------------------------------------
TBool CImpsFundHandler2::BooleanElementL( const TImpsContent aContent,
                                         const TInt aIndex )
    {
    TBool ret;
    iKey->AddL( CREATEKEY( aContent, aIndex ) );
    iDataAccessor->RestoreBooleanL( iKey, ret );
    iKey->PopL();
    return ret;
    }

// ----------------------------------------------------------------------------
// CImpsFundHandler2::IntegerElementL
// ----------------------------------------------------------------------------
TInt CImpsFundHandler2::IntegerElementL( const TImpsContent aContent,
                                        const TInt aIndex )
    {
    TInt ret = 0;
    iKey->AddL( CREATEKEY( aContent, aIndex ) );
    iDataAccessor->RestoreIntegerL( iKey, ret );
    iKey->PopL();
    return ret;
    }

// ----------------------------------------------------------------------------
// CImpsFundHandler2::ConstructL
// ----------------------------------------------------------------------------

void CImpsFundHandler2::ConstructL()
    {
    CImpsHandler2::ConstructL( );
    iDataAccessor = CImpsDataAccessor::NewL( iFields );
    iKey = CImpsKey::NewL();
    }

//  End of File