#include <OgreIteratorWrappers.h>
#include <OgreCamera.h>
#include <OgreSceneNode.h>
#include <OgreEntity.h>
#include <OgreSubEntity.h>
#include <OgreLogManager.h>
#include "OgreSceneNodeHierarchyInterface.h"
#include "OgrePlatformOcclusionQuery.h"


namespace Ogre {

//-----------------------------------------------------------------------
SceneNodeHierarchyInterface::SceneNodeHierarchyInterface(SceneManager *sm, RenderSystem *rsys): 
PlatformHierarchyInterface(sm, rsys)
{		
}
//-----------------------------------------------------------------------
void SceneNodeHierarchyInterface::TraverseNode(GtpVisibility::HierarchyNode *node)
{
	++ mNumTraversedNodes;
	
	SceneNode *sceneNode = static_cast<SceneNode *>(node);

	if (HasGeometry(node))
	{
		RenderNode(node);
	}

	// internal node: add children to priority queue for further processing
	Node::ChildNodeIterator it = sceneNode->getChildIterator();
				
	while (it.hasMoreElements())			
	{ 
		mDistanceQueue->push(it.getNext());
	}
}
//-----------------------------------------------------------------------
void SceneNodeHierarchyInterface::RenderNode(GtpVisibility::HierarchyNode *node)
{
#ifdef GTP_VISIBILITY_MODIFIED_OGRE
	SceneNode *sceneNode = static_cast<SceneNode *>(node);

	if (sceneNode->lastRendered() != sceneNode->lastVisited())
	{
		sceneNode->setLastRendered(sceneNode->lastVisited());
		mVisibleNodes.push_back(node);

		mSceneManager->_renderSceneNode(mCamera, sceneNode, mLeavePassesInQueue);
	}
#endif
}
//-----------------------------------------------------------------------
bool SceneNodeHierarchyInterface::IsLeaf(GtpVisibility::HierarchyNode *node) const
{
	return (static_cast<SceneNode *>(node)->numChildren() == 0);
}
//-----------------------------------------------------------------------
bool SceneNodeHierarchyInterface::HasGeometry(GtpVisibility::HierarchyNode *node) const
{
	return static_cast<SceneNode *>(node)->numAttachedObjects() > 0;
}
//-----------------------------------------------------------------------
void SceneNodeHierarchyInterface::PullUpVisibility(GtpVisibility::HierarchyNode *node) const
{
#ifdef GTP_VISIBILITY_MODIFIED_OGRE
	SceneNode *sceneNode = static_cast<SceneNode *>(node);

	while (sceneNode && !sceneNode->isNodeVisible())
	{
		sceneNode->setNodeVisible(true);
		sceneNode = sceneNode->getParentSceneNode();
	}
#endif
}
//-----------------------------------------------------------------------
float SceneNodeHierarchyInterface::GetSquaredDistance(GtpVisibility::HierarchyNode *node) const
{
	return static_cast<SceneNode *>(node)->getSquaredViewDepth(mCamera);
}
//-----------------------------------------------------------------------
void SceneNodeHierarchyInterface::SetNodeVisible(GtpVisibility::HierarchyNode *node, 
												 const bool visible) const
{
#ifdef GTP_VISIBILITY_MODIFIED_OGRE
	SceneNode *sceneNode = static_cast<SceneNode *>(node);
	sceneNode->setNodeVisible(visible);
#endif
}
//-----------------------------------------------------------------------
void SceneNodeHierarchyInterface::SetLastVisited(GtpVisibility::HierarchyNode *node, 
												 const unsigned int frameId) const
{
#ifdef GTP_VISIBILITY_MODIFIED_OGRE
	SceneNode *sceneNode = static_cast<SceneNode *>(node);
	sceneNode->setLastVisited(frameId);
#endif
}
//-----------------------------------------------------------------------
bool SceneNodeHierarchyInterface::IsNodeVisible(GtpVisibility::HierarchyNode *node) const
{
#ifdef GTP_VISIBILITY_MODIFIED_OGRE
	SceneNode *sceneNode = static_cast<SceneNode *>(node);
	return sceneNode->isNodeVisible();
#else
	return true;
#endif
}
//-----------------------------------------------------------------------
unsigned int SceneNodeHierarchyInterface::LastVisited(GtpVisibility::HierarchyNode *node) const
{
#ifdef GTP_VISIBILITY_MODIFIED_OGRE
	SceneNode *sceneNode = static_cast<SceneNode *>(node);
	return sceneNode->lastVisited();
#else
	return 0;
#endif
}
//-----------------------------------------------------------------------
AxisAlignedBox *SceneNodeHierarchyInterface::GetBoundingBox(GtpVisibility::HierarchyNode *node)
{
	// only create renderable bounding box for new node
	if (node != mSavedNode)
	{
		mSavedNode = node;
		mBox = static_cast<SceneNode *>(node)->_getWorldAABB();
	}

	return &mBox;
}
//-----------------------------------------------------------------------
void SceneNodeHierarchyInterface::VisualizeCulledNode(GtpVisibility::HierarchyNode *node, 
													  GtpVisibility::CullingType type) const
{
	// TODO
}
//-----------------------------------------------------------------------
void SceneNodeHierarchyInterface::GetNodeGeometryList(GtpVisibility::HierarchyNode *node,	
											  GtpVisibility::GeometryVector *geometryList, 
											  bool includeChildren)
{
	SceneNode::ObjectIterator objIt = 
		static_cast<SceneNode *>(node)->getAttachedObjectIterator();

	while (objIt.hasMoreElements())
    {
		MovableObject *movable = objIt.getNext();
		
		// we are interested only in the entities, i.e., instances of geometry
		if (movable->getMovableType() == "Entity")
		{
			Entity *ent = static_cast<Entity *>(movable);
			//std::stringstream d; d << "ent " << ent->getName(); 
			//LogManager::getSingleton().logMessage(d.str());
			geometryList->push_back(ent);
		}
    }
}

} // namespace Ogre