// Copyright (c) 2010 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 "Symbian Foundation License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//

#include <bluetooth/logger.h>

#include "encryptionkeyrefreshhelper.h"
#include "hcifacade.h"
#include "linkmgr.h"

#ifdef __FLOG_ACTIVE
_LIT8(KLogComponent, LOG_COMPONENT_LINKMGR);
#endif

CEncryptionKeyRefresher::CEncryptionKeyRefresher(CPhysicalLinksManager& aLinkMgr, CPhysicalLink& aLink)
	: CPhysicalLinkHelper(aLinkMgr, aLink)
	{
	LOG_FUNC
	}

CEncryptionKeyRefresher* CEncryptionKeyRefresher::NewL(CPhysicalLinksManager& aLinkMgr, CPhysicalLink& aLink)
	{
	LOG_STATIC_FUNC
	CEncryptionKeyRefresher* self = new(ELeave) CEncryptionKeyRefresher(aLinkMgr, aLink);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}
	
void CEncryptionKeyRefresher::ConstructL()
	{
	LOG_FUNC
	
	BaseConstructL();
	
	iStateFactory = CEncryptionKeyRefresherStateFactory::NewL();
	iState = &(iStateFactory->GetState(CEncryptionKeyRefresherStateFactory::EIdle));
	}
	
CEncryptionKeyRefresher::~CEncryptionKeyRefresher()
	{
	LOG_FUNC
	}

void CEncryptionKeyRefresher::EncryptionKeyRefreshComplete(TInt aError)
	{
	LOG_FUNC
	iState->EncryptionKeyRefreshComplete(*this, aError);
	}

void CEncryptionKeyRefresher::TimerExpired()
	{
	LOG_FUNC
	iState->TimerExpired(*this);
	}

void CEncryptionKeyRefresher::HandleError( TInt aError)
	{
	LOG_FUNC
	iState->Error(*this, aError);
	}

void CEncryptionKeyRefresher::StartHelper()
	{
	LOG_FUNC
	iState->Start(*this);
	}
	
void CEncryptionKeyRefresher::EventReceived(TBTBasebandEventNotification& aEvent)
	{
	LOG_FUNC
	iState->EventReceived(*this, aEvent);
	}
		

//----------------------------------------------------------------------------------
// STATE FACTORY
//----------------------------------------------------------------------------------

CEncryptionKeyRefresherStateFactory* CEncryptionKeyRefresherStateFactory::NewL()
	{
	LOG_STATIC_FUNC
	CEncryptionKeyRefresherStateFactory* ret=new (ELeave) CEncryptionKeyRefresherStateFactory();
	CleanupStack::PushL(ret);
	ret->ConstructL();
	CleanupStack::Pop(ret);
	return ret;
	}

void CEncryptionKeyRefresherStateFactory::ConstructL()
	{
	LOG_FUNC	
	iStates[EIdle]					=new (ELeave) TEkrStateIdle(*this);
	iStates[EDisablingLPM]			=new (ELeave) TEkrStateDisablingLPM(*this);
	iStates[ERefreshingKey]			=new (ELeave) TEkrStateRefreshingKey(*this);
	}

CEncryptionKeyRefresherStateFactory::CEncryptionKeyRefresherStateFactory()
	{
	LOG_FUNC
	iStates.DeleteAll();
	}

const TEncryptionKeyRefresherState& CEncryptionKeyRefresherStateFactory::GetState(CEncryptionKeyRefresherStateFactory::TEncryptionKeyRefresherStates aState) const
	{
	LOG_FUNC
	__ASSERT_DEBUG(iStates[aState],  Panic(EEncryptionKeyRefresherInvalidState));
	return *iStates[aState];
	}

TInt CEncryptionKeyRefresherStateFactory::StateIndex(const TEncryptionKeyRefresherState* aState) const
	{
	LOG_FUNC
	TInt state;
	for (state = 0; state < EEncryptionKeyRefresherMaxState; state++)
		{
		if (iStates[state] == aState)
			{
			return state;
			}
		}
	
	return KUnknownState;
	}


//----------------------------------------------------------------------------------
// STATES
//----------------------------------------------------------------------------------

TEncryptionKeyRefresherState::TEncryptionKeyRefresherState(CEncryptionKeyRefresherStateFactory& aFactory)
: iFactory(aFactory)
	{
	LOG_FUNC
	}

void TEncryptionKeyRefresherState::PanicInState(TLinkPanic aPanic) const
	{
	LOG_FUNC
	Panic(aPanic, iFactory.StateIndex(this));
	}

void TEncryptionKeyRefresherState::ChangeState(CEncryptionKeyRefresher& aContext, CEncryptionKeyRefresherStateFactory::TEncryptionKeyRefresherStates aState) const
	{
	LOG_FUNC
	
	aContext.iState->Exit(aContext);

#ifdef __FLOG_ACTIVE
	const TEncryptionKeyRefresherState* state=&iFactory.GetState(aState);
	LOG2(_L("EncryptionKeyRefresher: State %S -> %S"), &aContext.iState->iName, &state->iName);
#endif //__FLOG_ACTIVE
	aContext.iState=&iFactory.GetState(aState);

	aContext.iState->Enter(aContext);
	}

void TEncryptionKeyRefresherState::Enter(CEncryptionKeyRefresher& /*aContext*/) const
	{
	LOG_FUNC
	// do nothing
	}

void TEncryptionKeyRefresherState::Exit(CEncryptionKeyRefresher& /*aContext*/) const
	{
	LOG_FUNC
	// do nothing
	}

void TEncryptionKeyRefresherState::Start(CEncryptionKeyRefresher& /*aContext*/) const
	{
	LOG_FUNC
	PanicInState(EEncryptionKeyRefresherStateMachineInvalidEvent);
	}

void TEncryptionKeyRefresherState::Error(CEncryptionKeyRefresher& aContext, TInt /*aErr*/) const
	{
	LOG_FUNC
	aContext.CancelNotify();
	aContext.RemoveTimer();
	ChangeState(aContext, CEncryptionKeyRefresherStateFactory::EIdle);
	}

void TEncryptionKeyRefresherState::EventReceived(CEncryptionKeyRefresher& /*aContext*/, TBTBasebandEventNotification& /*aEvent*/) const
	{
	LOG_FUNC
	// do nothing
	}

void TEncryptionKeyRefresherState::TimerExpired(CEncryptionKeyRefresher& aContext) const
	{
	LOG_FUNC
	aContext.CancelNotify();
	ChangeState(aContext, CEncryptionKeyRefresherStateFactory::EIdle);
	}

void TEncryptionKeyRefresherState::EncryptionKeyRefreshComplete(CEncryptionKeyRefresher& /*aContext*/, TInt /*aError*/) const
	{
	LOG_FUNC
	// do nothing
	}

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

TEkrStateIdle::TEkrStateIdle(CEncryptionKeyRefresherStateFactory& aFactory)
: TEncryptionKeyRefresherState(aFactory)
	{
	LOG_FUNC
	STATENAME("TEkrStateIdle");
	}

void TEkrStateIdle::Start(CEncryptionKeyRefresher& aContext) const
	{
	LOG_FUNC
	aContext.QueueTimer(KTimeoutEncryptionKeyRefresh);	// watchdog timer
	ChangeState(aContext, CEncryptionKeyRefresherStateFactory::EDisablingLPM);
	}	

void TEkrStateIdle::Enter(CEncryptionKeyRefresher& aContext) const
	{
	LOG_FUNC
	// async call to delete the helper
	aContext.iLink.AsyncDeleteKeyRefresher();
	}	

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

TEkrStateDisablingLPM::TEkrStateDisablingLPM(CEncryptionKeyRefresherStateFactory& aFactory)
: TEncryptionKeyRefresherState(aFactory)
	{
	LOG_FUNC
	STATENAME("TEkrStateDisablingLPM");
	}

void TEkrStateDisablingLPM::Enter(CEncryptionKeyRefresher& aContext) const
	{
	LOG_FUNC
	
	if (aContext.iLink.LinkMode() == EActiveMode)
		{
		// Skip straight on to refresh the key
		ChangeState(aContext, CEncryptionKeyRefresherStateFactory::ERefreshingKey);
		}
	else
		{
		aContext.NotifyBasebandEvent(ENotifyActiveMode);
		}
	
	// DisableLPM even if link is active to prevent possible LPM requests during key refresh
	aContext.DisableLPM();
	}

void TEkrStateDisablingLPM::EventReceived(CEncryptionKeyRefresher& aContext, TBTBasebandEventNotification& aEvent) const
	{
	LOG_FUNC
	if (aEvent.EventType()==ENotifyActiveMode && aEvent.ErrorCode()==KErrNone)
		{
		ChangeState(aContext, CEncryptionKeyRefresherStateFactory::ERefreshingKey);
		}
	else 
		{
		LOG(_L("CEncryptionKeyRefresher failed in DisableLPM"));
		// If we can't put ourselves into active mode then don't bother with 
		// refresh, it'll probably cause more problems than it would solve
		// we can quit SM, don't need to rewind
		ChangeState(aContext, CEncryptionKeyRefresherStateFactory::EIdle);
		}
	}

//----------------------------------------------------------------------------------
TEkrStateRefreshingKey::TEkrStateRefreshingKey(CEncryptionKeyRefresherStateFactory& aFactory)
: TEncryptionKeyRefresherState(aFactory)
	{
	LOG_FUNC
	STATENAME("TEkrStateRefreshingKey");
	}

void TEkrStateRefreshingKey::Enter(CEncryptionKeyRefresher& aContext) const
	{
	LOG_FUNC
	
	TRAPD(err, aContext.iLinkMgr.HCIFacade().RefreshEncryptionKeyL(aContext.iLink.Handle()));
	
	if(err)
		{
		ChangeState(aContext, CEncryptionKeyRefresherStateFactory::EIdle);
		}
	}

void TEkrStateRefreshingKey::EncryptionKeyRefreshComplete(CEncryptionKeyRefresher& aContext, TInt __DEBUG_ONLY(aError)) const
	{
	LOG_FUNC
	LOG1(_L("EncryptionKeyRefresh completed with error %d"), aError);

	// Don't really care what the error is, this is just a best effort service
	// anyway
	ChangeState(aContext, CEncryptionKeyRefresherStateFactory::EIdle);
	}