/*
* Copyright (c) 2004 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:  Implementation.
*
*/

#include <sip.h>
#include <siperr.h>
#include <sipconnection.h>
#include <sipheaderbase.h>
#include <sipcseqheader.h>
#include <sipextensionheader.h>
#include <sipresponseelements.h>
#include <sipservertransaction.h>
#include <sipmanagedprofileregistry.h>
#include <sipprofileregistry.h>

#include <sipheaderlookup.h>

#include "TesterConstants.h"
#include "tcuid.h"
#include "TcLog.h"
#include "CTcFileHandler.h"
#include "ErrorHandling.h"

#include "CTcSIPProfileContainer.h"
#include "CTcSIPConnectionContainer.h"
#include "CTcSIPHttpDigestContainer.h"
#include "CTcSIPClientDiscoveryContainer.h"
#include "CTcSIPContext.h"
#include "SIPConstants.h"
#include "TTcSIPCommandBase.h"
#include "TTcSIPReceived.h"
#include "CTTcSIPFactory.h"
#include "CTcSIPIMSAuthenticator.h"
#include <sipclientresolverconfigcrkeys.h>

#include "CommandIndex.h"

CTcSIPContext* CTcSIPContext::NewLC( CTcCTRLCodec& aCodec,
									 TInt aIAPId,
                                     TBool aIsMandatory )
	{
	CTcSIPContext* self = new( ELeave ) CTcSIPContext( aCodec );

	CleanupStack::PushL( self );
	self->ConstructL( aIAPId, aIsMandatory );

	return self;
	}

CTcSIPContext::~CTcSIPContext()
	{
	TcLog::Write( _L8("CTcSIPContext::~CTcSIPContext() start\n") );
	
	iSipClientSimulator.Close();
	
	delete iFileHandler;
	
	delete iIMSAuthenticator;
	
	iFreezer->Remove( iTimerEntry );
	delete iFreezer;
	
	// Must be deleted before deleting transactions (in registry)
	delete iSipConnection;

    // We have to delete SIP Profiles before deleting
	// ManagedProfileRegistry instance.
	iRegistry.DestroyAll();

    delete iSipClientDiscovery;
    delete iSipHttpDigest;
    delete iSipProfile;
	SIPHeaderLookup::Close();
	delete iSip;
	delete iIapManager;
	delete iCenRep;
	TcLog::Write( _L8("CTcSIPContext::~CTcSIPContext() end\n") );
	}

CTcSIPContext::CTcSIPContext( CTcCTRLCodec& aCodec )
	: CTcContextBase( aCodec ), iIsMandatory( EFalse ), iSipClientDiscovery( 0 )
	{
	}

void CTcSIPContext::ConstructL( TInt aIAPId, TBool aIsMandatory )
	{
    iIAPId = aIAPId;
    iIsMandatory  = aIsMandatory;

	TcLog::Write( _L8("CTcSIPContext::ConstructL() start\n") );
	iIapManager = CTcIAPManager::NewL();
	
	iFileHandler = CTcFileHandler::NewL();

    iFreezer = CDeltaTimer::NewL( CActive::EPriorityStandard );
    
    if ( !iIsMandatory )
        {
	    TcLog::Write( _L8("CTcSIPContext::ConstructL() initializing SIP client\n") );
	    iSip = CSIP::NewL( TUid::Uid( TCUID ), *this );
	    iSipConnection = CTcSIPConnectionContainer::NewL( *this, IAPNameL( aIAPId ) );
	    SIPHeaderLookup::OpenL();

	    TcLog::Write( _L8("CTcSIPContext::ConstructL() initializing SIP Profiles client\n") );
        iSipProfile = CTcSIPProfileContainer::NewL( *this, *iSip );
        
        TcLog::Write( _L8("CTcSIPContext::ConstructL() initializing SIP Http Digest\n") );
        iSipHttpDigest = CTcSIPHttpDigestContainer::NewL( *this, *iSip );
        }

    User::LeaveIfError( iSipClientSimulator.Connect() );
    
    iCenRep = CRepository::NewL( KCRUidSIPClientResolverConfig );

	TcLog::Write( _L8("CTcSIPContext::ConstructL() end\n") );
	}

// -- CTcContextBase functions ------------------------------------------------

TTcCommandBase* CTcSIPContext::CreateCommandL( TTcIdentifier& aId,
											   MTcTestContext& aContext )
	{
	// Use base class to actually create commands. Just provide the command
	// array and its size.
	return CTcContextBase::CreateCommandL( KTcSIPCommands,
										   sizeof( KTcSIPCommands ),
										   aId, aContext );
	}

// -- MSIPObserver functions --------------------------------------------------

// Note that adding an object by-reference to the registry does NOT transfer
// ownership. Adding by-pointer does transfer ownership, however.
// Most/all SIP objects should be in the registry at this stage anyway,
// just make sure that's the case.

void CTcSIPContext::IncomingRequest( TUint32 aIapId,
									 CSIPServerTransaction* aTransaction )
	{
	TRAPD( err, {
		iRegistry.AddObjectL( aTransaction );
		TTcSIPReceived received;
		received.Set( aIapId );
		received.Set( aTransaction );
		iSipConnection->QueueReceivedL( received );
		} )
	__ASSERT_ALWAYS( !err, Panic( KSIPErrOOMInNotifier ) );
	}

void CTcSIPContext::TimedOut( CSIPServerTransaction& aSIPServerTransaction )
	{
	TRAPD( err, {
		iRegistry.AddObjectL( aSIPServerTransaction );
		TTcSIPReceived received;
		received.Set( &aSIPServerTransaction );
		received.SetError( KErrTimedOut );
		iSipConnection->QueueReceivedL( received );
		} )
	__ASSERT_ALWAYS( !err, Panic( KSIPErrOOMInNotifier ) );
	}

//
// -- Internal utility functions ----------------------------------------------
//
TBool CTcSIPContext::GetMandatoryValue( void ) const
    {
    return iIsMandatory;
    }

void CTcSIPContext::CreateSipStack( void )
    {
    TcLog::Write( _L8("CTcSIPContext::ConstructL() initializing SIP client\n") );
    iSip = CSIP::NewL( TUid::Uid( TCUID ), *this );
    iSipConnection = CTcSIPConnectionContainer::NewL( *this, IAPNameL( iIAPId ) );
    SIPHeaderLookup::OpenL();

    TcLog::Write( _L8("CTcSIPContext::ConstructL() initializing SIP Profiles client\n") );
    iSipProfile = CTcSIPProfileContainer::NewL( *this, *iSip );
    
    TcLog::Write( _L8("CTcSIPContext::ConstructL() initializing SIP Http Digest\n") );
    iSipHttpDigest = CTcSIPHttpDigestContainer::NewL( *this, *iSip );
    }

CTcSIPConnectionContainer* CTcSIPContext::CreateSipStack( const TDesC8& aName )
    {
    TcLog::Write( _L8("CTcSIPContext::ConstructL() initializing SIP client\n") );
    iSip = CSIP::NewL( TUid::Uid( TCUID ), *this );
    iSipConnection = CTcSIPConnectionContainer::NewL( *this, aName);
    SIPHeaderLookup::OpenL();

    TcLog::Write( _L8("CTcSIPContext::ConstructL() initializing SIP Profiles client\n") );
    iSipProfile = CTcSIPProfileContainer::NewL( *this, *iSip );
    
    TcLog::Write( _L8("CTcSIPContext::ConstructL() initializing SIP Http Digest\n") );
    iSipHttpDigest = CTcSIPHttpDigestContainer::NewL( *this, *iSip );
    
	return iSipConnection;
    }

CTcSIPHttpDigestContainer& CTcSIPContext::DigestContainerL()
    {
    __ASSERT_ALWAYS( iSipHttpDigest, User::Leave( KErrNotFound ) );
    return *iSipHttpDigest;
    }
    
void CTcSIPContext::RemoveDigestContainer()
    {
    delete iSipHttpDigest;
    iSipHttpDigest = NULL;
    }
    
void CTcSIPContext::CreateClientDiscoveryL( TUid aUid )
    {
    __ASSERT_ALWAYS( !iSipClientDiscovery, User::Leave( KErrAlreadyExists ) );
    #ifdef RD_SIP_TESTER
        iSipClientDiscovery = CTcSIPClientDiscoveryContainer::NewL( *this, aUid );
    #else
        aUid.iUid; // Avoid compiler warning
    #endif // RD_SIP_TESTER
    }
		
void CTcSIPContext::RemoveClientDiscovery()
    {
    #ifdef RD_SIP_TESTER
        delete iSipClientDiscovery;
        iSipClientDiscovery = 0;
    #endif // RD_SIP_TESTER
    }
		
CTcSIPClientDiscoveryContainer& CTcSIPContext::ClientDiscoveryL()
    {
    __ASSERT_ALWAYS( iSipClientDiscovery, User::Leave( KErrNotFound ) );
    return *iSipClientDiscovery;
    }
    
void CTcSIPContext::IssueFreezeL( TInt aFreezeTimeSeconds )
    {
    if ( iFreezer->IsActive() )
        {
        User::Leave( KErrInUse );
        }
        
    iFreezeTimeSeconds = aFreezeTimeSeconds;
    TCallBack callback( Freeze, &iFreezeTimeSeconds );
    iTimerEntry.Set( callback );
    iFreezer->Queue( KFreezeAfterTimer * KSecondAsMicros, iTimerEntry );
    }
    
TInt CTcSIPContext::Freeze( TAny* aAny )
    {
    TInt freezeTime = *static_cast< TInt* >( aAny );
    User::After( freezeTime * KSecondAsMicros );
    return KErrNone;
    }
    
CTcSIPIMSAuthenticationParams& CTcSIPContext::AuthenticateL( const TDesC8& aNonce )
    {
    if ( !iIMSAuthenticator )
        {
        iIMSAuthenticator = CTcSIPIMSAuthenticator::NewL();
        }
    return iIMSAuthenticator->AuthenticateL( aNonce );
    }

const TDesC8& CTcSIPContext::SIPErrorToText( TInt aError )
	{
	switch( aError )
		{
		case KErrSIPMalformedMessage:
			{
			return KSIPMalformedMessageErrMsg;
			}
		case KErrSIPInvalidRegistrarResponse:
			{
			return KSIPRegistrarRespondedWithDifferentAORErrMsg;
			}
		case KErrSIPRequestPending:
			{
			return KSIPRequestPendingErrMsg;
			}
		case KErrSIPInvalidTransactionState:
			{
			return KSIPInvalidTransactionStateErrMsg;
			}
		case KErrSIPInvalidDialogState:
			{
			return KSIPInvalidDialogStateErrMsg;
			}
		case KErrSIPInvalidDialogResponse:
			{
			return KSIPInvalidResponseInDialogsErrMsg;
			}
		case KErrSIPInvalidDialogRequest:
			{
			return KSIPInvalidRequestInDialogsErrMsg;
			}
		case KErrSIPTransportFailure:
			{
			return KSIPTransportFailureErrMsg;
			}
		case KErrSIPNoAckReceived:
			{
			return KSIPNoAckReceivedErrMsg;
			}
		case KErrSIPInvalidRegistrationState:
			{
			return KSIPInvalidRegistrationStateErrMsg;
			}
		case KErrSIPInvalidContact:
			{
			return KSIPInvalidContactErrMsg;
			}
		case KErrSIPResourceNotAvailable:
			{
			return KSIPResourceNotAvailableErrMsg;
			}
		case KErrSIPResolvingFailure:
			{
			return KSIPResolvingFailureErrMsg;
			}
		case KErrSIPForbidden:
			{
			return KSIPForbiddenErrMsg;
			}
		case KErrSIPMaxCompartmentsInUse:
			{
			return KSIPMaxCompartmentsInUseErrMsg;
			}
		case KErrSIPTerminatedWithResponse:
			{
			return KSIPTerminatedWithResponseErrMsg;
			}
		case KErrSIPOutboundProxyNotResponding:
			{
			return KSIPOutboundProxyNotRespondingErrMsg;
			}
		case KSIPErrInviteCanceled:
		    {
		    return KSIPInviteCanceledErrMsg;
		    }
		default:
			{
			return KSIPUnrecognizedErrMsg;
			}
		}
	}

RSipClientSimulator& CTcSIPContext::SipClientSimulator()
    {
    return iSipClientSimulator;
    }

CRepository& CTcSIPContext::Repository()
    {
    return *iCenRep;
    }