#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;

/** Struct storing walktrough statistics
*/
struct WalkthroughStats
{
public:

	unsigned long mAccFps;
	unsigned long mBestFps;
	unsigned long mWorstFps;
	unsigned long mAccTris;
	unsigned long mAccQueryCulledNodes;
	unsigned long mAccFrustumCulledNodes;
	unsigned long mFrameCount;
	unsigned long mAccRenderedNodes;
	
	WalkthroughStats(): 
	mAccFps(0), mBestFps(0), mWorstFps(0), mAccTris(0),
	mAccQueryCulledNodes(0), mAccFrustumCulledNodes(0),
	mFrameCount(0), mAccRenderedNodes(0)
	{}

	void Reset()
	{
		mAccFps = mBestFps = mWorstFps = mAccTris = mAccQueryCulledNodes = mAccFrustumCulledNodes = mFrameCount = mAccRenderedNodes = 0;
	}

	void UpdateFrame(int currentFps, int bestFps, int worstFps, int renderedTris, int renderedNodes, int queryCulledNodes, int frustumCulledNodes)
	{
		mAccFps += currentFps;
		mBestFps = bestFps;
		mWorstFps = worstFps;

		// accumulated #triangles (M)
		mAccTris += renderedTris / 1000;
		mAccRenderedNodes += renderedNodes;
		mAccQueryCulledNodes += queryCulledNodes;
		mAccFrustumCulledNodes += frustumCulledNodes;
	
		++ mFrameCount;
	}

	void Print(std::ostream &d, const std::string &algorithmName) const
	{
		// compuate average fps and triangle count
		float avgFps = (float)mAccFps / (float)mFrameCount;
		float avgTris = (float)mAccTris / (float)mFrameCount;
		float avgFrustumCulledNodes = 0;
		float avgRenderedNodes = 0;
		float avgQueryCulledNodes = 0;
		
		if (mFrameCount != 0)
		{
			avgFrustumCulledNodes = (float)mAccFrustumCulledNodes / (float)mFrameCount;
			avgQueryCulledNodes  = (float)mAccQueryCulledNodes / (float)mFrameCount;
			avgRenderedNodes = (float)mAccRenderedNodes / (float) mFrameCount;
		}

		//-- write out stats for recorded walkthrough
		d << "Algorithm: " << algorithmName << "\n"
			<< "avg. FPS: " << avgFps << "\n"
			<< "best FPS: " << mBestFps << "\n"
			<< "worst FPS: " << mWorstFps << "\n"
			<< "avg. #triangles: " << avgTris << " M\n"
			<< "#frames: " << mFrameCount << "\n"
			<< "avg. #query culled nodes: " << avgFrustumCulledNodes << "\n"
			<< "avg. #frustum culled nodes: " << avgQueryCulledNodes << "\n"
			<< "avg. #rendered nodes: " << avgRenderedNodes << "\n";
	}

};

/** 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);
     

   /* 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;
	   Real fps;
   } frame_info;

   typedef std::vector<frame_info> FrameInfoContainer;

   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(FrameInfoContainer &frameInfos, SceneNode *camNode, Real timeElapsed);
   void setCurrentFrameInfo(Real timeElapsed);

   void setAlgorithm(int algorithm);

   void moveCamera();

   void writeFrames();
   void loadFrames();

	// quick hack
	void writeNewFrameInfo();
    
    bool processUnbufferedKeyInput(const FrameEvent& evt);
    bool processUnbufferedMouseInput(const FrameEvent& evt);

	void switchMouseMode() 
	{
        mUseBufferedInputMouse = !mUseBufferedInputMouse;
		mInputDevice->setBufferedInput(true, mUseBufferedInputMouse);

		if (!mUseBufferedInputMouse)
			CEGUI::MouseCursor::getSingleton().hide();
		else
			CEGUI::MouseCursor::getSingleton().show();
	}

	/** Shows the frame / algorithm statistics.
	*/ 
    void showStats(bool show);

	/** Updates frame statistics and the frame statistics display.
	*/
	void updateStats();

	/** Toggles wether help screen is shown or not.
	*/
	void toggleShowHelp();
	
	/** Toggles wether shadows are shown or not.
	*/
	void toggleShowShadows();
	void toggleDisplayCameraDetails();
	/** Takes screenshot of the current scene.
	*/
	void takeScreenshot();
	/** Takes one video frame.
	*/
	void takeVideoFrame(std::ofstream &ofstr);

	void nextSceneDetailLevel();
	void nextFilter();
	void nextAlgorithm();
	void nextNodeVizMode();
	void nextAppState();
    void changeThreshold(int incr);
	void changeAssumedVisibility(int incr);
	void setTestGeometryForVisibleLeaves(bool testGeometryForVisibleLeaves);
	/** Shows octree hierarchy of the scene.
	*/
	void toggleShowOctree();
	/** Toggles wether we use the initial depth pass.
	*/
	void toggleUseDepthPass();
	/** Toggles wether we use ARB or NV queries.
	*/
	void toggleUseArbQueries();
	/** Toggles wether the visualization is shown.
	*/
	void toggleShowViz();
	/** Toggles wether the frames are recorded.
	*/
	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);

	/** Shows result from visibility queries.
	*/
	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();
	
	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;
	/// number of video frames
	int mNumVideoFrames;
	/// the newly created object
	SceneNode *mCurrentObject;    

	WalkthroughStats mWalkthroughStats;

	/// HACK for demo
	float mDemoFps;
	bool mUseDemoFps;

	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;

	RayQueryExecutor *mRayQueryExecutor;
	TerrainContentGenerator *mTerrainContentGenerator;

	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;
	
	/// Per frame data stored for a walkthrough
	FrameInfoContainer mFrameInfo;
	/// HACK: for demo
	FrameInfoContainer mSavedFrameInfo;
	
	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;
	
	//bool mUseBufferedInputKeys, mUseBufferedInputMouse, mInputTypeSwitchingOn;
	PlatformQueryManager *mQueryManager;

	float mDelayedQueriesIssued;
	float mDelayedTraversedNodes;

	int mCurrentObjectType;

	bool mDeleteObjects;
	bool mRecordVideo;

	Timer *mTimer;
	long mTimeFrameEnded;
	long mTimeFrameStarted;
	float mPureRenderTimeFps;
	TestCullingTerrainApplication *mApplication;

	bool mUseBufferedInputMouse;
	Matrix4 rotMatrix;
};


#endif //_TerrainFrameListener_H__