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

#include "resource.h"
#include "plComponent.h"
#include "plComponentReg.h"
#include "../MaxMain/plMaxNode.h"
#include "hsUtils.h"
#include "plAutoUIBlock.h"
#include "plAutoUIParams.h"
#include "../pnSceneObject/plSceneObject.h"
#include "../MaxMain/plPluginResManager.h"
#include "../pnMessage/plObjRefMsg.h"
#include "plVolumeGadgetComponent.h"
#include "plGUIComponents.h"
#include "pfGUISkinComp.h"
#include "plExcludeRegionComponent.h"
#include "plAnimComponent.h"
#include "plNotetrackAnim.h"
#include "plOneShotComponent.h"
#include "plMultistageBehComponent.h"
#include "../plInterp/plAnimEaseTypes.h"
#include "../plAgeDescription/plAgeDescription.h"
#include "plWaterComponent.h"
#include "../plDrawable/plWaveSetBase.h"
#include "plClusterComponent.h"
#include "../plDrawable/plClusterGroup.h"
#include "plPhysicalComponents.h"
//#include "../plHavok1/plHKPhysical.h"
#include "../plAvatar/plSwimRegion.h"
#include "../../PubUtilLib/plSurface/plGrassShaderMod.h"
#include "plGrassComponent.h"

#include "notify.h"

#include <vector>
#include <set>
#include <map>
#include <string>

#include "../pfPython/plPythonFileMod.h"
#include "../pfPython/plPythonParameter.h"

// for DynamicText hack to get the plKeys (could probably be removed later)
#include "../plGImage/plDynamicTextMap.h"

//// plCommonPythonLib ///////////////////////////////////////////////////////
//	Derived class for our global python fileMods, since they go in to the 
//	BuiltIn page
//	2.4.03 mcn - Added sceneObjects to the list, so that we can have an 
//				 associated sceneObject for our mod

#include "../MaxMain/plCommonObjLib.h"
#include "../plSDL/plSDL.h"

class plCommonPythonLib : public plCommonObjLib
{
	public:
		virtual hsBool	IsInteresting( const plKey &objectKey )
		{
			if( objectKey->GetUoid().GetClassType() == plPythonFileMod::Index() )
				return true;
			if( objectKey->GetUoid().GetClassType() == plSceneObject::Index() &&
				strcmp( objectKey->GetUoid().GetObjectName(), plSDL::kAgeSDLObjectName ) == 0 )
				return true;
			return false;
		}
};

static plCommonPythonLib		sCommonPythonLib;



static void NotifyProc(void *param, NotifyInfo *info);

// Notify us on file open so we can check for bad Python components
void DummyCodeIncludePythonFileFunc()
{
	RegisterNotification(NotifyProc, nil, NOTIFY_FILE_POST_OPEN);
	RegisterNotification(NotifyProc, nil, NOTIFY_FILE_PRE_SAVE);
	RegisterNotification(NotifyProc, nil, NOTIFY_SYSTEM_POST_RESET);
	RegisterNotification(NotifyProc, nil, NOTIFY_SYSTEM_POST_NEW);
	RegisterNotification(NotifyProc, nil, NOTIFY_SYSTEM_SHUTDOWN2);
}

// Param block ID's
enum
{
	kPythonFileType_DEAD,
	kPythonFilePB,
	kPythonVersion,
	kPythonFileIsGlobal
};

class plPythonFileComponent : public plComponent
{
public:
	typedef std::map<plMaxNode*, plKey> PythonKeys;

	// When we're auto-exporting and can't pop up an error dialog, we cache our
	// errors here and blab about it at export time
	static std::string fPythonError;

protected:
	PythonKeys		fModKeys;
	hsTArray<plKey>	fOthersKeys;

public:
	plPythonFileComponent();

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

	virtual void AddReceiverKey(plKey key, plMaxNode* node=nil) { fOthersKeys.Append(key); }

	// Returns false if the Python file for this component wasn't loaded, and clears
	// the data in the PB to prevent Max from crashing.
	enum Validate
	{
		kPythonOk,
		kPythonNoFile,
		kPythonBadVer,
		kPythonNoVer,
	};
	Validate ValidateFile();

	const char* GetPythonName();

	virtual PythonKeys& GetKeys() { return fModKeys; }

	virtual hsBool DeInit(plMaxNode *node, plErrorMsg *pErrMsg)
	{ 
		fModKeys.clear();
		fOthersKeys.Reset();

		return plComponent::DeInit(node, pErrMsg);
	}
};

CLASS_DESC(plPythonFileComponent, gPythonFileComponentDesc, "Python File", "PythonFile", COMP_TYPE_LOGIC, PYTHON_FILE_CID);

std::string plPythonFileComponent::fPythonError;

////////////////////////////////////////////////////////////////////////////////
// Called by the Python File manager
//

// Storage for all the registered Python file types
static std::vector<plAutoUIBlock*> gAutoUIBlocks;

void PythonFile::AddAutoUIBlock(plAutoUIBlock *block)
{
	for (int i = 0; i < gAutoUIBlocks.size(); i++)
	{
		if (gAutoUIBlocks[i]->GetBlockID() == block->GetBlockID())
		{
			char buf[256];
			sprintf(buf,
				"Duplicate Python File ID\n\n"
				"%s and %s use ID %d\n\n"
				"%s will be ignored.",
				gAutoUIBlocks[i]->GetName(),
				block->GetName(),
				block->GetBlockID(),
				block->GetName());
			hsMessageBox(buf, "Warning", hsMBoxOk);
			return;
		}
	}

	gAutoUIBlocks.push_back(block);
}

plComponentClassDesc *PythonFile::GetClassDesc()
{
	return &gPythonFileComponentDesc;
}

static plAutoUIBlock *FindAutoUI(IParamBlock2 *pb)
{
	if (!pb)
		return nil;

	for (int i = 0; i < gAutoUIBlocks.size(); i++)
	{
		if (gAutoUIBlocks[i]->GetBlockID() == pb->ID())
			return gAutoUIBlocks[i];
	}

	return nil;
}

////////////////////////////////////////////////////////////////////////////////


plPythonFileComponent::plPythonFileComponent()
{
	fClassDesc = &gPythonFileComponentDesc;
	fClassDesc->MakeAutoParamBlocks(this);
}

hsBool plPythonFileComponent::SetupProperties(plMaxNode *node, plErrorMsg *pErrMsg)
{
	if (fPythonError.length() > 0)
	{
		pErrMsg->Set(true, "Python Error", fPythonError.c_str()).Show();
		pErrMsg->Set();
		fPythonError = "";
	}

	fModKeys.clear();
	return true;
}

hsBool plPythonFileComponent::PreConvert(plMaxNode *node, plErrorMsg *pErrMsg)
{
	IParamBlock2 *pb = (IParamBlock2*)fCompPB->GetReferenceTarget(kPythonFilePB);
	plAutoUIBlock *block = FindAutoUI(pb);

	if (!block)
		return false;

	// if this is a multi-modifier python file component then is this the main (or first) maxnode
	bool	mainMultiModierNode = false;

	plPythonFileMod *mod = TRACKED_NEW plPythonFileMod;

	// create the modifier key ourselves so that we can get the name of the modifier in the name
	plSceneObject *obj = node->GetSceneObject();
	plKey modKey;
	if( fCompPB->GetInt( kPythonFileIsGlobal ) )
	{
		// Do we already have this guy?
		plPythonFileMod *existingOne = plPythonFileMod::ConvertNoRef( sCommonPythonLib.FindObject( plPythonFileMod::kGlobalNameKonstant ) );
		if( existingOne != nil )
		{
			// This component already exists, which can happen since it's in a common page. So we need
			// to nuke the key and its object so we can reuse it.
			modKey = existingOne->GetKey();

			// But first detach it from its target sceneObject
			if( existingOne->GetTarget( 0 ) != nil )
				existingOne->GetTarget( 0 )->GetKey()->Release( modKey );

			if( !sCommonPythonLib.RemoveObjectAndKey( modKey ) )
			{
				pErrMsg->Set( true, "Python File Component Error", 
									"The global Python File Component %s is attempting to export over an already "
									"existing component of the same name, and the exporter is unable to delete the "
									"old object to replace it. This would be a good time to call mcn for help.", GetINode()->GetName() ).Show(); 
				pErrMsg->Set( false );
			}

			// Pointer is invalid now anyways...
			existingOne = nil;
		}

		// Also make sure we have an age SDL object to attach to (currently only used for python, hence why it's safe here)
		obj = plSceneObject::ConvertNoRef( sCommonPythonLib.FindObject( plSDL::kAgeSDLObjectName ) );
		if( obj != nil )
		{
			plKey foo = obj->GetKey();
			if( !sCommonPythonLib.RemoveObjectAndKey( foo ) )
			{
				pErrMsg->Set( true, "Python File Component Error", 
									"The global Python File Component %s is attempting to export over an already "
									"existing component of the same name, and the exporter is unable to delete the "
									"old sceneObject to replace it. This would be a good time to call mcn for help.", GetINode()->GetName() ).Show(); 
				pErrMsg->Set( false );
			}

			// Pointer is invalid now anyways...
			obj = nil;
		}

		// Create us a new sceneObject to attach to
		obj = TRACKED_NEW plSceneObject;

		const plLocation &globalLoc = plPluginResManager::ResMgr()->GetCommonPage( node->GetLocation(), plAgeDescription::kGlobal );
		hsAssert( globalLoc.IsValid(), "Invalid common page location!!!" );
		modKey = hsgResMgr::ResMgr()->NewKey(plPythonFileMod::kGlobalNameKonstant, mod, globalLoc );

		// Make a key for our special sceneObject too
		plKey sdlObjectKey = hsgResMgr::ResMgr()->NewKey( plSDL::kAgeSDLObjectName, obj, globalLoc );
		plPluginResManager::ResMgr()->AddLooseEnd(sdlObjectKey);
	}
	else
	{
		if (block->IsMultiModifier())
		{
			// yup, then only create one modifier that will all the objects will attach to
			// in other words, one python module with many attached sceneobjects
			if ( fModKeys.empty())
			{
				// its empty so create the first and only one
				modKey = hsgResMgr::ResMgr()->NewKey(IGetUniqueName(node), mod, node->GetLocation());
				mainMultiModierNode = true;
			}
			else
			{
				// else we just take the first one (should be the only one)
				PythonKeys::iterator pos;
				pos = fModKeys.begin();
				modKey = pos->second;

				// Guess we won't be using that modifier we new'd up there. Does that mean we should delete it? Sure.
				delete mod;
				mod = nil;
			}
		}
		else	// else, nope... create a modifier for each object its attached to
		{
			modKey = hsgResMgr::ResMgr()->NewKey(IGetUniqueName(node), mod, node->GetLocation());
		}
	}
	hsgResMgr::ResMgr()->AddViaNotify(modKey, TRACKED_NEW plObjRefMsg(obj->GetKey(), plRefMsg::kOnCreate, -1, plObjRefMsg::kModifier), plRefFlags::kActiveRef);
	fModKeys[node] = modKey;

	// only let non-multimodifier or multimodifier then only the main node register for notifies
	if ( !block->IsMultiModifier() || mainMultiModierNode )
	{
		int nParams = block->NumParams();
		for (int i = 0; i < nParams; i++)
		{
			plAutoUIParam *param = block->GetParam(i);

			if (param->GetParamType() == plAutoUIParam::kTypeActivator)
			{
				// Register the modifier to recieve notifies from this activator.
				// We'll let the modifier know the activator key when it's available,
				// in the convert pass.
				int numcomps = param->GetCount(pb);
				for (int j=0; j< numcomps; j++ )
				{
					plComponentBase *comp = param->GetComponent(pb,j);
					if (comp)
						comp->AddReceiverKey(modKey);
				}
			}

			if (param->GetParamType() == plAutoUIParam::kTypeGUIDialog)
			{
				// Register the modifier to recieve notifies from this activator.
				// We'll let the modifier know the activator key when it's available,
				// in the convert pass.
				int numcomps = param->GetCount(pb);
				for (int j=0; j< numcomps; j++ )
				{
					plComponentBase *comp = param->GetComponent(pb,j);
					if (comp && comp->ClassID() == GUI_DIALOG_COMP_CLASS_ID )
					{
						// convert the comp to a GUIDialog component, so we can talk to it
						plGUIDialogComponent *dialog_comp = (plGUIDialogComponent*)comp;
						dialog_comp->SetNotifyReceiver(modKey);
					}
				}
			}
		}
	}

	return true;
}

#include "plActivatorBaseComponent.h"
#include "../pnKeyedObject/plKey.h"
#include "plResponderComponent.h"

hsBool plPythonFileComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
{
	IParamBlock2 *pb = (IParamBlock2*)fCompPB->GetReferenceTarget(kPythonFilePB);
	plAutoUIBlock *block = FindAutoUI(pb);

	if (!block)
		return false;

	plKey modKey = fModKeys[node];
	plPythonFileMod *mod = plPythonFileMod::ConvertNoRef(modKey->GetObjectPtr());

	// add in all the receivers that want to be notified from the Python coded script
	int j;
	for (j = 0; j < fOthersKeys.Count(); j++)
	{
		mod->AddToNotifyList(fOthersKeys[j]);
	}
	// remove all the Keys we know about to be re-built on the next convert
	fOthersKeys.Reset();

	// set the name of the source file
	mod->SetSourceFile(block->GetName());

	int nParams = block->NumParams();
	for (int i = 0; i < nParams; i++)
	{
		plAutoUIParam *param = block->GetParam(i);

		plPythonParameter pyParam;
		pyParam.fID = param->GetID();

		// Get the data for the param
		switch (param->GetParamType())
		{
		case plAutoUIParam::kTypeBool:
			pyParam.SetToBoolean(param->GetBool(pb));
			mod->AddParameter(pyParam);
			break;

		case plAutoUIParam::kTypeInt:
			pyParam.SetToInt(param->GetInt(pb));
			mod->AddParameter(pyParam);
			break;

		case plAutoUIParam::kTypeFloat:
			pyParam.SetToFloat(param->GetFloat(pb));
			mod->AddParameter(pyParam);
			break;

		case plAutoUIParam::kTypeString:
			pyParam.SetToString(param->GetString(pb));
			mod->AddParameter(pyParam);
			break;

		case plAutoUIParam::kTypeSceneObj:
			{
				int numKeys = param->GetCount(pb);
				hsBool found_atleast_one_good_one = false;
				for (int i = 0; i < numKeys; i++)
				{
					plKey skey = param->GetKey(pb, i);
					if ( skey != nil )
					{
						pyParam.SetToSceneObject(skey, true);
						// make sure that there really was a sceneobject
						mod->AddParameter(pyParam);
						found_atleast_one_good_one = true;
					}
				}
				if ( !found_atleast_one_good_one )
				{
					char buf[512];
					sprintf(buf,"The sceneobject attribute (ID=%d) that was selected in %s PythonFile, somehow does not exist!?",
								pyParam.fID,this->GetINode()->GetName());
					pErrMsg->Set(true, "PythonFile Warning", buf).Show();
					pErrMsg->Set(false);
				}
			}
			break;

		case plAutoUIParam::kTypeComponent:
			{
				int count = param->GetCount(pb);
				hsBool found_atleast_one_good_one = false;
				for (int i = 0; i < count; i++)
				{
					plComponentBase *comp = param->GetComponent(pb, i);
					if (comp)
					{
						for (int j = 0; j < comp->NumTargets(); j++)
						{
							plKey responderKey = Responder::GetKey(comp, comp->GetTarget(j));
							if ( responderKey != nil )
							{
								pyParam.SetToResponder(responderKey);
								mod->AddParameter(pyParam);
								found_atleast_one_good_one = true;
							}
						}
						if ( !found_atleast_one_good_one )
						{
							char buf[512];
							sprintf(buf,"The responder attribute %s that was selected in %s PythonFile, somehow does not exist!?",
										comp->GetINode()->GetName(),this->GetINode()->GetName());
							pErrMsg->Set(true, "PythonFile Warning", buf).Show();
							pErrMsg->Set(false);
						}
					}
				}
			}
			break;

		case plAutoUIParam::kTypeActivator:
			{
				int count = param->GetCount(pb);
				for (int i = 0; i < count; i++)
				{
					plComponentBase *comp = param->GetComponent(pb, i);
					// make sure we found a comp and then see if it is an activator type
					if (comp && comp->CanConvertToType(ACTIVATOR_BASE_CID))
					{
						plActivatorBaseComponent *activator = (plActivatorBaseComponent*)comp;
						const plActivatorBaseComponent::LogicKeys& logicKeys = activator->GetLogicKeys();
						plActivatorBaseComponent::LogicKeys::const_iterator it;
						for (it = logicKeys.begin(); it != logicKeys.end(); it++)
						{
							pyParam.SetToActivator(it->second);
							mod->AddParameter(pyParam);
						}
						// do special stuff for Volume sensors because they are stupid turds
						if (comp->ClassID() == VOLUMEGADGET_CID)
						{
							plVolumeGadgetComponent* pClick = (plVolumeGadgetComponent*)comp;
							const plVolumeGadgetComponent::LogicKeys &logicKeys2 = pClick->GetLogicOutKeys();
							plVolumeGadgetComponent::LogicKeys::const_iterator VGit;
							for (VGit = logicKeys2.begin(); VGit != logicKeys2.end(); VGit++)
							{
								pyParam.SetToActivator(VGit->second);
								mod->AddParameter(pyParam);
							}
						}
					}
					// now see if it is a PythonFile kinda activator thingy
					else if (comp && comp->ClassID() == PYTHON_FILE_CID)
					{
						plPythonFileComponent *pyfact = (plPythonFileComponent*)comp;
						const plPythonFileComponent::PythonKeys& pythonKeys = pyfact->GetKeys();
						plPythonFileComponent::PythonKeys::const_iterator it;
						for (it = pythonKeys.begin(); it != pythonKeys.end(); it++)
						{
							pyParam.SetToActivator(it->second);
							mod->AddParameter(pyParam);
						}
					}
				}
			}
			break;

		case plAutoUIParam::kTypeDynamicText:
			{
				int numKeys = param->GetCount(pb);
				for (int i = 0; i < numKeys; i++)
				{
					plKey key = param->GetKey(pb, i);
					// make sure we got a key and that it is a DynamicTextMap
					if (key && plDynamicTextMap::ConvertNoRef(key->GetObjectPtr()) )
					{
						pyParam.SetToDynamicText(key);
						mod->AddParameter(pyParam);
					}
				}
			}
			break;

		case plAutoUIParam::kTypeGUIDialog:
			{
				int count = param->GetCount(pb);
				for (int i = 0; i < count; i++)
				{
					plComponentBase *comp = param->GetComponent(pb, i);
					if (comp)
					{
						if (comp && comp->ClassID() == GUI_DIALOG_COMP_CLASS_ID )
						{
							// convert the comp to a GUIDialog component, so we can talk to it
							plGUIDialogComponent *dialog_comp = (plGUIDialogComponent*)comp;
							plKey dialogKey = dialog_comp->GetModifierKey();
							pyParam.SetToGUIDialog(dialogKey);
							if ( pyParam.fObjectKey == nil )
							{
								char buf[512];
								sprintf(buf,"The GUIDialog attribute %s that was selected in %s PythonFile, somehow does not exist!?",
											comp->GetINode()->GetName(),this->GetINode()->GetName());
								pErrMsg->Set(true, "PythonFile Warning", buf).Show();
								pErrMsg->Set(false);
							}
							else
							mod->AddParameter(pyParam);
						}
					}
				}
			}
			break;

		case plAutoUIParam::kTypeGUIPopUpMenu:
			{
				int count = param->GetCount(pb);
				for (int i = 0; i < count; i++)
				{
					plComponentBase *comp = param->GetComponent(pb, i);
					if (comp)
					{
						if (comp && comp->ClassID() == GUI_MENUANCHOR_CLASSID )
						{
							// convert the comp to a GUIPopUpMenu component, so we can talk to it
							plGUIMenuComponent *guiComp = (plGUIMenuComponent*)comp;
							plKey key = guiComp->GetConvertedMenuKey();
							pyParam.SetToGUIPopUpMenu( key );
							if ( pyParam.fObjectKey == nil )
							{
								char buf[512];
								sprintf(buf,"The GUIPopUpMenu attribute %s that was selected in %s PythonFile, somehow does not exist!?",
											comp->GetINode()->GetName(),this->GetINode()->GetName());
								pErrMsg->Set(true, "PythonFile Warning", buf).Show();
								pErrMsg->Set(false);
							}
							else
							mod->AddParameter(pyParam);
						}
					}
				}
			}
			break;

		case plAutoUIParam::kTypeGUISkin:
			{
				int count = param->GetCount(pb);
				for (int i = 0; i < count; i++)
				{
					plComponentBase *comp = param->GetComponent(pb, i);
					if (comp)
					{
						if (comp && comp->ClassID() == GUI_SKIN_CLASSID )
						{
							// convert the comp to a GUISkin component, so we can talk to it
							plGUISkinComp *guiComp = (plGUISkinComp *)comp;
							plKey key = guiComp->GetConvertedSkinKey();
							pyParam.SetToGUISkin( key );
							if ( pyParam.fObjectKey == nil )
							{
								char buf[512];
								sprintf(buf,"The GUISkin attribute %s that was selected in %s PythonFile, somehow does not exist!?",
											comp->GetINode()->GetName(),this->GetINode()->GetName());
								pErrMsg->Set(true, "PythonFile Warning", buf).Show();
								pErrMsg->Set(false);
							}
							else
							mod->AddParameter(pyParam);
						}
					}
				}
			}
			break;

		case plAutoUIParam::kTypeExcludeRegion:
			{
				int count = param->GetCount(pb);
				int number_of_real_targets_found = 0;
				for (int i = 0; i < count; i++)
				{
					plComponentBase *comp = param->GetComponent(pb, i);
					if (comp && comp->ClassID() == XREGION_CID )
					{
						for (int j = 0; j < comp->NumTargets(); j++)
						{
							plExcludeRegionComponent *excomp = (plExcludeRegionComponent*)comp;
							plKey exKey = excomp->GetKey((plMaxNode*)(comp->GetTarget(j)));
							if ( exKey != nil )
							{
								// only get one real target, just count the rest
								if ( number_of_real_targets_found == 0 )
								{
									pyParam.SetToExcludeRegion(exKey);
									mod->AddParameter(pyParam);
								}
								number_of_real_targets_found += 1;
							}
						}
						if ( number_of_real_targets_found != 1 )
						{
							// there is zero or more than one node attached to this exclude region
							char buf[512];
							if ( number_of_real_targets_found == 0 )
								sprintf(buf,"The ExcludeRegion %s that was selected as an attribute in %s PythonFile, has no scene nodes attached.",
											comp->GetINode()->GetName(),this->GetINode()->GetName());
							else
								sprintf(buf,"The ExcludeRegion %s that was selected as an attribute in %s PythonFile, has more than one scene node attached (using first one found).",
											comp->GetINode()->GetName(),this->GetINode()->GetName());

							pErrMsg->Set(true, "PythonFile Warning", buf).Show();
							pErrMsg->Set(false);
						}
					}
				}
			}
			break;
			
		case plAutoUIParam::kTypeWaterComponent:
			{
				plComponentBase* comp = param->GetComponent(pb, 0);
				plWaveSetBase* wsb = nil;

				if (comp)
				{
					wsb = plWaterComponent::GetWaveSet(comp->GetINode());

					if (wsb != nil)
					{
						plKey waterKey = wsb->GetKey();
						if ( waterKey != nil )
						{							
							pyParam.SetToWaterComponent(waterKey);
							mod->AddParameter(pyParam);
						}
					}
				}
			}
			break;

		case plAutoUIParam::kTypeSwimCurrentInterface:
			{
				plComponentBase* comp = param->GetComponent(pb, 0);
				plSwimRegionInterface* sri = nil;
				
				if (comp && comp->ClassID() == PHYS_SWIMSURFACE_CID)
				{
					plSwim2DComponent* swimcomp = (plSwim2DComponent*)comp;
					std::map<plMaxNode*, plSwimRegionInterface*>::const_iterator containsNode;
					plMaxNode* mnode = nil;

					for (int i = 0; i < swimcomp->NumTargets(); i++)
					{
						mnode = (plMaxNode*)swimcomp->GetTarget(i);
						containsNode = swimcomp->fSwimRegions.find(mnode);
						if ( containsNode != swimcomp->fSwimRegions.end() )
						{
							sri = swimcomp->fSwimRegions[mnode];
							break;
						}
					}

					if (sri != nil)
					{
						plKey swimKey = sri->GetKey();
						if ( swimKey != nil )
						{							
							pyParam.SetToSwimCurrentInterface(swimKey);
							mod->AddParameter(pyParam);
						}
					}
				}
			}
			break;
		
		case plAutoUIParam::kTypeClusterComponent:
			{
				plComponentBase* comp = param->GetComponent(pb, 0);
				plClusterGroup* clusterGroup = nil;

				if (comp && comp->ClassID() == CLUSTER_COMP_CID)
				{
					plClusterComponent* clusterComp = (plClusterComponent*)comp;
					int numGroups = clusterComp->GetNumGroups();
					int i;
					for (i=0; i<numGroups; i++)
					{
						plClusterGroup* group = clusterComp->GetGroup(i);
						plKey groupKey = group->GetKey();
						if (groupKey != nil)
						{
							pyParam.SetToClusterComponent(groupKey);
							mod->AddParameter(pyParam);
						}
					}
				}
			}
			break;

		case plAutoUIParam::kTypeAnimation:
			{
				int count = param->GetCount(pb);
				for (int i = 0; i < count; i++)
				{
					plComponentBase *comp = param->GetComponent(pb, i);
					if (comp && ( comp->ClassID() == ANIM_COMP_CID || comp->ClassID() == ANIM_GROUP_COMP_CID ) )
					{
						plAnimComponentBase *animcomp = (plAnimComponentBase*)comp;
						// save out the animation name first
						const char *tempAnimName = animcomp->GetAnimName();
						if (tempAnimName == nil)
							pyParam.SetToAnimationName(ENTIRE_ANIMATION_NAME);
						else
							pyParam.SetToAnimationName(tempAnimName);
						mod->AddParameter(pyParam);
						// gather up all the modkeys for all the targets attached to this animation component
						int j;
						for ( j=0; j<comp->NumTargets(); j++ )
						{
							pyParam.SetToAnimation(animcomp->GetModKey((plMaxNode*)(comp->GetTarget(j))));
							mod->AddParameter(pyParam);
						}
					}
				}
			}
			break;

		case plAutoUIParam::kTypeBehavior:
			{
				// The Behavior attribute is One-Shots and Multi-stage behaviors
				// For Python usage: we will only allow using behaviors that are
				// attached to one position node. In other words, Python will only
				// be used for special cases.
				int count = param->GetCount(pb);
				int number_of_real_targets_found = 0;
				for (int i = 0; i < count; i++)
				{
					plComponentBase *comp = param->GetComponent(pb, i);
					if (comp && comp->ClassID() == ONESHOTCLASS_ID )
					{
						// gather up all the modkeys for all the targets attached to this animation component
						int j;
						for ( j=0; j<comp->NumTargets(); j++ )
						{
							plKey behKey = OneShotComp::GetOneShotKey(comp,(plMaxNode*)(comp->GetTarget(j)));
							if ( behKey != nil )
							{
								// only get one real target, just count the rest
								if ( number_of_real_targets_found == 0 )
								{
									pyParam.SetToBehavior(behKey);
									mod->AddParameter(pyParam);
								}
								number_of_real_targets_found += 1;
							}
						}
					}
					else if (comp && comp->ClassID() == MULTISTAGE_BEH_CID )
					{
						// gather up all the modkeys for all the targets attached to this animation component
						int j;
						for ( j=0; j<comp->NumTargets(); j++ )
						{
							plKey behKey = MultiStageBeh::GetMultiStageBehKey(comp,(plMaxNode*)(comp->GetTarget(j)));
							if ( behKey != nil )
							{
								// only get one real target, just count the rest
								if ( number_of_real_targets_found == 0 )
								{
									pyParam.SetToBehavior(behKey);
									mod->AddParameter(pyParam);
								}
								number_of_real_targets_found += 1;
							}
						}
					}
					if ( number_of_real_targets_found != 1 )
					{
						// there is zero or more than one node attached to this exclude region
						char buf[512];
						if ( number_of_real_targets_found == 0 )
							sprintf(buf,"The Behavior component %s that was selected as an attribute in %s PythonFile, has no scene nodes attached.",
										comp->GetINode()->GetName(),this->GetINode()->GetName());
						else
							sprintf(buf,"The Behavior component %s that was selected as an attribute in %s PythonFile, has more than one scene node attached (using first one found).",
										comp->GetINode()->GetName(),this->GetINode()->GetName());

						pErrMsg->Set(true, "PythonFile Warning", buf).Show();
						pErrMsg->Set(false);
					}

				}
			}
			break;

		case plAutoUIParam::kTypeMaterial:
			{
				int numKeys = param->GetCount(pb);
				for (int i = 0; i < numKeys; i++)
				{
					plKey key = param->GetKey(pb, i);
					// make sure we got a key and that it is a plMipmap
					if (key && plMipmap::ConvertNoRef(key->GetObjectPtr()) )
					{
						pyParam.SetToMaterial(key);
						mod->AddParameter(pyParam);
					}
				}
			}
			break;
			
		case plAutoUIParam::kTypeMaterialAnimation:
			{
				plPickMaterialAnimationButtonParam* matAnim = (plPickMaterialAnimationButtonParam*)param;
				matAnim->CreateKeyArray(pb);

				int numKeys = param->GetCount(pb);
				for (int i = 0; i < numKeys; i++)
				{
					plKey key = param->GetKey(pb, i);
					
					if ( key )
					{
						pyParam.SetToMaterialAnimation(key);
						mod->AddParameter(pyParam);
					}
				}
				matAnim->DestroyKeyArray();

			}
			break;
		
		case plAutoUIParam::kTypeDropDownList:
			pyParam.SetToString(param->GetString(pb));
			mod->AddParameter(pyParam);
			break;

		case plAutoUIParam::kTypeGrassComponent:
			{
				plComponentBase* comp = param->GetComponent(pb, 0);
				plGrassShaderMod* shader = nil;

				if (comp)
				{
					shader = plGrassComponent::GetShader(comp->GetINode());

					if (shader != nil)
					{
						plKey shaderKey = shader->GetKey();
						if ( shaderKey != nil )
						{							
							pyParam.SetToGrassShaderComponent(shaderKey);
							mod->AddParameter(pyParam);
						}
					}
				}
			}
			break;

		}
	}

	return true;
}

plPythonFileComponent::Validate plPythonFileComponent::ValidateFile()
{
	// Make sure the type is in the valid range
	IParamBlock2 *pb = (IParamBlock2*)fCompPB->GetReferenceTarget(kPythonFilePB);
	plAutoUIBlock *block = FindAutoUI(pb);
	if (!block || fCompPB->GetInt(kPythonVersion) > block->GetVersion())
	{
		// Bad type, clear out the PB so this won't blow up during a save
		fCompPB->SetValue(kPythonFilePB, 0, (ReferenceTarget*)nil);

		if (!block)
			return kPythonNoFile;
		else
			return kPythonBadVer;
	}

	// Got a newer version of the Python file, update our version
	if (fCompPB->GetInt(kPythonVersion) < block->GetVersion())
		fCompPB->SetValue(kPythonVersion, 0, block->GetVersion());

	if (block->GetVersion() == 0)
		return kPythonNoVer;

	return kPythonOk;
}

const char* plPythonFileComponent::GetPythonName()
{
	// Make sure the type is in the valid range
	IParamBlock2 *pb = (IParamBlock2*)fCompPB->GetReferenceTarget(kPythonFilePB);
	plAutoUIBlock *block = FindAutoUI(pb);
	if (block)
		return block->GetName();

	return "(unknown)";
}

////////////////////////////////////////////////////////////////////////////////
// Verify that all Python File components in the scene are OK, and warn the user
// if any aren't
//

class plPythonError
{
public:
	plMaxNode* node;
	const char* pythonName;
	plPythonFileComponent::Validate error;

	bool operator< (const plPythonError& rhs) const { return rhs.node < node; }
};

typedef std::set<plPythonError> ErrorSet;

static void CheckPythonFileCompsRecur(plMaxNode *node, ErrorSet& badNodes)
{
	plComponentBase *comp = node->ConvertToComponent();
	if (comp && comp->ClassID() == PYTHON_FILE_CID)
	{
		plPythonFileComponent* pyComp = (plPythonFileComponent*)comp;

		const char* pythonName = pyComp->GetPythonName();

		plPythonFileComponent::Validate valid = pyComp->ValidateFile();
		if (valid != plPythonFileComponent::kPythonOk)
		{
			plPythonError err;
			err.node = node;
			err.pythonName = pythonName;
			err.error = valid;
			badNodes.insert(err);
		}
	}

	for (int i = 0; i < node->NumberOfChildren(); i++)
		CheckPythonFileCompsRecur((plMaxNode*)node->GetChildNode(i), badNodes);
}

static BOOL CALLBACK WarnDialogProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
	if (msg == WM_INITDIALOG)
	{
		HWND hList = GetDlgItem(hDlg, IDC_COMP_LIST);

		LVCOLUMN lvc;
		lvc.mask = LVCF_TEXT;
		lvc.pszText = "Component";
		ListView_InsertColumn(hList, 0, &lvc);
		lvc.pszText = "Python File";
		ListView_InsertColumn(hList, 1, &lvc);
		lvc.pszText = "Error";
		ListView_InsertColumn(hList, 2, &lvc);

		ErrorSet *badNodes = (ErrorSet*)lParam;
		ErrorSet::iterator it = badNodes->begin();
		for (; it != badNodes->end(); it++)
		{
			plPythonError& err = *it;

			plMaxNode* node = err.node;
			plPythonFileComponent* comp = (plPythonFileComponent*)node->ConvertToComponent();

			LVITEM lvi;
			lvi.mask = LVIF_TEXT;
			lvi.pszText = (char*)node->GetName();
			lvi.iItem = 0;
			lvi.iSubItem = 0;
			int idx = ListView_InsertItem(hList, &lvi);

			ListView_SetItemText(hList, idx, 1, (char*)err.pythonName);

			switch (err.error)
			{
			case plPythonFileComponent::Validate::kPythonBadVer:
				ListView_SetItemText(hList, idx, 2, "Old Version");
				break;
			case plPythonFileComponent::Validate::kPythonNoVer:
				ListView_SetItemText(hList, idx, 2, "No Version");
				break;
			case plPythonFileComponent::Validate::kPythonNoFile:
				ListView_SetItemText(hList, idx, 2, "No File/Python Error");
				break;
			}
		}

		ListView_SetColumnWidth(hList, 0, LVSCW_AUTOSIZE);
		ListView_SetColumnWidth(hList, 1, LVSCW_AUTOSIZE);
		ListView_SetColumnWidth(hList, 2, LVSCW_AUTOSIZE);

		return TRUE;
	}
	else if (msg == WM_COMMAND)
	{
		if (HIWORD(wParam) == BN_CLICKED && (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL))
		{
			DestroyWindow(hDlg);
			return TRUE;
		}
	}

	return FALSE;
}

static void WriteBadPythonText(ErrorSet& badNodes)
{
	ErrorSet::iterator it = badNodes.begin();
	for (; it != badNodes.end(); it++)
	{
		plPythonError& err = *it;

		const char* compName = err.node->GetName();
		const char* pythonFile = err.pythonName;
		const char* errorText = "";
		switch (err.error)
		{
		case plPythonFileComponent::kPythonBadVer:
			errorText = "Old Version";
			break;
		case plPythonFileComponent::Validate::kPythonNoVer:
			errorText = "No Version";
			break;
		case plPythonFileComponent::Validate::kPythonNoFile:
			errorText = "No File/Python Error";
			break;
		}

		std::string& pythonError = plPythonFileComponent::fPythonError;
		pythonError += "Python component ";
		pythonError += compName;
		pythonError += " (file ";
		pythonError += pythonFile;
		pythonError += ") is bad.  Reason: ";
		pythonError += errorText;
		pythonError += "\n";
	}
}

static void NotifyProc(void *param, NotifyInfo *info)
{
	static bool gotBadPython = false;

	if (info->intcode == NOTIFY_FILE_POST_OPEN)
	{
		ErrorSet badNodes;
		CheckPythonFileCompsRecur((plMaxNode*)GetCOREInterface()->GetRootNode(), badNodes);

		if (badNodes.size() > 0)
		{
			gotBadPython = true;
			
			if (hsMessageBox_SuppressPrompts)
				WriteBadPythonText(badNodes);
			else
				CreateDialogParam(hInstance, MAKEINTRESOURCE(IDD_PYTHON_FILE_WARN), GetCOREInterface()->GetMAXHWnd(), WarnDialogProc, (LPARAM)&badNodes);
		}
		else
			gotBadPython = false;
	}
	else if (info->intcode == NOTIFY_FILE_PRE_SAVE)
	{
		if (gotBadPython)
		{
			hsMessageBox("This file has bad Python components in it, you REALLY shouldn't save it.",
						"Python Component Warning",
						hsMBoxOk);
		}
	}
	else if (info->intcode == NOTIFY_SYSTEM_POST_RESET ||
			info->intcode == NOTIFY_SYSTEM_POST_NEW)
	{
		gotBadPython = false;
	}
	// Have to do this at system shutdown 2 (really final shutdown) because it deletes the
	// descriptor, which Max may still try to use in between shutdown 1 and 2.
	else if (info->intcode == NOTIFY_SYSTEM_SHUTDOWN2)
	{
		int count = gAutoUIBlocks.size();
		for (int i = 0; i < count; i++)
		{
			delete gAutoUIBlocks[i];
		}
		gAutoUIBlocks.clear();
	}
}


////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////


class plPythonFileComponentProc : public ParamMap2UserDlgProc
{
public:
	plPythonFileComponentProc() : fAutoUI(nil) {}
	BOOL DlgProc(TimeValue t, IParamMap2 *map, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
	void DeleteThis() { DestroyAutoUI(); }

protected:
	plAutoUIBlock *fAutoUI;

	void CreateAutoUI(plAutoUIBlock *autoUI, IParamBlock2 *pb);
	void DestroyAutoUI();
};	
static plPythonFileComponentProc gPythonFileProc;

ParamBlockDesc2 gPythonFileBlk
(
	plComponent::kBlkComp, _T("PythonFile"), 0, &gPythonFileComponentDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,

	//rollout
	IDD_COMP_PYTHON_FILE, IDS_COMP_PYTHON, 0, 0, &gPythonFileProc,

	kPythonFilePB,			_T("pb"),		TYPE_REFTARG,	0, 0,
		end,

	kPythonVersion,			_T("version"),	TYPE_INT,		0, 0,
		end,

	kPythonFileIsGlobal,	_T("isGlobal"), TYPE_BOOL, 0, 0,
		p_ui,	TYPE_SINGLECHEKBOX, IDC_PYTHON_GLOBAL,
		p_default, FALSE,
		end,

	end
);

#define WM_LOAD_AUTO_UI WM_APP+1

BOOL plPythonFileComponentProc::DlgProc(TimeValue t, IParamMap2 *pmap, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch (msg)
	{
	case WM_INITDIALOG:
		{
			IParamBlock2 *pb = pmap->GetParamBlock();

			HWND hCombo = GetDlgItem(hWnd, IDC_PYTHON_FILE);
			ComboBox_ResetContent(hCombo);

			SetDlgItemText(hWnd, IDC_VER_TEXT, "");

			IParamBlock2 *pythonPB = (IParamBlock2*)pb->GetReferenceTarget(kPythonFilePB);
			plAutoUIBlock *pythonBlock = FindAutoUI(pythonPB);

			int numPythonFiles = gAutoUIBlocks.size();
			for (int i = 0; i < numPythonFiles; i++)
			{
				plAutoUIBlock *block = gAutoUIBlocks[i];
				const char *name = block->GetName();

				int idx = ComboBox_AddString(hCombo, name);
				ComboBox_SetItemData(hCombo, idx, i);
				if (block == pythonBlock)
				{
					ComboBox_SetCurSel(hCombo, idx);
					SetDlgItemInt(hWnd, IDC_VER_TEXT, block->GetVersion(), TRUE);
				}
			}

			// Crappy hack, see WM_LOAD_AUTO_UI
			PostMessage(hWnd, WM_LOAD_AUTO_UI, 0, 0);
		}
		return TRUE;

	// Crappy hack.  If we put up the python file UI before returning from WM_INITDIALOG
	// it will show up ABOVE the main UI.  To get around this we post a message that won't
	// get processed until after the main UI is put up.
	case WM_LOAD_AUTO_UI:
		{
			IParamBlock2 *pb = pmap->GetParamBlock();

			IParamBlock2 *pythonPB = (IParamBlock2*)pb->GetReferenceTarget(kPythonFilePB);
			plAutoUIBlock *pythonBlock = FindAutoUI(pythonPB);

			if (pythonBlock && pythonPB)
				CreateAutoUI(pythonBlock, pythonPB);
		}
		return TRUE;

	case WM_COMMAND:
		if (HIWORD(wParam) == CBN_SELCHANGE && LOWORD(wParam) == IDC_PYTHON_FILE)
		{
			HWND hCombo = (HWND)lParam;
			int sel = ComboBox_GetCurSel(hCombo);

			int type = ComboBox_GetItemData(hCombo, sel);

			plAutoUIBlock *block = gAutoUIBlocks[type];
			IParamBlock2 *autoPB = block->CreatePB();

			CreateAutoUI(block, autoPB);

			IParamBlock2 *pb = pmap->GetParamBlock();
			pb->SetValue(kPythonFilePB, 0, (ReferenceTarget*)autoPB);

			SetDlgItemInt(hWnd, IDC_VER_TEXT, block->GetVersion(), TRUE);

			return TRUE;
		}
		break;
	}
	
	return FALSE;	
}

void plPythonFileComponentProc::CreateAutoUI(plAutoUIBlock *autoUI, IParamBlock2 *pb)
{
	DestroyAutoUI();

	if (autoUI && pb)
	{
		fAutoUI = autoUI;
		autoUI->CreateAutoRollup(pb);
	}
}

void plPythonFileComponentProc::DestroyAutoUI()
{
	if (fAutoUI)
	{
		fAutoUI->DestroyAutoRollup();
		fAutoUI = nil;
	}
}