// 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 "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:
// Server-side representation of a target client, which may have multiple 
// sessions associated with it.
// 


#include <e32base.h>
#include <bluetooth/logger.h>

#include "server.h"
#include "bearermanager.h"
#include "remconmessage.h"
#include "targetsession.h"

#include "targetclientprocess.h"

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

#ifdef _DEBUG
PANICCATEGORY("tgclient");
#endif

TBool TargetSessionCompareUsingSupportedInterface(const TUid* aInterfaceUid, const CRemConTargetSession& aSession)
	{
	return aSession.InterfaceSupported(*aInterfaceUid);
	}

TBool TargetSessionCompareUsingSupportedMessage(const CRemConMessage* aMessage, const CRemConTargetSession& aSession)
	{
	return aSession.SupportedMessage(*aMessage);
	}

CRemConTargetClientProcess* CRemConTargetClientProcess::NewLC(TClientInfo& aClientInfo, TRemConClientId aClientId, CRemConServer& aServer, CBearerManager& aBearerManager)
	{
	LOG_STATIC_FUNC

	CRemConTargetClientProcess* result = new (ELeave) CRemConTargetClientProcess(aClientInfo, aClientId, aServer, aBearerManager);
	CleanupStack::PushL(result);
	return result;
	}

CRemConTargetClientProcess::CRemConTargetClientProcess(TClientInfo& aClientInfo, TRemConClientId aClientId, CRemConServer& aServer, CBearerManager& aBearerManager)
	: iClientInfo(aClientInfo),
	iClientId(aClientId),
	iServer(aServer),
	iBearerManager(aBearerManager),
	iPlayerInfoSet(EFalse),
	iTargetSessions(KMaxNumberTargetSessions)
	{
	LOG_FUNC
	}

CRemConTargetClientProcess::~CRemConTargetClientProcess()
	{
	LOG_FUNC

	iPlayerName.Close();
	iTargetSessions.Close();
	iServer.TargetClientClosed(*this);
	}

CRemConTargetSession* CRemConTargetClientProcess::NewSessionL(TUint aSessionId)
	{
	LOG_FUNC
	CRemConTargetSession* sess = NULL;

	// Only create a session if we havent reached our maximum.
	if (TargetSessionCount() < KMaxNumberTargetSessions)
		{
		sess = CRemConTargetSession::NewL(*this, iServer, iBearerManager, aSessionId);
		}
	else
		{
		LEAVEIFERRORL(KErrOverflow);
		}

	return sess;
	}


TInt CRemConTargetClientProcess::TargetSessionOpened(CRemConTargetSession& aSession)
	{
	LOG_FUNC
	LOG1(_L("\t&aSession = 0x%08x"), &aSession)

	// Register the session by appending it to our array and asking the server to
	// make an item for it in the record of which points in the connection history 
	// sessions are interested in.
	ASSERT(iTargetSessions.Count() < KMaxNumberTargetSessions);	// Should have been caught by now.

	// The append should never fail because the RPointerArray was constructed with a granularity of 
	// KMaxNumberTargetSessions items.
#ifdef _DEBUG	
	TInt err = iTargetSessions.Append(&aSession);
	ASSERT(err == KErrNone);
#else
	static_cast<void>(iTargetSessions.Append(&aSession));
#endif

	TInt ret = iServer.RegisterTargetSessionPointerToConnHistory(aSession);
			
	if ( ret != KErrNone )
		{
		iTargetSessions.Remove(iTargetSessions.Count() - 1);
		}
	else
		{
		// Session successfully registered.
		iServer.CancelShutdownTimer();
		}
	
	LOG1(_L("\tret = %d"), ret)
	return ret;
	}

void CRemConTargetClientProcess::TargetSessionClosed(CRemConTargetSession& aSession)
	{
	LOG_FUNC
	LOG1(_L("\t&aSession = 0x%08x"), &aSession)

	// Remove session from our list
	TInt sessionIndex = iTargetSessions.Find(&aSession);

	if (sessionIndex > KErrNotFound)
		{
		iTargetSessions.Remove(sessionIndex);

		// Inform server that session has dropped. 			
		iServer.TargetSessionClosed(*this, aSession);
		
		if (iTargetSessions.Count() > 0)
		    {
            iServer.TargetFeaturesUpdated(*this);
		    }
		
		}
	}

void CRemConTargetClientProcess::SetPlayerInformationL(const TPlayerTypeInformation& aPlayerType, const TDesC8& aPlayerName)
	{
	LOG_FUNC
	ASSERT_DEBUG(!HasPlayerInformation());

	if (!HasPlayerInformation())
		{
		iPlayerName.CreateL(aPlayerName);
		iPlayerType = aPlayerType;
		iPlayerInfoSet = ETrue;
		}
	}

void CRemConTargetClientProcess::InterfacesRegistered()
	{
	LOG_FUNC

	// If this client has not been made available yet, do so now.
	// Otherwise, notify the server that new interfaces have been registered. 
	if (!iClientAvailable)
		{
		iServer.TargetClientAvailable(*this);	
		iClientAvailable = ETrue;
		}
	else
		{
		iServer.TargetFeaturesUpdated(*this);
		}

	}

TBool CRemConTargetClientProcess::IsInterfaceTypeRegisteredByAnotherSession(CRemConTargetSession& aSession, TUid aInterfaceUid) const
	{
	LOG_FUNC

	TUint sessionCount = iTargetSessions.Count();
	for (TUint i=0; i < sessionCount; ++i)
		{
		if (aSession.Id() != iTargetSessions[i]->Id())
			{
			if (iTargetSessions[i]->InterfaceSupported(aInterfaceUid))
				{
				return ETrue;
				}
			}
		}

	return EFalse;
	}

TInt CRemConTargetClientProcess::ReceiveMessage(CRemConMessage& aMessage)
	{
	LOG_FUNC

	// Find the session supporting this message
	CRemConTargetSession* sess = FindSessionForMessage(aMessage);

	if (sess)
		{
		// Session found. Check session is able to handle this message.
		if (sess->CurrentReceiveMessage().Handle())
			{
			// Pass message to session and return the error code obtained.
			return sess->WriteMessageToClient(aMessage);
			}
		else
			{
			// Session not able to handle message at this time.
			return KErrNotReady;
			}
		}
	else
		{
		// No session supports this message
		return KErrArgument;
		}
	}

void CRemConTargetClientProcess::ConnectionsChanged()
	{
	LOG_FUNC

	// Notify each session
	TUint sessionCount = iTargetSessions.Count();
	for (TUint i = 0; i < sessionCount; ++i)
		{
		iTargetSessions[i]->ConnectionsChanged();
		}
	}

TInt CRemConTargetClientProcess::SupportedInterfaces(RArray<TUid>& aUids)
	{
	LOG_FUNC
	
	TInt err = KErrNone;
	aUids.Reset();

	// Gather the list of supported interfaces from each session.
	TUint sessionCount = iTargetSessions.Count();
	for (TUint i = 0 ; i < sessionCount && err == KErrNone; ++i)
		{
		err = iTargetSessions[i]->AppendSupportedInterfaces(aUids);
		}

	return err;
	}

TInt CRemConTargetClientProcess::SupportedBulkInterfaces(RArray<TUid>& aUids)
	{
	LOG_FUNC
	
	TInt err = KErrNone;
	aUids.Reset();

	// Gather the list of supported bulk interfaces from each session.
	TUint sessionCount = iTargetSessions.Count();
	for (TUint i = 0 ; i < sessionCount && err == KErrNone; ++i)
		{
		err = iTargetSessions[i]->AppendSupportedBulkInterfaces(aUids);
		}

	return err;
	}

TInt CRemConTargetClientProcess::SupportedOperations(TUid aInterfaceUid, RArray<TUint>& aOperations)
	{
	LOG_FUNC

	// Find the session supporting this interface.
	TInt sessIndex = FindSessionForInterface(aInterfaceUid);

	if (sessIndex >= KErrNone)
		{
		return iTargetSessions[sessIndex]->SupportedOperations(aInterfaceUid, aOperations);
		}
	else
		{
		// Interface not found, so operation not supported.
		return KErrNotSupported;
		}
	}

CRemConTargetSession* CRemConTargetClientProcess::FindSessionForMessage(const CRemConMessage& aMessage)
	{
	LOG_FUNC

	TInt result = iTargetSessions.Find(aMessage, TargetSessionCompareUsingSupportedMessage);
	if (result >= KErrNone)
		{
		return iTargetSessions[result];
		}
	else
		{
		return NULL;
		}

	}

TInt CRemConTargetClientProcess::FindSessionForInterface(TUid aInterfaceUid) const
	{
	LOG_FUNC

	return iTargetSessions.Find(aInterfaceUid, TargetSessionCompareUsingSupportedInterface);
	}

void CRemConTargetClientProcess::CompleteMessageForSession(const CRemConMessage& aMessage, CRemConTargetSession& aSession)
	{
	LOG_FUNC

	// Targets can only send responses or rejects.
	switch (aMessage.MsgType())
		{
	case ERemConResponse:
	case ERemConReject:
		aSession.CompleteSend();
		break;
	default:
		ASSERT_DEBUG(EFalse);
		break;
		}

	}

void CRemConTargetClientProcess::MrcmsoMessageSendResult(const CRemConMessage& /*aMessage*/, TInt /*aError*/)
	{
	LOG_FUNC
	
	// This method should never be called, as it is not required to support target client processes.
	ASSERT_DEBUG(EFalse);
	}

void CRemConTargetClientProcess::MrcmsoMessageSendOneOrMoreAttempt(const CRemConMessage& aMessage, TUint aNumRemotes)
	{
	LOG_FUNC

	// Notifications should not be received for reject messages, as the client did not request these be sent.
	ASSERT_DEBUG(aMessage.MsgType() != ERemConReject);
	
	// Find session and notify
	CRemConTargetSession* sess = FindSessionForMessage(aMessage);
	ASSERT_DEBUG(sess);
	
	// Session should not already be sending a message to n remotes
	ASSERT_DEBUG(sess->NumRemotesToTry() == 0);

	sess->NumRemotes() = 0;
	sess->NumRemotesToTry() = aNumRemotes;
	sess->SendError() = KErrNone;
	}

void CRemConTargetClientProcess::MrcmsoMessageSendOneOrMoreIncremental(const CRemConMessage& aMessage, TUint aNumRemotes)
	{
	LOG_FUNC

	// Notifications should not be received for reject messages, as the client did not request these be sent.
	ASSERT_DEBUG(aMessage.MsgType() != ERemConReject);
	
	// Find session and notify
	CRemConTargetSession* sess = FindSessionForMessage(aMessage);
	ASSERT_DEBUG(sess);

	if (sess->NumRemotesToTry() == 0)
		{
		MrcmsoMessageSendOneOrMoreAttempt(aMessage,aNumRemotes);
		}
	else
		{
		// No send should have yet been attempted
		ASSERT_DEBUG(sess->NumRemotes() == 0);

		sess->NumRemotesToTry() += aNumRemotes;
		}
	}
	
void CRemConTargetClientProcess::MrcmsoMessageSendOneOrMoreAttemptFailed(const CRemConMessage& aMessage, TInt aError)
	{
	LOG_FUNC

	// Notifications should not be received for reject messages, as the client did not request these be sent.
	ASSERT_DEBUG(aMessage.MsgType() != ERemConReject);
	
	// Find session and notify
	CRemConTargetSession* sess = FindSessionForMessage(aMessage);
	ASSERT_DEBUG(sess);
	
	// Session should not already be sending a message to n remotes
	ASSERT_DEBUG(sess->NumRemotesToTry() == 0);

	sess->NumRemotes() = 0;
	sess->SendError() = aError;
	CompleteMessageForSession(aMessage, *sess);
	}

void CRemConTargetClientProcess::MrcmsoMessageSendOneOrMoreResult(const CRemConMessage& aMessage, TInt aError)
	{
	LOG_FUNC

	// Notifications should not be received for reject messages, as the client did not request these be sent.
	ASSERT_DEBUG(aMessage.MsgType() != ERemConReject);
	
	// Find session and notify
	CRemConTargetSession* sess = FindSessionForMessage(aMessage);
	ASSERT_DEBUG(sess);
	
	// Ignore notification if client has been completed
	if (sess->NumRemotesToTry() > 0)
		{
		// Only set error if different from KErrNone
		if (aError == KErrNone)
			{
			++sess->NumRemotes();
			}
		else
			{
			sess->SendError() = aError;
			}

		--sess->NumRemotesToTry();
		if (sess->NumRemotesToTry() == 0)
			{
			CompleteMessageForSession(aMessage, *sess);
			}
		}
	}

void CRemConTargetClientProcess::MrcmsoMessageSendOneOrMoreAbandoned(const CRemConMessage& aMessage)
	{
	LOG_FUNC
	
	// Notifications should not be received for reject messages, as the client did not request these be sent.
	ASSERT_DEBUG(aMessage.MsgType() != ERemConReject);

	// Find session and notify
	CRemConTargetSession* sess = FindSessionForMessage(aMessage);
	ASSERT_DEBUG(sess);
	
	// Ignore notification if client has been completed
	if (sess->NumRemotesToTry() > 0)
		{
		// Do not adjust NumRemotes() as the message was not sent (but we still don't error the client!)
		--sess->NumRemotesToTry();
		if (sess->NumRemotesToTry() == 0)
			{
			CompleteMessageForSession(aMessage, *sess);
			}
		}
	}