#pragma once

class CMapReflexion : public scene::ILightManager
{
      public:
        CMapReflexion(scene::ISceneManager* sceneManager)
          :  SceneManager(sceneManager), SceneLightList(0),
             CurrentRenderPass(scene::ESNRP_NONE), CurrentSceneNode(0)
        {
        }

        virtual void OnPreRender(core::array<scene::ISceneNode*> & lightList)
        {
            Mode = RequestedMode;
            SceneLightList = &lightList;
        }

        virtual void OnPostRender()
        {
        }

        virtual void OnRenderPassPreRender(scene::E_SCENE_NODE_RENDER_PASS renderPass)
        {
            CurrentRenderPass = renderPass;
            
            if(renderPass == ESNRP_LIGHT)
            {
                const vector3df nodePosition = smgr->getActiveCamera()->getAbsolutePosition();

                array<LightDistanceElement> sortingArray;
                sortingArray.reallocate(SceneLightList->size());

                u32 i;
                for(i = 0; i < SceneLightList->size(); ++i)
                {
                  scene::ISceneNode* lightNode = (*SceneLightList)[i];
                  const f64 distance = lightNode->getAbsolutePosition().getDistanceFromSQ(nodePosition);
                  sortingArray.push_back(LightDistanceElement(lightNode, distance));
                }

                sortingArray.sort();

                for(i = 0; i < sortingArray.size(); ++i)
                    sortingArray[i].node->setVisible(i < 3);
            }
        }

        virtual void OnRenderPassPostRender(scene::E_SCENE_NODE_RENDER_PASS renderPass)
        {
        }

        virtual void OnNodePreRender(scene::ISceneNode* node)
        {
            nodeIsVisible = node->isVisible();
            node->setVisible(nodeIsVisible && (CurrentRenderPass == ESNRP_SOLID && CurrentRenderPass == ESNRP_SKY_BOX));
        }

        virtual void OnNodePostRender(scene::ISceneNode* node)
        {
            node->setVisible(nodeIsVisible);
        }

    private:
        bool nodeIsVisible;
        scene::ISceneManager * SceneManager;
        core::array<scene::ISceneNode*> * SceneLightList;
        scene::E_SCENE_NODE_RENDER_PASS CurrentRenderPass;
    private:

        // A utility class to aid in sorting scene nodes into a distance order
        struct LightDistanceElement
        {
            LightDistanceElement() {};

            LightDistanceElement(scene::ISceneNode* n, f64 d)
              : node(n), distance(d) { }

            scene::ISceneNode* node;
            f64 distance;

            // Lower distance elements are sorted to the start of the array
            bool operator < (const LightDistanceElement& other) const
            {
              return (distance < other.distance);
            }
        };
};

void CMapWater::OnAnimate(u32 timeMs)
{
    if (IsVisible)
    {
        video::IVideoDriver* Driver = SceneManager->getVideoDriver();

        Driver->setRenderTarget(ReflectionMap,true,true);

        scene::ICameraSceneNode* CurrentCamera=SceneManager->getActiveCamera();
        scene::ICameraSceneNode* newcamera=SceneManager->addCameraSceneNode();

        newcamera->setFarValue(CurrentCamera->getFarValue());
        newcamera->setFOV(CurrentCamera->getFOV());
        newcamera->setAspectRatio(1.33f);

        core::vector3df position=CurrentCamera->getPosition();
        position.Y=-position.Y+2.0f*RelativeTranslation.Y;
        newcamera->setPosition(position);

        core::vector3df target=CurrentCamera->getTarget();
        target.Y=-target.Y+2.0f*RelativeTranslation.Y;
        newcamera->setTarget(target);
        
        f32 last_time = Dev->getTimer()->getRealTime();

        SceneManager->setActiveCamera(newcamera);

            SceneManager->setLightManager(lmgr);
            SceneManager->drawAll();
            SceneManager->setLightManager(0);

        Driver->setRenderTarget(0);

        SceneManager->setActiveCamera(CurrentCamera);

        newcamera->remove();

        ISceneNode::OnAnimate(timeMs);
    }
}