/** @file
* Copyright (c) 2005-2006 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:  CUpnpServiceImplementation
*
*/



// INCLUDE FILES
#include <e32def.h>
#include <e32math.h>
#include <f32file.h>
#include <s32file.h>
#include "upnpserviceimplementation.h"
#include "upnphttpmessage.h"
#include "upnpsoapmessage.h"
#include "upnpsoapmessagefactory.h"
#include "upnpgenamessage.h"
#include "upnpgenamessagefactory.h"
#include "upnpstring.h"
#include "upnpcommonupnplits.h"
#include "upnphttpmessagefactory.h"
#include "upnpdevice.h"
#include "upnpdeviceimplementationbase.h"
#include "upnpcommonstructs.h"
#include "upnplist.h"
#include "upnpfileutils.h"
#include "upnpdispatcher.h"
#include "upnpcontenthandlerscontroller.h"
#include "upnpeventcontroller.h"
#include "upnpsoapparser.h"

#define KLogFile _L("UPnPStack.txt")
#include "upnpcustomlog.h"

// -----------------------------------------------------------------------------
// CUpnpService::SetDispatcher
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpServiceImplementation::SetDispatcher( CUpnpDispatcher* aDispatcher )
    {
    if(iDispatcher)
        {
        iDispatcher->RemoveCustomer(*this, EFalse);
        }

    iDispatcher = aDispatcher;
    }

// -----------------------------------------------------------------------------
// CUpnpService::SendL
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpServiceImplementation::SendL( CUpnpHttpMessage *aMessage )
    {
    if ( iDispatcher )
        {
        iDispatcher->SendMessageL( aMessage, *this );
        }
    }

// -----------------------------------------------------------------------------
// CUpnpService::Path
// -----------------------------------------------------------------------------
//
EXPORT_C const TDesC8& CUpnpServiceImplementation::Path()
    {
    return *iPath;
    }

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

// -----------------------------------------------------------------------------
// CUpnpServiceImplementation::CUpnpServiceImplementation
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
EXPORT_C CUpnpServiceImplementation::CUpnpServiceImplementation( CUpnpDevice& aDevice )
: CUpnpService(aDevice)
    {
    }

// -----------------------------------------------------------------------------
// CUpnpServiceImplementation::~CUpnpServiceImplementation
// Destructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CUpnpServiceImplementation::~CUpnpServiceImplementation()
    {
    DeviceImpl().DetachService( this );
    iEventedVariables.Reset();
    delete iEventController;
    delete iSaxController;
    delete iSoapParser;
    }

// -----------------------------------------------------------------------------
// CUpnpServiceImplementation::BaseConstructL
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpServiceImplementation::BaseConstructL( const TDesC& aFileName,
        const TDesC8& aServiceType )
    {
    //subscriber library initialization
    LOGS("CUpnpServiceImplementation::BaseConstructL");

    HBufC8* descr = UpnpFileUtil::ReadFileL( aFileName );
    CleanupStack::PushL(descr);
    // File ready

    this->ConstructL( *descr, aServiceType );

    CleanupStack::PopAndDestroy(descr);

    iEventController = CUpnpEventController::NewL( *this );

    // from device
    DeviceImpl().AttachServiceL( this );
    iComplete = ETrue;
    iDispatcher->AddCustomerL( *this, EFalse );

    iSaxController = CUpnpContentHandlersController::NewL();
    iSoapParser = new (ELeave) TUpnpSoapParser( *iSaxController );
    }

// -----------------------------------------------------------------------------
// CUpnpServiceImplementation::MessageReceivedLD
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpServiceImplementation::MessageReceivedLD( CUpnpHttpMessage* aMessage )
    {
    LOGS("CUpnpServiceImplementation::MessageReceivedL(CUpnpHttpMessage*)");

    if ( !aMessage )
        {
        return;
        }

    CleanupStack::PushL( aMessage );
    if ( aMessage->IsSoap() )
        {
        // checking content type of action. Checking that content type exists.
        TPtrC8 tempHeaderValue = aMessage->GetHeaderValue( UpnpGENA::KContentType() );
        TPtrC8 headerValue;
        TInt posOfSemicolon = tempHeaderValue.Find( UpnpString::KSemiColon() );

        // checking if content type contains semicolon
        if ( posOfSemicolon != KErrNotFound )
            {
            tempHeaderValue.Set( tempHeaderValue.Left( posOfSemicolon ) );
            TPtrC8 trimmed( UpnpString::Trim( tempHeaderValue, EFalse ) );
            headerValue.Set( trimmed );
            }
        else
            {
            headerValue.Set( tempHeaderValue );
            }

        if ( headerValue.CompareC( UpnpGENA::KDefaultContentType ) != 0 )
            {
            // content type of action is not text/xml. Invalid action.
            CUpnpHttpMessage* messageOut
            = RUpnpHttpMessageFactory::HttpResponseErrorL(aMessage,
                    EHttpUnsupportedMediaType
            );
            CleanupStack::PushL( messageOut );
            SendL( messageOut );
            CleanupStack::PopAndDestroy( messageOut );
            CleanupStack::PopAndDestroy( aMessage );
            return;
            }

        TRAPD( err, HandleActionL( reinterpret_cast<CUpnpSoapMessage*>( aMessage ) ) );
        if ( err )
            {
            SendL( reinterpret_cast<CUpnpSoapMessage*>( aMessage ),
                    MapGenericErrorToUpnp( err ) );
            }
        }
    else if ( aMessage->IsGena() )
        {
        TRAPD( err, HandleActionL( reinterpret_cast<CUpnpGenaMessage*>( aMessage ) ) );
        if ( err )
            {
            // send proper errormessage
            CUpnpHttpMessage* messageOut
            = RUpnpHttpMessageFactory::UpnpResponseErrorL(aMessage,
                    EActionFailed
            );
            CleanupStack::PushL( messageOut );
            SendL( messageOut );
            CleanupStack::PopAndDestroy( messageOut );
            }
        }
    else
        {
        //should never happen        
        LOGS1( "CUpnpServiceImplementation::MessageReceivedLD msg type %d", aMessage->Type() );
        ASSERT( EFalse );       
        }
    CleanupStack::PopAndDestroy( aMessage );
    }

// -----------------------------------------------------------------------------
// CUpnpServiceImplementation::MapGenericErrorToUpnp
// -----------------------------------------------------------------------------
//
TUpnpErrorCode CUpnpServiceImplementation::MapGenericErrorToUpnp( TInt aError )
    {
    if ( aError == KErrArgument )
        {
        return EInvalidArgs;
        }
    else
        {
        return EActionFailed;
        }
    }

// -----------------------------------------------------------------------------
// CUpnpServiceImplementation::HandleActionL
// -----------------------------------------------------------------------------
//
void CUpnpServiceImplementation::HandleActionL(CUpnpGenaMessage* aMessage)
    {
    LOGS("CUpnpServiceImplementation::HandleActionL(CUpnpGenaMessage*)");

    if ( !aMessage )
        {
        return;
        }

    TPtrC8 method = aMessage->Method();

    if (method.Compare(UpnpGENA::KGenaSubscribe) == 0)
        {
        // Subscription or renewing:
        iEventController->SubscribeL( aMessage );
        }
    else if (method.Compare(UpnpGENA::KGenaUnSubscribe) == 0)
        {
        // UnSubscription:
        iEventController->UnSubscribeL( aMessage );
        }
    }

// -----------------------------------------------------------------------------
// CUpnpServiceImplementation::HandleActionL
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CUpnpServiceImplementation::HandleActionL( CUpnpSoapMessage* aMessage )
    {
    LOGS("CUpnpServiceImplementation::HandleActionL(CUpnpSoapMessage*)");
    if ( !aMessage )
        {
        return;
        }

    // parse SOAP to CUpnpAction
    CUpnpAction* action = CreateActionLC( aMessage->ActionName() );

    if ( !action )
        {
        // send errormessage
        SendL( aMessage, EInvalidAction );
        }
    else
        {
        iSoapParser->UpdateActionWithRequestL( aMessage, action );
        TInt actionError( action->Error() );
        if ( ( EUpnpOk == actionError ) || ( EHttp200Ok == actionError ) )
            {
            CleanupStack::Pop( action );
            // a valid action received
            ActionReceivedLD( action );
            }
        else
            {
            TUpnpErrorCode upnpError;
            // error
            if ( actionError < 0 ) //is generic symbian error

                {
                upnpError = MapGenericErrorToUpnp( actionError );
                }
            else
                {
                upnpError = (TUpnpErrorCode) actionError;
                }
            SendL( aMessage, upnpError );
            CleanupStack::PopAndDestroy( action );
            }
        }
    }

// -----------------------------------------------------------------------------
// CUpnpServiceImplementation::SendL
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpServiceImplementation::SendL( CUpnpAction* aAction,
        TUpnpErrorCode aError)
    {
    LOGS1("CUpnpServiceImplementation::SendL(CUpnpAction*, TUpnpErrorCode: %d)", aError);

    CUpnpHttpMessage* msg( NULL );
    if ( EHttpOk == aError )
        {
        msg = reinterpret_cast<CUpnpHttpMessage*>
        (RUpnpSoapMessageFactory::SoapResponseL( aAction ));
        }
    else
        {
        LOGS1("Error: %i", aError);
        msg = reinterpret_cast<CUpnpHttpMessage*>
        (RUpnpSoapMessageFactory::SoapResponseL( aAction, aError ));
        }
    CleanupStack::PushL( msg );
    SendL( msg );
    CleanupStack::PopAndDestroy( msg );
    }

// -----------------------------------------------------------------------------
// CUpnpServiceImplementation::SendL
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpServiceImplementation::SendL(CUpnpSoapMessage* aMessage,
        TUpnpErrorCode aError)
    {
    LOGS1("CUpnpServiceImplementation::SendL(CUpnpSoapMessage*, TUpnpErrorCode: %d)", aError);

    CUpnpHttpMessage* msg = reinterpret_cast<CUpnpHttpMessage*>(
            RUpnpSoapMessageFactory::SoapResponseL(aMessage, aError));
    CleanupStack::PushL(msg);
    SendL(msg);
    CleanupStack::PopAndDestroy(msg);
    }

// -----------------------------------------------------------------------------
// CUpnpServiceImplementation::SetStateVariableL
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpServiceImplementation::SetStateVariableL( const TDesC8& aName,
        const TDesC8& aValue,
        TBool aIsModerated )
    {
    LOGS("CUpnpServiceImplementation::SetStateVariableL");
    TInt totalDesLength(0);
    totalDesLength = KGenaXml().Length() + KGenaPropertysetStart().Length()+
    KGenaPropertysetEnd().Length();
    for ( TInt i(0);i<iStateVariables.Count();i++ )
        {
        if ( iStateVariables[i]->Eventable().CompareF(KYes) == 0 )
            {
            totalDesLength+=KGenaPropertyStart().Length();
            totalDesLength+=iStateVariables[i]->Name().Length();
            totalDesLength+=KCloseBracket().Length();
            if ( aName.Compare( iStateVariables[i]->Name() ) == 0 )
                {
                totalDesLength+=aValue.Length();
                }
            else
                {
                totalDesLength+=iStateVariables[i]->Value().Length();
                }
            totalDesLength+=KOpenBracket().Length();
            totalDesLength+=( UpnpString::KSlash )().Length();
            totalDesLength+=iStateVariables[i]->Name().Length();
            totalDesLength+=KGenaPropertyEnd().Length();
            }
        }
    if (totalDesLength<KMaxGenaMessageLength)
        {
        CUpnpStateVariable* variable = StateVariable( aName );
        if( !variable )
            {
            User::Leave( KErrBadHandle );
            }

        variable->SetValueL( aValue, aIsModerated );
        }
    else
        {
        iEventController->SendModeratedNotification();
        }
    }
 
// -----------------------------------------------------------------------------
// CUpnpServiceImplementation::StateVariableValue
// -----------------------------------------------------------------------------
//
EXPORT_C const TPtrC8 CUpnpServiceImplementation::StateVariableValue(
        const TDesC8& aVariableName )
    {
    CUpnpStateVariable* variable = StateVariable(aVariableName);
    if (variable)
        {
        return variable->Value();
        }
    return KNullDesC8();
    }

// -----------------------------------------------------------------------------
// CUpnpServiceImplementation::StateVariable
// -----------------------------------------------------------------------------
//
EXPORT_C CUpnpStateVariable* CUpnpServiceImplementation::StateVariable(
        const TDesC8& aVariableName )
    {
    CUpnpStateVariable* variable = NULL;
    variable = CUpnpService::StateVariable(aVariableName);
    if (variable)
        {
        variable->SetParentImplementation(*this);
        }
    return variable;
    }

// -----------------------------------------------------------------------------
// CUpnpServiceImplementation::AddEventVariable
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpServiceImplementation::AddEventVariable
(const CUpnpStateVariable& aVariable,
        TBool aIsModerated )
    {
    LOGS("CUpnpServiceImplementation::AddEventVariable");

    if (iEventedVariables.Find(&aVariable) == KErrNotFound)
        {
        iEventedVariables.Append(&aVariable);
        }
    if (aIsModerated)
        {
        iEventController->SendModeratedNotification();
        }
    else
        {
        iEventController->SendNonModeratedNotification();
        }

    }

// -----------------------------------------------------------------------------
// CUpnpServiceImplementation::SetVariableMaxEventRate
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpServiceImplementation::SetVariableMaxEventRate
(const TDesC8& aVariable, TInt aMaxRate)

    {
    LOGS("CUpnpServiceImplementation::SetVariableMaxEventRate");

    for(TInt i = 0; i < iEventedVariables.Count(); i++)
        {
        if(iEventedVariables[i]->Name().Compare(aVariable)==0)
            {
            iEventedVariables[i]->SetMaxEventRate(aMaxRate, KMaxEventRate);
            }
        }

    }

// -----------------------------------------------------------------------------
// CUpnpServiceImplementation::StateVariableEvented
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpServiceImplementation::StateVariableEvented(
        const TDesC8& /*aVariableName*/)
    {
    }

// -----------------------------------------------------------------------------
// CUpnpServiceImplementation::SubcribersAmount
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CUpnpServiceImplementation::SubcribersAmount()
    {
    return iEventController->SubscribersAmount();
    }

// -----------------------------------------------------------------------------
// CUpnpServiceImplementation::DeviceImpl
// -----------------------------------------------------------------------------
//
CUpnpDeviceImplementationBase& CUpnpServiceImplementation::DeviceImpl()
    {
    return (CUpnpDeviceImplementationBase&) Device();
    }

// -----------------------------------------------------------------------------
// CUpnpServiceImplementation::EventedStateVariables
// -----------------------------------------------------------------------------
//
EXPORT_C RPointerArray<CUpnpStateVariable>&
CUpnpServiceImplementation::EventedStateVariables()
    {
    return iEventedVariables;
    }

//  End of File