/*
* Copyright (c) 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:    Simple Engine
*
*/




// INCLUDE FILES

#include <e32std.h>
#include <s32mem.h>

// own simple
#include "msimpleconnection.h"
#include "simplecommon.h"
#include "simpleenginerequest.h"
#include "msimplewinfo.h"
#include "msimplefilterdocument.h"
#include "msimplewinfoobserver.h"
#include "simplewinfowatcher.h"
#include "simplexmlfactory.h"
#include "simplesipconnection.h"
#include "simpleerrors.h"

#ifdef _DEBUG
#include "simpledebugutils.h"
#endif

const TInt KExpandSize = 512;

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

// ----------------------------------------------------------
// CSimpleWinfoWatcher::CSimpleWinfoWatcher
// ----------------------------------------------------------
//
CSimpleWinfoWatcher::CSimpleWinfoWatcher(
    MSimpleConnection& aConn,
    MSimpleWinfoObserver& aObserver )
: CSimpleClient( aConn ),
  iObserver( aObserver ),
  iResCount(0), iComplete( EFalse ),
  iBuffer(NULL)
    {
    }

// ----------------------------------------------------------
// CSimpleWinfoWatcher::~CSimpleWinfoWatcher
// ----------------------------------------------------------
//
CSimpleWinfoWatcher::~CSimpleWinfoWatcher()
    {
#ifdef _DEBUG
    TSimpleLogger::Log(_L("WinfoWatcher: Destructor this=%d" ), (TInt)this );
#endif
    delete iBuffer;
    }

// ----------------------------------------------------------
// CSimpleWinfoWatcher::ConstructL
// ----------------------------------------------------------
//
void CSimpleWinfoWatcher::ConstructL()
    {
    BaseConstructL();
    iBuffer = CBufFlat::NewL(KExpandSize);
    }

// ----------------------------------------------------------
// CSimpleWinfoWatcher::NewL
// ----------------------------------------------------------
//
CSimpleWinfoWatcher* CSimpleWinfoWatcher::NewL(
    MSimpleConnection& aConn,
    MSimpleWinfoObserver& aObserver )
    {
    CSimpleWinfoWatcher* self = new (ELeave) CSimpleWinfoWatcher(
        aConn, aObserver );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
#ifdef _DEBUG
    TSimpleLogger::Log(_L("WinfoWatcher: NewL this=%d"), (TInt)self );
#endif    
    return self;
    }

// ----------------------------------------------------------
// CSimpleWinfoWatcher::Connection
// ----------------------------------------------------------
//
const MSimpleConnection& CSimpleWinfoWatcher::Connection()
    {
    return iConn;
    }

// ----------------------------------------------------------
// CSimpleWinfoWatcher::SIPStatus
// ----------------------------------------------------------
//
TUint CSimpleWinfoWatcher::SIPStatus()
    {
    return DoSIPStatus();
    }

// ----------------------------------------------------------
// CSimpleWinfoWatcher::SIPRetryAfter
// ----------------------------------------------------------
//
TUint CSimpleWinfoWatcher::SIPRetryAfter()
    {
    return DoRetryAfter();
    }

// ----------------------------------------------------------
// CSimpleWinfoWatcher::Close
// ----------------------------------------------------------
//
void CSimpleWinfoWatcher::Close( )
    {
    delete this;
    }

// ----------------------------------------------------------
// CSimpleWinfoWatcher::NewRequestL
// ----------------------------------------------------------
//
void CSimpleWinfoWatcher::NewRequestL( MSimpleEngineRequest& aReq )
    {
    TPtrC8 content = aReq.ResponseData();
    TPtrC8 contType = aReq.ResponseContentType();
    TPtrC8 p8;
    p8.Set( KSimpleWinfoType );
    TInt mySize = p8.Length();

    if ( !contType.Left(mySize).CompareF(KSimpleWinfoType))
        {
        MSimpleWinfo* d = TSimpleXmlFactory::NewWinfoL( content );
        CleanupClosePushL( *d );
#ifdef _DEBUG
        TSimpleLogger::Log(_L("WinfoWatcher: call WinfoNotificationL"));
#endif
        iObserver.WinfoNotificationL( *d );
        CleanupStack::PopAndDestroy( d );
        }
    }

// ----------------------------------------------------------
// CSimpleWinfoWatcher::Complete
// ----------------------------------------------------------
//
void CSimpleWinfoWatcher::Complete(
    TInt aOpId, TInt aStatus, MSimpleEngineRequest& aReq )
    {
#ifdef _DEBUG
    TSimpleLogger::Log(_L("WinfoWatcher: Complete opid=%d, status=%d" ),
                       aOpId, aStatus );
#endif

    TBool completeNow( EFalse );
    MSimpleEngineRequest::TSimpleRequest orig = aReq.RequestType();

    if ( orig == MSimpleEngineRequest::EDestroyStart )
        {
        // It's time to delete the request of delayed deletion from both DLLs.
        // Delete immediately from another DLL.
        aReq.ModifyType( MSimpleEngineRequest::EDestroy );
        TRAP_IGNORE( SendReqL( aReq ));
        // Delete from this DLL,
        aReq.Destroy();
        return;
        }

    GetSIPStatus( aOpId );

    // Reset data buffer
    iBuffer->Reset();

    // Set the member to point to stack variable
    TBool destroyed( EFalse );
    iDestroyedPtr = &destroyed;

    MSimpleEngineRequest::TSimpleSIPResponse respMet = aReq.ResponseMethod();

    // Convert KSimpleErrPending to OK when needed
    if ( aStatus == KSimpleErrPending )
        {
        aStatus = KErrNone;
        }

    // Handle SIP notification first
    if ( respMet == MSimpleEngineRequest::ENotify )
        {
        // This is true in notifications. Ignore some responses.
        if ( aStatus == KErrCompletion )
            {
            iResCount++;
            }
        if ( orig != MSimpleEngineRequest::ESubscribeStop )
            {
            TRAP_IGNORE( NewRequestL( aReq ) );
            // Check whether an application has called destructor in callback method.
            // Destructor will handle deletion of all the open requests.
            if ( destroyed )
                {
                return;
                }
            } 
        else if ( iResCount > 1  )
            {
            // Stop request is not completed until ok + Notify(terminated) received.  
            // Error completes the stop reqest without Notification.        
            completeNow = ETrue;
            if ( DoCallReqComplete( aOpId, KErrNone ))
                {
                return;
                }            
            }    
        }
    else
        {
        // SIP Status response or client originated cancellation
        iResCount++;
        if ( aStatus != KErrNone )        
            {
            iResCount++;  
            if ( orig == MSimpleEngineRequest::ESubscribeStop )     
                    {
                    // Any response to stop subscribe is ok.
                    aStatus = KErrNone;
                    }                      
            }
               
        if ( !iComplete && 
              ( orig != MSimpleEngineRequest::ESubscribeStop || 
                orig == MSimpleEngineRequest::ESubscribeStop && iResCount > 1 ) )
            {
            // Stop request is not completed until ok + Notify(terminated) received.  
            // Error completes the stop reqest without Notification.        
            completeNow = ETrue;
            if ( DoCallReqComplete( aOpId, aStatus ))
                {
                return;
                }
            }
        }

    // Delete request when not needed
    if ( iResCount > 1 )
        {
        iRequest = MSimpleEngineRequest::ENone;
        iComplete = EFalse;
        TInt reason = ResponseReason( aReq );
        // Delete corresponding request from another DLL with delay. This decreases
        // the counter of active subscriptions there.
        aReq.ModifyType( MSimpleEngineRequest::EDestroyStart );
        TRAP_IGNORE( SendReqL( aReq ));        
        // call WinfoTerminatedL when needed, i.e. no Stop 
        if ( orig != MSimpleEngineRequest::ESubscribeStop &&
             !completeNow )
            {
#ifdef _DEBUG
            TSimpleLogger::Log(_L("WinfoWatcher: call WinfoTerminatedL opid=%d"),
                aOpId );
#endif
            TRAP_IGNORE( iObserver.WinfoTerminatedL( aOpId, reason ) );
            // Check whether an application has called destructor in callback method.
            // Destructor of CSimpleClient base class will handle deletion of
            // all the open requests.
            if ( destroyed )
                {
                return;
                }
            }
        // delete request from this DLL later.
        }

    iDestroyedPtr = NULL;
    }

// ----------------------------------------------------------
// CSimpleWinfoWatcher::SubscribeWatcherListL
// ----------------------------------------------------------
//
TInt CSimpleWinfoWatcher::SubscribeWatcherListL(
    MSimpleFilterDocument* aFilter )
    {

    if ( iRequest != MSimpleEngineRequest::ENone )
        {
#ifdef _DEBUG
        TSimpleLogger::Log(_L("winfoWatcher: SubscribeWatcherListL IN-USE **" ) );
#endif
        User::Leave( KErrInUse );
        }

    IncreaseOpId();

#ifdef _DEBUG
    TSimpleLogger::Log(_L("WinfoWatcher: SubscribeWatcherListL opid=%d"),iOpId);
#endif
    CSimpleEngineRequest* req = CSimpleEngineRequest::NewL(
        *this, MSimpleEngineRequest::ESubscribeWinfo, iOpId );
    CleanupStack::PushL( req );

    // handle optional filter document
    if ( aFilter )
        {
        StreamDocumentL( *req, *aFilter );
        }

    SendReqL( *req );
    iRequestList.AddLast( *req );
    CleanupStack::Pop( req );

    iRequest = MSimpleEngineRequest::ESubscribeWinfo;
    iResCount = 0;
    iSubsId = iOpId;

    return iOpId;
    }

// ----------------------------------------------------------
// CSimpleWinfoWatcher::UnsubscribeL
// ----------------------------------------------------------
//
TInt CSimpleWinfoWatcher::UnsubscribeL( )
    {

#ifdef _DEBUG
    TSimpleLogger::Log(_L("WinfoWatcher: UnsubscribeL opid=%d" ), iSubsId);
#endif
    // use the old opid and request
    CSimpleEngineRequest* req = SearchRequests( iSubsId );
    if ( !req )
        {
        User::Leave( KErrNotFound );
        }
    req->ModifyType( MSimpleEngineRequest::ESubscribeStop );

    SendReqL( *req );

    iRequest = MSimpleEngineRequest::ESubscribeStop;
    iComplete = EFalse;
    iResCount = 0;

    return iOpId;
    }

// ----------------------------------------------------------
// CSimpleWinfoWatcher::StreamDocumentL
// ----------------------------------------------------------
//
void CSimpleWinfoWatcher::StreamDocumentL(
    CSimpleEngineRequest& aReq,
    MSimpleFilterDocument& aFilter )
    {
    // add request data
    // externalize the document a stream
    iBuffer->Reset();
    RBufWriteStream stream( *iBuffer );
    stream.Open( *iBuffer );
    aFilter.ExternalizeL( stream );
    stream.Close();
    aReq.SetRequestData( iBuffer->Ptr(0) );
    }
    
// ----------------------------------------------------------
// CSimpleWinfoWatcher::DoCallReqComplete
// ----------------------------------------------------------
//
TInt CSimpleWinfoWatcher::DoCallReqComplete(
    TInt aOpId, TInt aStatus )
    {
    // Set the member to point to stack variable
    TBool destroyed( EFalse );
    iDestroyedPtr = &destroyed;
        
    iComplete = ETrue;    
#ifdef _DEBUG
    TSimpleLogger::Log(_L("WinfoWatcher: call WinfoReqCompleteL opid=%d status=%d"),
        aOpId, aStatus);
#endif
    TRAP_IGNORE( iObserver.WinfoReqCompleteL( aOpId, aStatus ));
    // Check whether an application has called destructor in callback method.
    // Destructor will handle deletion of all the open requests.
    if ( destroyed )
        {
        return KErrGeneral;
        }
    return KErrNone; 
    }