/**
    \file 
        TestCullingApplication.h
*/
#include "CEGUIForwardRefs.h"
#include "ExampleApplication.h"
#include "OgreOcclusionCullingSceneManager.h"

class MouseQueryListener : public ExampleFrameListener, public MouseListener, public MouseMotionListener
{
public:

    MouseQueryListener(RenderWindow* win, Camera* cam, SceneManager *sceneManager, CEGUI::Renderer *renderer,
					   SceneNode* shipNode)
        : ExampleFrameListener(win, cam, false, true), mGUIRenderer(renderer), mShipNode(shipNode),  mShutdownRequested(false)
    {

		// Setup default variables
        mCurrentObject = NULL;
        mLMouseDown = false;
        mRMouseDown = false;
        mSceneMgr = sceneManager;

        // Reduce move speed
        mMoveSpeed = 50;
        mRotateSpeed *= 2;
	
		mAlgorithmType = OcclusionCullingSceneManager::RENDER_COHERENT;

		//mMyOverlay = OverlayManager::getSingleton().getByName("scripts/MyPanel");
		mMyOverlay = OverlayManager::getSingleton().getByName("Core/MyPanel");

		//mDebugOverlay->hide();
		//mMyOverlay->show();
		// Register this so that we get mouse events.
        mEventProcessor->addMouseListener(this);
        mEventProcessor->addMouseMotionListener(this);
		mEventProcessor->addKeyListener(this);
    } // MouseQueryListener

    ~MouseQueryListener( )
    {
    }

	void myShowOverlay(bool show)
	{
		if (mDebugOverlay)
        {
            if (show)
            {
                mDebugOverlay->show();
            }
            else
            {
                mDebugOverlay->hide();
            }
        }
		if(mMyOverlay)
		{
			mMyOverlay->show();
		}

	}
    bool frameStarted(const FrameEvent &evt)
    {
	/*    Real MoveFactor = 80.0 * evt.timeSinceLastFrame;
 
		mInputDevice->capture();
 
		if(mInputDevice->isKeyDown(Ogre::KC_UP))
		{
			mAlgorithmType = (mAlgorithmType + 1) % OcclusionCullingSceneManager::NUM_RENDERMODES;
			//mShipNode->translate(0.0, MoveFactor, 0.0);
		}
 
		if(mInputDevice->isKeyDown(Ogre::KC_DOWN))
			mShipNode->translate(0.0, -MoveFactor, 0.0);
 
		if(mInputDevice->isKeyDown(Ogre::KC_LEFT))
			mShipNode->translate(-MoveFactor, 0.0, 0.0);
 
		if(mInputDevice->isKeyDown(Ogre::KC_RIGHT))
			mShipNode->translate(MoveFactor, 0.0, 0.0);		
 
		if(mInputDevice->isKeyDown(Ogre::KC_ESCAPE))
			return false;*/

		if(mInputDevice->isKeyDown(Ogre::KC_L))
			myShowOverlay(false);

		return ExampleFrameListener::frameStarted(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.
    virtual void mousePressed(MouseEvent* e);

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

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

    void keyPressed(KeyEvent* e)
    {
        if(e->getKey() == KC_ESCAPE)
        {
            mShutdownRequested = true;
            e->consume();
            return;
        }

        CEGUI::System::getSingleton().injectKeyDown(e->getKey());
		CEGUI::System::getSingleton().injectChar(e->getKeyChar());
        e->consume();
    }

	void keyReleased(KeyEvent* e)
	{
		CEGUI::System::getSingleton().injectKeyUp(e->getKey());
		e->consume();
	}
	void keyClicked(KeyEvent* e) 
	{
		// Do nothing
		e->consume();
	}

	  bool frameEnded(const FrameEvent& evt)
    {
        if (mShutdownRequested)
            return false;
        else
            return ExampleFrameListener::frameEnded(evt);
    }

	void setAlgorithmType(int type) { mAlgorithmType = type; }
	int getAlgorithmType() { return mAlgorithmType; }

protected:
    bool mLMouseDown, mRMouseDown;     // True if the mouse buttons are down
    SceneManager *mSceneMgr;           // A pointer to the scene manager
    SceneNode *mCurrentObject;         // The newly created object
    CEGUI::Renderer *mGUIRenderer;     // cegui renderer
	SceneNode* mShipNode;
	bool mShutdownRequested;
	int mAlgorithmType;
	Overlay *mMyOverlay;
};


class TestCullingApplication : public ExampleApplication
{
public:
    /*TestCullingApplication()
    {

    }*/

protected:
	void createScene(void);

	void createFrameListener(void)
    {
		mFrameListener= new MouseQueryListener(mWindow, mCamera, mSceneMgr, mGUIRenderer, mShipNode);
		mFrameListener->showDebugOverlay(true);
		mRoot->addFrameListener(mFrameListener);
    }

	CEGUI::OgreCEGUIRenderer *mGUIRenderer;
	CEGUI::System *mGUISystem;

private:
	Entity* mShip;
	SceneNode* mShipNode;

/*    String mQuakePk3;
    String mQuakeLevel;

    // Override resource sources (include Quake3 archives)
    void setupResources(void)
    {

        // Load Quake3 locations from a file
        ConfigFile cf;

        cf.load("quake3settings.cfg");

        mQuakePk3 = cf.getSetting("Pak0Location");
        mQuakeLevel = cf.getSetting("Map");

		ExampleApplication::setupResources();
        ResourceManager::addCommonArchiveEx(mQuakePk3, "Zip");

    }*/
    // Override scene manager (use indoor instead of generic)
    void chooseSceneManager(void)
    {
        mSceneMgr = mRoot->getSceneManager(ST_GENERIC);
    }
	
};