/** @file
* Copyright (c) 2008-2008 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:  Encapsulates http client for eventing
*
*/



#include <e32base.h>

#include "upnpsettings.h"
#include "upnpeventcontroller.h"
#include "upnpgenamessagefactory.h"
#include "upnphttpmessagefactory.h"
#include "upnphttpinitialeventtransaction.h"
#include "upnpnonmoderatedeventqueuemanager.h"
#include "upnpmoderatedeventqueuemanager.h"
#include "upnpinitialeventqueuemanager.h"
#include "upnpdeviceimplementationbase.h"
#include "upnpcommonupnplits.h"

#define KLogFile _L("UPnPStack.txt")
#include "upnpcustomlog.h"
  
  
// -----------------------------------------------------------------------------
// CUpnpEventController::CUpnpEventController
// Default C++ constructor
// -----------------------------------------------------------------------------
//  
CUpnpEventController::CUpnpEventController( CUpnpServiceImplementation& aServiceImpl )
    :iServiceImpl( aServiceImpl )
    {
    }

// -----------------------------------------------------------------------------
// CUpnpEventController::CUpnpEventController
// Destructor
// -----------------------------------------------------------------------------
//  
CUpnpEventController::~CUpnpEventController()
    {
    iPendingTransactions.ResetAndDestroy();
    delete iModQueue;
    delete iNonModQueue;
    delete iInitialEventQueue;
    delete iSubscriberLibrary;
    delete iHttpEngine;
    }

// -----------------------------------------------------------------------------
// CUpnpEventController::NewLC
// Two phased constructor
// -----------------------------------------------------------------------------
//  
CUpnpEventController* CUpnpEventController::NewLC( CUpnpServiceImplementation& aServiceImpl )
    {
    CUpnpEventController* self = new (ELeave) CUpnpEventController( aServiceImpl );
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }

// -----------------------------------------------------------------------------
// CUpnpEventController::NewL
// Two phased constructor
// -----------------------------------------------------------------------------
//  
CUpnpEventController* CUpnpEventController::NewL( CUpnpServiceImplementation& aServiceImpl )
    {
    CUpnpEventController* self=CUpnpEventController::NewLC( aServiceImpl );
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CUpnpEventController::ConstructL
// Two phased constructor
// -----------------------------------------------------------------------------
//  
void CUpnpEventController::ConstructL()
    {
    iSubscriberLibrary = CUpnpSubscriberLibrary::NewL( *this );
    iHttpEngine = CUpnpHttpClientEngine::NewL( *this, CUpnpSettings::GetIapL() );
    iNonModQueue = CUpnpNonModeratedEventQueueManager::NewL( iServiceImpl , *this, iSubscriberLibrary );
    iModQueue =  CUpnpModeratedEventQueueManager::NewL(  iServiceImpl , *this, iSubscriberLibrary );
    iInitialEventQueue = CUpnpInitialEventQueueManager::NewL(  iServiceImpl , *this, iSubscriberLibrary );
    }

// -----------------------------------------------------------------------------
// CUpnpEventController::SendInitialNotification
// Sends initial event
// -----------------------------------------------------------------------------
//  
void CUpnpEventController::SendInitialNotification( )
    {
    iInitialEventQueue->SendEvent();
    }

// -----------------------------------------------------------------------------
// CUpnpEventController::SendNonModeratedNotification
// Sends not-moderated events
// -----------------------------------------------------------------------------
//  
void CUpnpEventController::SendNonModeratedNotification( )
    {
    iNonModQueue->SendEvent();
    }

// -----------------------------------------------------------------------------
// CUpnpEventController::SendModeratedNotification
// Sends moderated event
// -----------------------------------------------------------------------------
//  
void CUpnpEventController::SendModeratedNotification(  )
    {
    iModQueue->SendEvent();
    }
    
// -----------------------------------------------------------------------------
// CUpnpEventController::SendTransactionL
// Sends event to subscriber
// -----------------------------------------------------------------------------
//  
void  CUpnpEventController::SendTransactionL( CUpnpHttpTransaction* aTransaction )
    {
    CleanupStack::PushL( aTransaction );
    iPendingTransactions.AppendL( aTransaction );
    CleanupStack::Pop( aTransaction );
    
    iHttpEngine->SendL( *aTransaction );
    }
 
// -----------------------------------------------------------------------------
// CUpnpEventController::SubscribeL
// Proccess subscribe message
// -----------------------------------------------------------------------------
//  
void CUpnpEventController::SubscribeL( CUpnpGenaMessage* aMessage )
    {
    TInt subscribers = iSubscriberLibrary->SubscriberLibrary().Count();
        
    CUpnpSubscriberLibraryElement* subscriber( NULL );
    TUpnpErrorCode subscriptionState 
        = iSubscriberLibrary->AddInfoL( aMessage, &subscriber );

    // Responding:
    if ( subscriber && subscriptionState == EHttpOk )
        {
        // for a new subscriber: SID generation
        if ( subscribers < iSubscriberLibrary->SubscriberLibrary().Count() )
            {
            GenerateSidL( subscriber );
            }
            
        HBufC8* timeout( TimerHeaderLC( subscriber->Timeout() ) );
        
        CUpnpHttpMessage* messageOut = reinterpret_cast<CUpnpHttpMessage*>(
                                    RUpnpGenaMessageFactory::SubscribeResponseL(
                                                    aMessage->SessionId(), 
                                                    aMessage->Sender(), 
                                                    subscriber->Sid(), 
                                                    timeout->Des() )
                                                                            );
        CleanupStack::PopAndDestroy( timeout );                    
        timeout = NULL;
        CleanupStack::PushL( messageOut );

        iServiceImpl.SendL( messageOut );

        CleanupStack::PopAndDestroy( messageOut );
        messageOut = NULL;
        
            
        // for a new subscriber: initial event message
        if ( subscribers < iSubscriberLibrary->SubscriberLibrary().Count() )
            {
            SendInitialNotification( );
            }
        }
    else
        {       
        CUpnpHttpMessage* messageOut = RUpnpHttpMessageFactory::UpnpResponseErrorL( 
                                                                aMessage, 
                                                                subscriptionState 
                                                                                  );
        CleanupStack::PushL( messageOut );
        iServiceImpl.SendL( messageOut );
        CleanupStack::PopAndDestroy( messageOut );
        }       
    }

// -----------------------------------------------------------------------------
// CUpnpEventController::UnSubscribeL
// Proccess unsubscribe message
// -----------------------------------------------------------------------------
//  
void CUpnpEventController::UnSubscribeL( CUpnpGenaMessage* aMessage )
    {
    TUpnpErrorCode subscriptionState( CheckHeaders( aMessage ) );

    if ( subscriptionState == EUndefined )
        {
        subscriptionState = iSubscriberLibrary->Remove( aMessage->Sid() );
        } 
    
    if ( subscriptionState == EHttpOk )
        {
        CUpnpHttpMessage* messageOut = reinterpret_cast<CUpnpHttpMessage*>(
                RUpnpGenaMessageFactory::UnsubscribeResponseL( aMessage->SessionId(), 
                                                               aMessage->Sender() ) 
                                                                           );
        CleanupStack::PushL( messageOut );        
        iServiceImpl.SendL( messageOut );
        CleanupStack::PopAndDestroy( messageOut );   
        }
    else
        {
        CUpnpHttpMessage* messageOut = RUpnpHttpMessageFactory::UpnpResponseErrorL( 
                                                                    aMessage,
                                                                    subscriptionState
                                                                                   );
        CleanupStack::PushL( messageOut );
        iServiceImpl.SendL( messageOut );
        CleanupStack::PopAndDestroy( messageOut );
        }
    } 

// -----------------------------------------------------------------------------
// CUpnpEventController::CancelInvalidSessions
// Cancels not completed transaction 
// -----------------------------------------------------------------------------
// 
void CUpnpEventController::CancelInvalidSessions( const TDesC8& aSid )
    {
    for ( TInt i(0) ; i < iPendingTransactions.Count() ; i++ )
        {
        if ( static_cast<CUpnpGenaMessage*>( iPendingTransactions[i]->Request() )->Sid().Compare( aSid ) == 0 )
            {         
            iHttpEngine->Cancel( *iPendingTransactions[i] );
            }
        }
    }

// -----------------------------------------------------------------------------
// CUpnpEventController::SubscribersAmount
// Returns number of subscribers 
// -----------------------------------------------------------------------------
// 
TInt CUpnpEventController::SubscribersAmount()
    {
    return iSubscriberLibrary->SubscriberLibrary().Count();
    }

// -----------------------------------------------------------------------------
// CUpnpEventController::CheckHeader
// Check if unsubscribe header are comlete 
// -----------------------------------------------------------------------------
// 
TUpnpErrorCode CUpnpEventController::CheckHeaders( CUpnpGenaMessage* aMessage )
    {
    TUpnpErrorCode subscriptionState( EUndefined );

    // Errors: Incompatible headers
    if ( aMessage->Sid().Compare( KNoHeader) != 0 )
        {
        if ( aMessage->Nt().Compare( KNoHeader) != 0 )
            {
            subscriptionState = EBadRequest;
            }
        else if (aMessage->Callback().Compare( KNoHeader ) != 0 )
            {
            subscriptionState = EBadRequest;
            }
        else
            {
            }
        }
    return subscriptionState;
    }

// -----------------------------------------------------------------------------
// CUpnpEventController::GenerateSidL
// Genereated uuid for a subscriber 
// -----------------------------------------------------------------------------
// 
void CUpnpEventController::GenerateSidL( CUpnpSubscriberLibraryElement* aSubscriber )
    {
    HBufC8* uuid = iServiceImpl.DeviceImpl().GenerateUuidL();
    CleanupStack::PushL( uuid );
    aSubscriber->SetSidL( *uuid );
    CleanupStack::PopAndDestroy( uuid );
    LOGS("  new subscriber:");
    }
// -----------------------------------------------------------------------------
// CUpnpEventController::SubscribersAmount
// Returns evented state variables
// -----------------------------------------------------------------------------
//    
RPointerArray<CUpnpStateVariable>& CUpnpEventController::EventedStateVariables()
    {
    return iServiceImpl.EventedStateVariables();
    }
   
// -----------------------------------------------------------------------------
// CUpnpEventController::SubscriberRemoved
// Resumes processing when subscriber  has been removed
// -----------------------------------------------------------------------------
//    
void CUpnpEventController::SubscriberRemoved( CUpnpSubscriberLibraryElement* aSubscriber , TInt aPos )
    {
    CancelInvalidSessions( aSubscriber->Sid() );
    
    iNonModQueue->UpdateQueue( aPos );
    iModQueue->UpdateQueue( aPos );
    }

// -----------------------------------------------------------------------------
// CUpnpEventController::TimerHeaderLC
// Creates timeout header
// -----------------------------------------------------------------------------
//    
HBufC8* CUpnpEventController::TimerHeaderLC( const TDesC8& aTimeout )
    {
    HBufC8* timeout= HBufC8::NewLC( aTimeout.Length() + KTimeoutPrefix().Length() );
    timeout->Des().Zero();
    timeout->Des().Append( KTimeoutPrefix );
    timeout->Des().Append( aTimeout );
    return timeout;
    }
// -----------------------------------------------------------------------------
// CUpnpEventController::ClientResponseRecivedLD
// Handles event response
// -----------------------------------------------------------------------------
//          
void CUpnpEventController::ClientResponseRecivedLD( CUpnpHttpTransaction& aEndedTransaction )
{
    TInt idx( iPendingTransactions.Find( &aEndedTransaction ) );
    ASSERT( idx >= 0 ); //it should never happen that we received transaction that wasn't sent by us
    iPendingTransactions.Remove( idx );
    aEndedTransaction.ProcessResponseL();
    delete ( &aEndedTransaction );
}
//end of file