/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/

#include <algorithm>
#include "hsMatrix44.h"
#include "hsGeometry3.h"
#include "plNetClientMgr.h"

#include "../plNetMessage/plNetMessage.h"
#include "../pnNetCommon/plNetServers.h"
#include "../pnSceneObject/plSceneObject.h"
#include "../pnSceneObject/plCoordinateInterface.h"
#include "../pnKeyedObject/plKey.h"

#include "../plNetTransport/plNetTransportMember.h"
#include "../plMessage/plMemberUpdateMsg.h"
#include "../plMessage/plNetVoiceListMsg.h"
#include "../plStatusLog/plStatusLog.h"
#include "../plVault/plVault.h"


#define SAME_TALK_AND_LISTEN

struct DistSqInfo
{
	plNetTransportMember* fMbr;
	float fDistSq;
	DistSqInfo(plNetTransportMember* m, float d) : fMbr(m),fDistSq(d) {}
};

bool lessComp(DistSqInfo a, DistSqInfo b)
{
	return (a.fDistSq<b.fDistSq);
}

//
// see if new listen list differs from current one
// apply new list if there's a difference
// send listenList update msgs to old and new members in the list
// return true if the new list is different
//
hsBool plNetClientMgr::IApplyNewListenList(std::vector<DistSqInfo>& newListenList, hsBool forceSynch)
{
	hsBool changed=false;
	int i;

	// see if new listen list differs from current one
	if (forceSynch || newListenList.size() != GetListenList()->GetNumMembers())
		changed=true;
	else
	{
		for(i=0;i<newListenList.size(); i++)
		{			
			if (GetListenList()->FindMember(newListenList[i].fMbr)==-1)
			{
				changed=true;
				break;				
			}
		}
	}

	// set as new listen list
	if (changed)
	{	
		DebugMsg("ListenList changed, forceSynch=%d\n", forceSynch);

		plNetMsgListenListUpdate llu;
		llu.SetPlayerID(GetPlayerID());
		llu.SetNetProtocol(kNetProtocolCli2Game);
		
		//
		// for each client in the old list, if not in the new list, send a ListenList remove msg
		//
		llu.Receivers()->Clear();
		llu.SetAdding(false);
		for(i=0;i<GetListenList()->GetNumMembers(); i++)
		{
			hsBool found=false;
			if (!forceSynch)
			{			
				int j;
				for(j=0;j<newListenList.size(); j++)
				{
					if (newListenList[j].fMbr==GetListenList()->GetMember(i))
					{
						found=true;
						break;
					}
				}
			}
			if (found==false)
			{
				llu.Receivers()->AddReceiverPlayerID(GetListenList()->GetMember(i)->GetPlayerID());
			}
		}

#ifndef SAME_TALK_AND_LISTEN
		if (llu.Receivers()->GetNumReceivers())
		{		
			// DEBUGGING
			int i;
			for(i=0;i<llu.Receivers()->GetNumReceivers(); i++)
			{
				int idx=fTransport.FindMember(llu.Receivers()->GetReceiverClientNum(i));
				plNetTransportMember* mbr=fTransport.GetMember(idx);
				DebugMsg("<SEND %s> ListenListUpdate msg, adding=%d\n", 
					mbr->AsStdString().c_str(), llu.GetAdding());
			}
			
			SendMsg(&llu);
		}
#endif

		//
		// for each client in the new list, [if not in the old list,] send a ListenList add msg
		//
		llu.Receivers()->Clear();
		llu.SetAdding(true);
		for(i=0;i<newListenList.size(); i++)
		{
			if (forceSynch || GetListenList()->FindMember(newListenList[i].fMbr)==-1)
			{
				// if not in the old list, send a ListenList add msg
				llu.Receivers()->AddReceiverPlayerID(newListenList[i].fMbr->GetPlayerID());
			}
		}

#ifndef SAME_TALK_AND_LISTEN
		if (llu.Receivers()->GetNumReceivers())
		{
			// DEBUGGING
			int i;
			for(i=0;i<llu.Receivers()->GetNumReceivers(); i++)
			{
				int cNum=llu.Receivers()->GetReceiverClientNum(i);
				int idx=fTransport.FindMember(cNum);
				plNetTransportMember* mbr=fTransport.GetMember(idx);
				DebugMsg("<SEND %s> ListenListUpdate msg, adding=%d, cNum=%d\n", 
					mbr->AsStdString().c_str(), llu.GetAdding(), cNum);
			}

			SendMsg(&llu);
		}
#endif

		//
		// set as new listen list
		//
		GetListenList()->Clear();
#ifdef HS_DEBUGGING
		DebugMsg("New ListenList, size=%d\n", newListenList.size());
#endif
		for(i=0;i<newListenList.size(); i++)
		{
			GetListenList()->AddMember(newListenList[i].fMbr);
#ifdef HS_DEBUGGING
			DebugMsg("\tLL Member %d, name=%s, cNum=%d, dist=%f\n", 
				i, newListenList[i].fMbr->AsStdString().c_str(), 
				newListenList[i].fMbr->GetPlayerID(), newListenList[i].fDistSq);
#endif
		}
	}		
	return changed;
}
//
// Periodically updates the list of what remote players I'm listening to.
// Used to filter voice streams.
// Returns true if the listenList was changed.
// Note: Updates distSq to each member. Other things rely on this so we must do it even if p2p is disabled.
//
hsBool plNetClientMgr::IUpdateListenList(double secs)
{
	if (GetFlagsBit(kDisabled))
		return false;
	if (!fLocalPlayerKey || !fLocalPlayerKey->ObjectIsLoaded())
		return false;
	
	hsBool changed = false;
	
	if (secs - GetListenList()->GetLastUpdateTime()>plNetListenList::kUpdateInterval)
	{
		GetListenList()->SetLastUpdateTime(secs);
		std::vector<DistSqInfo> newListenList;
		
		switch (fListenListMode)
		{
		case kListenList_Forced:
			{
#ifdef SAME_TALK_AND_LISTEN
				SynchTalkList();
#endif
			}
			return true;
		case kListenList_Distance:
			{
				// Finds the 3 closest players to our local player
				// Search is unoptimized for now...

				// compute our players pos
				plSceneObject* locPlayer = plSceneObject::ConvertNoRef(fLocalPlayerKey->ObjectIsLoaded());
				hsAssert(locPlayer, "local player is not a sceneObject?");
				hsAssert(locPlayer->GetCoordinateInterface(), "locPlayer has no coordInterface");
				hsMatrix44 l2w=locPlayer->GetCoordinateInterface()->GetLocalToWorld();
				hsPoint3 locPlayerPos=l2w.GetTranslate();

				int i;
				for(i=0;i<fTransport.GetNumMembers();i++)
				{
					fTransport.GetMember(i)->SetDistSq(hsScalarMax);

					if (fTransport.GetMember(i)->IsServer())
						continue;
					if(VaultAmIgnoringPlayer(fTransport.GetMember(i)->GetPlayerID()))
					{			
						continue;
					}
					plKey k=fTransport.GetMember(i)->GetAvatarKey();
#if 0
					if (!k)
					{
						DebugMsg("UpdateListenList: Nil avatar key on member %s\n", 
							fTransport.GetMember(i)->AsStdString().c_str());
					}
#endif
					plSceneObject* obj=plSceneObject::ConvertNoRef(k ? k->ObjectIsLoaded() : nil);
					if (obj && obj->GetCoordinateInterface())
					{
#if 1
						// compute distSq to me
						l2w=obj->GetCoordinateInterface()->GetLocalToWorld();
						hsPoint3 pos=l2w.GetTranslate();
						float distSq = hsVector3(&pos, &locPlayerPos).MagnitudeSquared();

						fTransport.GetMember(i)->SetDistSq(distSq);
						
						// I can't listen to players that are more than 50 ft away 
						if (distSq>plNetListenList::kMaxListenDistSq)
							continue;
						// if we are p2p and member isn't, skip them.
						if ( IsPeerToPeer() && !fTransport.GetMember(i)->IsPeerToPeer() )
							continue;
						// otherwise, we aren't p2p so just update the listen list
						// normally so it will update in the gui as distance changes.
#else
						float distSq=1;
#endif
						// if we have < 3 elements in the list, grow the list, or,
						// if obj is closer than item 3, add it to the list.
						// keep the list (3) elements sorted.
						if (plNetListenList::kMaxListenListSize==-1 ||
							newListenList.size()<plNetListenList::kMaxListenListSize ||
							(distSq<newListenList[plNetListenList::kMaxListenListSize-1].fDistSq) )
						{
							DistSqInfo dsi(fTransport.GetMember(i), distSq);
							if (plNetListenList::kMaxListenListSize==-1 ||
								newListenList.size()<plNetListenList::kMaxListenListSize)
							{
								newListenList.push_back(dsi);	
							}
							else
							{
								newListenList[plNetListenList::kMaxListenListSize-1]=dsi;
							}
							if (plNetListenList::kMaxListenListSize!=-1)	// don't need to sort every time in this case
							{
								std::sort(newListenList.begin(), newListenList.end(), lessComp);
							}
						}
					}
					if (plNetListenList::kMaxListenListSize==-1 && newListenList.size())
					{
						std::sort(newListenList.begin(), newListenList.end(), lessComp);
					}
				}
			}
			break;
		default:
			break;
		
		}

		hsAssert(plNetListenList::kMaxListenListSize==-1 || newListenList.size()<=plNetListenList::kMaxListenListSize, 
		"illegal new listenlist size");
	
		changed = IApplyNewListenList(newListenList, 
#ifdef SAME_TALK_AND_LISTEN
			false 
#else
			GetListenList()->CheckForceSynch()
#endif
		);
	}
	// update talkList based on listenList
	if (changed)
	{

#ifdef SAME_TALK_AND_LISTEN
		SynchTalkList();
#endif
		// notify KI, member distances have been updated
		plMemberUpdateMsg* mu = TRACKED_NEW plMemberUpdateMsg;
		mu->Send();
	}

	return changed;
}


void plNetClientMgr::SynchTalkList()
{
	GetTalkList()->Clear();
	int i;
	for(i=0;i<GetListenList()->GetNumMembers(); i++)
		GetTalkList()->AddMember(GetListenList()->GetMember(i));
}

void plNetClientMgr::SetListenListMode(int i)
{
	// set new mode, clear list and force update
	fListenListMode = i;
	GetListenList()->Clear();
	GetListenList()->SetLastUpdateTime(0.f);
}

void plNetClientMgr::IHandleNetVoiceListMsg(plNetVoiceListMsg* msg)
{
	if (msg->GetCmd() == plNetVoiceListMsg::kForcedListenerMode)
	{
		// first make sure this message applies to us:
		int i;
		bool included = false;
		for (i = 0; i < msg->GetClientList()->Count(); i++)
		{	
			if (msg->GetClientList()->AcquireArray()[i] == NetCommGetPlayer()->playerInt)
			{	
				included = true;
				break;
			}
		}
		if (!included)
			return;
		SetListenListMode(kListenList_Forced);
		// add in the members we receive from python
		for (i = 0; i < msg->GetClientList()->Count(); i++)
		{
			plNetTransportMember **members = nil;
			plNetClientMgr::GetInstance()->TransportMgr().GetMemberListDistSorted( members );
					
			if( members != nil)
			{
				for(int j= 0; j < plNetClientMgr::GetInstance()->TransportMgr().GetNumMembers(); j++ )
				{
					plNetTransportMember *mbr = members[ j ];
					if( mbr != nil && mbr->GetAvatarKey() != nil && mbr->GetPlayerID() == msg->GetClientList()->AcquireArray()[i])
					{
						plNetClientMgr::GetInstance()->GetListenList()->AddMember(mbr);
					}
				}
			}
			delete [] members;
		}
	}
	else
	if (msg->GetCmd() == plNetVoiceListMsg::kDistanceMode)
	{
		// again, see that it is us that we care about:
		if (msg->GetRemovedKey() == GetLocalPlayerKey())
			SetListenListMode(kListenList_Distance);
	}	
}