/*==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 "plPickNode.h"
#include "iparamb2.h"
#include <algorithm>

#include "plActivatorBaseComponent.h"
#include "plPythonFileComponent.h"
#include "plBehavioralComponents.h"
#include "plNavigableComponents.h"
#include "plPhysicalComponents.h"
#include "plCameraComponents.h"

class plPickNodeMax : public HitByNameDlgCallback
{
protected:
	bool fSingle;
	bool fCanConvertToType;
	IParamBlock2 *fPB;
	int fNodeListID;
	std::vector<Class_ID> fCIDs;	
	bool fRefKludge;
	plComponentBase *fComp;
	Mtl* fMtl;

	bool CanConvertToType(Object *obj);

public:
	plPickNodeMax(IParamBlock2 *pb, int nodeListID, std::vector<Class_ID>* cids, bool single, bool canConvertToType);

	virtual TCHAR *dialogTitle();
	virtual TCHAR *buttonText() { return "OK"; }

	virtual int filter(INode *node);

	virtual void proc(INodeTab &nodeTab);
	
	virtual BOOL showHiddenAndFrozen() { return TRUE; }
	virtual BOOL singleSelect() { return fSingle; }

	void SetRefKludge(bool on) { fRefKludge = on; }

	void SetComponent(plComponentBase *comp) { fComp = comp; }
	void SetMtl(Mtl* mtl) { fMtl = mtl; }
};

bool plPickNodeMax::CanConvertToType(Object *obj)
{
	for (int i = 0; i < fCIDs.size(); i++)
	{
		if (obj->CanConvertToType(fCIDs[i]))
			return true;
	}

	return false;
}

plPickNodeMax::plPickNodeMax(IParamBlock2 *pb, int nodeListID, std::vector<Class_ID>* cids, bool single, bool canConvertToType) :
  fPB(pb), fNodeListID(nodeListID), fSingle(single), fCanConvertToType(canConvertToType), fRefKludge(false), fComp(nil), fMtl(nil)
{
	if (cids)
		fCIDs = *cids; 
}

TCHAR *plPickNodeMax::dialogTitle()
{
	return fSingle ? "Select Node" : "Select Nodes";
}

int plPickNodeMax::filter(INode *node)
{
	if (node && node->GetObjectRef())
	{
		// Filtering by nodes a component is attached to
		if (fComp)
		{
			for (int i = 0; i < fComp->NumTargets(); i++)
			{
				if (fComp->GetTarget(i) == (plMaxNodeBase*)node)
					return TRUE;
			}

			return FALSE;
		}

		// Filtering by nodes with a specific material on them
		if (fMtl)
		{
			if (node->GetMtl() == fMtl)
				return TRUE;
			return FALSE;
		}

		// Not filtering by ClassID and node is hidden or frozen
		if (fCIDs.size() == 0 && (node->IsHidden() || node->IsFrozen()))
			return FALSE;

		// We aren't filtering by ClassID or we are and we found a match
		if (fCIDs.size() == 0 ||
			(fCanConvertToType && CanConvertToType(node->GetObjectRef()) ||
			std::find(fCIDs.begin(), fCIDs.end(), node->GetObjectRef()->ClassID()) != fCIDs.end()))
		{
			if (fSingle)
			{
				if (fPB->GetReferenceTarget(fNodeListID) == (ReferenceTarget*)node)
					return FALSE;
			}
			else
			{
				// Make sure we don't already ref this node
				for (int i = 0; i < fPB->Count(fNodeListID); i++)
				{
					if (fPB->GetReferenceTarget(fNodeListID, 0, i) == (ReferenceTarget*)node)
						return FALSE;
				}
			}

			// Don't allow a ref to ourselves (a cyclical reference)
			if (fPB->GetOwner() == node)
				return FALSE;

			// Approved and not in the list, add it
			return TRUE;
		}
	}

	return FALSE;
}

void plPickNodeMax::proc(INodeTab &nodeTab)
{
	if (nodeTab.Count() > 0)
	{
		if (!fRefKludge)
		{
			if (fSingle)
				fPB->SetValue(fNodeListID, 0, nodeTab[0]);
			else
				fPB->Append(fNodeListID, nodeTab.Count(), &nodeTab[0]);
		}
		// Have to be a little wacky here since some of the params that use this are
		// ReferenceTargets while some are actually INodes (like they're supposed to be).
		else
		{
			if (fSingle)
				fPB->SetValue(fNodeListID, 0, (ReferenceTarget*)nodeTab[0]);
			else
				fPB->Append(fNodeListID, nodeTab.Count(), (ReferenceTarget**)&nodeTab[0]);
		}
	}
}

#include "plPickNodeBase.h"

bool plPick::Node(IParamBlock2 *pb, int paramID, std::vector<Class_ID>* cids, bool single, bool canConvertToType)
{
	plPickNodeMax pick(pb, paramID, cids, single, canConvertToType);
	return (GetCOREInterface()->DoHitByNameDialog(&pick) != 0);
}

bool plPick::NodeRefKludge(IParamBlock2 *pb, int paramID, std::vector<Class_ID>* cids, bool single, bool canConvertToType)
{
	plPickNodeMax pick(pb, paramID, cids, single, canConvertToType);
	pick.SetRefKludge(true);
	return (GetCOREInterface()->DoHitByNameDialog(&pick) != 0);
}

bool plPick::CompTargets(IParamBlock2 *pb, int paramID, plComponentBase *comp)
{
	plPickCompNode pick(pb, paramID, comp);
	return pick.DoPick();
}

bool plPick::MtlNodes(IParamBlock2* pb, int paramID, Mtl* mtl)
{
	plPickMtlNode pick(pb, paramID, mtl);
	return pick.DoPick();
}

#include "plMultistageBehComponent.h"

bool plPick::Activator(IParamBlock2 *pb, int paramID, bool single)
{
	std::vector<Class_ID> cid;
	cid.push_back(ACTIVATOR_BASE_CID);
	cid.push_back(PYTHON_FILE_CID);
	cid.push_back(BEHAVIORAL_SITTING_CID);
	cid.push_back(MULTISTAGE_BEH_CID);
	cid.push_back(SUBWORLD_REGION_CID);
	plPickNodeMax pick(pb, paramID, &cid, single, true);

	return (GetCOREInterface()->DoHitByNameDialog(&pick) != 0);
}

bool plPick::DetectorEnable(IParamBlock2 *pb, int paramID, bool single)
{
	std::vector<Class_ID> cid;
	cid.push_back(ACTIVATOR_BASE_CID);
	cid.push_back(PYTHON_FILE_CID);
	cid.push_back(BEHAVIORAL_SITTING_CID);
	cid.push_back(NAV_LADDER_CID);
	cid.push_back(NAV_LADDER_CID);
	cid.push_back(CAM_REGION_CID);
	plPickNodeMax pick(pb, paramID, &cid, single, true);

	return (GetCOREInterface()->DoHitByNameDialog(&pick) != 0);
}

#include "plGUIComponents.h"

bool plPick::GUIDialog(IParamBlock2 *pb, int paramID, bool single)
{
	std::vector<Class_ID> cid;
	cid.push_back(GUI_DIALOG_COMP_CLASS_ID);
	plPickNodeMax pick(pb, paramID, &cid, single, true);

	return (GetCOREInterface()->DoHitByNameDialog(&pick) != 0);
}

bool plPick::GenericClass(IParamBlock2 *pb, int paramID, bool single, Class_ID classIDToPick )
{
	std::vector<Class_ID> cid;
	cid.push_back(classIDToPick);
	plPickNodeMax pick(pb, paramID, &cid, single, true);

	return (GetCOREInterface()->DoHitByNameDialog(&pick) != 0);
}

#include "plExcludeRegionComponent.h"

bool plPick::ExcludeRegion(IParamBlock2 *pb, int paramID, bool single)
{
	std::vector<Class_ID> cid;
	cid.push_back(XREGION_CID);
	plPickNodeMax pick(pb, paramID, &cid, single, true);

	return (GetCOREInterface()->DoHitByNameDialog(&pick) != 0);
}

#include "plWaterComponent.h"

bool plPick::WaterComponent(IParamBlock2 *pb, int paramID, bool single)
{
	std::vector<Class_ID> cid;
	cid.push_back(WATER_COMP_CID);
	plPickNodeMax pick(pb, paramID, &cid, single, true);

	return (GetCOREInterface()->DoHitByNameDialog(&pick) != 0);
}

#include "plPhysicalComponents.h"

bool plPick::Swim2DComponent(IParamBlock2 *pb, int paramID, bool single)
{
	std::vector<Class_ID> cid;
	cid.push_back(PHYS_SWIMSURFACE_CID);
	plPickNodeMax pick(pb, paramID, &cid, single, true);

	return (GetCOREInterface()->DoHitByNameDialog(&pick) != 0);
}

#include "plClusterComponent.h"

bool plPick::ClusterComponent(IParamBlock2 *pb, int paramID, bool single)
{
	std::vector<Class_ID> cid;
	cid.push_back(CLUSTER_COMP_CID);
	plPickNodeMax pick(pb, paramID, &cid, single, true);

	return (GetCOREInterface()->DoHitByNameDialog(&pick) != 0);
}

#include "plAnimComponent.h"

bool plPick::Animation(IParamBlock2 *pb, int paramID, bool single)
{
	std::vector<Class_ID> cid;
	cid.push_back(ANIM_COMP_CID);
	cid.push_back(ANIM_GROUP_COMP_CID);
	plPickNodeMax pick(pb, paramID, &cid, single, true);

	return (GetCOREInterface()->DoHitByNameDialog(&pick) != 0);
}

#include "plOneShotComponent.h"
#include "plMultistageBehComponent.h"

bool plPick::Behavior(IParamBlock2 *pb, int paramID, bool single)
{
	std::vector<Class_ID> cid;
	cid.push_back(ONESHOTCLASS_ID);
	cid.push_back(MULTISTAGE_BEH_CID);
	plPickNodeMax pick(pb, paramID, &cid, single, true);

	return (GetCOREInterface()->DoHitByNameDialog(&pick) != 0);
}

#include "plGrassComponent.h"

bool plPick::GrassComponent(IParamBlock2 *pb, int paramID, bool single)
{
	std::vector<Class_ID> cid;
	cid.push_back(GRASS_COMPONENT_CLASS_ID);
	plPickNodeMax pick(pb, paramID, &cid, single, true);

	return (GetCOREInterface()->DoHitByNameDialog(&pick) != 0);
}