/*
* Copyright (c) 2002-2007 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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 of the UmacDot11DisassociationPending class
*
*/

/*
* %version: 22 %
*/

#include "config.h"
#include "UmacDot11DisassociationPending.h"
#include "UmacContextImpl.h"

#ifndef NDEBUG
const TInt8 WlanDot11DisassociationPending::iName[] = "dot11-disassociationpending";

const TUint8 WlanDot11DisassociationPending::iStateName
    [ESTATEMAX][KMaxStateStringLength] = 
    {
        {"EINIT"}, 
        {"ETXDISASSOCIATIONFRAME"}, 
        {"EWAIT4PUSHPACKET"},
        {"ECONTINUEDOT11TRAVERSE"}
    };

const TUint8 WlanDot11DisassociationPending::iEventName
    [EEVENTMAX][KMaxEventStringLength] = 
    {
        {"ESTATEENTRY"}, 
        {"ETXPACKETCOMPLETE"},
        {"ETX_SCHEDULER_FULL"},
        {"EPUSHPACKET"}
    };
#endif 

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

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
WlanDot11DisassociationPending::WlanDot11DisassociationPending() 
    : iState( EINIT )
    {
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
WlanDot11DisassociationPending::~WlanDot11DisassociationPending()
    {
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
void WlanDot11DisassociationPending::Entry( 
    WlanContextImpl& aCtxImpl )
    {
    OsTracePrint( 
        KUmacProtocolState | KUmacAssoc, 
        (TUint8*)("UMAC: WlanDot11DisassociationPending::Entry()"));

    if ( aCtxImpl.WsaCmdActive() )
        {
        // sanity checking code
        OsAssert( (TUint8*)("UMAC: panic"), (TUint8*)(WLAN_FILE), __LINE__ );
        }

    // no need to do event dispatching as this
    // thing is triggered by the user and
    // is executed synchronously as we only do OID completion
    // at the end of reassociation process
    // Additionally we don't execute any asynchronous WHA commands 
    // from here so disassociation protocol does not include multiple 
    // this object entry method executions

    if ( iState == EINIT )
        {
        // this is the start of the the FSM actions
        Fsm( aCtxImpl, ESTATEENTRY );
        }
    else
        {
        // implementation error see comment block above why
#ifndef NDEBUG
        OsTracePrint( KErrorLevel, (TUint8*)("UMAC: state:"));
        OsTracePrint( KErrorLevel, iStateName[iState] );
#endif
        OsAssert( (TUint8*)("UMAC: panic"), (TUint8*)(WLAN_FILE), __LINE__ );
        }        
    }
    
// -----------------------------------------------------------------------------
// completion method called when packet has been sent from the WLAN device
// -----------------------------------------------------------------------------
//
void WlanDot11DisassociationPending::OnPacketSendComplete(
    WlanContextImpl& aCtxImpl, 
    WHA::TStatus aStatus,
    TUint32 aPacketId,
    WHA::TRate aRate,
    TUint32 /*aPacketQueueDelay*/,
    TUint32 /*aMediaDelay*/,
    TUint /*aTotalTxDelay*/,
    TUint8 /*aAckFailures*/,
    WHA::TQueueId aQueueId,
    WHA::TRate aRequestedRate,
    TBool /*aMulticastData*/ )
    {
    OsTracePrint( 
        KUmacAssoc, 
        (TUint8*)("UMAC: WlanDot11DisassociationPending::OnPacketSendComplete"));

    aCtxImpl.OnTxCompleted( aRate, 
        static_cast<TBool>(aStatus == WHA::KSuccess), 
        aQueueId,
        aRequestedRate );

    if ( aPacketId == E802Dot11FrameTypeDisassociation )
        {
        // disassociation tx message has been sent from the WLAN device
        // No matter whether the sending was successful or not we will proceed
        // with our roaming actions

        Fsm( aCtxImpl, ETXPACKETCOMPLETE );
        }
    }
    
#ifndef NDEBUG 
// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
const TInt8* WlanDot11DisassociationPending::GetStateName( TUint8& aLength ) const
    {
    aLength = sizeof( iName );
    return iName;
    }
#endif

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
void WlanDot11DisassociationPending::Exit( WlanContextImpl& /*aCtxImpl*/ )
    {
    OsTracePrint( 
        KUmacProtocolState, 
        (TUint8*)("UMAC: WlanDot11DisassociationPending::Exit()"));

    // we are departing this dot11state to another dot11state (dot11synchronize)
    // we simple reset our local FSM for the next time...
    iState = EINIT;
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
void WlanDot11DisassociationPending::Fsm( 
    WlanContextImpl& aCtxImpl, 
    TEvent aEvent )
    {
#ifndef NDEBUG
    OsTracePrint( 
        KUmacAssoc, 
        (TUint8*)("UMAC: WlanDot11DisassociationPending::Fsm(): event: "));
    OsTracePrint( KUmacAssoc, iEventName[aEvent] );
    OsTracePrint( 
        KUmacAssoc, 
        (TUint8*)("UMAC: WlanDot11DisassociationPending::Fsm(): state: ")); 
    OsTracePrint( KUmacAssoc, iStateName[iState] );
#endif

    switch ( aEvent )
        {
        case ESTATEENTRY:
            OnStateEntryEvent( aCtxImpl );
            break;
        case ETXPACKETCOMPLETE:
            OnTxCompleteEvent( aCtxImpl );
            break;
        case ETX_SCHEDULER_FULL:
            OnTxSchedulerFullEvent( aCtxImpl );
            break;
        case EPUSHPACKET:
            OnPushPacketEvent( aCtxImpl );
            break;
        default:
            OsAssert( (TUint8*)("UMAC: panic"), (TUint8*)(WLAN_FILE), __LINE__ );
        }
    }

// -----------------------------------------------------------------------------
// Handler for state entry event.
// -----------------------------------------------------------------------------
//
void WlanDot11DisassociationPending::OnStateEntryEvent( 
    WlanContextImpl& aCtxImpl )
    {
    OsTracePrint( 
        KUmacAssoc, 
        (TUint8*)("UMAC: WlanDot11DisassociationPending::OnStateEntryEvent()"));

    switch ( iState )
        {
        case EINIT:
            // continue with the state traversal
            ChangeInternalState( aCtxImpl, ETXDISASSOCIATIONFRAME );
            break;
        case ETXDISASSOCIATIONFRAME:
            if ( !TxDisassociate( 
                    aCtxImpl, 
                    E802Dot11ReasonDisAssocStationLeft,
                    ETrue ) )
                {
                // tx of dot11 disassociate frame failed  
                // because packet scheduler was full
                // or because we didn't get a Tx buffer
                // so we enter to a wait state
                Fsm( aCtxImpl, ETX_SCHEDULER_FULL );
                }
            break;
        case EWAIT4PUSHPACKET:
            // nothing to do here than wait 
            break;
        case ECONTINUEDOT11TRAVERSE:
            ContinueDot11StateTraversal( aCtxImpl );                    
            break;
        default:
            // programming error
            OsTracePrint( KErrorLevel, 
                (TUint8*)("UMAC: state: %d"), iState);        
            OsAssert( (TUint8*)("UMAC: panic"), (TUint8*)(WLAN_FILE), __LINE__ );
            break;
        }
    }

// -----------------------------------------------------------------------------
// Handler for tx complete event.
// -----------------------------------------------------------------------------
//
void WlanDot11DisassociationPending::OnTxCompleteEvent( 
    WlanContextImpl& aCtxImpl )
    {
    OsTracePrint( 
        KUmacAssoc, 
        (TUint8*)("UMAC: WlanDot11DisassociationPending::OnTxCompleteEvent()"));

    if ( iState == ETXDISASSOCIATIONFRAME )
        {

        // disassociate frame has been sent
        // continue state traversal
        ChangeInternalState( aCtxImpl, ECONTINUEDOT11TRAVERSE );                        
        }
    else
        {
        // programming error
        OsTracePrint( KErrorLevel, (TUint8*)("UMAC: state: %d"), iState);        
        OsAssert( (TUint8*)("UMAC: panic"), (TUint8*)(WLAN_FILE), __LINE__ );
        }
    }

// -----------------------------------------------------------------------------
// Handler for scheduler full event upon trying to tx dot11 disassociate frame
// -----------------------------------------------------------------------------
//
void WlanDot11DisassociationPending::OnTxSchedulerFullEvent( 
    WlanContextImpl& aCtxImpl )
    {
    // change state
    OsTracePrint( KWarningLevel | KUmacAssoc, (TUint8*)
        ("UMAC: WlanDot11DisassociationPending::OnTxSchedulerFullEvent:packet scheduler full during disassociation process") );

    ChangeInternalState( aCtxImpl, EWAIT4PUSHPACKET );
    }

// -----------------------------------------------------------------------------
// Handler for push packet to packet scheduler possible event
// -----------------------------------------------------------------------------
//
void WlanDot11DisassociationPending::OnPushPacketEvent( 
    WlanContextImpl& aCtxImpl )
    {
    if ( iState == EWAIT4PUSHPACKET )
        {
        ChangeInternalState( aCtxImpl, ETXDISASSOCIATIONFRAME );
        }
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
void WlanDot11DisassociationPending::ContinueDot11StateTraversal( 
    WlanContextImpl& aCtxImpl )
    {
    OsTracePrint( 
        KUmacAssoc, 
        (TUint8*)
        ("UMAC: WlanDot11DisassociationPending::ContinueDot11StateTraversal()"));
        
    // proceed to synchronize state...
    ChangeState( aCtxImpl, 
        *this,                              // prev state
        aCtxImpl.iStates.iSynchronizeState  // next state
        );
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
void WlanDot11DisassociationPending::ChangeInternalState( 
    WlanContextImpl& aCtxImpl, 
    TState aNewState )
    {
#ifndef NDEBUG
    OsTracePrint( 
        KUmacDetails, 
        (TUint8*)
        ("UMAC: WlanDot11DisassociationPending::ChangeInternalState(): old state:"));
    OsTracePrint( KUmacAssoc, iStateName[iState] );
    OsTracePrint( 
        KUmacDetails, 
        (TUint8*)
        ("UMAC: WlanDot11DisassociationPending::ChangeInternalState(): new state:"));
    OsTracePrint( KUmacAssoc, iStateName[aNewState] );
#endif

    iState = aNewState;
    Fsm( aCtxImpl, ESTATEENTRY );
    }

// -----------------------------------------------------------------------------
// packet sceduler notification that a packet push is guaranteed to succeed 
// -----------------------------------------------------------------------------
//
void WlanDot11DisassociationPending::OnPacketPushPossible( 
    WlanContextImpl& aCtxImpl )
    {
    // feed a critter to the fsm
    Fsm( aCtxImpl, EPUSHPACKET );
    }