#include "Ogre.h"
#include "OgreEffectWrapper.h"
#include "ManagedOgreRenderTexturePass.h"
#include "FinalRenderingRun.h"
#include "illuminationmanager.h"

void IlluminationManager::render(RenderTarget* rt, CubeMapFaces cf)
{
	static std::vector<bool> entityVisibilityList;
	static std::vector<bool> billboardVisibilityList;

	RenderSystem* renderSystem = Root::getSingleton().getRenderSystem();
	SceneManager* sceneManager = Root::getSingleton().getSceneManager(ST_GENERIC);

	const ColourValue& backgroundColour = rt->getViewport(0)->getBackgroundColour();

	//save visibility (entities)
	//set all invisible (entities)
	{
		SceneManager::EntityIterator ei = sceneManager->getEntityIterator();
		while(ei.hasMoreElements())
		{
			Entity* entity = ei.getNext();
			entityVisibilityList.push_back(entity->isVisible());
			entity->setVisible(false);
		}
	}
	//save visibility (billboardsets)
	//set all invisible (billboardsets)
	{
		SceneManager::BillboardSetIterator bi = sceneManager->getBillboardSetIterator();
		while(bi.hasMoreElements())
		{
			BillboardSet* billboard = bi.getNext();
			billboardVisibilityList.push_back(billboard->isVisible());
			billboard->setVisible(false);
		}
	}

	//foreach entity prerender
	if(performPreRenderStep)
	{
		SceneManager::EntityIterator ei = sceneManager->getEntityIterator();
		while(ei.hasMoreElements())
		{
			UserDefinedObject* pudo = ei.getNext()->getUserObject();
			OgreAssert(pudo && pudo->getTypeID() == MultipleUserDefinedObject::multipleUserDefinedObjectTypeId, "An entity does not contain a valid MultipleUserDefinedObject.");
			pudo = ((MultipleUserDefinedObject*)pudo)->getUserObjectByType(EntityRenderingObject::entityRenderingObjectTypeId);
			OgreAssert(pudo && pudo->getTypeID() == EntityRenderingObject::entityRenderingObjectTypeId, "An entity does not contain a valid EntityRenderingObject.");
			EntityRenderingObject* eObject = (EntityRenderingObject*)pudo;
			FinalRenderingRun* fRun = eObject->getFinalRenderingRun();

			fRun->setVisible(true);
			fRun->preRender(rt, cf);
			fRun->setVisible(false);
		}
	}

	//foreach entity render
	{
		SceneManager::EntityIterator ei = sceneManager->getEntityIterator();
		while(ei.hasMoreElements())
		{
			UserDefinedObject* pudo = ei.getNext()->getUserObject();
			OgreAssert(pudo && pudo->getTypeID() == MultipleUserDefinedObject::multipleUserDefinedObjectTypeId, "An entity does contain a valid MultipleUserDefinedObject.");
			pudo = ((MultipleUserDefinedObject*)pudo)->getUserObjectByType(EntityRenderingObject::entityRenderingObjectTypeId);
			OgreAssert(pudo && pudo->getTypeID() == EntityRenderingObject::entityRenderingObjectTypeId, "An entity does contain a valid EntityRenderingObject.");
			EntityRenderingObject* eObject = (EntityRenderingObject*)pudo;
			FinalRenderingRun* fRun = eObject->getFinalRenderingRun();

			fRun->setVisible(true);
			fRun->renderSingleEntity(rt, cf);
			fRun->setVisible(false);
		}
	}

	//foreach entity postrender
	if(performPostRenderStep)
	{
		SceneManager::EntityIterator ei = sceneManager->getEntityIterator();
		while(ei.hasMoreElements())
		{
			UserDefinedObject* pudo = ei.getNext()->getUserObject();
			OgreAssert(pudo && pudo->getTypeID() == MultipleUserDefinedObject::multipleUserDefinedObjectTypeId, "An entity does contain a valid MultipleUserDefinedObject.");
			pudo = ((MultipleUserDefinedObject*)pudo)->getUserObjectByType(EntityRenderingObject::entityRenderingObjectTypeId);
			OgreAssert(pudo && pudo->getTypeID() == EntityRenderingObject::entityRenderingObjectTypeId, "An entity does contain a valid EntityRenderingObject.");
			EntityRenderingObject* eObject = (EntityRenderingObject*)pudo;
			FinalRenderingRun* fRun = eObject->getFinalRenderingRun();

			fRun->setVisible(true);
			fRun->postRender(rt, cf);
			fRun->setVisible(false);
		}
	}

	//foreach image based lighting directional light sample
	if(performImageBasedLighting)
	{
		imageLightingSamplesRun.rewind();
		while(imageLightingSamplesRun.renderNextDepthMaps())
		{
			//foreach entity postrender
			{
				SceneManager::EntityIterator ei = sceneManager->getEntityIterator();
				while(ei.hasMoreElements())
				{
					UserDefinedObject* pudo = ei.getNext()->getUserObject();
					OgreAssert(pudo && pudo->getTypeID() == MultipleUserDefinedObject::multipleUserDefinedObjectTypeId, "An entity does contain a valid MultipleUserDefinedObject.");
					pudo = ((MultipleUserDefinedObject*)pudo)->getUserObjectByType(EntityRenderingObject::entityRenderingObjectTypeId);
					OgreAssert(pudo && pudo->getTypeID() == EntityRenderingObject::entityRenderingObjectTypeId, "An entity does contain a valid EntityRenderingObject.");
					EntityRenderingObject* eObject = (EntityRenderingObject*)pudo;
					FinalRenderingRun* fRun = eObject->getFinalRenderingRun();

					fRun->setVisible(true);
					fRun->postRender(rt, cf);
					fRun->setVisible(false);
				}
			}
		}
	}

	//restore visibility (billboardsets)
	{
		unsigned int elementNumber = 0;
		SceneManager::BillboardSetIterator bi = sceneManager->getBillboardSetIterator();
		while(bi.hasMoreElements())
		{
			BillboardSet* billboard = bi.getNext();
			billboard->setVisible(billboardVisibilityList.at(elementNumber++));
		}
		billboardVisibilityList.clear();
	}

	//render billboardsets


	//restore visibility (entities)
	{
		unsigned int elementNumber = 0;
		SceneManager::EntityIterator ei = sceneManager->getEntityIterator();
		while(ei.hasMoreElements())
		{
			Entity* entity = ei.getNext();
			entity->setVisible(entityVisibilityList.at(elementNumber++));
		}
		entityVisibilityList.clear();
	}
}

void IlluminationManager::updateStaticLightData()
{
	RenderSystem* renderSystem = Root::getSingleton().getRenderSystem();
	SceneManager* sceneManager = Root::getSingleton().getSceneManager(ST_GENERIC);


	SceneManager::LightIterator li = sceneManager->getLightIterator();
	bool pointLightUpdated[32];
	bool spotLightUpdated[32];
	bool directionalLightUpdated[32];
	for(unsigned int i=0; i<32; i++)
	{
		pointLightUpdated[i] = spotLightUpdated[i] = directionalLightUpdated[i] = false;
	}
	while(li.hasMoreElements())
	{
		Light* light = li.getNext();
		if(light->getType() == Light::LT_POINT && computePointLightShadows)
		{
			bool newLight = true;
			for(unsigned int il=0; il < nPointLights; il++)
			{
				if(pointLights[il]->ogreLight == light)
				{
					pointLights[il]->update();
					pointLightUpdated[il] = true;
					newLight = false;
					break;
				}
			}
			if(newLight)
			{
				OgreAssert(nPointLights < 32, "More than 32 lights!");
				if(nPointLights < nAllocatedPointLights)
				{
					pointLights[nPointLights]->ogreLight = light;
					pointLights[nPointLights]->preProcRun.setLight(light);
					nPointLights++;
				}
				else
				{
					pointLights[nPointLights] = new PointLightPreProcData();
					pointLights[nPointLights]->ogreLight = light;
					pointLights[nPointLights]->preProcRun.setLight(light);
					nPointLights++;
					nAllocatedPointLights++;
				}
			}
		}
		else if(light->getType() == Light::LT_SPOTLIGHT && computeSpotLightShadows)
		{
			bool newLight = true;
			for(unsigned int il=0; il < nSpotLights; il++)
			{
				if(spotLights[il]->ogreLight == light)
				{
					spotLights[il]->update();
					spotLightUpdated[il] = true;
					newLight = false;
					break;
				}
			}
			if(newLight)
			{
				OgreAssert(nSpotLights < 32, "More than 32 lights!");
				if(nSpotLights < nAllocatedSpotLights)
				{
					spotLights[nSpotLights]->ogreLight = light;
					spotLights[nSpotLights]->preProcRun.setLight(light);
					nSpotLights++;
				}
				else
				{
					spotLights[nSpotLights] = new SpotLightPreProcData();
					spotLights[nSpotLights]->ogreLight = light;
					spotLights[nSpotLights]->preProcRun.setLight(light);
					nSpotLights++;
					nAllocatedSpotLights++;
				}
			}
		}
		else if(light->getType() == Light::LT_DIRECTIONAL && computeDirectionalLightShadows)
		{
			bool newLight = true;
			for(unsigned int il=0; il < nDirectionalLights; il++)
			{
				if(directionalLights[il]->ogreLight == light)
				{
					directionalLights[il]->update();
					directionalLightUpdated[il] = true;
					newLight = false;
					break;
				}
			}
			if(newLight)
			{
				OgreAssert(nDirectionalLights < 32, "More than 32 lights!");
				if(nDirectionalLights < nAllocatedDirectionalLights)
				{
					directionalLights[nDirectionalLights]->ogreLight = light;
					directionalLights[nDirectionalLights]->preProcRun.setLight(light);
					nDirectionalLights++;
				}
				else
				{
					directionalLights[nDirectionalLights] = new DirectionalLightPreProcData();
					directionalLights[nDirectionalLights]->ogreLight = light;
					directionalLights[nDirectionalLights]->preProcRun.setLight(light);
					nDirectionalLights++;
					nAllocatedDirectionalLights++;
				}
			}
		}
	}
	//dump unused lights
}

void IlluminationManager::update(unsigned long frameNumber, RenderTarget* rt, CubeMapFaces cf)
{
	RenderSystem* renderSystem = Root::getSingleton().getRenderSystem();
	SceneManager* sceneManager = Root::getSingleton().getSceneManager(ST_GENERIC);


	//update static light data


	//foreach entity render VRM
	{
		SceneManager::EntityIterator ei = sceneManager->getEntityIterator();
		while(ei.hasMoreElements())
		{
			UserDefinedObject* pudo = ei.getNext()->getUserObject();
			OgreAssert(pudo && pudo->getTypeID() == MultipleUserDefinedObject::multipleUserDefinedObjectTypeId, "An entity does contain a valid MultipleUserDefinedObject.");
			pudo = ((MultipleUserDefinedObject*)pudo)->getUserObjectByType(EntityRenderingObject::entityRenderingObjectTypeId);
			OgreAssert(pudo && pudo->getTypeID() == EntityRenderingObject::entityRenderingObjectTypeId, "An entity does contain a valid EntityRenderingObject.");
			EntityRenderingObject* eObject = (EntityRenderingObject*)pudo;
			FinalRenderingRun* fRun = eObject->getFinalRenderingRun();

			eObject->updateVRM(frameNumber);
		}
	}
	//foreach entity render caustic map
	{
		SceneManager::EntityIterator ei = sceneManager->getEntityIterator();
		while(ei.hasMoreElements())
		{
			UserDefinedObject* pudo = ei.getNext()->getUserObject();
			OgreAssert(pudo && pudo->getTypeID() == MultipleUserDefinedObject::multipleUserDefinedObjectTypeId, "An entity does contain a valid MultipleUserDefinedObject.");
			pudo = ((MultipleUserDefinedObject*)pudo)->getUserObjectByType(EntityRenderingObject::entityRenderingObjectTypeId);
			OgreAssert(pudo && pudo->getTypeID() == EntityRenderingObject::entityRenderingObjectTypeId, "An entity does contain a valid EntityRenderingObject.");
			EntityRenderingObject* eObject = (EntityRenderingObject*)pudo;
			FinalRenderingRun* fRun = eObject->getFinalRenderingRun();

			eObject->updateCausticMap(frameNumber);
		}
	}

	//foreach entity render PRM
	{
		SceneManager::EntityIterator ei = sceneManager->getEntityIterator();
		while(ei.hasMoreElements())
		{
			UserDefinedObject* pudo = ei.getNext()->getUserObject();
			OgreAssert(pudo && pudo->getTypeID() == MultipleUserDefinedObject::multipleUserDefinedObjectTypeId, "An entity does contain a valid MultipleUserDefinedObject.");
			pudo = ((MultipleUserDefinedObject*)pudo)->getUserObjectByType(EntityRenderingObject::entityRenderingObjectTypeId);
			OgreAssert(pudo && pudo->getTypeID() == EntityRenderingObject::entityRenderingObjectTypeId, "An entity does contain a valid EntityRenderingObject.");
			EntityRenderingObject* eObject = (EntityRenderingObject*)pudo;
			FinalRenderingRun* fRun = eObject->getFinalRenderingRun();

			eObject->updatePRM(frameNumber);
		}
	}

	//foreach entity render environment map cubes
	{
		SceneManager::EntityIterator ei = sceneManager->getEntityIterator();
		while(ei.hasMoreElements())
		{
			UserDefinedObject* pudo = ei.getNext()->getUserObject();
			OgreAssert(pudo && pudo->getTypeID() == MultipleUserDefinedObject::multipleUserDefinedObjectTypeId, "An entity does contain a valid MultipleUserDefinedObject.");
			pudo = ((MultipleUserDefinedObject*)pudo)->getUserObjectByType(EntityRenderingObject::entityRenderingObjectTypeId);
			OgreAssert(pudo && pudo->getTypeID() == EntityRenderingObject::entityRenderingObjectTypeId, "An entity does contain a valid EntityRenderingObject.");
			EntityRenderingObject* eObject = (EntityRenderingObject*)pudo;
			FinalRenderingRun* fRun = eObject->getFinalRenderingRun();

			eObject->updateEnvironmentCubes(frameNumber);
		}
	}

	renderSystem->clearFrameBuffer(0, rt->getViewport(0)->getBackgroundColour());
	render(rt, cf);
}