// Copyright (c) 2006-2009 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 "lbsnetworkgatewayhandler.h"
#include "lbsassistancedatacacheapi.h"
#include <lbs/lbsassistancealmanac.h>
#include <lbs/lbsassistancebadsatlist.h>
#include <lbs/lbsassistanceaquisitionassistance.h>
#include <lbs/lbsassistancenavigationmodel.h>
#include <lbs/lbsassistancereferencetime.h>
#include <lbs/lbsassistanceionosphericmodel.h>
#include <lbs/lbsassistanceutcmodel.h>
#include <lbs/lbsassistancereferencelocation.h>
#include "lbscommoninternaldatatypes.h"
#include "lbsagpsngmsgs.h"
#include "lbsdevloggermacros.h"
#include <lbs/lbslocerrors.h>


// We can queue up to 4 messages
const TInt KNetworkGatewayHandlerQSize = 4;


CNetworkGatewayHandler * CNetworkGatewayHandler::NewL
	(
	MNetworkGatewayHandlerObserver* aObserver
	)
	{
	LBSLOG(ELogP1, "CNetworkGatewayHandler::NewL()");
	CNetworkGatewayHandler * self = new(ELeave) CNetworkGatewayHandler (aObserver);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self;
	}
	
CNetworkGatewayHandler::CNetworkGatewayHandler(MNetworkGatewayHandlerObserver* aObserver) : 
	CActive(EPriorityStandard),
	iObserver(aObserver),
	iQ(KNetworkGatewayHandlerQSize)
	{
	LBSLOG(ELogP1, "CNetworkGatewayHandler::CNetworkGatewayHandler()");
	}

void CNetworkGatewayHandler::ConstructL()
	{
	LBSLOG(ELogP1, "CNetworkGatewayHandler::ConstructL()");
	CActiveScheduler::Add(this);
	iAssistanceDataCache.OpenL();
	iNGChannel.OpenL(RLbsNetChannel::EChannelAGPS2NG, *this);
	iQ.OpenL();
	}

//------------------------------------------------------------------------------------------------------------
CNetworkGatewayHandler::~CNetworkGatewayHandler()
	{
	LBSLOG(ELogP1, "CNetworkGatewayHandler::~CNetworkGatewayHandler()");
	iAssistanceDataCache.Close(); 
	iNGChannel.Close();
	iQ.Close();
	}

 // request from integration module to read a particular  assistance data item
TInt CNetworkGatewayHandler::GetAssistanceDataItem(TLbsAssistanceDataItem aItem,RDataReaderRootBase& aDataRoot,	TTime& aTimeStamp)
	{
	LBSLOG(ELogP1, "CNetworkGatewayHandler::GetAssistanceDataItem()");
	TInt error = iAssistanceDataCache.GetAssistDataItem(aItem,aDataRoot);
	if (KErrNone == error)
		{
		TBool dataAvailable = EFalse;
		switch(aItem)
        	{
	        case EAssistanceDataAquisitionAssistance:
	            dataAvailable = reinterpret_cast<RUEPositioningGpsAcquisitionAssistanceReader*>(&aDataRoot)->IsDataAvailable();
	            break;
	        case EAssistanceDataBadSatList:
	        	dataAvailable = reinterpret_cast<RBadSatListReader*>(&aDataRoot)->IsDataAvailable();
	            break;
	        case EAssistanceDataNavigationModel:
	        	dataAvailable = reinterpret_cast<RUEPositioningGpsNavigationModelReader*>(&aDataRoot)->IsDataAvailable();
	            break;
	        case EAssistanceDataReferenceTime:
	        	dataAvailable = reinterpret_cast<RUEPositioningGpsReferenceTimeReader*>(&aDataRoot)->IsDataAvailable();
	            break;
	        case EAssistanceDataIonosphericModel:
	        	dataAvailable = reinterpret_cast<RUEPositioningGpsIonosphericModelReader*>(&aDataRoot)->IsDataAvailable();
	            break;
	        case EAssistanceDataReferenceLocation:
	        	dataAvailable = reinterpret_cast<RReferenceLocationReader*>(&aDataRoot)->IsDataAvailable();
	            break;
	        case EAssistanceDataAlmanac:
	        	dataAvailable = reinterpret_cast<RUEPositioningGpsAlmanacReader*>(&aDataRoot)->IsDataAvailable();
	            break;
	        case EAssistanceDataPositioningGpsUtcModel:
	        	dataAvailable = reinterpret_cast<RUEPositioningGpsUtcModelReader*>(&aDataRoot)->IsDataAvailable();
	            break;
	        default:
	            //Intentionally empty. dataAvailable remains EFalse.
	            break;
	        }
	        
		if (!dataAvailable)
			{
			error = KErrNotFound;
			}
		else
			{
			aTimeStamp = aDataRoot.TimeStamp();	
			}
		}
	return error;
	}

// request from integration module to read a particular  assistance data item time stamp only
TInt CNetworkGatewayHandler::GetAssistanceDataItemTimeStamp(TLbsAssistanceDataItem aItem, TTime& aTimeStamp)
	{
	LBSLOG(ELogP1, "CNetworkGatewayHandler::GetAssistanceDataItemTimeStamp()");
	TInt error = KErrNone;
	TTime timeStamp;
	
	switch(aItem)
    	{
        case EAssistanceDataAquisitionAssistance:
			{
			RUEPositioningGpsAcquisitionAssistanceReader reader;
			TRAP(error, reader.OpenL());
			if (KErrNone == error)
			    {
	            error = GetAssistanceDataItem(aItem, reader, timeStamp);
	            reader.Close();
			    }
			break;
			}
        case EAssistanceDataBadSatList:
			{
			RBadSatListReader reader;
			TRAP(error, reader.OpenL());
            if (KErrNone == error)
                {
                error = GetAssistanceDataItem(aItem, reader, timeStamp);
                reader.Close();
                }
			break;
			}
        case EAssistanceDataNavigationModel:
			{
			RUEPositioningGpsNavigationModelReader reader;
			TRAP(error, reader.OpenL());
            if (KErrNone == error)
                {
                error = GetAssistanceDataItem(aItem, reader, timeStamp);
                reader.Close();
                }
			break;
			}
        case EAssistanceDataReferenceTime:
			{
			RUEPositioningGpsReferenceTimeReader reader;
            TRAP(error, reader.OpenL());
            if (KErrNone == error)
                {
                error = GetAssistanceDataItem(aItem, reader, timeStamp);
                reader.Close();
                }
			break;
			}
        case EAssistanceDataIonosphericModel:
			{
			RUEPositioningGpsIonosphericModelReader reader;
            TRAP(error, reader.OpenL());
            if (KErrNone == error)
                {
                error = GetAssistanceDataItem(aItem, reader, timeStamp);
                reader.Close();
                }
			break;
			}
        case EAssistanceDataReferenceLocation:
			{
			RReferenceLocationReader reader;
            TRAP(error, reader.OpenL());
            if (KErrNone == error)
                {
                error = GetAssistanceDataItem(aItem, reader, timeStamp);
                reader.Close();
                }
			break;
			}
        case EAssistanceDataAlmanac:
			{
			RUEPositioningGpsAlmanacReader reader;
            TRAP(error, reader.OpenL());
            if (KErrNone == error)
                {
                error = GetAssistanceDataItem(aItem, reader, timeStamp);
                reader.Close();
                }
			break;
			}
        case EAssistanceDataPositioningGpsUtcModel:
			{
			RUEPositioningGpsUtcModelReader reader;
            TRAP(error, reader.OpenL());
            if (KErrNone == error)
                {
                error = GetAssistanceDataItem(aItem, reader, timeStamp);
                reader.Close();
                }
			break;
			}
        default:
			{
			error = KErrNotFound;
			break;
			}
        }
        
    if (KErrNone == error)
    	{
    	aTimeStamp = timeStamp;
    	}

	return error;
	}


// request from integration module to request a new set of assistance data from network
void CNetworkGatewayHandler::SendAssistanceDataRequest(TLbsAsistanceDataGroup aDataItemMask)
	{
	LBSLOG(ELogP1, "CNetworkGatewayHandler::SendAssistanceDataRequest()");
 	TLbsNetAssistanceDataRequestMsg msg(aDataItemMask);
 	SendOrQueueMessage(msg);
 	}
	
void CNetworkGatewayHandler::SendSelfLocationRequest(const TLbsNetSessionIdInt& aSessionId, 
													 const TLbsNetPosRequestOptionsAssistanceInt& aOptions)
	{
	LBSLOG(ELogP1, "CNetworkGatewayHandler::SendSelfLocationRequest()");
 	TLbsNetSelfLocationRequestMsg msg(aSessionId, aOptions);
 	SendOrQueueMessage(msg);
	}
	
void CNetworkGatewayHandler::SendSelfLocationCancel(const TLbsNetSessionIdInt& aSessionId, TInt aReason)
	{
	LBSLOG(ELogP1, "CNetworkGatewayHandler::SendSelfLocationCancel()");
 	TLbsNetSelfLocationCancelMsg msg(aSessionId, aReason);
 	SendOrQueueMessage(msg);
	}

void CNetworkGatewayHandler::SendSystemStatusAdvice(TBool aTracking)
	{
	LBSLOG(ELogP1, "CNetworkGatewayHandler::SendSystemStatusAdvice()");
 	TLbsNetSystemStatusAdviceMsg msg(aTracking);
 	SendOrQueueMessage(msg);
	}
	
void CNetworkGatewayHandler::RunL()
	{
	LBSLOG2(ELogP1, "CNetworkGatewayHandler::RunL() Begin. Status: %d\n", iStatus.Int());
	__ASSERT_DEBUG(iStatus.Int() == KErrNone, User::Panic(KLbsAGPSManFault, iStatus.Int()));
	
	// Check if more queued messages await sending
	if (!iQ.IsEmpty())
		{
 		iNGChannel.SendMessage(iQ.Read(), iStatus);
 		SetActive();
		}
	LBSLOG(ELogP1, "CNetworkGatewayHandler::RunL() End\n");
	}
	
void CNetworkGatewayHandler::DoCancel()
	{
	LBSLOG(ELogP1, "CNetworkGatewayHandler::DoCancel()");
	iNGChannel.CancelSendMessageNotification();
	}
	
TInt CNetworkGatewayHandler::RunError(TInt aError)
	{
	LBSLOG(ELogP1, "CNetworkGatewayHandler::RunError()\n");
	LBSLOG_ERR2(ELogP2, " %d \n", aError);
 	return aError;
	}

void CNetworkGatewayHandler::SendOrQueueMessage(TLbsNetInternalMsgBase& aMsg)
	{
	LBSLOG(ELogP1, "CNetworkGatewayHandler::SendOrQueueMessage()\n");
	if (!IsActive())
		{
 		iNGChannel.SendMessage(aMsg, iStatus);
 		SetActive();
		}
	else
		{
		QueueMessage(aMsg);
		}
	}
/**
Queues messages.
Performs implicit cancels if the queue not empty.
Supports only one self location session at a time.
*/	
void CNetworkGatewayHandler::QueueMessage(TLbsNetInternalMsgBase& aMsg)
	{
	LBSLOG(ELogP1, "CNetworkGatewayHandler::QueueMessage()\n");
	TBool removed;
	
	switch (aMsg.Type())
		{
		case TLbsNetInternalMsgBase::ESelfLocationRequest:
			// A new request implicitly cancels a previous request and/or cancel
			iQ.FindAndRemove(TLbsNetInternalMsgBase::ESelfLocationRequest);
			iQ.FindAndRemove(TLbsNetInternalMsgBase::ESelfLocationCancel);
			iQ.Write(aMsg);
			break;
			
		case TLbsNetInternalMsgBase::ESelfLocationCancel:
			// The AGPS manager should not send a Cancel twice
			removed = iQ.FindAndRemove(TLbsNetInternalMsgBase::ESelfLocationCancel);
			__ASSERT_DEBUG(removed == EFalse, User::Panic(KLbsAGPSManFault, KErrAlreadyExists));
			removed = removed == removed; //dummy for UREL
			iQ.Write(aMsg);
			break;
			
		case TLbsNetInternalMsgBase::EAssistanceDataRequest:
			// It is an implicit cancel of a previous Assistance Data Request
			iQ.FindAndRemove(TLbsNetInternalMsgBase::EAssistanceDataRequest);
			iQ.Write(aMsg);
			break;
			
		case TLbsNetInternalMsgBase::ESystemStatusAdvice:
			// It is an implicit cancel of a previous System Status Advice
			iQ.FindAndRemove(TLbsNetInternalMsgBase::ESystemStatusAdvice);
			iQ.Write(aMsg);
			break;
			
		default:
			break;
			
		}
	}

//---------------------------------------------------------------------------------------------------
void CNetworkGatewayHandler::ProcessNetChannelMessage(RLbsNetChannel::TLbsNetChannelId aChannelId, 
													  const TLbsNetInternalMsgBase& aMessage)
	{
	LBSLOG(ELogP1, "CNetworkGatewayHandler::ProcessNetChannelMessage()\n");
	__ASSERT_DEBUG(aChannelId == RLbsNetChannel::EChannelAGPS2NG, User::Panic(KLbsAGPSManFault, EAGPSManUnexpectedNetChannelId));
	(void) aChannelId;
		
	const TLbsNetSessionCompleteAgpsMsg& msgComp = static_cast<const TLbsNetSessionCompleteAgpsMsg&>(aMessage);
	const TLbsNetAssistanceDataResponseMsg& msgAss = static_cast<const TLbsNetAssistanceDataResponseMsg&>(aMessage);

	switch (aMessage.Type())
		{
		case TLbsNetInternalMsgBase::ESessionComplete:
			iObserver->OnSessionComplete(msgComp.Reason(), msgComp.SessionId());
			break;
			
		case TLbsNetInternalMsgBase::EAssistanceDataResponse:
			iObserver->OnAssistanceDataResponse(msgAss.Reason(), msgAss.DataResponseMask());
			break;
			
		default:
			LBSLOG_ERR2(ELogP2, "Unexpected message type: %d \n", aMessage.Type());
			__ASSERT_DEBUG(EFalse, User::Panic(KLbsAGPSManFault, KErrArgument));
			break;
		}
	}