#include "OgreVisibilityTerrainSceneManager.h"
#include "OgreOctreeHierarchyInterface.h"
#include "OgreVisibilityOptionsManager.h"
#include <OgreMath.h>
#include <OgreIteratorWrappers.h>
#include <OgreRenderSystem.h>
#include <OgreCamera.h>
#include <OgreLogManager.h>
#include <OgreStringConverter.h>

#include <windows.h>

namespace Ogre {

//-----------------------------------------------------------------------
VisibilityTerrainSceneManager::VisibilityTerrainSceneManager(
	GtpVisibility::VisibilityManager *visManager)
: mVisibilityManager(visManager), 
mUseVisibilityCulling(true),
mShowVisualization(false),
mRenderNodesForViz(false)
{
	mHierarchyInterface = 
		new OctreeHierarchyInterface(this, mDestRenderSystem);

	//mDisplayNodes = true;
	//mShowBoundingBoxes = true;

	// TODO: set maxdepth to reasonable value
	mMaxDepth = 50;
}
//-----------------------------------------------------------------------
VisibilityTerrainSceneManager::~VisibilityTerrainSceneManager()
{
	delete mHierarchyInterface;
}
//-----------------------------------------------------------------------
void VisibilityTerrainSceneManager::_findVisibleObjects(Camera* cam, bool onlyShadowCasters)
{
	mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters);
	// does nothing if hierarchical culling is used =>
	// we interleave identification and rendering of objects 
	// in _renderVisibibleObjects
	if (!mUseVisibilityCulling)
	{
		OctreeSceneManager::_findVisibleObjects(cam, onlyShadowCasters);
		return;	
	}

	//-- show visibile scene nodes and octree bounding boxes from last frame
	if (mShowVisualization)
    {
		// add player camera for visualization purpose
		try {
			Camera *c;
			if ((c = getCamera("PlayerCam")) != NULL)
			{
				getRenderQueue()->addRenderable(c);
			}   
        }
        catch(...)
        {
            // ignore
        }
				
		for (NodeList::iterator it = mVisible.begin(); it != mVisible.end(); ++it)
		{
			getRenderQueue()->addRenderable(*it);

			if (mRenderNodesForViz)
			{
				(*it)->_addToRenderQueue(cam, getRenderQueue(), false);
			}
		}
		for (BoxList::iterator it = mBoxes.begin(); it != mBoxes.end(); ++it)
		{
			getRenderQueue()->addRenderable(*it);
		}
	}
	
	mVisible.clear();
    mBoxes.clear();
}
//-----------------------------------------------------------------------
void VisibilityTerrainSceneManager::_renderVisibleObjects()
{
	if (!mShowVisualization)
	{
		// two cameras (one for culling, one for rendering)
		mHierarchyInterface->InitFrame(mOctree, mCameraInProgress, 
								mCullCamera ? getCamera("CullCamera") : NULL);

		// call initframe to reset culling manager stats
		mVisibilityManager->GetCullingManager()->InitFrame();
	}

	// standard terrain scenemanager rendering without hierarchical culling
	if (!mUseVisibilityCulling || mShowVisualization)
	{	
		TerrainSceneManager::_renderVisibleObjects();
	
		return;
	} 
	
	//-- hierarchical culling
	// the objects of different layers (e.g., background, scene, 
	// overlay) must be identified and rendered one after another

	//-- render background
	clearSpecialCaseRenderQueues();
	addSpecialCaseRenderQueue(RENDER_QUEUE_BACKGROUND);
	addSpecialCaseRenderQueue(RENDER_QUEUE_SKIES_EARLY);

	setSpecialCaseRenderQueueMode(SceneManager::SCRQM_INCLUDE);
	SceneManager::_renderVisibleObjects();

#ifdef GTP_VISIBILITY_MODIFIED_OGRE
	_deleteRenderedQueueGroups();
#endif

	//-- render visible objects (i.e., all but overlay)
	clearSpecialCaseRenderQueues();
	addSpecialCaseRenderQueue(RENDER_QUEUE_OVERLAY);
	setSpecialCaseRenderQueueMode(SceneManager::SCRQM_EXCLUDE);


	/** 
	* the hierarchical culling algorithm
	**/
	mVisibilityManager->ApplyVisibilityCulling();


#ifdef GTP_VISIBILITY_MODIFIED_OGRE
	_deleteRenderedQueueGroups();
#endif

	//-- render overlay
	clearSpecialCaseRenderQueues();
	SceneManager::_renderVisibleObjects();

	//WriteLog(); // write out stats
}
//-----------------------------------------------------------------------
void VisibilityTerrainSceneManager::_updateSceneGraph(Camera* cam)
{
	mVisibilityManager->GetCullingManager()->SetHierarchyInterface(mHierarchyInterface);
	mHierarchyInterface->SetRenderSystem(mDestRenderSystem);

#ifdef GTP_VISIBILITY_MODIFIED_OGRE
    mHierarchyInterface->SetNumOctreeNodes(mNumOctreeNodes);
#endif
	TerrainSceneManager::_updateSceneGraph(cam);
}
//-----------------------------------------------------------------------
bool VisibilityTerrainSceneManager::setOption(const String & key, const void * val)
{
	if (key == "UseVisibilityCulling")
	{
		mUseVisibilityCulling = (*static_cast<const bool *>(val));
		return true;
	}
	if (key == "ShowVisualization")
	{
		mShowVisualization = (*static_cast<const bool *>(val));
		return true;
	}
	if (key == "RenderNodesForViz")
	{
		mRenderNodesForViz = (*static_cast<const bool *>(val));
		return true;
	}
	if (key == "SkyBoxEnabled")
	{
		mSkyBoxEnabled = (*static_cast<const bool *>(val));
		return true;
	}
	if (key == "SkyPlaneEnabled")
	{
		mSkyPlaneEnabled = (*static_cast<const bool *>(val));
		return true;
	}
	if (key == "SkyDomeEnabled")
	{
		mSkyDomeEnabled = (*static_cast<const bool *>(val));
		return true;
	}
	return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
		setOption(key, val) || TerrainSceneManager::setOption(key, val);
}
//-----------------------------------------------------------------------
bool VisibilityTerrainSceneManager::getOption(const String & key, void *val)
{
	if (key == "NumHierarchyNodes")
	{
		* static_cast<unsigned int *>(val) = (unsigned int)mNumOctreeNodes;
		return true;
	}
	
	return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
		getOption(key, val) && TerrainSceneManager::getOption(key, val);
}
//-----------------------------------------------------------------------
bool VisibilityTerrainSceneManager::getOptionValues(const String & key, StringVector &refValueList)
{
	return TerrainSceneManager::getOptionValues( key, refValueList);
}
//-----------------------------------------------------------------------
bool VisibilityTerrainSceneManager::getOptionKeys(StringVector & refKeys)
{
	return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
		getOptionKeys(refKeys) || TerrainSceneManager::getOptionKeys(refKeys);
}
//-----------------------------------------------------------------------
void VisibilityTerrainSceneManager::setVisibilityManager(GtpVisibility::VisibilityManager *visManager)
{
	mVisibilityManager = visManager;
}
//-----------------------------------------------------------------------
GtpVisibility::VisibilityManager *VisibilityTerrainSceneManager::getVisibilityManager( void )
{
	return mVisibilityManager;
}

//-----------------------------------------------------------------------
void VisibilityTerrainSceneManager::WriteLog()
{
	std::stringstream d;

	d << "Algorithm type: " << mVisibilityManager->GetCullingManagerType() << ", "
	  << "Hierarchy nodes: " << mNumOctreeNodes << ", " 
	  << "Traversed nodes: " << mHierarchyInterface->GetNumTraversedNodes() << ", "
	  << "Rendered nodes: " << mHierarchyInterface->GetNumRenderedNodes() << ", "
	  << "Query culled nodes: " << mVisibilityManager->GetCullingManager()->GetNumQueryCulledNodes() << ", "
	  << "Frustum culled nodes: " << mVisibilityManager->GetCullingManager()->GetNumFrustumCulledNodes() << ", "
      << "Queries issued: " << mVisibilityManager->GetCullingManager()->GetNumQueriesIssued() << "\n";

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


} // namespace Ogre