/*==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 "hsTypes.h"
#include "../pnKeyedObject/plKey.h"
#include "hsTemplates.h"
#include "hsStream.h"
#include "plLinkEffectsMgr.h"
#include "../pnMessage/plEventCallbackMsg.h"
#include "../pnMessage/plTimeMsg.h"
#include "../pnMessage/plPlayerPageMsg.h"
#include "../plMessage/plLinkToAgeMsg.h"
#include "../plMessage/plTransitionMsg.h"
#include "plgDispatch.h"
#include "hsResMgr.h"
#include "hsTimer.h"
#include "../pnNetCommon/plNetApp.h"
#include "../plNetClient/plNetClientMgr.h"
#include "../pnSceneObject/plSceneObject.h"
#include "../plNetTransport/plNetTransportMember.h"
#include "../plVault/plVault.h"
#include "../plNetClient/plNetLinkingMgr.h"
#include "../plAgeLoader/plAgeLoader.h"
#include "../pnSceneObject/plCoordinateInterface.h"
#include "../pnMessage/plWarpMsg.h"
#include "../pnKeyedObject/plFixedKey.h"

// chronicle var
#define kCleftSolved					L"CleftSolved"

#include "../plAvatar/plArmatureMod.h"
#include "../plAvatar/plAvatarTasks.h"
#include "../plAvatar/plAGAnim.h"
#include "../plMessage/plAvatarMsg.h"
#include "../plMessage/plLoadAgeMsg.h"

plLinkEffectsMgr::plLinkEffectsMgr()
{
}

plLinkEffectsMgr::~plLinkEffectsMgr()
{
	int	i;
	for( i = 0; i < fLinks.GetCount(); i++ )
	{
		hsRefCnt_SafeUnRef(fLinks[i]);
	}
	for( i = 0; i < fWaitlist.GetCount(); i++ )
	{
		hsRefCnt_SafeUnRef(fWaitlist[i]);
	}
	for( i = 0; i < fDeadlist.GetCount(); i++ )
	{
		hsRefCnt_SafeUnRef(fDeadlist[i]);
	}
}

void plLinkEffectsMgr::Init()
{
	plgDispatch::Dispatch()->RegisterForExactType(plPlayerPageMsg::Index(), GetKey());
	plgDispatch::Dispatch()->RegisterForExactType(plPseudoLinkEffectMsg::Index(), GetKey());
}	

plLinkEffectsTriggerMsg *plLinkEffectsMgr::IFindLinkTriggerMsg(plKey linkKey)
{
	int i;
	for (i = 0; i < fLinks.GetCount(); i++)
	{
		if (fLinks[i]->GetLinkKey() == linkKey)
			return fLinks[i];
	}
	return nil;
}

void plLinkEffectsMgr::IAddLink(plLinkEffectsTriggerMsg *msg)
{
	hsRefCnt_SafeRef(msg);
	fLinks.Append(msg);
}

void plLinkEffectsMgr::IAddWait(plLinkEffectsTriggerMsg *msg)
{
	hsRefCnt_SafeRef(msg);
	fWaitlist.Append(msg);
}

void plLinkEffectsMgr::IAddDead(plLinkEffectsTriggerMsg *msg)
{
	hsRefCnt_SafeRef(msg);
	fDeadlist.Append(msg);
}

void plLinkEffectsMgr::IAddPsuedo(plPseudoLinkEffectMsg *msg)
{
	hsRefCnt_SafeRef(msg);
	fPseudolist.Append(msg);
}

hsBool plLinkEffectsMgr::IHuntWaitlist(plLinkEffectsTriggerMsg *msg)
{
	int i;
	hsBool found = false;
	for (i = fWaitlist.GetCount() - 1; i >= 0; i--)
	{
		if (fWaitlist[i] == msg)
		{
			found = true;
			hsRefCnt_SafeUnRef(fWaitlist[i]);			
			fWaitlist.Remove(i);
			plNetApp::GetInstance()->DebugMsg("Received backup LinkEffectsTriggerMsg. Never got remote trigger!\n");			
		}
	}
	
	return found || IHuntWaitlist(msg->GetLinkKey());
}

hsBool plLinkEffectsMgr::IHuntWaitlist(plKey linkKey)
{
	int i;
	hsBool found = false;
	for (i = fWaitlist.GetCount() - 1; i >= 0; i--)
	{
		if (fWaitlist[i]->GetLinkKey() == linkKey)
		{
			found = true;
			IAddDead(fWaitlist[i]);

			hsRefCnt_SafeUnRef(fWaitlist[i]);
			fWaitlist.Remove(i);
			plNetApp::GetInstance()->DebugMsg("Received remote LinkEffectsTriggerMsg. Awaiting backup.\n");
		}
	}

	return found;
}

hsBool plLinkEffectsMgr::IHuntDeadlist(plLinkEffectsTriggerMsg *msg)
{
	int i;
	hsBool found = false;
	for (i = fDeadlist.GetCount() - 1; i >= 0; i--)
	{
		if (fDeadlist[i] == msg)
		{
			found = true;
			hsRefCnt_SafeUnRef(fDeadlist[i]);
			fDeadlist.Remove(i);
			plNetApp::GetInstance()->DebugMsg("Received backup LinkEffectsTriggerMsg. Cleanly ignoring since we received remote trigger.\n");
		}
	}

	return found;
}



void plLinkEffectsMgr::ISendAllReadyCallbacks()
{
	int i;
	for (i = fLinks.GetCount() - 1; i >= 0; i--)
	{
		if (fLinks[i]->fEffects <= 0)
		{
			if (fLinks[i]->IsLeavingAge())
			{
				if (fLinks[i]->GetLinkKey() == plNetClientApp::GetInstance()->GetLocalPlayerKey())
				{
					plLinkOutUnloadMsg* lam = TRACKED_NEW plLinkOutUnloadMsg;	// derived from LoadAgeMsg
					lam->SetAgeFilename( NetCommGetAge()->ageDatasetName );
					lam->AddReceiver(plNetClientMgr::GetInstance()->GetKey());
					lam->SetPlayerID(plNetClientMgr::GetInstance()->GetPlayerID());
					lam->Send();
				}
			}
			else
			{
				plLinkInDoneMsg* lid = TRACKED_NEW plLinkInDoneMsg;
				lid->AddReceiver(fLinks[i]->GetLinkKey());
				lid->SetBCastFlag(plMessage::kPropagateToModifiers);
				lid->Send();					

				if (fLinks[i]->GetLinkKey() == plNetClientApp::GetInstance()->GetLocalPlayerKey())
				{
					plLinkInDoneMsg* lid = TRACKED_NEW plLinkInDoneMsg;
					lid->AddReceiver(plNetClientMgr::GetInstance()->GetKey());
					lid->Send();
				}
			}

			hsRefCnt_SafeUnRef(fLinks[i]);
			fLinks.Remove(i);

			hsStatusMessage("Done - removing link FX msg\n");
		}
	}
}

hsBool plLinkEffectsMgr::MsgReceive(plMessage *msg)
{
	plNetClientMgr* nc = plNetClientMgr::GetInstance();
	plNetLinkingMgr* lm = plNetLinkingMgr::GetInstance();

	plPseudoLinkEffectMsg* pSeudoMsg = plPseudoLinkEffectMsg::ConvertNoRef(msg);
	if (pSeudoMsg)
	{
		// verify valid avatar and "link" objects
		if (!pSeudoMsg->fAvatarKey) 
			return true;
		if (!pSeudoMsg->fLinkObjKey)
			return true;
		if (!pSeudoMsg->fLinkObjKey->ObjectIsLoaded())
			return true;
		if (!plNetClientMgr::GetInstance()->IsAPlayerKey(pSeudoMsg->fAvatarKey))
			return true;
		// send the trigger message to the avatar...
		plPseudoLinkAnimTriggerMsg* pMsg = TRACKED_NEW plPseudoLinkAnimTriggerMsg(true, pSeudoMsg->fAvatarKey);
		pMsg->SetSender(GetKey());
		pMsg->Send();
		IAddPsuedo(pSeudoMsg);
	}

	plPseudoLinkAnimCallbackMsg* pSeudoCallback = plPseudoLinkAnimCallbackMsg::ConvertNoRef(msg);
	if (pSeudoCallback)
	{
		// warp the avatar to his new position
		plPseudoLinkEffectMsg* pMsg = IFindPseudo(pSeudoCallback->fAvatarKey);
		if (pMsg)
		{
			plSceneObject* pObj = plSceneObject::ConvertNoRef(pMsg->fLinkObjKey->ObjectIsLoaded());
			if (pObj && pObj->GetCoordinateInterface())
			{
				hsMatrix44 mat = pObj->GetCoordinateInterface()->GetLocalToWorld();
				// create message
				plWarpMsg* pMsg = TRACKED_NEW plWarpMsg(mat);
				pMsg->SetWarpFlags(plWarpMsg::kFlushTransform);
				pMsg->AddReceiver(pSeudoCallback->fAvatarKey);
				plUoid U(kVirtualCamera1_KEY);
				plKey pCamKey = hsgResMgr::ResMgr()->FindKey(U);
				if (pCamKey)
				{
					pMsg->AddReceiver(pCamKey);
				}
				plgDispatch::MsgSend( pMsg );	// whoosh... off it goes
				// now make him re-appear
				plPseudoLinkAnimTriggerMsg* pTrigMsg = TRACKED_NEW plPseudoLinkAnimTriggerMsg(false, pSeudoCallback->fAvatarKey);
				pTrigMsg->SetSender(GetKey());
				pTrigMsg->Send();
				IRemovePseudo(pSeudoCallback->fAvatarKey);
				
			}
		}
	}
	plLinkEffectsTriggerPrepMsg *tpMsg = plLinkEffectsTriggerPrepMsg::ConvertNoRef(msg);
	if (tpMsg)
	{
		plNetApp::GetInstance()->DebugMsg("Received LinkEffectsTriggerPREPMsg\n");
		IAddWait(tpMsg->GetTrigger());
		plLinkEffectPrepBCMsg *bcpMsg = TRACKED_NEW plLinkEffectPrepBCMsg;
		bcpMsg->fLeavingAge = tpMsg->fLeavingAge;
		bcpMsg->fLinkKey = tpMsg->fLinkKey;
		bcpMsg->Send();

		return true;
	}

	plLinkEffectsTriggerMsg* pTriggerMsg = plLinkEffectsTriggerMsg::ConvertNoRef(msg);
	if (pTriggerMsg)
	{
		plNetApp::GetInstance()->DebugMsg("Received LinkEffectsTriggerMsg, local=%d, linkingIn=%d, stealth=%d", 
			!msg->HasBCastFlag(plMessage::kNetNonLocal),
			!pTriggerMsg->IsLeavingAge(), pTriggerMsg->GetInvisLevel());

		plKey linkKey = pTriggerMsg->GetLinkKey();
		if (linkKey == nil)
			return true;

		if ((linkKey != nc->GetLocalPlayerKey()) &&
			(!pTriggerMsg->IsLeavingAge()))
		{
			if (IHuntDeadlist(pTriggerMsg)) // Just an obselete safety trigger
				return true;
			
			if (!IHuntWaitlist(pTriggerMsg))
			{
				plNetApp::GetInstance()->DebugMsg("Unexpected linkEffectsTriggerMsg. Ignoring\n");
				return true;
			}
		}
		
		plSceneObject *avatar = plSceneObject::ConvertNoRef(linkKey->ObjectIsLoaded());
		if (avatar == nil)
		{
			plNetApp::GetInstance()->DebugMsg("Can't find avatar, mod=%s\n", linkKey->GetName());
			return true;
		}

		// This is not the right place to catch this problem.
//		if (IFindLinkTriggerMsg(linkKey) != nil)
//		{ 
//			hsAssert(false, "Trying to link an Avatar already in the process of linking.");
//			return true;
//		}
		
		if (pTriggerMsg->GetInvisLevel() && linkKey != nc->GetLocalPlayerKey())
		{
#ifdef PLASMA_EXTERNAL_RELEASE
			// Verify that the server told us that the invisible avatar is a CCR
			plNetTransportMember* mbr=nc->TransportMgr().GetMember(nc->TransportMgr().FindMember(linkKey));
			if (!mbr || mbr->GetCCRLevel()<pTriggerMsg->GetInvisLevel())
			{
				plNetApp::StaticErrorMsg("Remote Avatar trying to be stealthy - REJECTING since he's not a CCR");
			}
			else
#endif
			{
				plNetApp::StaticDebugMsg("Remote Avatar is in stealth mode - making invisible");
				nc->MakeCCRInvisible(pTriggerMsg->GetLinkKey(), pTriggerMsg->GetInvisLevel());
			}
		}
		
		if (pTriggerMsg->IsLeavingAge())
			hsStatusMessage("Starting LinkOut FX\n");
		else
			hsStatusMessage("Starting LinkIn FX\n");
		
		plLinkEffectBCMsg *BCMsg = TRACKED_NEW plLinkEffectBCMsg();
		BCMsg->fLinkKey = linkKey;
		BCMsg->SetLinkFlag(plLinkEffectBCMsg::kLeavingAge, pTriggerMsg->IsLeavingAge());
		BCMsg->SetLinkFlag(plLinkEffectBCMsg::kSendCallback, true);
		
		// Check if you have a Yeesha book, and mute sound if you don't.
		// 'CleftSolved' gets set when you click on the linking panel in the cleft,
		// so we use that instead of checking KILevel.
		// Also, check if you're going to/from the ACA, or through the fissure, and mute sound if you are.
		if (linkKey == nc->GetLocalPlayerKey())
		{
			if(lm) {
				const char *ageName = lm->GetAgeLink()->GetAgeInfo()->GetAgeFilename();
				const char *prevAgeName = lm->GetPrevAgeLink()->GetAgeInfo()->GetAgeFilename();

				bool linkToStartup = ageName && !stricmp(ageName, kStartUpAgeFilename	);		// To Startup
				bool linkFromStartup = prevAgeName && !stricmp(prevAgeName,	kStartUpAgeFilename);	// Leaving Startup

				bool cleftSolved = VaultHasChronicleEntry( kCleftSolved );

				bool linkToACA = ageName &&	!stricmp(ageName, kAvCustomizationFilename);
				bool linkFromACA = prevAgeName && !stricmp(prevAgeName,	kAvCustomizationFilename);

				bool linkToFissureDrop = lm && 
										lm->GetAgeLink()->HasSpawnPt() && 
										lm->GetAgeLink()->SpawnPoint().GetName() &&
										!stricmp(lm->GetAgeLink()->SpawnPoint().GetName(), kCleftAgeLinkInPointFissureDrop);
				bool linkToDsntFromShell = lm && 
										lm->GetAgeLink()->HasSpawnPt() && 
										lm->GetAgeLink()->SpawnPoint().GetTitle() &&
										!stricmp(lm->GetAgeLink()->SpawnPoint().GetTitle(), kDescentLinkFromShell);
				if ( linkToACA || linkFromACA || linkToStartup || linkFromStartup || linkToFissureDrop || linkToDsntFromShell)
				{
					BCMsg->SetLinkFlag(plLinkEffectBCMsg::kMute);
				}			
			}
		}
		
		BCMsg->SetSender(GetKey());
		if (msg->HasBCastFlag(plMessage::kNetNonLocal))
			// terminate the remote cascade and start a new (local) cascade, since the rcvr is localOnly and will reject remote msgs
			BCMsg->SetBCastFlag(plMessage::kNetStartCascade);	
		plgDispatch::MsgSend(BCMsg);
		
		if (!pTriggerMsg->IsLeavingAge()) // Avatar is currently entering a new age
		{
			plATCAnim *linkInAnim = nil;
			plKey linkInAnimKey = nil;
			const plArmatureMod *avMod = plArmatureMod::ConvertNoRef(avatar->GetModifierByType(plArmatureMod::Index()));
			if (pTriggerMsg->HasBCastFlag(plMessage::kNetNonLocal))
			{
				// Remote trigger, they should tell us how they linked in.
				linkInAnimKey = pTriggerMsg->GetLinkInAnimKey();
			}
			else
			{
				// this is our backup trigger we send ourselves. We've already received the remote player's SDL.
				linkInAnimKey = avMod ? avMod->GetLinkInAnimKey() : nil;
			}
			linkInAnim = plATCAnim::ConvertNoRef(linkInAnimKey ? linkInAnimKey->ObjectIsLoaded() : nil);
			
			if (avMod && linkInAnim)
			{	
				plAvOneShotTask *task = TRACKED_NEW plAvOneShotTask(linkInAnim->GetName(), false, false, nil);
				task->fBackwards = true;
				task->fDisableLooping = true;
				task->fDisablePhysics = false;
				(TRACKED_NEW plAvTaskMsg(GetKey(), avMod->GetKey(), task))->Send();
			}
				
		}
		
		IAddLink(pTriggerMsg); // refs the avatarMod
		
		// Dummy msg sent after the broadcast. This guarantees we have a callback to actually trigger the
		// link, plus we know any effect broadcast messages will have processed before this (and therefore
		// have told us to wait for them.)
		pTriggerMsg->fEffects++;
		plLinkCallbackMsg *dummyMsg = TRACKED_NEW plLinkCallbackMsg();
		dummyMsg->AddReceiver(GetKey());
		dummyMsg->fLinkKey = linkKey;
		plgDispatch::MsgSend(dummyMsg);

		return true;
	}

	// callbacks from linkout events
	plLinkCallbackMsg* pLinkCallbackMsg = plLinkCallbackMsg::ConvertNoRef(msg);
	if (pLinkCallbackMsg)
	{
		plNetApp::GetInstance()->DebugMsg("Received pLinkCallbackMsg, localmsg=%d\n", 
			!msg->HasBCastFlag(plMessage::kNetNonLocal));

		static char str[ 128 ];
		plLinkEffectsTriggerMsg *pTriggerMsg = IFindLinkTriggerMsg(pLinkCallbackMsg->fLinkKey);
		if (pTriggerMsg == nil)
		{
			hsAssert(true, "Received a callback for an avatar that isn't linking.");
			return true;
		}

		if (--pTriggerMsg->fEffects == 0)
		{
			plNetApp::GetInstance()->DebugMsg("All link callbacks received.\n" );
			plgDispatch::Dispatch()->RegisterForExactType(plTimeMsg::Index(), GetKey());
		}
		else if (pTriggerMsg->fEffects < 0 )
		{
			plNetApp::GetInstance()->DebugMsg("Too many link callbacks received for avatar %s. Ignoring extras.\n",
					pTriggerMsg->GetLinkKey()->GetName());			
		}
		else
		{
			plNetApp::GetInstance()->DebugMsg("%d link callbacks left until avatar %s links...\n", 
					 pTriggerMsg->fEffects, pTriggerMsg->GetLinkKey()->GetName());
		}
		return true;
	}

	plTimeMsg *time = plTimeMsg::ConvertNoRef(msg);
	if (time) // This is how we know we're out of the render function, and it's safe to pageIn/Out nodes
	{
		plgDispatch::Dispatch()->UnRegisterForExactType(plTimeMsg::Index(), GetKey());
		ISendAllReadyCallbacks();

		return true;
	}

	plPlayerPageMsg *pageMsg = plPlayerPageMsg::ConvertNoRef(msg);
	if (pageMsg)
	{
		if (pageMsg->fUnload)
		{
			IHuntWaitlist(pageMsg->fPlayer);
			return true;
		}

		const hsScalar kMaxTimeForLinkTrigger = 30.f;

		// If we're not loading state, we're in the age. So this avatar coming in must be linking in.
		// If the player is us, no prep is necessary.
		if (!plNetClientApp::GetInstance()->IsLoadingInitialAgeState() && 
			(pageMsg->fPlayer != nc->GetLocalPlayerKey()))
		{
			plLinkEffectsTriggerMsg *trigMsg = TRACKED_NEW plLinkEffectsTriggerMsg;
			trigMsg->SetLeavingAge(false);
			trigMsg->SetLinkKey(pageMsg->fPlayer);

			// Send off the prep message right away
			plLinkEffectsTriggerPrepMsg *trigPrepMsg = TRACKED_NEW plLinkEffectsTriggerPrepMsg;
			trigPrepMsg->fLinkKey = pageMsg->fPlayer;
			trigPrepMsg->SetTrigger(trigMsg);
			trigPrepMsg->Send(GetKey());

			// Send off a delayed safety trigger. If things are going along properly,
			// we'll get a trigger from the player linking in before this message is
			// received, and we'll ignore it.
			double timeToDeliver = hsTimer::GetSysSeconds() + kMaxTimeForLinkTrigger;
			trigMsg->SetTimeStamp(timeToDeliver);
			trigMsg->Send(GetKey());
		}
		
		return true;
	}

	return hsKeyedObject::MsgReceive(msg);
}

void plLinkEffectsMgr::WaitForEffect(plKey linkKey, hsScalar time)
{
	plLinkEffectsTriggerMsg *msg = IFindLinkTriggerMsg(linkKey);
	if (msg == nil)
	{
		hsAssert(true, "Request to wait on an effect for an avatar that isn't linking.");
		return;
	}

	msg->fEffects++;
	plLinkCallbackMsg *callback = TRACKED_NEW plLinkCallbackMsg();
	callback->fEvent = kStop;
	callback->fRepeats = 0;
	callback->fLinkKey = linkKey;
	double timeToDeliver = hsTimer::GetSysSeconds() + time;
	callback->SetTimeStamp( timeToDeliver );
	callback->Send( GetKey() );
}

plMessage *plLinkEffectsMgr::WaitForEffect(plKey linkKey)
{
	plLinkEffectsTriggerMsg *msg = IFindLinkTriggerMsg(linkKey);
	if (msg == nil)
	{
		hsAssert(true, "Request to wait on an effect for an avatar that isn't linking.");
		return nil;
	}

	msg->fEffects++;

	plLinkCallbackMsg *callback = TRACKED_NEW plLinkCallbackMsg();
	callback->fEvent = kStop;
	callback->fRepeats = 0;
	callback->fLinkKey = linkKey;
	callback->AddReceiver( GetKey() );
	return callback;
}

void plLinkEffectsMgr::WaitForPseudoEffect(plKey linkKey, hsScalar time)
{
	plPseudoLinkEffectMsg* msg = IFindPseudo(linkKey);
	if (msg == nil)
	{
		hsAssert(true, "Request to wait on an fake effect for an avatar that isn't fake linking.");
		return;
	}

	plPseudoLinkAnimCallbackMsg* callback = TRACKED_NEW plPseudoLinkAnimCallbackMsg();
	callback->fAvatarKey = linkKey;
	double timeToDeliver = hsTimer::GetSysSeconds() + time;
	callback->SetTimeStamp( timeToDeliver );
	callback->Send( GetKey() );
}

plPseudoLinkEffectMsg* plLinkEffectsMgr::IFindPseudo(plKey avatarKey)
{
	int i;
	for (i = 0; i < fPseudolist.GetCount(); i++)
	{
		if (fPseudolist[i]->fAvatarKey == avatarKey)
			return fPseudolist[i];
	}
	return nil;

}

void plLinkEffectsMgr::IRemovePseudo(plKey avatarKey)
{
	int i;
	for (i = 0; i < fPseudolist.GetCount(); i++)
	{
		if (fPseudolist[i]->fAvatarKey == avatarKey)
		{	
			fPseudolist.Remove(i);
			return;
		}
	}

}