/*

* Copyright (c) 2002-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:           

*

*/

#include "senhostlettransportplugin.h"

#include <SenServiceConnection.h>   // errorcode constants, like KErrSenNoEndpoint

#include "msenprovider.h"

#include "senhostletrequest.h"      // internal Provider\inc

#include "senhostletresponse.h"     // internal Provider\inc

#include "senidentifier.h"          // internal Utils\inc

#include "senidentifier.h"          // internal Utils\inc

#include "sendebug.h"               // internal Utils\inc - debugging MACROs

#include "senprovider.h"            // internal Framework\inc

#include "sensyncrequester.h"       // internal Framework\inc

#include <SenTransportProperties.h> // internal Framework\inc

#include "senservicesession.h"      // internal Framework\inc

#include "msentransport.h"          // internal Framework\inc

#include "msenremotehostlet.h"      // internal Framework\inc

#include "msencoreservicemanager.h" // internal: Core\inc

#include "senchunk.h"               // Internal Utils\inc

#include "senlogger.h"              // internal Logger\inc - logging MACROs

#include "msenservicesession.h"

#include "msenremoteserviceconsumer.h"

#include "senlayeredtransportproperties.h"

#include "senvtcptransportproperties.h"

#include "SenHttpTransportProperties.h"

namespace

    {

    }

CSenHostletTransportPlugin* CSenHostletTransportPlugin::NewL(CSenTransportContext* apCtx)

    {

    CSenHostletTransportPlugin* pNew = NewLC(apCtx);

    CleanupStack::Pop(pNew);

    return pNew;

    }

CSenHostletTransportPlugin* CSenHostletTransportPlugin::NewLC(CSenTransportContext* apCtx)

    {

    const CSenServiceSession* pSession = apCtx->GetSession();

    if( pSession == NULL ||  pSession->Hostlet() == NULL) 

        {

        User::Leave( KErrSenHostNotAvailable );

        }

    CSenHostletTransportPlugin* pNew = new (ELeave) CSenHostletTransportPlugin(apCtx);

    CleanupStack::PushL(pNew);

    pNew->ConstructL();

    return pNew;

    }

CSenHostletTransportPlugin::CSenHostletTransportPlugin(CSenTransportContext* apCtx)

:   CSenTransport(apCtx),

	ipRequester(NULL),

    iInvokedProvider(NULL),

    iStatusCode(0),

    iTransactionID(0),

//    iConsumerMap(EFalse, ETrue), 

//    iSessionMap(EFalse, EFalse), // iConsumerMap deletes the txnIds (using same "new reserved" TInt here!)

    iRequestMap(EFalse, ETrue), // CSenActiveHostletRequest (keys) objects are NOT owned!

    ipLayeredXmlProperties(NULL)

    {

    }

CSenHostletTransportPlugin::~CSenHostletTransportPlugin()

    {

    TLSLOG_L(KHostletTransportLogChannel, KMinLogLevel, "Log file closed.");

    TLSLOG_CLOSE( KHostletTransportLogChannel );

    TInt count( iRequestMap.Count() );

    for ( TInt i = 0; i < count; i++ )

        {

        CSenActiveHostletRequest* pReq = iRequestMap.KeyAt(i);

        if( pReq )

            {

            pReq->Deque();

            }

        }

    iRequestMap.Reset(); 

    delete ipRequester;

    delete iInvokedProvider;

    delete ipLayeredXmlProperties;

    }

void CSenHostletTransportPlugin::ConstructL()

    {

    // Open connection to the file logger server

    TLSLOG_OPEN(KHostletTransportLogChannel, KHostletTransportLogLevel, KLogDir, KLogFile);

    //LOG_CONNECT;

    // LOG_CREATELOG((KLogDir, KLogFile, EFileLoggingModeOverwrite));

    //TLSLOG_L(KHostletTransportLogChannel, KHostletTransportLogLevel,  "CSenHostletTransportPlugin::ConstructL(): log file opened.");

    MSenCoreServiceManager& core = Context().GetCoreL();

    ipRequester = CSenSyncRequester::NewL(*this, core);

    ipLayeredXmlProperties = CSenLayeredTransportProperties::NewL();    

    }

TInt CSenHostletTransportPlugin::SubmitL(const TDesC8& aEndpoint,

                                       const TDesC8& aMessage,

                                       const TDesC8& aTransportProperties,

                                       HBufC8*& apResponse,

                                       MSenRemoteServiceConsumer& /*aConsumer*/)

    {

    TLSLOG_L(KHostletTransportLogChannel, KMinLogLevel,  "CSenHostletTransportPlugin::SubmitL:");

    // Sanity check the endpoint

    if (aEndpoint.Length() <= 0)

        {

        TLSLOG_L(KHostletTransportLogChannel, KMinLogLevel,  "- No endpoint!");

        return KErrSenNoEndpoint; // from SenServiceConnection.h (public API)

        }

    TLSLOG_FORMAT((KHostletTransportLogChannel, KMinLogLevel, _L8("- Endpoint: %S"), &aEndpoint));

//    TLSLOG_L(KHostletTransportLogChannel, KMinLogLevel,  "- Message:");

//    TLSLOG_ALL((KHostletTransportLogChannel, KHostletTransportLogLevel,  aMessage ));

    TLSLOG_FORMAT((KHostletTransportLogChannel, KMaxLogLevel, _L8("- Message: %S"), &aMessage));

    TInt leaveCode(KErrNone);

    TInt statusCode(KErrNone);

    /*

    statusCode = ipRequester->SubmitL(aEndpoint,            // endpoint

                                      aMessage,             // request body

                                      aTransportProperties, // request props

                                      apResponse);

    */

    TRAP( leaveCode, statusCode = ipRequester->SubmitL(aEndpoint,            // endpoint

                                                       aMessage,             // request body

                                                       aTransportProperties, // request props

                                                       apResponse); )         // response body

    TLSLOG_FORMAT((KHostletTransportLogChannel, KMinLogLevel, _L8("CSenHostletTransportPlugin::SubmitL returned: (%d)"), statusCode));

    if(leaveCode!=KErrNone)

        {

        TLSLOG_FORMAT((KHostletTransportLogChannel, KMinLogLevel, _L8("CSenHostletTransportPlugin::SubmitL leaved: (%d)"), leaveCode));

        if(statusCode==KErrNone)

            {

            statusCode = leaveCode;

            }

        }

    else // did not leave

        {

        if(!apResponse)

            {

            TLSLOG_L(KHostletTransportLogChannel, KMinLogLevel, "After calling CSenHostletTransportPlugin::SubmitL => response==NULL => leaving!");

            User::Leave(KErrCorrupt);

            }

        TLSLOG_L(KHostletTransportLogChannel, KMaxLogLevel,  "CSenHostletTransportPlugin::SubmitL response:");

//        TLSLOG_ALL((KHostletTransportLogChannel, KHostletTransportLogLevel, *apResponse));

        TLSLOG_FORMAT((KHostletTransportLogChannel, KMaxLogLevel, _L8("- Response: %S"), apResponse));

        }

    return statusCode;

    }

/*

TInt CSenHostletTransportPlugin::SendL(const TDesC8& aEndpoint,

                                     const TDesC8& aMessage,

                                     const TDesC8& aTransportProperties,

                                     MSenServiceSession& aReplyTo,

                                     MSenRemoteServiceConsumer& aConsumer, // "addressee", could be CSenIdentifier

                                     TInt& aTxnId)

    {

    TLSLOG_L(KHostletTransportLogChannel, KHostletTransportLogLevel,  "CSenHostletTransportPlugin::SendL:");

    // Sanity check the endpoint

    if (aEndpoint.Length() <= 0)

        {

        TLSLOG_L(KHostletTransportLogChannel, KHostletTransportLogLevel,  "- No endpoint!");

        return KErrSenNoEndpoint; // from SenServiceConnection.h (public API)

        }

    TLSLOG_FORMAT((KHostletTransportLogChannel, KHostletTransportLogLevel, _L8("- Endpoint: %S"), &aEndpoint));

    TLSLOG_L(KHostletTransportLogChannel, KHostletTransportLogLevel,  "- Message:");

//    TLSLOG_ALL((KHostletTransportLogChannel, KHostletTransportLogLevel,  aMessage ));

//    MSenCoreServiceManager& core = Context().GetCoreL();

    //const CSenServiceSession* pSession = Context().GetSession();

    //if( pSession == NULL ||  pSession->Hostlet() == NULL) 

    // NOTE: this solution requires following line in CSenClientSession::SendMsgL:

///    iAllowShowDialogCount++;

///    TInt transactionId( KErrNotFound );

///    pSenChunk->ChunkHeader().SetTransactionId( transactionId ); 

///    TInt sendRetCode(KErrNone);

    if(aReplyTo.Hostlet() == NULL) 

        {

        User::Leave( KErrSenHostNotAvailable );

        }

    CSenChunk* pChunk = NULL;

    TInt retVal = aConsumer.ChunkByTxnIdL(aTxnId, pChunk);

    if ( retVal >= KErrNone )

        {

        iTransactionID++;

        TInt* txnID = new (ELeave) TInt(iTransactionID);

        aTxnId = iTransactionID;

        pChunk->ChunkHeader().SetTransactionId(aTxnId);

        MSenRemoteHostlet* pHostlet = aReplyTo.Hostlet();

        TInt retVal = pHostlet->ProcessRequestFromConsumerL(aMessage, aTxnId, aConsumer);

        TLSLOG_FORMAT((KHostletTransportLogChannel, KHostletTransportLogLevel, _L("- ProcessRequestFromConsumerL returned: %d"), retVal ));

        // No leave occurred

        if( retVal == KErrNone )

            {

            TInt retVal = iSessionMap.Append(&aReplyTo, txnID);

            if( retVal==KErrNone )

                {

                retVal = iConsumerMap.Append(&aConsumer, txnID);

                if(retVal!=KErrNone)

                    {

                    TLSLOG_FORMAT((KHostletTransportLogChannel, KHostletTransportLogLevel, 

                        _L("- iConsumerMap.Append failed: %d"), retVal ));

                    // Last entry to iSessionMap must be removed

                    TInt removeRetVal = iSessionMap.Remove(*txnID);

#ifdef _SENDEBUG

                    if(removeRetVal==KErrNotFound)

                        {

                        TLSLOG_FORMAT((KHostletTransportLogChannel, KHostletTransportLogLevel, 

                            _L("- MAJOR: Could not remove session by txnId(%d)"), *txnID));

                        }

#endif // _SENDEBUG

                    removeRetVal = 0; // not used in release builds

                    }

                }

            else

                {

                TLSLOG_FORMAT((KHostletTransportLogChannel, KHostletTransportLogLevel, _L("- FATAL: iConsumerMap.Append failed: %d"), retVal ));

                }

            }

        }

    return retVal;

    }

*/

/*

RConsumerMap CSenHostletTransportPlugin::ConsumerMap()

    {

    return iConsumerMap;    

    }

RSessionMap CSenHostletTransportPlugin::SessionMap()

    {

    return iSessionMap;

    }

*/

TInt CSenHostletTransportPlugin::SendL(const TDesC8& aEndpoint,

                                     const TDesC8& aMessage,

                                     const TDesC8& /* aTransportProperties */,

                                     MSenServiceSession& aReplyTo,

                                     MSenRemoteServiceConsumer& aConsumer, // "addressee", could be CSenIdentifier

                                     TInt& aTxnId)

    {

    TLSLOG_L(KHostletTransportLogChannel, KMinLogLevel,  "CSenHostletTransportPlugin::SendL:");

    // Sanity check the endpoint

    if (aEndpoint.Length() <= 0)

        {

        TLSLOG_L(KHostletTransportLogChannel, KMinLogLevel,  "- No endpoint!");

        return KErrSenNoEndpoint; // from SenServiceConnection.h (public API)

        }

    if(aReplyTo.Hostlet() == NULL) 

        {

        TLSLOG_L(KHostletTransportLogChannel, KMinLogLevel,  "- Failure: no Hostlet for the session: leave with KErrSenHostNotAvailable");

        return KErrSenHostNotAvailable;

        }

    TLSLOG_FORMAT((KHostletTransportLogChannel, KMinLogLevel, _L8("- Endpoint: %S"), &aEndpoint));

//    TLSLOG_L(KHostletTransportLogChannel, KHostletTransportLogLevel,  "- Message:");

//    TLSLOG_ALL((KHostletTransportLogChannel, KHostletTransportLogLevel, aMessage));

    TLSLOG_FORMAT((KHostletTransportLogChannel, KMinLogLevel, _L8("- Message: %S"), &aMessage));

    iTransactionID++;

    TInt* txnID = new (ELeave) TInt(iTransactionID);

    aTxnId = iTransactionID;

//    MSenCoreServiceManager& core = Context().GetCoreL();

    CSenActiveHostletRequest* pRequest = CSenActiveHostletRequest::NewLC( aEndpoint,

                                                                          //aMessage, 

                                                                          //aTransportProperties,

                                                                          aReplyTo,

                                                                          aConsumer,

                                                                          *txnID,

                                                                          iRequestMap,

                                                                          *this,

                                                                          *ipCtx );

    TInt retVal = iRequestMap.Append(pRequest, txnID);

    if(retVal==KErrNone)

        {

        CleanupStack::Pop(pRequest);

        if(!pRequest->IsActive())

            {

            TLSLOG_L(KHostletTransportLogChannel, KMinLogLevel,  "- Activating request / async call to the provider.");

            pRequest->SetActive();

            }

        pRequest->iStatus = KRequestPending;

        TRequestStatus* status = &pRequest->iStatus;

        User::RequestComplete( status, CSenActiveHostletRequest::EInvokeService ); //iTransactionID );

        TLSLOG_FORMAT((KHostletTransportLogChannel, KNormalLogLevel, _L8("- Request status: %d"), pRequest->iStatus.Int()));

        }

    else

        {

        TLSLOG_FORMAT((KHostletTransportLogChannel, KMinLogLevel, _L("- FATAL: iRequestMap.Append failed: %d"), retVal ));

        CleanupStack::PopAndDestroy(pRequest); // orphanized request

        }

    return retVal; // status code

    }

TInt CSenHostletTransportPlugin::SetPropertiesL(const TDesC8& /* aProperties */,

                                                MSenLayeredProperties::TSenPropertiesLayer /* aTargetLayer */,

												MSenRemoteServiceConsumer* /*aConsumer*/)

    {

    return KErrNotSupported; // not implemented

    }

TInt CSenHostletTransportPlugin::PropertiesL(HBufC8*& /* aProperties */)

    {

    return KErrNotSupported; // not implemented

    }

// ASYNC

TInt CSenHostletTransportPlugin::CompleteTransaction(const TInt aTxnId,

                                                     const TInt aCompletionCode)

    {

    TLSLOG_FORMAT((KHostletTransportLogChannel, KNormalLogLevel, 

        _L("CSenHostletTransportPlugin::CompleteTransaction(%d, %d)"), aTxnId, aCompletionCode));

    TInt index = iRequestMap.FindValue(aTxnId);

    // complete the request (transaction)

    if(index != KErrNotFound)

        {

        // Consumer found

        TLSLOG_FORMAT((KHostletTransportLogChannel, KNormalLogLevel, 

            _L("- Pending transaction at index %d found. Completing it."),

            index));

        CSenActiveHostletRequest* pRequest = iRequestMap.KeyAt(index);

        TRequestStatus status;

        TRequestStatus* pStatus = &status;

        index = pRequest->Complete(pStatus, aCompletionCode);

        TLSLOG_FORMAT((KHostletTransportLogChannel, KNormalLogLevel, _L("- Request.Complete() returned: %d"), index));

        }

#ifdef _SENDEBUG

    else

        {

        TLSLOG_L(KHostletTransportLogChannel, KMinLogLevel,  "- Cannot find pending transaction with given ID.");

        }

#endif

    return index;

    }

TInt CSenHostletTransportPlugin::CancelTransaction( const TInt aTxnId )

    {

    TLSLOG_FORMAT((KHostletTransportLogChannel, KMinLogLevel, _L("CSenHostletTransportPlugin::CancelTransaction(%d)"), aTxnId));

    return CompleteTransaction( aTxnId, KErrSenCancelled );

    }

TPtrC8 CSenHostletTransportPlugin::UriSchemeL()

    {

    return KSenHostletTransportUriScheme();

    }

MSenProperties& CSenHostletTransportPlugin::PropertiesL()

    {

    return *ipLayeredXmlProperties;

    }

// ------------------------------------------------------------------------------- //

CSenActiveHostletRequest* CSenActiveHostletRequest::NewLC(const TDesC8& aEndpoint,

                                          MSenServiceSession& aReplyTo,

                                          MSenRemoteServiceConsumer& aConsumer,

                                          TInt aTxnId,

                                          RLocalRequestMap& aRequestMap,

                                          MSenTransport& aParent,

                                          MSenTransportContext& aParentCtx)

    {

    CSenActiveHostletRequest* pNew = new (ELeave) CSenActiveHostletRequest(aEndpoint, aReplyTo, aConsumer, aTxnId, aRequestMap, aParent, aParentCtx);

    CleanupStack::PushL(pNew);

    pNew->ConstructL();

    return pNew;

    }

CSenActiveHostletRequest::CSenActiveHostletRequest(const TDesC8& aEndpoint,

                                                   MSenServiceSession& aReplyTo,

                                                   MSenRemoteServiceConsumer& aConsumer,

                                                   TInt aTxnId,

                                                   RLocalRequestMap& aRequestMap,

                                                   MSenTransport& aParent,

                                                   MSenTransportContext& aParentContext)

:   CActive(EPriorityStandard),

    iEndpoint(aEndpoint),

    iCompletionCode(KErrNone),

    iReplyTo(aReplyTo),

    iConsumer(aConsumer),

    iTxnId(aTxnId),

    iRequestMap(aRequestMap),

    iParent(aParent),

    iParentContext(aParentContext),

    iMessage(KNullDesC8),

    iProperties(KNullDesC8)

    {

    CActiveScheduler::Add(this);

    }

CSenActiveHostletRequest::~CSenActiveHostletRequest()

    {

    if ( IsActive() )

        {

        Cancel(); // calls CSenActiveHostletRequest::DoCancel()

        }

    else

        {

        RequestMap().Remove(TxnId());

        }

    }

// returns chunk index or an error

CSenChunk* CSenActiveHostletRequest::FindChunkL(const TInt aTxnId, TInt& aRetVal)

    {

    TLSLOG_L(KHostletTransportLogChannel, KMinLogLevel, "CSenActiveHostletRequest::DataFromChunkL");

    CSenChunk* pChunk = NULL;

    // This lookup needs to be performed at every state of this AO,

    //  since the transaction (chunk) might have been removed..

    aRetVal = iConsumer.ChunkByTxnIdL(aTxnId, pChunk);

    TLSLOG_FORMAT((KHostletTransportLogChannel, KNormalLogLevel, _L("- ChunkByTxnIdL() returned: %d"), aRetVal));

    if( aRetVal == KErrNone )

        {

        if ( pChunk )

            {

            iMessage.Set(KNullDesC8);

            iProperties.Set(KNullDesC8);

            TInt error(KErrNone);

            if (pChunk->ChunkHeader().PropertiesType() == MSenProperties::ENotInUse )

                {

                error = pChunk->DescFromChunk(iMessage);

                }

            else

                {

                error = pChunk->DescsFromChunk(iMessage, iProperties);

                }

            if( error )

                {

                aRetVal = error;

                iMessage.Set(KNullDesC8);

                iProperties.Set(KNullDesC8);

                }

            }

        else

            {

            TLSLOG_L(KHostletTransportLogChannel, KMinLogLevel, "- Chunk from consumer == NULL, eventhough getter returned KErrNone(!)");

            // No chunk, eventhough KErrNone was returned, should NEVER happen

            // ==> report "internal error"

            aRetVal = KErrSenInternal; // error code is from SenServiceConnection.h

            }

        }

    return pChunk;        

    }

TInt CSenActiveHostletRequest::RunError(TInt aError)

    {

    TLSLOG_FORMAT((KHostletTransportLogChannel, KMinLogLevel, _L("CSenActiveHostletRequest::RunError(%d)"), aError));

    delete this;

    return KErrNone;

    }

CSenTransportProperties* CSenActiveHostletRequest::NewPropertiesByTypeL( MSenProperties::TSenPropertiesClassType aType, const TDesC8& aPropertiesAsXml )

    {

    TLSLOG_L(KHostletTransportLogChannel, KMinLogLevel, "CSenActiveHostletRequest::NewPropertiesByTypeL - begin");    

    TLSLOG_FORMAT((KHostletTransportLogChannel, KMinLogLevel, _L(" - aProperties: '%S'"), &aPropertiesAsXml ));