#ifndef _IVFrameListener_H__
#define _IVFrameListener_H__

#include "CEGUIForwardRefs.h"
#include <Ogre.h>
#include <OgreKeyEvent.h>
#include <OgreEventListeners.h>
#include <OgreStringConverter.h>
#include <OgreException.h>
#include "VisibilityEnvironment.h"
#include "VisibilityManager.h"



class TestCullingIVApplication;


using namespace Ogre;


/** Frame listener specialised for terrains.
*/
class IVFrameListener: public FrameListener, public MouseListener, 
							public MouseMotionListener, public KeyListener
{
public:

	IVFrameListener(RenderWindow* win, 
						Camera* cam, 
						SceneManager *sceneManager, 
						CEGUI::Renderer *renderer, 
						Camera *vizCamera,
						SceneNode *camNode, 
						Light *sunLight,
						TestCullingIVApplication *app);

	~IVFrameListener();


	bool frameStarted(const FrameEvent& evt);
	bool frameEnded(const FrameEvent& evt);
   //bool processUnbufferedKeyInput(const FrameEvent& evt);
    

	/* MouseListener callbacks. */
	virtual void mouseClicked(MouseEvent* e) { }
	virtual void mouseEntered(MouseEvent* e) { }
	virtual void mouseExited(MouseEvent* e)  { }

	// This is when the mouse button goes DOWN.
	void mousePressed(MouseEvent* e);

	// This is when the mouse button is let UP.
	void mouseReleased(MouseEvent* e);

	/* MouseMotionListener callbacks */
	void mouseMoved(MouseEvent *e);

	// This is when the mouse is clicked, held and dragged.
	void mouseDragged(MouseEvent *e);

	void mouseDragDropped(MouseEvent *e);
	void keyPressed(KeyEvent* e);

	void keyReleased(KeyEvent* e);
	void keyClicked(KeyEvent* e);

	/** The information about camera position and orienation per frame.
	*/
	typedef struct
	{
		Vector3 position;
		Quaternion orientation;
		Real timeElapsed;
	} frame_info;

	enum  {WALKTHROUGH, REPLAY, STATE_NUM};

	// visualization modes for scene nodes
	enum {NODEVIZ_NONE, NODEVIZ_RENDER_NODES, NODEVIZ_RENDER_NODES_AND_CONTENT, NODEVIZ_MODES_NUM};
	//enum {NODEVIZ_NONE, NODEVIZ_RENDER_GEOMETRY, NODEVIZ_MODES_NUM};

	void zoomVizCamera(int zoom);

	void addFrameInfo(SceneNode *camNode, Real timeElapsed);
	void setCurrentFrameInfo(Real timeElapsed);

	void setAlgorithm(int algorithm);

	void moveCamera();

	void writeFrames();
	void loadFrames();

	bool processUnbufferedKeyInput(const FrameEvent& evt);
	bool processUnbufferedMouseInput(const FrameEvent& evt);

	void showStats(bool show);

	void updateStats();
	void toggleShowHelp();
	void toggleShowStats();

	void toggleShowShadows();
	void toggleDisplayCameraDetails();
	void takeScreenshot();
	void nextSceneDetailLevel();
	void nextFilter();
	void nextAlgorithm();
	void nextNodeVizMode();
	void nextAppState();
	void changeThreshold(int incr);
	void changeAssumedVisibility(int incr);
	void toggleTestGeometryForVisibleLeaves();
	void toggleShowOctree();
	void toggleUseDepthPass();
	void toggleUseArbQueries();
	void toggleShowViz();
	void toggleRecord();

	bool Clamp2Floor();

	static String msAlgorithmCaptions[];
		
	protected:

	void initHelpOverlayElement(String name, int top);
	void initOverlayElement(OverlayElement **elInfo, String ext, String name, 
							int top, String caption);

	//-- initialise overlays
	void initHelpOverlay();
	void initVisStatsOverlay();
	void initQueryOverlay();

	void resetStats();

	SceneManager *mSceneMgr;           // A pointer to the scene manager

	CEGUI::Renderer *mGUIRenderer;     // cegui renderer

	int mCurrentAlgorithm;
	int mVisibilityThreshold;
	int mAssumedVisibility;
	// the current frame number
	int mCurrentFrame;
	// the current application state
	int mAppState;
	// visualization mode
	int mNodeVizMode;


	OverlayElement *mAlgorithmInfo;
	OverlayElement *mThresholdInfo;
	OverlayElement *mAssumedVisibilityInfo;
	OverlayElement *mFrustumCulledNodesInfo;
	OverlayElement *mQueryCulledNodesInfo;
	OverlayElement *mTraversedNodesInfo;
	OverlayElement *mHierarchyNodesInfo;
	OverlayElement *mTestGeometryForVisibleLeavesInfo;
	OverlayElement *mUseDepthPassInfo;
	OverlayElement *mUseArbQueriesInfo;
	OverlayElement *mRenderedNodesInfo;
	OverlayElement *mObjectsCountInfo;
	OverlayElement *mQueriesIssuedInfo;
	OverlayElement *mDelayedQueriesIssuedInfo;
	OverlayElement *mDelayedTraversedNodesInfo;
	OverlayElement *mCurrentObjectTypeInfo;

	OverlayElement *mQueryTypeInfo;
	OverlayElement *mQueryVisibleNodesInfo;
	OverlayElement *mQueryVisibleGeometryInfo;
	OverlayElement *mQueryVisiblePatchInfo;

	OverlayElement *mQueryVisiblityInfo;
	OverlayElement *mQueryNodeVisibilityInfo;
	OverlayElement *mQueryGeometryVisibilityInfo;
	OverlayElement *mQueryPatchVisibilityInfo;
	//OverlayElement *mHelpInfo;
	
	bool mTestGeometryForVisibleLeaves;
	bool mShowOctree;
	bool mUseDepthPass;
	bool mUseArbQueries;
	bool mShowVisualization;
	bool mCullCamera;
	bool mRecordFrames;
	bool mShowShadows;
	bool mVisualizeCulledNodes;
	bool mShowHelp;
	bool mStatsOn;
	bool mLMouseDown, mRMouseDown;     // True if the mouse buttons are down
	bool mShutdownRequested;
	bool mDisplayCameraDetails;
	bool mUseItemBuffer;
	bool mUseAnimation;

	int mItemBufferMode;

	Real mVizCameraHeight;

	Camera *mVizCamera;
	SceneNode *mCamNode;

	std::vector<frame_info> mFrameInfo;
		
	Real mReplayTimeElapsed;
	//EventProcessor* mEventProcessor;
	InputReader* mInputDevice;
	Camera* mCamera;

	Vector3 mTranslateVector;
	RenderWindow* mWindow;

	unsigned int mNumScreenShots;
	int mSceneDetailIndex;
	int mAniso;

	float mMoveScale;
	Real mMoveSpeed;
	Degree mRotScale;

	// just to stop toggles flipping too fast
	Real mTimeDelay;
	Radian mRotX, mRotY;
	TextureFilterOptions mFiltering;

	Degree mRotateSpeed;

	Overlay* mDebugOverlay;
	Overlay* mHelpOverlay;
	Overlay* mCullStatsOverlay;
	Overlay* mQueryOverlay;

	Light *mSunLight;
	GtpVisibility::VisibilityManager *mVisibilityManager;
	EventProcessor* mEventProcessor;

	bool mShiftPressed;
	bool mShowQueryStats;

	unsigned long mAccumulatedFps;
	unsigned long mAccumulatedTris;
	unsigned long mFrameCount;

	//bool mUseBufferedInputKeys, mUseBufferedInputMouse, mInputTypeSwitchingOn;
	
	float mDelayedQueriesIssued;
	float mDelayedTraversedNodes;

	TestCullingIVApplication *mApplication;
	RaySceneQuery *mRaySceneQuery;
};


#endif //_IVFrameListener_H__