#include "CoherentHierarchicalCullingManager.h"
#include "CullingLogManager.h"

#include <time.h>
#include <sstream>


namespace GtpVisibility {



//-----------------------------------------------------------------------
CoherentHierarchicalCullingManager::CoherentHierarchicalCullingManager():
mAssumedVisibility(0)
{
}
//-----------------------------------------------------------------------
CoherentHierarchicalCullingManager::CoherentHierarchicalCullingManager(
														const unsigned int assumedVisibility):
mAssumedVisibility(assumedVisibility)
{
}
//-----------------------------------------------------------------------
void CoherentHierarchicalCullingManager::AssignAssumedVisibility(GtpVisibility::HierarchyNode *node)
{
	if (!mHierarchyInterface->IsNodeVisible(node))
		// previously invisible nodes: give random offset just for the first test after
		// becoming visible to avoid that all nodes are tested in the same frame
		mHierarchyInterface->SetNodeAssumedVisible(node, rand() * mAssumedVisibility / RAND_MAX);
	else
		mHierarchyInterface->SetNodeAssumedVisible(node, mAssumedVisibility);
}
//-----------------------------------------------------------------------
void CoherentHierarchicalCullingManager::RenderScene()
{
	if (0) CullingLogManager::GetSingleton()->LogMessage("chc");
	unsigned int visiblePixels = 0;
	
	/////////////
	//-- PART 1: process finished occlusion queries

	while (!mHierarchyInterface->GetQueue()->empty() || !mQueryQueue.empty())
	{
		//////////
		//-- only wait for result if there are no nodes to process

		while (!mQueryQueue.empty() && 
			   (NodeInvalid(mQueryQueue.front().first) ||
			    mQueryQueue.front().second->GetQueryResult(
				             visiblePixels, mHierarchyInterface->GetQueue()->empty())))
		{
			HierarchyNode *node = mQueryQueue.front().first;
			mQueryQueue.pop();

			// parent was tested invisible => remove children from queue
			// "invalid nodes" happen for hierarchies where interiors store geometry
			if (NodeInvalid(node)) continue;

			// tested visible
			if (visiblePixels > mVisibilityThreshold)
			{
				// assing the #frames the node is assumed to stay visible
				AssignAssumedVisibility(node);

				// traverse node if not already traversed in this frame 
				// (i.e., the visible flag is not set)
				// note: it is necessary to do this test because we query
				// previously visible interior node containing geometry 
				// without waiting for the result
				if (!mHierarchyInterface->IsNodeVisible(node))
					mHierarchyInterface->TraverseNode(node);

				mHierarchyInterface->PullUpVisibility(node);
			}
			else
			{	
				mHierarchyInterface->SetNodeVisible(node, false);

                ++ mNumQueryCulledNodes;

				if (mVisualizeCulledNodes)
					mHierarchyInterface->VisualizeCulledNode(node, QUERY_CULLED);
			}
			
			// update node's visited flag
			mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId());	
		}
		
		////////////////
		//-- PART 2: hierarchical traversal

		if (!mHierarchyInterface->GetQueue()->empty())
		{
			HierarchyNode *node = mHierarchyInterface->GetQueue()->top();
			mHierarchyInterface->GetQueue()->pop();
				
			// parent was tested invisible => remove children from queue
			if (NodeInvalid(node)) continue;

			bool intersects = false;

			if (!mHierarchyInterface->CheckFrustumVisible(node, intersects))
			{
				++ mNumFrustumCulledNodes;

				if (mVisualizeCulledNodes)
					mHierarchyInterface->VisualizeCulledNode(node, FRUSTUM_CULLED);
			}
			//-- if node intersects near plane, skip query because wrong results possible
			else if (intersects)
			{
				SkipQuery(node);
			}
			else
			{
				// identify previously visible nodes
				bool wasVisible = mHierarchyInterface->IsNodeVisible(node) && 
					(mHierarchyInterface->LastVisited(node) == mHierarchyInterface->GetFrameId() - 1);
				
				// if we assume node to be visible in this frame => skip query 
				const bool skipQuery = wasVisible &&
									   DecideVisible(node) && 
									   mHierarchyInterface->HasGeometry(node);

				if (skipQuery)
				{
					SkipQuery(node);
					continue;
				}

                // identify nodes that we cannot skip queries for
				// geometry not only in leaves => test for renderable geometry
				bool issueQuery = !wasVisible || mHierarchyInterface->HasGeometry(node);
							
				// set node's visibility classification
				// we identify previously visible / invisible nodes in the query queue
				mHierarchyInterface->SetNodeVisible(node, wasVisible && issueQuery);

				if (issueQuery)
				{
					++ mNumQueriesIssued;
					
					const bool testGeometry = 
						wasVisible && mHierarchyInterface->IsLeaf(node) && mTestGeometryForVisibleLeaves;

					mQueryQueue.push(QueryPair(node, mHierarchyInterface->
						IssueNodeOcclusionQuery(node, testGeometry)));
				}
				else
				{
					// skip testing previously visible nodes without geometry
                    // just update node's visited flag
					mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId());
				}

				// always traverse a node if it was visible
				if (wasVisible)
				{
					mHierarchyInterface->TraverseNode(node);
				}
			}
		}
	}
}
//-----------------------------------------------------------------------
void CoherentHierarchicalCullingManager::SetAssumedVisibility(const unsigned int assumedVisibility)
{
	mAssumedVisibility = assumedVisibility;
}
//-----------------------------------------------------------------------
inline bool CoherentHierarchicalCullingManager::DecideVisible(HierarchyNode *node) const
{
	mHierarchyInterface->DecNodeAssumedVisible(node);
	//std::stringstream d; d << "node visible: " << mHierarchyInterface->GetNodeAssumedVisible(node);
	//CullingLogManager::GetSingleton()->LogMessage(d.str());
	return mHierarchyInterface->GetNodeAssumedVisible(node) > 0;
}
//-----------------------------------------------------------------------
inline void CoherentHierarchicalCullingManager::SkipQuery(HierarchyNode *node) const
{
	//-- set node to be visible in this frame, then traverse it
	mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId());
	
	mHierarchyInterface->PullUpVisibility(node);			
	mHierarchyInterface->TraverseNode(node);
}
//-----------------------------------------------------------------------
bool CoherentHierarchicalCullingManager::NodeInvalid(HierarchyNode *node) const
{
	// parent was tested invisible in this frame
    const bool nodeInvalid = ( 
		    mHierarchyInterface->GetParent(node) && 
		    (mHierarchyInterface->LastVisited(node) == mHierarchyInterface->GetFrameId()) && 
		    !mHierarchyInterface->IsNodeVisible(mHierarchyInterface->GetParent(node))
           );
	return nodeInvalid;
}
//-----------------------------------------------------------------------
void CoherentHierarchicalCullingManager::SetTestGeometryForVisibleLeaves(const bool testGeometry)
{
	mTestGeometryForVisibleLeaves = testGeometry;
}
//-----------------------------------------------------------------------
bool CoherentHierarchicalCullingManager::GetTestGeometryForVisibleLeaves()
{
	return mTestGeometryForVisibleLeaves;
}

}