/*==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==*/
#ifndef _plNotifyMsg_h_
#define _plNotifyMsg_h_

#include "plMessage.h"
#include "hsResMgr.h"
#include "pnModifier/plSingleModifier.h"
#include "hsUtils.h"
#include "hsGeometry3.h"


//
//  repeatable Event data in Notify message
//
// Updated 4.13.2002 mcn - Unions are all well and good, but only work on simple data types, and since
// plKey now isn't so simple...

class proEventData
{
public:
	// keep this enum synchronized with the list at the top of PlasmaTypes.py
	enum eventType
	{
		kCollision=1,
		kPicked =2,
		kControlKey=3,
		kVariable=4,
		kFacing=5,
		kContained=6,
		kActivate=7,
		kCallback=8,
		kResponderState=9,
		kMultiStage=10,
		kSpawned=11,
		kClickDrag=12,
		kCoop=13,
		kOfferLinkingBook=14,
		kBook=15,
		kClimbingBlockerHit=16,
		kNone
	};

	proEventData( Int32 evtType = kNone ) : fEventType( evtType )
	{
	}
	virtual ~proEventData() {}

	enum dataType
	{
		kNumber=1,
		kKey,
		kNotta
	};

	// what the multstage event types are for multistage.fEvent
	enum multiStageEventType
	{
		kEnterStage=1,
		kBeginingOfLoop,
		kAdvanceNextStage,
		kRegressPrevStage,
		kNothing
	};

	Int32 fEventType;		// what type of event (evenType enum)

	static proEventData* ICreateEventDataType(Int32 type);

	static proEventData* Read(hsStream* stream, hsResMgr* mgr);
	void Write(hsStream* stream, hsResMgr* mgr);

	static proEventData* ReadVersion(hsStream* s, hsResMgr* mgr);
	void WriteVersion(hsStream* s, hsResMgr* mgr);

protected:
	virtual void IInit() {}
	virtual void IDestruct() {}
	virtual void IRead(hsStream* stream, hsResMgr* mgr) {}
	virtual void IWrite(hsStream* stream, hsResMgr* mgr) {}

	virtual void IReadVersion(hsStream* s, hsResMgr* mgr) {}
	virtual void IWriteVersion(hsStream* s, hsResMgr* mgr) {}
};

// The following macro makes it easy (or easier) to define new event data types
#define proEventType(type) class pro##type##EventData : public proEventData { public: pro##type##EventData() : proEventData( k##type ) {IInit();} virtual ~pro##type##EventData(){IDestruct();}

proEventType(Collision)
	hsBool	fEnter;		// entering? (false is exit)
	plKey	fHitter;	// collision hitter (other probably player)
	plKey	fHittee;	// collision hittee (probably us)

protected:
	virtual void IRead(hsStream* stream, hsResMgr* mgr);
	virtual void IWrite(hsStream* stream, hsResMgr* mgr);

	virtual void IReadVersion(hsStream* s, hsResMgr* mgr);
	virtual void IWriteVersion(hsStream* s, hsResMgr* mgr);
};

proEventType(Picked)
	plKey	fPicker;	// who picked it (problably player)
	plKey	fPicked;	// object that was picked
	hsBool	fEnabled;	// pick (true) or un-pick (false)
	hsPoint3 fHitPoint;	// where on the picked object that it was picked on

protected:
	virtual void IRead(hsStream* stream, hsResMgr* mgr);
	virtual void IWrite(hsStream* stream, hsResMgr* mgr);

	virtual void IReadVersion(hsStream* s, hsResMgr* mgr);
	virtual void IWriteVersion(hsStream* s, hsResMgr* mgr);
};

proEventType(Spawned)
	plKey	fSpawner;	// who spawned it (typicall plNPCSpawnMod)
	plKey	fSpawnee;	// what was spawned (typically a scene object with an armature mod)

protected:
	virtual void IRead(hsStream* stream, hsResMgr* mgr);
	virtual void IWrite(hsStream* stream, hsResMgr* mgr);

	virtual void IReadVersion(hsStream* s, hsResMgr* mgr);
	virtual void IWriteVersion(hsStream* s, hsResMgr* mgr);
};

proEventType(ControlKey)
	Int32	fControlKey;	// what control key was hit
	hsBool	fDown;			// was the key going down (false if going up)

protected:
	virtual void IRead(hsStream* stream, hsResMgr* mgr);
	virtual void IWrite(hsStream* stream, hsResMgr* mgr);

	virtual void IReadVersion(hsStream* s, hsResMgr* mgr);
	virtual void IWriteVersion(hsStream* s, hsResMgr* mgr);
};

proEventType(Variable)
	char*	fName;			// name of variable
	Int32	fDataType;		// type of data

	// Can't be a union, sadly, but it isn't that much of a waste of space...
	hsScalar	fNumber;	// if its a number
	plKey		fKey;		// if its a plKey (pointer to something)


protected:
	virtual void IInit();
	virtual void IDestruct();
	virtual void IRead(hsStream* stream, hsResMgr* mgr);
	virtual void IWrite(hsStream* stream, hsResMgr* mgr);

	virtual void IReadVersion(hsStream* s, hsResMgr* mgr);
	virtual void IWriteVersion(hsStream* s, hsResMgr* mgr);
};

proEventType(Facing)
	plKey		fFacer; // what was facing
	plKey		fFacee; // what was being faced
	hsScalar	dot;	 // the dot prod of their view vectors
	hsBool		enabled; // Now meets facing requirement (true) or no longer meets requirement (false)

protected:
	virtual void IRead(hsStream* stream, hsResMgr* mgr);
	virtual void IWrite(hsStream* stream, hsResMgr* mgr);

	virtual void IReadVersion(hsStream* s, hsResMgr* mgr);
	virtual void IWriteVersion(hsStream* s, hsResMgr* mgr);
};

proEventType(Contained)
	plKey	fContained;	// who's inside of 
	plKey	fContainer;	// this containing volume
	hsBool	fEntering;	// entering volume (true) or exiting (false)

protected:
	virtual void IRead(hsStream* stream, hsResMgr* mgr);
	virtual void IWrite(hsStream* stream, hsResMgr* mgr);

	virtual void IReadVersion(hsStream* s, hsResMgr* mgr);
	virtual void IWriteVersion(hsStream* s, hsResMgr* mgr);
};

proEventType(Activate)
	hsBool fActive;		// Whether or not to use the data in this field
	hsBool fActivate;	// the data

protected:
	virtual void IRead(hsStream* stream, hsResMgr* mgr);
	virtual void IWrite(hsStream* stream, hsResMgr* mgr);

	virtual void IReadVersion(hsStream* s, hsResMgr* mgr);
	virtual void IWriteVersion(hsStream* s, hsResMgr* mgr);
};		

proEventType(Callback)
	Int32	fEventType;  // enumerated in plEventCallbackMsg.h

protected:
	virtual void IRead(hsStream* stream, hsResMgr* mgr);
	virtual void IWrite(hsStream* stream, hsResMgr* mgr);

	virtual void IReadVersion(hsStream* s, hsResMgr* mgr);
	virtual void IWriteVersion(hsStream* s, hsResMgr* mgr);
};

proEventType(ResponderState)
	Int32	fState;		// what state the responder should be switched to before triggering

protected:
	virtual void IRead(hsStream* stream, hsResMgr* mgr);
	virtual void IWrite(hsStream* stream, hsResMgr* mgr);

	virtual void IReadVersion(hsStream* s, hsResMgr* mgr);
	virtual void IWriteVersion(hsStream* s, hsResMgr* mgr);
};

proEventType(MultiStage)
	Int32	fStage;	
	Int32	fEvent;
	plKey	fAvatar;	// who was running the stage

protected:
	virtual void IRead(hsStream* stream, hsResMgr* mgr);
	virtual void IWrite(hsStream* stream, hsResMgr* mgr);

	virtual void IReadVersion(hsStream* s, hsResMgr* mgr);
	virtual void IWriteVersion(hsStream* s, hsResMgr* mgr);
};

proEventType(Coop)
	UInt32	fID;		// player ID of the initiator
	UInt16	fSerial;	// serial number for the initiator
protected:
	virtual void IRead(hsStream* stream, hsResMgr* mgr);
	virtual void IWrite(hsStream* stream, hsResMgr* mgr);

	virtual void IReadVersion(hsStream* s, hsResMgr* mgr);
	virtual void IWriteVersion(hsStream* s, hsResMgr* mgr);
};


proEventType(ClickDrag)
	plKey picker; // always the local avatar in this case
	plKey picked;
	hsScalar animPos; // 0.0 to 1.0 animation percentage
};

proEventType(OfferLinkingBook)
	plKey offerer; // the avatar offering the linking book to you
	int targetAge; // the age the book is for - taken from konstant list of age buttons in xLinkingBookPopupGUI.py
	int offeree; // who we are offering the book to
protected:
	virtual void IRead(hsStream* stream, hsResMgr* mgr);
	virtual void IWrite(hsStream* stream, hsResMgr* mgr);

	virtual void IReadVersion(hsStream* s, hsResMgr* mgr);
	virtual void IWriteVersion(hsStream* s, hsResMgr* mgr);
};

proEventType(Book)
	UInt32	fEvent;		// The type of event. See pfJournalBook.h for enumsu
	UInt32	fLinkID;	// The link ID of the image clicked, if an image link event, otherwise unused
protected:
	virtual void IRead(hsStream* stream, hsResMgr* mgr);
	virtual void IWrite(hsStream* stream, hsResMgr* mgr);

	virtual void IReadVersion(hsStream* s, hsResMgr* mgr);
	virtual void IWriteVersion(hsStream* s, hsResMgr* mgr);
};

proEventType(ClimbingBlockerHit)
	plKey	fBlockerKey;	// collision hittee (probably us)

protected:
	virtual void IRead(hsStream* stream, hsResMgr* mgr);
	virtual void IWrite(hsStream* stream, hsResMgr* mgr);

	virtual void IReadVersion(hsStream* s, hsResMgr* mgr);
	virtual void IWriteVersion(hsStream* s, hsResMgr* mgr);
};


/////////////////////////////////////////////////////////////////////////////
//
//  MESSAGE    : plNotifyMsg
//  PARAMETERS : none
//
//  PURPOSE    : This is the message that notifies someone (either a responder or activator)
//             : that some event or transition of state has happened
//
//
class plNotifyMsg : public plMessage
{
protected:
	virtual void IInit();

public:
	plNotifyMsg() { IInit(); }
	plNotifyMsg(const plKey &s, const plKey &r);
	~plNotifyMsg();

	CLASSNAME_REGISTER( plNotifyMsg );
	GETINTERFACE_ANY( plNotifyMsg, plMessage );

	// data area
	enum notificationType
	{
		kActivator=0,
		kVarNotification,
		kNotifySelf,

		kResponderFF,			// Fast forward
		kResponderChangeState,	// Change state without triggering
	};
	Int32		fType;				// what type of notification
	hsScalar	fState;				// state of the notifier 0.0=false, 1.0=true
	Int32		fID;				// special ID mostly for responder State transitions
	hsTArray<proEventData*> fEvents;// list of events with data

	void SetType(notificationType type) { fType = type; }
	void SetState(hsScalar state) { fState = state; }

	// event records for the notify message
	void AddEvent( proEventData* ed);
	void AddCollisionEvent( hsBool enter, const plKey &other, const plKey &self, hsBool onlyOneCollision=true );
	void AddPickEvent( const plKey &other, const plKey& self, hsBool enabled, hsPoint3 hitPoint );
	void AddControlKeyEvent( Int32 key, hsBool down );
	void AddVariableEvent( const char* name, hsScalar number );
	void AddVariableEvent( const char *name, const plKey &key);
	void AddFacingEvent( const plKey &other, const plKey &self, hsScalar dot, hsBool enabled);
	void AddContainerEvent( const plKey &container, const plKey &contained, hsBool entering);
	void AddActivateEvent( hsBool activate );
	void AddCallbackEvent( Int32 event );
	void AddResponderStateEvent( Int32 state );
	void AddMultiStageEvent( Int32 stage, Int32 event, const plKey& avatar );
	void AddCoopEvent(UInt32 id, UInt16 serial);
	void AddSpawnedEvent (const plKey &spawner, const plKey &spawned);
	void AddClickDragEvent(const plKey& dragger, const plKey& dragee, hsScalar animPos);
	void AddOfferBookEvent(const plKey& offerer, int targetAge, int offeree);
	void AddBookEvent( UInt32 event, UInt32 linkID = 0 );
	void AddHitClimbingBlockerEvent(const plKey &blocker);
	proEventData* FindEventRecord( Int32 eventtype );
	Int32 GetEventCount() { return fEvents.Count(); }
	proEventData* GetEventRecord(Int32 i) { return fEvents[i]; }
	void ClearEvents();

	// Searches the event records for an event triggered by an avatar, and returns that key
	plKey GetAvatarKey();

	// IO 
	void Read(hsStream* stream, hsResMgr* mgr);
	void Write(hsStream* stream, hsResMgr* mgr);
	
	void ReadVersion(hsStream* s, hsResMgr* mgr);
	void WriteVersion(hsStream* s, hsResMgr* mgr);
};



#endif // _plNotifyMsg_h_