#include "VisibilityManager.h"
#include "StopAndWaitCullingManager.h"
#include "CoherentHierarchicalCullingManager.h"
#include "FrustumCullingManager.h"
#include "DummyPreprocessingManager.h"
#include "RandomUpdateCullingManager.h"
#include "CoherentHierarchicalCullingPlusPlusManager.h"
#include "CullingLogManager.h"


namespace GtpVisibility {

//-----------------------------------------------------------------------
VisibilityManager::VisibilityManager(VisibilityEnvironment *visEnvironment):
mVisibilityThreshold(0), 
mCullingManager(NULL),
mQueryManager(NULL),
mPreprocessingManager(new DummyPreprocessingManager(NULL)),
mVisibilityEnvironment(visEnvironment),
mAssumedVisibilityForChc(0)
{
	SetCullingManager(VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING);
}
//-----------------------------------------------------------------------
VisibilityManager::~VisibilityManager()
{
	delete mCullingManager;
	delete mPreprocessingManager;
	CullingLogManager::DelSingleton();
}
//-----------------------------------------------------------------------
void VisibilityManager::SetCullingManager(VisibilityEnvironment::
										  CullingManagerType ocmType)
{
	// change only if necessary
	if (!mCullingManager || (mCullingManagerType != ocmType))
	{
		// delete old culling manager
		if (mCullingManager)
			delete mCullingManager;

		mCullingManagerType = ocmType;
		
		switch (ocmType)
		{
		case VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING:
			{
				CoherentHierarchicalCullingManager *chcm = new CoherentHierarchicalCullingManager(mAssumedVisibilityForChc);
				chcm->SetTestGeometryForVisibleLeaves(mTestGeometryForVisibleLeaves);
				mCullingManager = chcm;
			}
			break;
		case VisibilityEnvironment::FRUSTUM_CULLING:
			mCullingManager = new FrustumCullingManager();
			break;
		case VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING_PLUSPLUS:
			{
				CoherentHierarchicalCullingPlusPlusManager *chcm = 
					new CoherentHierarchicalCullingPlusPlusManager(mAssumedVisibilityForChc);
				mCullingManager = chcm;
			}
			break;
		case VisibilityEnvironment::STOP_AND_WAIT_CULLING:
			mCullingManager = new StopAndWaitCullingManager();
			break;
		default:
			mCullingManager = new CoherentHierarchicalCullingManager(mAssumedVisibilityForChc);
			break;
		}

		/////////
		//-- set threshold

		mCullingManager->SetVisibilityThreshold(mVisibilityThreshold);	
	}
}
//-----------------------------------------------------------------------
void VisibilityManager::SetVisibilityCullingThreshold(unsigned int visibilityThreshold)
{
	mVisibilityThreshold = visibilityThreshold;
	mCullingManager->SetVisibilityThreshold(mVisibilityThreshold);
}
//-----------------------------------------------------------------------
CullingManager *VisibilityManager::GetCullingManager()
{
	return mCullingManager;
}
//-----------------------------------------------------------------------
void VisibilityManager::ApplyVisibilityCulling()
{
	mCullingManager->RenderScene();
}
//-----------------------------------------------------------------------
VisibilityEnvironment::CullingManagerType VisibilityManager::GetCullingManagerType()
{
	return mCullingManagerType;
}
//-----------------------------------------------------------------------
void VisibilityManager::SetQueryManager(QueryManager *queryManager)
{
	mQueryManager = queryManager;
}
//-----------------------------------------------------------------------
QueryManager *VisibilityManager::GetQueryManager()
{
	return mQueryManager;
}
//-----------------------------------------------------------------------
void VisibilityManager::SetAssumedVisibilityForChc(unsigned int assumedVisibility) 									 
{
	mAssumedVisibilityForChc = assumedVisibility;

	switch (mCullingManagerType)
	{
	case VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING:
		static_cast<CoherentHierarchicalCullingManager *>(mCullingManager)->
				SetAssumedVisibility(mAssumedVisibilityForChc);
		break;
	case VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING_PLUSPLUS:
		static_cast<CoherentHierarchicalCullingPlusPlusManager *>(mCullingManager)->
				SetAssumedVisibility(mAssumedVisibilityForChc);
		break;
	}
}
//-----------------------------------------------------------------------
void VisibilityManager::SetRandomUpdateCandidatesForRuc(unsigned int randomCandidates) 									 
{
	mRandomCandidatesForRuc = randomCandidates;

	if (mCullingManagerType == VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING_PLUSPLUS)
	{
		static_cast<RandomUpdateCullingManager *>(mCullingManager)->
				SetRandomCandidates(mRandomCandidatesForRuc);
	}
}
//-----------------------------------------------------------------------
VisibilityEnvironment *VisibilityManager::GetVisibilityEnvironment()
{
	return mVisibilityEnvironment;
}
//-----------------------------------------------------------------------
unsigned int VisibilityManager::GetAssumedVisibilityForChc()
{
	return mAssumedVisibilityForChc;
}
//-----------------------------------------------------------------------
unsigned int VisibilityManager::GetRandomUpdateCandidatesForRuc()
{
	return mRandomCandidatesForRuc;
}
//-----------------------------------------------------------------------
void VisibilityManager::SetTestGeometryForVisibleLeaves(bool testGeometryForVisibleLeaves)
{
	mTestGeometryForVisibleLeaves = testGeometryForVisibleLeaves;

	if (mCullingManagerType == VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING)
	{
		static_cast<CoherentHierarchicalCullingManager *>(mCullingManager)->
				SetTestGeometryForVisibleLeaves(mTestGeometryForVisibleLeaves);
	}
	/*else if (mCullingManagerType == VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING_PLUSPLUS)
	{
		static_cast<RandomUpdateCullingManager *>(mCullingManager)->
				SetTestGeometryForVisibleLeaves(mTestGeometryForVisibleLeaves);
	}*/
}
//-----------------------------------------------------------------------
bool VisibilityManager::GetTestGeometryForVisibleLeaves()
{
	return mTestGeometryForVisibleLeaves;
}

} // namespace GtpVisibility