/*==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"
//Resource related
#include "resource.h"

//Max related
#include "plComponent.h"
#include "plComponentReg.h"

//Messages related
#include "plgDispatch.h"
#include "../pnMessage/plObjRefMsg.h"
#include "../pnMessage/plIntRefMsg.h"
#include "../pnMessage/plNodeRefMsg.h"
#include "../MaxMain/plPlasmaRefMsgs.h"

//Scene related
#include "../plScene/plSceneNode.h"
#include "../plInterp/plController.h"
#include "../MaxMain/plMaxNode.h"
#include "../MaxMain/plMaxNodeData.h"
#include "../pnKeyedObject/plKey.h"
#include "../pnSceneObject/plSceneObject.h"
#include "../pnSceneObject/plCoordinateInterface.h"
#include "hsResMgr.h"

//Conversion related
#include "../MaxConvert/hsConverterUtils.h"
#include "../MaxConvert/hsControlConverter.h"

//Avatar related
#include "../plAvatar/plAGAnim.h"
#include "../plAvatar/plMatrixChannel.h"
#include "BipedKiller.h"

//Anim related
#include "plNotetrackAnim.h"


//
//	DummyCodeIncludeFuncAGComp Function
//		Necessary to keep the compiler from tossing this file.
//		No functions herein are directly called, excepting this
//		one.
//
//
void DummyCodeIncludeFuncAGComp()
{
}

enum	{
		kShareableBool,			//Added in v1
		kGlobalBool,			//Added in v1
		};

//////////////////////////////////////////////////////////////
//
//	AnimAvatar Component
//
//
//
class plAnimAvatarComponent : public plComponent
{
//protected:
//	static plAGAnimMgr *fManager;
public:
		plAnimAvatarComponent();
		virtual hsBool SetupProperties(plMaxNode* node, plErrorMsg *pErrMsg);

		virtual hsBool Convert(plMaxNode* node, plErrorMsg *pErrMsg);

		virtual plATCAnim * NewAnimation(const char *name, double begin, double end);

		hsBool ConvertNode(plMaxNode *node, plErrorMsg *pErrMsg);
		hsBool ConvertNodeSegmentBranch(plMaxNode *node, plAGAnim *mod, plErrorMsg *pErrMsg);
		hsBool MakePersistent(plMaxNode *node, plAGAnim *anim, const char *animName, plErrorMsg *pErrMsg);

		virtual void CollectNonDrawables(INodeTab& nonDrawables) { AddTargetsToList(nonDrawables); }

		void DeleteThis() { delete this; }
};

//plAGAnimMgr * plAnimAvatarComponent::fManager = nil;

CLASS_DESC(plAnimAvatarComponent, gAnimAvatarDesc, "Compound Animation",  "Compound Animation", COMP_TYPE_AVATAR, Class_ID(0x3192253d, 0x60c4178c))

//
//	Anim Avatar ParamBlock2
//
//
ParamBlockDesc2 gAnimAvatarBk
(	
	plComponent::kBlkComp, _T("CompoundAnim"), 0, &gAnimAvatarDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,

	//Roll out
	IDD_COMP_ANIM_AVATAR, IDS_COMP_ANIM_AVATARS, 0, 0, NULL,

	// params
	kShareableBool, _T("ShareableBool"), TYPE_BOOL, 0, 0, 	
		p_default, FALSE,
		p_ui,	TYPE_SINGLECHEKBOX, IDC_COMP_ANIM_AVATAR_SHAREBOOL,
		end,

	kGlobalBool, _T("ShareableBool"), TYPE_BOOL, 0, 0, 	
		p_default, FALSE,
		p_ui,	TYPE_SINGLECHEKBOX, IDC_COMP_ANIM_AVATAR_GLOBALBOOL,
		end,

	//kBoundCondRadio, _T("BoundingConditions"),		TYPE_INT, 		0, 0,
	//	p_ui,		TYPE_RADIO, 2, IDC_COMP_PHYS_DETECTOR_RAD1, IDC_COMP_PHYS_DETECTOR_RAD2,
	//	end,

	end
);


//
//	Anim Avatar CONSTRUCTOR
//
//
plAnimAvatarComponent::plAnimAvatarComponent()
{
	fClassDesc = &gAnimAvatarDesc;
	fClassDesc->MakeAutoParamBlocks(this);
}


//
//	Anim Avatar PRECONVERT
//
//
hsBool plAnimAvatarComponent::SetupProperties(plMaxNode *node, plErrorMsg *pErrMsg)
{
	if(node->GetMaxNodeData())
	{
		node->SetMovable(true);
		node->SetForceLocal(true);
		node->SetDrawable(false);
	}
	
	int childCount = node->NumberOfChildren();
	for (int i = 0; i < childCount; i++)
	{
		SetupProperties((plMaxNode *)node->GetChildNode(i), pErrMsg);
	}

	return true; 
}

//
//
// CONVERT
// top level conversion: recursive descent on the node and children
// for each node, search for segments to convert...
//
//
hsBool plAnimAvatarComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
{
	Interface *theInterface = node->GetInterface();
	RemoveBiped(node, theInterface);

	ConvertNode(node, pErrMsg);

	((plSceneNode *)node->GetRoomKey()->GetObjectPtr())->SetFilterGenericsOnly(true);
	
	return true;
}

//
// CONVERTNODE
// look for all the segments on this node and convert them
// recurse on children
//
//
hsBool plAnimAvatarComponent::ConvertNode(plMaxNode *node, plErrorMsg *pErrMsg)
{
	plNotetrackAnim noteAnim(node, pErrMsg);
	// does this node have any segments specified?
	if (noteAnim.HasNotetracks())
	{
		// for each segment we found: 
		while (const char *animName = noteAnim.GetNextAnimName())
		{
			plAnimInfo info = noteAnim.GetAnimInfo(animName);

			plATCAnim *anim = NewAnimation(info.GetAnimName(), info.GetAnimStart(), info.GetAnimEnd());

			const char *loopName = info.GetNextLoopName();
			if (loopName)
			{
				anim->SetLoop(true);
				hsScalar loopStart = info.GetLoopStart(loopName);
				hsScalar loopEnd = info.GetLoopEnd(loopName);
				anim->SetLoopStart(loopStart == -1 ? anim->GetStart() : loopStart);
				anim->SetLoopEnd(loopEnd == -1 ? anim->GetEnd() : loopEnd);
			}
			while (const char *marker = info.GetNextMarkerName())
				anim->AddMarker(marker, info.GetMarkerTime(marker));

			ConvertNodeSegmentBranch(node, anim, pErrMsg);
			MakePersistent(node, anim, info.GetAnimName(), pErrMsg);
		}
	}

	// let's see if the children have any segments specified...
	int childCount = node->NumberOfChildren();
	for (int i = 0; i < childCount; i++)
		ConvertNode((plMaxNode *)(node->GetChildNode(i)), pErrMsg);

	return true;
}

// NewAnimation -------------------------------------------------------------------------
// -------------
plATCAnim * plAnimAvatarComponent::NewAnimation(const char *name, double begin, double end)
{
	return TRACKED_NEW plATCAnim(name, begin, end); 
}


//
// CONVERT NODE SEGMENT BRANCH
// we're now in the middle of converting a segment
// every node gets an animation channel for the time period in question
//
//
hsBool plAnimAvatarComponent::ConvertNodeSegmentBranch(plMaxNode *node, plAGAnim *mod, plErrorMsg *pErrMsg)
{
	// Check for a suppression marker
	plNotetrackAnim noteAnim(node, pErrMsg);
	plAnimInfo info = noteAnim.GetAnimInfo(nil);
	hsBool suppressed = info.IsSuppressed(mod->GetName());

	// Get the affine parts and the TM Controller
	plSceneObject *obj = node->GetSceneObject();
	if(obj && !suppressed) {
		hsAffineParts parts;
		hsControlConverter::Instance().ReduceKeys(node->GetTMController(), node->GetKeyReduceThreshold());
		plController* tmc = hsControlConverter::Instance().ConvertTMAnim(obj, node, &parts, mod->GetStart(), mod->GetEnd());
		
		if (tmc)
		{
			plMatrixChannel *channel;
			hsMatrix44 constSetting;
			parts.ComposeMatrix(&constSetting);

			// If all our keys match, there's no point in keeping an animation controller
			// around. Just nuke it and replace it with a constant channel.
			if (tmc->PurgeRedundantSubcontrollers())
			{
				channel = TRACKED_NEW plMatrixConstant(constSetting);
				delete tmc;
				tmc = nil;
			}
			else
			{
				channel = TRACKED_NEW plMatrixControllerChannel(tmc, &parts);
			}
			plMatrixChannelApplicator *app = TRACKED_NEW plMatrixChannelApplicator();
			app->SetChannelName(node->GetKey()->GetName());
			app->SetChannel(channel);
			mod->AddApplicator(app);
		}

		// let's see if the children have any segments specified...
		int childCount = node->NumberOfChildren();
		for (int i = 0; i < childCount; i++)
			ConvertNodeSegmentBranch((plMaxNode *)(node->GetChildNode(i)), mod, pErrMsg);

		return true;
	} else {
		return false;
	}
}

plKey FindSceneNode(plMaxNode *node)
{
	plSceneObject *obj = node->GetSceneObject();
	if(obj)
	{
		return obj->GetSceneNode();
	} else {
		plMaxNode *parent = (plMaxNode *)node->GetParentNode();

		if(parent)
		{
			return FindSceneNode(parent);
		} else {
			return nil;
		}
	}
}

//
// MAKE PERSISTENT
// Perform wizardry necessary to make the object save itself.
//
//
hsBool plAnimAvatarComponent::MakePersistent(plMaxNode *node, plAGAnim *anim, const char *animName, plErrorMsg *pErrMsg)
{
	// new approach: add to the generic pool on the scene node
	plLocation nodeLoc = node->GetLocation();
	plKey sceneNodeKey = FindSceneNode(node);
	if(sceneNodeKey)
	{
		plKey animKey = hsgResMgr::ResMgr()->NewKey(animName, anim, nodeLoc);

		plNodeRefMsg* refMsg = TRACKED_NEW plNodeRefMsg(sceneNodeKey, plNodeRefMsg::kOnRequest, -1, plNodeRefMsg::kGeneric);

		hsgResMgr::ResMgr()->AddViaNotify(animKey, refMsg, plRefFlags::kActiveRef);
	}
	else
	{
		pErrMsg->Set(true, "Sorry", "Can't find node to save animation. Animation will not be saved.");
	}

	return true;
}




// plEmoteComponent ---------------------------------
// -----------------
class plEmoteComponent : public plAnimAvatarComponent
{
public:
	enum {
		kBodyUsage,
		kFadeIn,
		kFadeOut
	};
	
	enum {
		kBodyUnknown,
		kBodyUpper,
		kBodyFull
	};

	plEmoteComponent();
	virtual hsBool Convert(plMaxNode *node, plErrorMsg *pErrMsg);
	virtual plATCAnim * NewAnimation(const char *name, double begin, double end);

protected:
	float fFadeIn;
	float fFadeOut;
	plEmoteAnim::BodyUsage fBodyUsage;
};


// gEmoteDesc ---------------------------------------------------------------------------------------------------------------------
// -----------
CLASS_DESC(plEmoteComponent, gEmoteDesc, "Emote Animation",  "Emote Animation", COMP_TYPE_AVATAR, Class_ID(0x383c55ba, 0x6f1d454c))


// gEmoteDesc ----------
// -----------
ParamBlockDesc2 gEmoteBk
(
	plComponent::kBlkComp, _T("EmoteAnim"), 0, &gEmoteDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,

	//Roll out
	IDD_COMP_EMOTE, IDS_COMP_EMOTE, 0, 0, NULL,

	plEmoteComponent::kBodyUsage, _T("Blend"),		TYPE_INT, 		0, 0,
		p_ui,		TYPE_RADIO, 3,	IDC_BODY_UNKNOWN, IDC_BODY_UPPER, IDC_BODY_FULL,
		p_vals,	plEmoteComponent::kBodyUnknown, plEmoteComponent::kBodyUpper, plEmoteComponent::kBodyFull,
		p_default, plEmoteComponent::kBodyUnknown,
		end,

	plEmoteComponent::kFadeIn, _T("Length"), TYPE_FLOAT, 	0, 0,	
		p_default, 2.0,
		p_range, 0.1, 10.0,
		p_ui,	TYPE_SPINNER,	EDITTYPE_POS_FLOAT,	
		IDC_EMO_FADEIN, IDC_EMO_FADEIN_SPIN, 0.1,
		end,	

	plEmoteComponent::kFadeOut, _T("Length"), TYPE_FLOAT, 	0, 0,	
		p_default, 2.0,
		p_range, 0.1, 10.0,
		p_ui,	TYPE_SPINNER,	EDITTYPE_POS_FLOAT,	
		IDC_EMO_FADEOUT, IDC_EMO_FADEOUT_SPIN, 0.1,
		end,	


	end
);


// plEmoteComponent ----------------
// -----------------
plEmoteComponent::plEmoteComponent()
{
	fClassDesc = &gEmoteDesc;
	fClassDesc->MakeAutoParamBlocks(this);
}


// Convert ------------------------------------------------------------
// --------
plEmoteComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
{
	Interface *theInterface = node->GetInterface();
	RemoveBiped(node, theInterface);

	fFadeIn = fCompPB->GetFloat(kFadeIn);
	fFadeOut = fCompPB->GetFloat(kFadeOut);
	fBodyUsage = static_cast<plEmoteAnim::BodyUsage>(fCompPB->GetInt(kBodyUsage));

	ConvertNode(node, pErrMsg);
	((plSceneNode *)node->GetRoomKey()->GetObjectPtr())->SetFilterGenericsOnly(true);
	return true;
}


// NewAnimation ----------------------------------------------------------------------
// -------------
plATCAnim * plEmoteComponent::NewAnimation(const char *name, double begin, double end)
{
	return TRACKED_NEW plEmoteAnim(name, begin, end, fFadeIn, fFadeOut, fBodyUsage);
}