/*==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 "HeadSpin.h"

#include "plCameraModifier.h"
#include "plCameraBrain.h"
#include "plVirtualCamNeu.h"
#include "hsTimer.h"
#include "plgDispatch.h"
#include "../pnSceneObject/plSceneObject.h"
#include "../pnSceneObject/plCoordinateInterface.h"
#include "../plMessage/plInputEventMsg.h"
#include "../plMessage/plAnimCmdMsg.h"
#include "../pnMessage/plTimeMsg.h"
#include "../pnKeyedObject/plKey.h"
#include "../pnKeyedObject/plFixedKey.h"
#include "../plInputCore/plInputDevice.h"
#include "../plInputCore/plInputManager.h"
#include "hsResMgr.h"
#include "../pnMessage/plCameraMsg.h"
#include "../plPhysical/plSimDefs.h"

#include "plPhysical.h"
#include "../pnSceneObject/plSimulationInterface.h"
#include "../plAvatar/plAvatarMgr.h"
#include "../plAvatar/plArmatureMod.h"
#include "../plAvatar/plAvCallbackAction.h"

// new stuff

plCameraModifier1::plCameraModifier1() :
fBrain(nil),
fSubObj(nil),
fFOVw(45.0f),
fFOVh(33.75f),
fAnimated(false),
fStartAnimOnPush(false),
fStopAnimOnPop(false),
fResetAnimOnPop(false),
fInSubLastUpdate(false),
fUpdateBrainTarget(false)
{
	fFrom.Set(0,0,0);
	fAt.Set(0,1,0);
}


plCameraModifier1::~plCameraModifier1()
{
	int i;
	for (i = 0; i < GetNumTrans(); i++)
		delete(GetTrans(i));
	fTrans.SetCountAndZero(0);
	
	for (i = 0; i < fMessageQueue.Count(); i++)
		hsRefCnt_SafeUnRef(fMessageQueue[i]);
	fMessageQueue.SetCountAndZero(0);

	for (i = 0; i < fFOVInstructions.Count(); i++)
		hsRefCnt_SafeUnRef(fFOVInstructions[i]);
	fFOVInstructions.SetCountAndZero(0);

}


void plCameraModifier1::AddTarget(plSceneObject* so)
{
	fTarget = so;
	if( plVirtualCam1::Instance() )
		plVirtualCam1::Instance()->AddCameraLoaded(so);
	fFrom = (so->GetWorldToLocal().GetTranslate());
	if (GetBrain())
	{
		if (fTarget->GetCoordinateInterface())
			GetBrain()->AddTarget();
		else
			fUpdateBrainTarget = true; // update the brain later
	}
	if (GetKey())
	{	
		plgDispatch::Dispatch()->RegisterForExactType(plEvalMsg::Index(), GetKey());
	}
}

void plCameraModifier1::SetSubject(plSceneObject* pObj)
{ 
	if (GetBrain())
		GetBrain()->SetSubject(pObj); 
	else 
		fSubObj = pObj; 
}

plSceneObject* plCameraModifier1::GetSubject()
{
	if (GetBrain())
		return GetBrain()->GetSubject();
	else
		return fSubObj;
}	

void plCameraModifier1::SetFOVw(hsScalar f, hsBool fUpdateVCam) 
{ 
	fFOVw = f; 
	if (plVirtualCam1::Instance() && fUpdateVCam)
		plVirtualCam1::SetFOV(fFOVw, fFOVh, this); 
}

void plCameraModifier1::SetFOVh(hsScalar f, hsBool fUpdateVCam) 
{ 
	fFOVh = f; 
	if (plVirtualCam1::Instance() && fUpdateVCam)
		plVirtualCam1::SetFOV(fFOVw, fFOVh, this); 
}

hsBool plCameraModifier1::SetFaded(hsBool b)
{
	if (GetBrain())
		return GetBrain()->SetFaded(b);
	return false;
}

hsBool plCameraModifier1::GetFaded()
{
	if (GetBrain())
		return GetBrain()->GetFaded();
	return false;
}
hsBool plCameraModifier1::MsgReceive(plMessage* msg)
{
	if (GetBrain())
		GetBrain()->MsgReceive(msg);
		
	plCameraMsg* pCamMsg = plCameraMsg::ConvertNoRef(msg);
	if (pCamMsg)
	{
		if (pCamMsg->Cmd(plCameraMsg::kAddFOVKeyframe))
		{
			hsRefCnt_SafeRef(msg);
			fFOVInstructions.Append(pCamMsg);
			return true;
		}
		else
		if (pCamMsg->Cmd(plCameraMsg::kSetAnimated))
		{
			fAnimated = true;
			return true;
		}
	}
	plEventCallbackMsg* pEventMsg = plEventCallbackMsg::ConvertNoRef(msg);
	if (pEventMsg)
	{
		double time = (double)fFOVInstructions[pEventMsg->fIndex]->GetConfig()->fAccel;
		double time2 = (double)pEventMsg->fEventTime;
		time = hsABS(time - time2);
		hsScalar h = fFOVInstructions[pEventMsg->fIndex]->GetConfig()->fFOVh;
		if (GetBrain())
			GetBrain()->SetFOVGoal(h, time);
	}

	plAnimCmdMsg* pAnimMsg = plAnimCmdMsg::ConvertNoRef(msg);
	if (pAnimMsg)
	{
		hsRefCnt_SafeRef(msg);
		msg->ClearReceivers();
		msg->AddReceiver(msg->GetSender());
		fMessageQueue.Append(msg);
		return true;
	}
	plGenRefMsg* pRefMsg = plGenRefMsg::ConvertNoRef(msg);
	if (pRefMsg )
	{
		if( pRefMsg->GetContext() & (plRefMsg::kOnCreate | plRefMsg::kOnRequest) )
		{
			if (pRefMsg->fType == kRefBrain)
			{
				plCameraBrain1* pBrain = plCameraBrain1::ConvertNoRef(pRefMsg->GetRef());
				if (pBrain)
				{
					pBrain->SetCamera(this);
					fBrain = pBrain;
					if (fSubObj)
						fBrain->SetSubject(fSubObj);
				}
			}
			else
			if (pRefMsg->fType == kRefCallbackMsg && fMessageQueue[pRefMsg->fWhich] != nil)
			{
				
				plgDispatch::MsgSend(fMessageQueue[pRefMsg->fWhich]);
				fMessageQueue[pRefMsg->fWhich] = nil;
			}
		}
		else if( pRefMsg->GetContext() & (plRefMsg::kOnDestroy | plRefMsg::kOnRemove) )
		{
			plCameraBrain1* pBrain = (plCameraBrain1*)(pRefMsg->GetRef());
			if (fBrain == pBrain)
				fBrain = nil;
		}
		return true;
	 }
	return plSingleModifier::MsgReceive(msg);
}


void plCameraModifier1::Update()
{
	// update the brain

	// this freeze thing is a useful debugging tool...	
	if (plVirtualCam1::Instance()->freeze)
		return;
	
	if (GetBrain())
	{
		if (fUpdateBrainTarget && fTarget->GetCoordinateInterface()) // if we need to update the brain and the target is loaded
		{
			fUpdateBrainTarget = false;
			GetBrain()->AddTarget(); // update the brain's target
		}

		hsBool moveInSub = !(GetBrain()->HasFlag(plCameraBrain1::kIgnoreSubworldMovement));

		if (moveInSub && GetBrain()->GetSubject())
		{
			plKey worldKey = nil;

			// First check if this is a physical.  If so, grab the subworld from that
			if (GetBrain()->GetSubject()->GetSimulationInterface())
			{
				plPhysical* phys = GetBrain()->GetSubject()->GetSimulationInterface()->GetPhysical();
				if (phys)
					worldKey = phys->GetWorldKey();
			}
			// Also, check if this is an avatar.  They don't have physicals, you
			// have to ask the avatar controller for the subworld key.
			if (!worldKey)
			{
				plArmatureMod* armMod = plAvatarMgr::FindAvatar(plKey(GetBrain()->GetSubject()->GetKey()));
				if (armMod && armMod->GetController() )
					worldKey = armMod->GetController()->GetSubworld();
			}

			if (worldKey)
			{
				// this picks up and moves the camera to it's previous subworld coordinate (so the subworld isn't moving out from underneath us)
				hsMatrix44 l2w, w2l;
				plSceneObject* so = plSceneObject::ConvertNoRef(worldKey->ObjectIsLoaded());
				if (so)
				{
					l2w = so->GetLocalToWorld();
					w2l = so->GetWorldToLocal();

					if (fInSubLastUpdate)
					{
						if (!(fLastSubPos == fFrom && fLastSubPOA == fAt))
						{
							SetTargetPos(l2w * fLastSubPos);
							SetTargetPOA(l2w * fLastSubPOA);
						}
					}
					else
					{
						fInSubLastUpdate = true;
					}
					GetBrain()->Update();
					fLastSubPos = w2l * GetTargetPos();
					fLastSubPOA = w2l * GetTargetPOA();
				}
				return;
			}
			else
			{
				fInSubLastUpdate = false;
			}
		}
		GetBrain()->Update();
		fLastSubPos = GetTargetPos();
		fLastSubPOA = GetTargetPOA();
	}
}	

void plCameraModifier1::Read(hsStream* stream, hsResMgr* mgr)
{
	hsKeyedObject::Read(stream, mgr);
	fBrain = nil;
	mgr->ReadKeyNotifyMe(stream, TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, 0, kRefBrain), plRefFlags::kActiveRef);
	int count = stream->ReadSwap32();
	int i;
	for (i = 0; i < count; i++)
	{
		
		plKey key = mgr->ReadKey(stream);
		hsBool cutpos = stream->ReadBool();
		hsBool cutpoa = stream->ReadBool();
		hsBool ignore = stream->ReadBool();
		hsScalar v = stream->ReadSwapScalar();
		hsScalar a = stream->ReadSwapScalar();
		hsScalar d = stream->ReadSwapScalar();
		hsScalar pV = stream->ReadSwapScalar();
		hsScalar pA = stream->ReadSwapScalar();
		hsScalar pD = stream->ReadSwapScalar();

		CamTrans* camTrans = TRACKED_NEW CamTrans(key);
		camTrans->fAccel = a;
		camTrans->fDecel = d;
		camTrans->fVelocity = v;
		camTrans->fPOAAccel = pA;
		camTrans->fPOADecel = pD;
		camTrans->fPOAVelocity = pV;
		camTrans->fCutPos = cutpos;
		camTrans->fCutPOA = cutpoa;
		camTrans->fIgnore = ignore;

		fTrans.Append(camTrans);
	}
	fFOVw = stream->ReadSwapFloat();
	fFOVh = stream->ReadSwapFloat();
	int	n = stream->ReadSwap32();
	fMessageQueue.SetCountAndZero(n);
	for(i = 0; i < n; i++ )
	{	
		plMessage* pMsg =  plMessage::ConvertNoRef(mgr->ReadCreatable(stream));
		fMessageQueue[i] = pMsg;
	}
	for(i = 0; i < n; i++ )
	{	
		mgr->ReadKeyNotifyMe(stream, TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, i, kRefCallbackMsg), plRefFlags::kActiveRef);
	}

	n = stream->ReadSwap32();
	fFOVInstructions.SetCountAndZero(n);
	for(i = 0; i < n; i++ )
	{	
		plCameraMsg* pMsg =  plCameraMsg::ConvertNoRef(mgr->ReadCreatable(stream));
		fFOVInstructions[i] = pMsg;
	}
	fAnimated = stream->ReadBool();
	fStartAnimOnPush = stream->ReadBool();
	fStopAnimOnPop = stream->ReadBool();
	fResetAnimOnPop = stream->ReadBool();
	
}

void plCameraModifier1::Write(hsStream* stream, hsResMgr* mgr)
{
	hsKeyedObject::Write(stream, mgr);
	if (fBrain)
		mgr->WriteKey(stream, fBrain );
	
	int i = fTrans.Count();
	stream->WriteSwap32(i);
	for (i = 0; i < fTrans.Count(); i++)
	{	
		mgr->WriteKey(stream, fTrans[i]->fTransTo);
		stream->WriteBool(fTrans[i]->fCutPos);
		stream->WriteBool(fTrans[i]->fCutPOA);
		stream->WriteBool(fTrans[i]->fIgnore);
		stream->WriteSwapScalar(fTrans[i]->fVelocity);
		stream->WriteSwapScalar(fTrans[i]->fAccel);
		stream->WriteSwapScalar(fTrans[i]->fDecel);
		stream->WriteSwapScalar(fTrans[i]->fPOAVelocity);
		stream->WriteSwapScalar(fTrans[i]->fPOAAccel);
		stream->WriteSwapScalar(fTrans[i]->fPOADecel);
	}
	stream->WriteSwapFloat(fFOVw);
	stream->WriteSwapFloat(fFOVh);
	stream->WriteSwap32(fMessageQueue.Count());
	for (i = 0; i < fMessageQueue.Count(); i++)
	{
		mgr->WriteCreatable(stream, fMessageQueue[i]);
	}
	for (i = 0; i < fMessageQueue.Count(); i++)
	{
		mgr->WriteKey(stream, fMessageQueue[i]->GetSender());
	}
	stream->WriteSwap32(fFOVInstructions.Count());
	for (i = 0; i < fFOVInstructions.Count(); i++)
	{
		mgr->WriteCreatable(stream, fFOVInstructions[i]);
	}
	stream->WriteBool(fAnimated);
	stream->WriteBool(fStartAnimOnPush);
	stream->WriteBool(fStopAnimOnPop);
	stream->WriteBool(fResetAnimOnPop);
}

void plCameraModifier1::Push(hsBool recenter)
{
	if (fAnimated)
	{
		if (fStartAnimOnPush)
		{
			plAnimCmdMsg* pMsg = TRACKED_NEW plAnimCmdMsg;
			pMsg->SetCmd(plAnimCmdMsg::kRunForward);
			pMsg->SetBCastFlag(plMessage::kPropagateToModifiers);
			pMsg->AddReceiver(GetTarget()->GetKey());
			if (GetBrain() && GetBrain()->GetSubject())
				pMsg->AddReceiver(GetBrain()->GetSubject()->GetKey());
			pMsg->Send();
		}
	}
	if (fBrain)
		fBrain->Push(recenter);


	if (GetKey())
	{	
		plgDispatch::Dispatch()->RegisterForExactType(plMouseEventMsg::Index(), GetKey());
	}
}

void plCameraModifier1::Pop()
{
	if (fAnimated)
	{
		if (fStopAnimOnPop)
		{
			plAnimCmdMsg* pMsg = TRACKED_NEW plAnimCmdMsg;
			pMsg->SetCmd(plAnimCmdMsg::kStop);
			pMsg->SetBCastFlag(plMessage::kPropagateToModifiers);
			pMsg->AddReceiver(GetTarget()->GetKey());
			if (GetBrain() && GetBrain()->GetSubject())
				pMsg->AddReceiver(GetBrain()->GetSubject()->GetKey());
			pMsg->Send();		
		}
		if (fResetAnimOnPop)
		{
			plAnimCmdMsg* pMsg = TRACKED_NEW plAnimCmdMsg;
			pMsg->SetCmd(plAnimCmdMsg::kGoToBegin);
			pMsg->SetBCastFlag(plMessage::kPropagateToModifiers);
			pMsg->AddReceiver(GetTarget()->GetKey());
			if (GetBrain() && GetBrain()->GetSubject())
				pMsg->AddReceiver(GetBrain()->GetSubject()->GetKey());
			pMsg->Send();
		}
	}
	if (fBrain)
		fBrain->Pop();
	if (GetKey()) // the reason we might not have a key is a special run-time POA which doesn't need to receive messages...
	{		
		plgDispatch::Dispatch()->UnRegisterForExactType(plMouseEventMsg::Index(), GetKey());
	}
}	

void plCameraModifier1::SetTransform(hsPoint3 at)
{
	if (!GetTarget())
		return;
	hsMatrix44 l2w;
	hsMatrix44 w2l;
	hsVector3 up(0,0,1);
	l2w.Make(&fFrom, &at, &up);
	l2w.GetInverse(&w2l);
	IGetTargetCoordinateInterface(0)->SetTransform( l2w, w2l );
}