#ifndef _TerrainFrameListener_H__
#define _TerrainFrameListener_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"
#include "OgreTerrainContentGenerator.h"
#include "OgrePlatformQueryManager.h"


class TestCullingTerrainApplication;


using namespace Ogre;


/** Frame listener specialised for terrains.
*/
class TerrainFrameListener: public FrameListener, public MouseListener, 
							public MouseMotionListener, public KeyListener
{
public:
	
   TerrainFrameListener(RenderWindow* win, 
						Camera* cam, 
						SceneManager *sceneManager, 
						CEGUI::Renderer *renderer, 
						TerrainContentGenerator *contentGenerator, 
						Camera *vizCamera,
						SceneNode *camNode, 
						Light *sunLight,
						TestCullingTerrainApplication *app);

   ~TerrainFrameListener();


   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();

  
    // Constructor takes a RenderWindow because it uses that to determine input context
    //ExampleFrameListener(RenderWindow* win, Camera* cam, bool useBufferedInputKeys = false, bool useBufferedInputMouse = false)
    
    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 toggleShowViz();
	void toggleRecord();

	/** Applies visibility query. Collects the visible objects 
		and their visibility information.
		@param fromPoint if query should be from point or from camera
		@param relativeVisibility if query should return number of visible pixels or 
		the ratio visible / projected pixels.
		@param useItemBuffer if item buffer should be used or occlusion queries
	*/
	void applyVisibilityQuery(bool fromPoint, bool relativeVisibility, bool useItemBuffer);

	void toggleShowQueryStats();

	/** Sets the type of the objects generated in the scene.
	*/
	void setObjectType(int objectType);

	static String msAlgorithmCaptions[];
	static String msQueryTypeCaptions[]; 
	static String msQueryRelativeVisCaptions[];
	static String msQueryMethodCaptions[];
	static Real msObjectTerrainOffsets[]; 
	static Real msObjectScales[];
	static String msObjectCaptions[];

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;
	// The number of objects on the screen
	int mObjectCount;            
	// visualization mode
	int mNodeVizMode;

	SceneNode *mCurrentObject;    // the newly created object

	OverlayElement *mAlgorithmInfo;
	OverlayElement *mThresholdInfo;
	OverlayElement *mAssumedVisibilityInfo;
	OverlayElement *mFrustumCulledNodesInfo;
	OverlayElement *mQueryCulledNodesInfo;
    OverlayElement *mTraversedNodesInfo;
	OverlayElement *mHierarchyNodesInfo;
	OverlayElement *mTestGeometryForVisibleLeavesInfo;
	OverlayElement *mUseDepthPassInfo;
	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;

	RayQueryExecutor *mRayQueryExecutor;
	TerrainContentGenerator *mTerrainContentGenerator;

	bool mTestGeometryForVisibleLeaves;
	bool mShowOctree;
	bool mUseDepthPass;
	bool mShowVisualization;
	bool mCullCamera;
	bool mRecord;
	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;
	bool mRenderPatchesForItemBuffer;

	Real mVizCameraHeight;

	Camera *mVizCamera;
	SceneNode *mCamNode;
	
	//std::deque<Vector3> mWalkList;   // The list of points we are walking to
	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;
    Degree mRotScale;

    // just to stop toggles flipping too fast
    Real mTimeDelay;
    Radian mRotX, mRotY;
    TextureFilterOptions mFiltering;
  
	Real mMoveSpeed;
    Degree mRotateSpeed;
    
	Overlay* mDebugOverlay;
	Overlay* mHelpOverlay;
	Overlay* mCullStatsOverlay;
	Overlay* mQueryOverlay;

	Light *mSunLight;
	GtpVisibility::VisibilityManager *mVisibilityManager;
	EventProcessor* mEventProcessor;
	
	bool mShiftPressed;
	bool mShowQueryStats;

	unsigned long mAvgFps;
	unsigned long mFrameCount;

	//bool mUseBufferedInputKeys, mUseBufferedInputMouse, mInputTypeSwitchingOn;
	PlatformQueryManager *mQueryManager;

	float mDelayedQueriesIssued;
	float mDelayedTraversedNodes;

	int mCurrentObjectType;

	bool mDeleteObjects;

	TestCullingTerrainApplication *mApplication;
};


#endif //_TerrainFrameListener_H__