#include "ivreader.h"
#include "ExampleApplication.h"
//#include <OgreLogManager.h>

#include "ExampleApplication.h"
#include "IVReader.h"

Real timeDelay = 0;
/*#define KEY_PRESSED(_key,_timeDelay, _macro) \
{ \
    if (mInputDevice->isKeyDown(_key) && timeDelay <= 0) \
{ \
    timeDelay = _timeDelay; \
    _macro ; \
} \
}*/

RaySceneQuery* raySceneQuery = 0;

//-- captions for overlays
String algorithmCaptions[] = 
{
	"Coherent Hierarchical Culling",
	"View Frustum Culling", 
	"Stop and Wait Culling"
};

class TutorialFrameListener : public ExampleFrameListener
{
protected:
	int mCurrentAlgorithm;
	Overlay* mDebugOverlay;
	Overlay* mHelpOverlay;
	Overlay* mCullStatsOverlay;
	Overlay* mQueryOverlay;

	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;

public:
	
	//-----------------------------------------------------------------------
	void initOverlayElement(OverlayElement **elInfo, String ext, 
						    String name, int top, String caption)
	{
		OverlayElement *el = 
			OverlayManager::getSingleton().getOverlayElement(ext + name);

		(*elInfo) = OverlayManager::getSingleton().getOverlayElement(ext + name + "Info");
		(*elInfo)->setCaption(caption);

		el->setTop(top);
		(*elInfo)->setTop(top);
	}
	//-----------------------------------------------------------------------
	void initVisStatsOverlay()
	{
		const int border_height = 10;
		const int vert_space = 15;

		//-- visibility culling stats overlay
		int top = border_height;

		String ext = "Example/Visibility/";
	
		initOverlayElement(&mAlgorithmInfo, ext, "Algorithm", top,
			": " + algorithmCaptions[mCurrentAlgorithm]); top += vert_space;

		initOverlayElement(&mThresholdInfo, ext, "Threshold", top, ": 0"); top += vert_space;
		initOverlayElement(&mTestGeometryForVisibleLeavesInfo, ext, 
			"TestGeometryForVisibleLeaves", top, ": true"); top += vert_space;
		initOverlayElement(&mUseDepthPassInfo, ext, "UseDepthPass", top, ": false"); top += vert_space;
		initOverlayElement(&mAssumedVisibilityInfo, ext, "AssumedVisibility", top, ": 0"); top += vert_space;
		initOverlayElement(&mCurrentObjectTypeInfo, ext, "CurrentObjectType", top, ": "); top += vert_space;
		//initOverlayElement(&mHelpInfo, ext, "Help", top, ": "); top += vert_space;

		OverlayElement *optionsPanel = OverlayManager::getSingleton().
			getOverlayElement("Example/Visibility/VisibilityPanel");

		optionsPanel->setHeight(top + border_height);

		top = border_height;
		//ext = "Example/Visibility/";
		initOverlayElement(&mFrustumCulledNodesInfo, ext, "FrustumCulledNodes", top, ": 0"); top += vert_space;
		initOverlayElement(&mQueryCulledNodesInfo, ext, "QueryCulledNodes", top, ": 0"); top += vert_space;
		initOverlayElement(&mTraversedNodesInfo, ext, "TraversedNodes", top, ": 0"); top += vert_space;
		initOverlayElement(&mHierarchyNodesInfo, ext, "HierarchyNodes", top, ": 0"); top += vert_space;
		initOverlayElement(&mRenderedNodesInfo, ext, "RenderedNodes", top, ": 0"); top += vert_space;
		initOverlayElement(&mObjectsCountInfo, ext, "ObjectsCount", top, ": 0"); top += vert_space;
		initOverlayElement(&mQueriesIssuedInfo, ext, "QueriesIssued", top, ": 0"); top += vert_space;

		OverlayElement *visPanel = OverlayManager::getSingleton().
			getOverlayElement("Example/Visibility/VisibilityStatsPanel");

		visPanel->setHeight(top + border_height);
	}
	//-----------------------------------------------------------------------
	void initQueryOverlay()
	{
		const int border_height = 10;
		const int vert_space = 15;

		//-- visibility culling stats overlay
		int top = border_height + 25;

		String ext = "Example/Visibility/Query/";
	    
		initOverlayElement(&mQueryTypeInfo , ext, "QueryType", top,	": 0"); top += vert_space;
	
		initOverlayElement(&mQueryVisibleNodesInfo , ext, "VisibleNodes", top,	": 0"); top += vert_space;
		initOverlayElement(&mQueryVisibleGeometryInfo , ext, "VisibleGeometry", top,	": 0"); top += vert_space;
		initOverlayElement(&mQueryVisiblePatchInfo , ext, "VisiblePatches", top,	": 0"); top += vert_space;
	
		initOverlayElement(&mQueryNodeVisibilityInfo , ext, "NodeVisibility", top,	": 0"); top += vert_space;
		initOverlayElement(&mQueryGeometryVisibilityInfo , ext, "GeometryVisibility", top,	": 0"); top += vert_space;
		initOverlayElement(&mQueryPatchVisibilityInfo , ext, "PatchVisibility", top,	": 0"); top += vert_space;


		OverlayElement *queryPanel = OverlayManager::getSingleton().
		getOverlayElement("Example/Visibility/Query/QueryPanel");

		queryPanel->setHeight(top + border_height);
	}

	//-----------------------------------------------------------------------
	void showStats(bool show)
	{
		if (mDebugOverlay && mCullStatsOverlay)
		{
			if (show)
			{
				mDebugOverlay->show();
				mCullStatsOverlay->show();
			}
			else
			{
				mDebugOverlay->hide();
				mCullStatsOverlay->hide();
			}
		}
	}
}

    TutorialFrameListener(RenderWindow* win, Camera* cam, SceneManager *sceneMgr)
        : ExampleFrameListener(win, cam, false, false), mSceneMgr(sceneMgr), mCurrentAlgorithm(0)
    {
		mMoveSpeed = 50;

		//-- overlays
		mDebugOverlay = OverlayManager::getSingleton().getByName("Core/DebugOverlay");
		//mHelpOverlay = OverlayManager::getSingleton().getByName("Example/Visibility/HelpOverlay"); 
		mQueryOverlay = OverlayManager::getSingleton().getByName("Example/Visibility/QueryOverlay"); 
		mCullStatsOverlay = OverlayManager::getSingleton().getByName("Example/Visibility/CullStatsOverlay"); 

		initVisStatsOverlay(); // visibility stats overlay
		//initHelpOverlay(); // help overlay
		initQueryOverlay(); // visibility query stats overlay

		// show stats overlays
		showStats(true);	
    }

	bool frameStarted(const FrameEvent& evt)
	{
		/*mInputDevice->capture();
		if (mInputDevice->isKeyDown(KC_B))
		{
			showbb = !showbb;
			mSceneMgr->showBoundingBoxes(showbb);
		} return ExampleFrameListener::frameStarted(evt);
		*/

        // clamp to terrain
        bool ret = ExampleFrameListener::frameStarted(evt);

        static Ray updateRay;
        
		updateRay.setOrigin(mCamera->getPosition());
        updateRay.setDirection(Vector3::NEGATIVE_UNIT_Y);
        raySceneQuery->setRay(updateRay);

        RaySceneQueryResult& qryResult = raySceneQuery->execute();
        
		RaySceneQueryResult::iterator i = qryResult.begin();
        
		if (i != qryResult.end() && i->movable)
        {
			mCamera->setPosition(mCamera->getPosition().x, 
								 i->movable->getWorldBoundingBox().getCenter().y + 5, 
								 mCamera->getPosition().z);
	
			std::stringstream d; 
			d << "World: " << i->movable->getWorldBoundingBox().getCenter().y <<
				 ", Object: " << i->movable->getBoundingBox().getCenter().y <<
				 ", Camera: " << mCamera->getPosition();

			LogManager::getSingleton().logMessage(d.str());

        }
		
        return ret;
    }

	/*bool frameEnded(const FrameEvent& evt)
    {
        if (timeDelay >= 0) 
            timeDelay -= evt.timeSinceLastFrame;

        return ExampleFrameListener::frameEnded(evt);        
    }*/

protected:
    bool mMouseDown;       // Whether or not the left mouse button was down last frame
    Real mToggle;          // The time left until next toggle
    Real mRotate;          // The rotate constant
    Real mMove;            // The movement constant
    SceneManager *mSceneMgr;   // The current SceneManager
    SceneNode *mCamNode;   // The SceneNode the camera is currently attached to

	

private:
	bool showbb;
};


class TerrainApplication : public ExampleApplication
{
public:
    TerrainApplication()
    {
		ivr = new IVReader();
	}

    ~TerrainApplication() 
    {
		OGRE_DELETE(ivr);
		OGRE_DELETE(raySceneQuery);
    }

protected:

	IVReader *ivr;
	

    virtual void chooseSceneManager(void)
    {
		//mSceneMgr = mRoot->getSceneManager(ST_EXTERIOR_CLOSE);
		mSceneMgr = mRoot->getSceneManager(ST_GENERIC);
    }

    virtual void createCamera(void)
    {
        // Create the camera
        mCamera = mSceneMgr->createCamera("PlayerCam");

        mCamera->setPosition(Vector3(0, 15, -200));
        // Look back along -Z
        mCamera->lookAt(Vector3(0, 0, -300));
        mCamera->setNearClipDistance(1);
        mCamera->setFarClipDistance(20000);

    }

	////////////////////////////
    void createScene(void)
    {
		String path = "D:/gametools/trunk/VUT/Ogre/resources/";
		
		   // Set ambient light
        mSceneMgr->setAmbientLight(ColourValue(0.5, 0.5, 0.5));

        // Create a light
        Light* l = mSceneMgr->createLight("MainLight");
        // Accept default settings: point light, white diffuse, just set position
        // NB I could attach the light to a SceneNode if I wanted it to move automatically with
        // other objects, but I don't
        l->setPosition(20,80,50);

		mSceneMgr->setSkyBox(true, "Examples/CloudyNoonSkyBox", 2000, true);
		ColourValue fadeColour(0.1, 0.1, 0.6);
		mWindow->getViewport(0)->setBackgroundColour(fadeColour);


		SceneNode *node1 = mSceneMgr->getRootSceneNode()->createChildSceneNode("Node1");
		SceneNode *node2 = mSceneMgr->getRootSceneNode()->createChildSceneNode("Node2");
		SceneNode *node3 = mSceneMgr->getRootSceneNode()->createChildSceneNode("Node3");
		SceneNode *node4 = mSceneMgr->getRootSceneNode()->createChildSceneNode("Node4");
		SceneNode *node5 = mSceneMgr->getRootSceneNode()->createChildSceneNode("Node5");
		SceneNode *node6 = mSceneMgr->getRootSceneNode()->createChildSceneNode("Node6");
		SceneNode *node7 = mSceneMgr->getRootSceneNode()->createChildSceneNode("Node7");
		SceneNode *node8 = mSceneMgr->getRootSceneNode()->createChildSceneNode("Node8");
		SceneNode *node9 = mSceneMgr->getRootSceneNode()->createChildSceneNode("Node9");

	
		node1->translate(Vector3(-500, 0, 750));
		node2->translate(Vector3(-400, 0, 750));
		node3->scale(Vector3(100, 100 ,100));
		node3->pitch(Radian(3 * Math::HALF_PI));
		node4->translate(Vector3(-100, 0, 0));
		node5->translate(Vector3(0, 300, 0));
		
		node6->scale(Vector3(100, 100 ,100));
		node6->pitch(Radian(3 * Math::HALF_PI));
		node6->roll(Radian(Math::HALF_PI));
		node6->translate(Vector3(0, -100, 0));

		node7->scale(Vector3(100, 100 ,100));
		node7->pitch(Radian(3 * Math::HALF_PI));
		node7->roll(Radian(Math::HALF_PI));
		node7->translate(Vector3(100, 0, 0));
		
		node8->translate(Vector3(-300, -300, 0));

		Log *log = LogManager::getSingleton().createLog("IVLog.log");
		ivr->setLog(log);

		/*if (ivr->loadFile("media\\house_test1.iv"))
		{
			ivr->buildTree(mSceneMgr, node1);
			ivr->buildTree(mSceneMgr, node2);
		}
		if (ivr->loadFile("media\\anhk.wrl"))
		{
			ivr->buildTree(mSceneMgr, node3);
		}
		if (ivr->loadFile("media\\ant.wrl"))
		{
			ivr->buildTree(mSceneMgr, node4);
		}
		if (ivr->loadFile("media\\zepplin0.wrl"))
		{
			ivr->buildTree(mSceneMgr, node5);
		}
		if (ivr->loadFile("media\\warbird.wrl"))
		{
			ivr->buildTree(mSceneMgr, node6);
		}
		if (ivr->loadFile("media\\z_wing.wrl"))
		{
			ivr->buildTree(mSceneMgr, node7);
		}*/

		String fileName = path + "media\\city1500_flat_1.iv";
		if (ivr->loadFile(fileName.c_str()))
		{
			ivr->buildTree(mSceneMgr, node8);
		}

		fileName = path + "media\\roofs_1500.iv";
		if (ivr->loadFile(fileName.c_str()))
		{
			ivr->buildTree(mSceneMgr, node8);
		}

		fileName = path + "media\\CityRoads60.iv";
		if (ivr->loadFile(fileName.c_str()))
		{
			ivr->buildTree(mSceneMgr, node8);
		}

		fileName = path + "media\\CityPlane60.iv";
        if (ivr->loadFile(fileName.c_str()))
		{
			ivr->buildTree(mSceneMgr, node8);
		}
		
		fileName = path + "media\\test.iv";
		if (ivr->loadFile(fileName.c_str()))
		{
			ivr->buildTree(mSceneMgr, node9);
		}
	
		ivr->collapse();

		raySceneQuery = mSceneMgr->createRayQuery(
            Ray(mCamera->getPosition(), Vector3::NEGATIVE_UNIT_Y));
	}

  

    // Create new frame listener
    void createFrameListener(void)
    {
        mFrameListener = new TutorialFrameListener(mWindow, mCamera, mSceneMgr);
        mRoot->addFrameListener(mFrameListener);
    }
};




/*class TutorialApplication : public ExampleApplication
{

public:
    TutorialApplication()
    {
		//LogManager::getSingleton().logMessage("here 0");
		ivr = new IVReader();
		mfl = NULL;

    }

    ~TutorialApplication() 
    {
		if (ivr != NULL) delete ivr;
		if (mfl != NULL) delete mfl;
    }
protected:

	IVReader *ivr;
	TutorialFrameListener *mfl;

	////////////////////////////
    void createScene(void)
    {
		//LogManager::getSingleton().logMessage("here 1");

		mSceneMgr->setAmbientLight( ColourValue( 0.3, 0.3, 0.3 ) );

		Light *light = mSceneMgr->createLight( "Light1" );
        light->setType( Light::LT_DIRECTIONAL );
        light->setDiffuseColour( ColourValue( 1, 1, 1 ) );
        light->setSpecularColour( ColourValue( .25, .25, .25 ) );
		light->setDirection( Vector3( 0, -1, -1 ) );

		Light *light2 = mSceneMgr->createLight( "Light2" );
        light2->setType( Light::LT_DIRECTIONAL );
        light2->setDiffuseColour( ColourValue( 1, 1, 1 ) );
        light2->setSpecularColour( ColourValue( .25, .25, .25 ) );
		light2->setDirection( Vector3( 0, 1, 1 ) );


		SceneNode *node1 = mSceneMgr->getRootSceneNode()->createChildSceneNode( "Node1" );
		SceneNode *node2 = mSceneMgr->getRootSceneNode()->createChildSceneNode( "Node2" );
		SceneNode *node3 = mSceneMgr->getRootSceneNode()->createChildSceneNode( "Node3" );
		SceneNode *node4 = mSceneMgr->getRootSceneNode()->createChildSceneNode( "Node4" );
		SceneNode *node5 = mSceneMgr->getRootSceneNode()->createChildSceneNode( "Node5" );
		SceneNode *node6 = mSceneMgr->getRootSceneNode()->createChildSceneNode( "Node6" );
		SceneNode *node7 = mSceneMgr->getRootSceneNode()->createChildSceneNode( "Node7" );
		SceneNode *node8 = mSceneMgr->getRootSceneNode()->createChildSceneNode( "Node8" );
		SceneNode *node9 = mSceneMgr->getRootSceneNode()->createChildSceneNode( "Node9" );

		LogManager::getSingleton().logMessage("here 2");


		node1->translate(Vector3(-500, 0, 750));
		node2->translate(Vector3(-400, 0, 750));
		node3->scale(Vector3(100, 100 ,100));
		node3->pitch(Radian(3*1.57));
		node4->translate(Vector3(-100, 0, 0));
		node5->translate(Vector3(0, 300, 0));
		node6->scale(Vector3(100, 100 ,100));
		node6->pitch(Radian(3*1.57));
		node6->roll(Radian(1.57));
		node6->translate(Vector3(0, -100, 0));
		node7->scale(Vector3(100, 100 ,100));
		node7->pitch(Radian(3*1.6));
		node7->roll(Radian(1.57));
		node7->translate(Vector3(100, 0, 0));
		node8->translate(Vector3(-300, -300, 0));

		Log *log = LogManager::getSingleton().createLog("IVLog.log");

		LogManager::getSingleton().logMessage("here 3");
		ivr->setLog(log);

		if (ivr->loadFile("media\\house_test1.iv"))
		{
			ivr->buildTree(mSceneMgr, node1);
			ivr->buildTree(mSceneMgr, node2);
		}
		if (ivr->loadFile("media\\anhk.wrl"))
		{
			ivr->buildTree(mSceneMgr, node3);
		}
		if (ivr->loadFile("media\\ant.wrl"))
		{
			ivr->buildTree(mSceneMgr, node4);
		}
		if (ivr->loadFile("media\\zepplin0.wrl"))
		{
			ivr->buildTree(mSceneMgr, node5);
		}
		if (ivr->loadFile("media\\warbird.wrl"))
		{
			ivr->buildTree(mSceneMgr, node6);
		}
		if (ivr->loadFile("media\\z_wing.wrl"))
		{
			ivr->buildTree(mSceneMgr, node7);
		}

		if (0) {
		if (ivr->loadFile("media\\city1500_flat_1.iv"))
		{
			ivr->buildTree(mSceneMgr, node8);
		}
		if (ivr->loadFile("media\\roofs_1500.iv"))
		{
			ivr->buildTree(mSceneMgr, node8);
		}	
		if (ivr->loadFile("media\\CityRoads60.iv"))
		{
			ivr->buildTree(mSceneMgr, node8);
		}

		if (ivr->loadFile("media\\CityPlane60.iv"))
		{
			ivr->buildTree(mSceneMgr, node8);
		}

		if (ivr->loadFile("media\\test.iv"))
		{
			ivr->buildTree(mSceneMgr, node9);
		}
}
		ivr->collapse();
	
 		
		
    }
	// Create new frame listener
    void createFrameListener(void)
    {
		mfl = new TutorialFrameListener(mWindow, mCamera, mSceneMgr);
        mRoot->addFrameListener(mfl);
    }
};
*/