#include "sky.hpp"
#include "Caelum.h"

#include <OgreMesh.h>
#include <OgreSceneNode.h>
#include <OgreSceneManager.h>
#include <OgreCamera.h>
#include <OgreHardwareVertexBuffer.h>
#include <OgreHighLevelGpuProgramManager.h>

#include <components/nifogre/ogre_nif_loader.hpp>

// this distance has to be set accordingly so that the
// celestial bodies are behind the clouds, but in front of the atmosphere
#define CELESTIAL_BODY_DISTANCE 1000.f

using namespace Ogre;

namespace MWRender
{
    class CelestialBody
    {
    public:
        CelestialBody(  const String& pTextureName,
                        const unsigned int pInitialSize,
                        const Vector3& pInitialPosition,
                        SceneNode* pRootNode
                    );
        CelestialBody();
                            
        void setPosition(const Vector3& pPosition);
        void setVisible(const bool visible) { mNode->setVisible(visible); };
        
    protected:
        virtual void init(const String& pTextureName,
                        const unsigned int pInitialSize,
                        const Vector3& pInitialPosition,
                        SceneNode* pRootNode);
    
        SceneNode* mNode;
        MaterialPtr mMaterial;
    };
    
    /*
     * The moons need a seperate class because of their shader (which allows them to be partially transparent)
     */
    class Moon : public CelestialBody
    {
    public:
        Moon(  const String& pTextureName,
                        const unsigned int pInitialSize,
                        const Vector3& pInitialPosition,
                        SceneNode* pRootNode
                    );
    
        void setVisibility(const float pVisibility);
        ///< set the transparency factor for this moon
        
        void setColour(const ColourValue& pColour);
        
        /// \todo Moon phases
    };
    
    CelestialBody::CelestialBody( const String& textureName,
                        const unsigned int initialSize,
                        const Vector3& pInitialPosition,
                        SceneNode* pRootNode)
    {
        init(textureName, initialSize, pInitialPosition, pRootNode);
    }
    
    CelestialBody::CelestialBody()
    {
    }
    
    void CelestialBody::setPosition(const Vector3& pPosition)
    {
        Vector3 finalPosition = pPosition.normalisedCopy() * CELESTIAL_BODY_DISTANCE;

        mNode->setPosition(finalPosition);
    }
    
    void CelestialBody::init(const String& textureName,
                        const unsigned int initialSize,
                        const Vector3& pInitialPosition,
                        SceneNode* pRootNode)
    {
        SceneManager* sceneMgr = pRootNode->getCreator();
        
        const float scale = initialSize*550.f;
        
        Vector3 finalPosition = pInitialPosition.normalisedCopy() * CELESTIAL_BODY_DISTANCE;
        
        static unsigned int bodyCount=0;
        
        /// \todo These billboards are not 100% correct, might want to revisit them later
        BillboardSet* bbSet = sceneMgr->createBillboardSet("SkyBillboardSet"+StringConverter::toString(bodyCount), 1);
        bbSet->setDefaultDimensions(scale, scale);
        bbSet->setRenderQueueGroup(RENDER_QUEUE_SKIES_EARLY+1);
        bbSet->setBillboardType(BBT_PERPENDICULAR_COMMON);
        bbSet->setCommonDirection( -pInitialPosition.normalisedCopy() );
        mNode = pRootNode->createChildSceneNode();
        mNode->setPosition(finalPosition);
        mNode->attachObject(bbSet);
        bbSet->createBillboard(0,0,0);
        
        mMaterial = MaterialManager::getSingleton().create("CelestialBody"+StringConverter::toString(bodyCount), ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
        mMaterial->removeAllTechniques();
        Pass* p = mMaterial->createTechnique()->createPass();
        p->setSceneBlending(SBT_TRANSPARENT_ALPHA);
        p->setDepthCheckEnabled(false);
        p->setDepthWriteEnabled(false);
        p->setSelfIllumination(1.0,1.0,1.0);
        p->setDiffuse(0.0,0.0,0.0,1.0);
        p->setAmbient(0.0,0.0,0.0);
        p->createTextureUnitState(textureName);
        bbSet->setMaterialName("CelestialBody"+StringConverter::toString(bodyCount));
        
        bodyCount++;
    }
    
    Moon::Moon( const String& textureName,
                        const unsigned int initialSize,
                        const Vector3& pInitialPosition,
                        SceneNode* pRootNode)
    {
        init(textureName, initialSize, pInitialPosition, pRootNode);

        HighLevelGpuProgramManager& mgr = HighLevelGpuProgramManager::getSingleton();
        HighLevelGpuProgramPtr vshader;
        if (mgr.resourceExists("Moon_VP"))
            vshader = mgr.getByName("Moon_VP");
        else
            vshader = mgr.createProgram("Moon_VP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, "cg", GPT_VERTEX_PROGRAM);
        vshader->setParameter("profiles", "vs_2_x arbvp1");
		vshader->setParameter("entry_point", "main_vp");
		StringUtil::StrStreamType outStream;
		outStream <<
		"void main_vp(	\n"
		"	float4 position : POSITION,	\n"
        "   in float2 uv : TEXCOORD0, \n"
        "   out float2 oUV : TEXCOORD0, \n"
		"	out float4 oPosition : POSITION,	\n"
		"	uniform float4x4 worldViewProj	\n"
        ")	\n"
		"{	\n"
        "   oUV = uv; \n"
		"	oPosition = mul( worldViewProj, position );  \n"
		"}";
		vshader->setSource(outStream.str());
		vshader->load();
		vshader->getDefaultParameters()->setNamedAutoConstant("worldViewProj", GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
        mMaterial->getTechnique(0)->getPass(0)->setVertexProgram(vshader->getName());
        
        HighLevelGpuProgramPtr fshader;
        if (mgr.resourceExists("Moon_FP"))
            fshader = mgr.getByName("Moon_FP");
        else
            fshader = mgr.createProgram("Moon_FP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, "cg", GPT_FRAGMENT_PROGRAM);

        fshader->setParameter("profiles", "ps_2_x arbfp1");
		fshader->setParameter("entry_point", "main_fp");
		StringUtil::StrStreamType outStream2;
		outStream2 <<
		"void main_fp(	\n"
        "   in float2 uv : TEXCOORD0, \n"
		"	out float4 oColor    : COLOR, \n"
        "   uniform sampler2D texture : TEXUNIT0, \n"
        "   uniform float visibilityFactor, \n"
        "   uniform float4 emissive \n"
        ")	\n"
		"{	\n"
        "   float4 tex = tex2D(texture, uv); \n"
        "   oColor = float4(emissive.xyz,1) * tex2D(texture, uv) * float4(1,1,1,visibilityFactor); \n"
		"}";
		fshader->setSource(outStream2.str());
		fshader->load();
        fshader->getDefaultParameters()->setNamedAutoConstant("emissive", GpuProgramParameters::ACT_SURFACE_EMISSIVE_COLOUR);
        mMaterial->getTechnique(0)->getPass(0)->setFragmentProgram(fshader->getName());
    }
    
    void Moon::setVisibility(const float pVisibility)
    {
        mMaterial->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstant("visibilityFactor", Real(pVisibility));
    }
    
    void Moon::setColour(const ColourValue& pColour)
    {
        mMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(pColour);
    }
    
    class MWSkyManager : public SkyManager
    {
    public:
        MWSkyManager(Ogre::SceneNode* pMwRoot, Ogre::Camera* pCamera);
        virtual ~MWSkyManager();
        
        virtual void update(float duration);
        
        virtual void enable();
        
        virtual void disable();
        
        virtual void setHour (double hour) {}
        ///< will be called even when sky is disabled.
        
        virtual void setDate (int day, int month) {}
        ///< will be called even when sky is disabled.
        
        virtual int getMasserPhase() const { return 0; }
        ///< 0 new moon, 1 waxing or waning cresecent, 2 waxing or waning half,
        /// 3 waxing or waning gibbous, 4 full moon
        
        virtual int getSecundaPhase() const { return 0; }
        ///< 0 new moon, 1 waxing or waning cresecent, 2 waxing or waning half,
        /// 3 waxing or waning gibbous, 4 full moon
        
        virtual void setMoonColour (bool red);
        ///< change Secunda colour to red
        
    private:
        CelestialBody* mSun;
        Moon* mMasser;
        Moon* mSecunda;
    
        Camera* mCamera;
        Viewport* mViewport;
        SceneNode* mRootNode;
        SceneManager* mSceneMgr;
        
        MaterialPtr mCloudMaterial;
        MaterialPtr mAtmosphereMaterial;
        
        HighLevelGpuProgramPtr mCloudFragmentShader;
        
        void ModVertexAlpha(Entity* ent, unsigned int meshType);
    };
    
    void MWSkyManager::ModVertexAlpha(Entity* ent, unsigned int meshType)
    {
        // Get the vertex colour buffer of this mesh
        const Ogre::VertexElement* ves_diffuse = ent->getMesh()->getSubMesh(0)->vertexData->vertexDeclaration->findElementBySemantic( Ogre::VES_DIFFUSE );
        HardwareVertexBufferSharedPtr colourBuffer = ent->getMesh()->getSubMesh(0)->vertexData->vertexBufferBinding->getBuffer(ves_diffuse->getSource());
        
        // Lock
        void* pData = colourBuffer->lock(HardwareBuffer::HBL_NORMAL);
        
        // Iterate over all vertices
        int vertex_size = colourBuffer->getVertexSize();
        float * currentVertex = NULL;
        for (unsigned int i=0; i<colourBuffer->getNumVertices(); ++i)
        {
            // Get a pointer to the vertex colour
            ves_diffuse->baseVertexPointerToElement( pData, &currentVertex );
            
            unsigned char alpha;
            if (meshType == 0) alpha = i%2 ? 0 : 255; // this is a cylinder, so every second vertex belongs to the bottom-most row
            else if (meshType == 1)
            {
                if (i>= 49 && i <= 64) alpha = 0; // bottom-most row
                else if (i>= 33 && i <= 48) alpha = 64; // second bottom-most row
                else alpha = 255;
            }
            
            uint8 tmpR = static_cast<uint8>(255);
            uint8 tmpG = static_cast<uint8>(255);
            uint8 tmpB = static_cast<uint8>(255);
            uint8 tmpA = static_cast<uint8>(alpha);
            
            // This does not matter since R and B are always 1.
            /*VertexElementType format = Root::getSingleton().getRenderSystem()->getColourVertexElementType();
            switch (format)
            {
            case VET_COLOUR_ARGB:
                std::swap(tmpR, tmpB);
                break;
            case VET_COLOUR_ABGR:
                break;
            default:
                break;
            }*/
             
            // Modify
            *((uint32*)currentVertex) = tmpR | (tmpG << 8) | (tmpB << 16) | (tmpA << 24);
            
            // Move to the next vertex
            pData+=vertex_size;
        }
        
        // Unlock
        ent->getMesh()->getSubMesh(0)->vertexData->vertexBufferBinding->getBuffer(ves_diffuse->getSource())->unlock();
    }
    
    MWSkyManager::MWSkyManager (SceneNode* pMwRoot, Camera* pCamera)
    {
        mViewport = pCamera->getViewport();
        mSceneMgr = pMwRoot->getCreator();
        mRootNode = pMwRoot->createChildSceneNode();
        mRootNode->setScale(100.f, 100.f, 100.f);

        mViewport->setBackgroundColour(ColourValue(0.87, 0.87, 0.87));
        
        mSun = new CelestialBody("textures\\tx_sun_05.dds", 1, Vector3(0.4, 0.4, 1.0), mRootNode);
        mMasser = new Moon("textures\\tx_masser_full.dds", 1, Vector3(-0.4, -0.4, 0.5), mRootNode);
        mSecunda = new Moon("textures\\tx_secunda_full.dds", 1, Vector3(0.4, -0.4, 0.5), mRootNode);
        mMasser->setVisibility(0.2);
        mSecunda->setVisibility(0.2);
        mMasser->setVisible(false);
        mSecunda->setVisible(false);
        
        HighLevelGpuProgramManager& mgr = HighLevelGpuProgramManager::getSingleton();

        // Atmosphere
        MeshPtr mesh = NifOgre::NIFLoader::load("meshes\\sky_atmosphere.nif");        
        Entity* atmosphere_ent = mSceneMgr->createEntity("meshes\\sky_atmosphere.nif");
        
        ModVertexAlpha(atmosphere_ent, 0);
        
        atmosphere_ent->setRenderQueueGroup(RENDER_QUEUE_SKIES_EARLY);
        Ogre::SceneNode* atmosphere_node = mRootNode->createChildSceneNode();
        atmosphere_node->attachObject(atmosphere_ent);
        mAtmosphereMaterial = atmosphere_ent->getSubEntity(0)->getMaterial();
        
        // Atmosphere shader
		HighLevelGpuProgramPtr vshader = mgr.createProgram("Atmosphere_VP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, 
			"cg", GPT_VERTEX_PROGRAM);

        vshader->setParameter("profiles", "vs_2_x arbvp1");
		vshader->setParameter("entry_point", "main_vp");
		
		StringUtil::StrStreamType outStream;
		outStream <<
		"void main_vp(	\n"
		"	float4 position : POSITION,	\n"
		"	in float4 color	: COLOR,	\n"
		"	out float4 oPosition : POSITION,	\n"
		"	out float4 oColor    : COLOR, \n"
        "   uniform float4 emissive, \n"
		"	uniform float4x4 worldViewProj	\n"
        ")	\n"
		"{	\n"
		"	oPosition = mul( worldViewProj, position );  \n"
        "   oColor = color * emissive; \n"
		"}";
		vshader->setSource(outStream.str());
		vshader->load();
		
		vshader->getDefaultParameters()->setNamedAutoConstant("worldViewProj", GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
        vshader->getDefaultParameters()->setNamedAutoConstant("emissive", GpuProgramParameters::ACT_SURFACE_EMISSIVE_COLOUR);
        mAtmosphereMaterial->getTechnique(0)->getPass(0)->setVertexProgram(vshader->getName());

        // Clouds
        NifOgre::NIFLoader::load("meshes\\sky_clouds_01.nif");
        Entity* clouds_ent = mSceneMgr->createEntity("meshes\\sky_clouds_01.nif");
        clouds_ent->setRenderQueueGroup(RENDER_QUEUE_SKIES_EARLY+2);
        SceneNode* clouds_node = mRootNode->createChildSceneNode();
        clouds_node->attachObject(clouds_ent);
        mCloudMaterial = clouds_ent->getSubEntity(0)->getMaterial();
        
        // Clouds vertex shader
		HighLevelGpuProgramPtr vshader2 = mgr.createProgram("Clouds_VP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, 
			"cg", GPT_VERTEX_PROGRAM);
        vshader2->setParameter("profiles", "vs_2_x arbvp1");
		vshader2->setParameter("entry_point", "main_vp");
		StringUtil::StrStreamType outStream3;
		outStream3 <<
		"void main_vp(	\n"
		"	float4 position : POSITION,	\n"
		"	in float4 color	: COLOR,	\n"
        "   out float4 oColor : TEXCOORD1, \n"
        "   in float2 uv : TEXCOORD0, \n"
        "   out float2 oUV : TEXCOORD0, \n"
		"	out float4 oPosition : POSITION,	\n"
		"	uniform float4x4 worldViewProj	\n"
        ")	\n"
		"{	\n"
        "   oUV = uv; \n"
        "   oColor = color; \n"
		"	oPosition = mul( worldViewProj, position );  \n"
		"}";
		vshader2->setSource(outStream3.str());
		vshader2->load();
		vshader2->getDefaultParameters()->setNamedAutoConstant("worldViewProj", GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
        mCloudMaterial->getTechnique(0)->getPass(0)->setVertexProgram(vshader2->getName());
        
        // Clouds fragment shader
		mCloudFragmentShader = mgr.createProgram("Clouds_FP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, 
			"cg", GPT_FRAGMENT_PROGRAM);
        mCloudFragmentShader->setParameter("profiles", "ps_2_x arbfp1");
		mCloudFragmentShader->setParameter("entry_point", "main_fp");
		StringUtil::StrStreamType outStream2;
		outStream2 <<
		"void main_fp(	\n"
        "   in float2 uv : TEXCOORD0, \n"
		"	out float4 oColor    : COLOR, \n"
        "   in float4 color : TEXCOORD1, \n"
        "   uniform sampler2D texture : TEXUNIT0, \n"
        "   uniform float time, \n"
        "   uniform float4 emissive \n"
        ")	\n"
		"{	\n"
        "   uv += float2(1,1) * time * 0.01; \n" // Scroll in x,y direction
        "   float4 tex = tex2D(texture, uv); \n"
        "   oColor = color * float4(emissive.xyz,1) * tex2D(texture, uv); \n"
		"}";
		mCloudFragmentShader->setSource(outStream2.str());
		mCloudFragmentShader->load();
        mCloudFragmentShader->getDefaultParameters()->setNamedAutoConstant("emissive", GpuProgramParameters::ACT_SURFACE_EMISSIVE_COLOUR);
        mCloudMaterial->getTechnique(0)->getPass(0)->setFragmentProgram(mCloudFragmentShader->getName());
        
        ModVertexAlpha(clouds_ent, 1);
        
        // I'm not sure if the materials are being used by any other objects
        // Make a unique "modifiable" copy of the materials to be sure
        mCloudMaterial = mCloudMaterial->clone("Clouds");
        clouds_ent->getSubEntity(0)->setMaterial(mCloudMaterial);
        mAtmosphereMaterial = mAtmosphereMaterial->clone("Atmosphere");
        atmosphere_ent->getSubEntity(0)->setMaterial(mAtmosphereMaterial);
        
        // Default atmosphere color: light blue
        mAtmosphereMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(0.235, 0.5, 0.73);
        mAtmosphereMaterial->getTechnique(0)->getPass(0)->setDiffuse(0.0, 0.0, 0.0, 0.0);
        mAtmosphereMaterial->getTechnique(0)->getPass(0)->setAmbient(0.0, 0.0, 0.0);
        // Set up an UV scroll animation to move the clouds
        mCloudMaterial->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setScrollAnimation(0.01f, 0.01f);
        mCloudMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(1.0, 1.0, 1.0);
        // Disable depth writing so that the sky does not cover any objects
        mCloudMaterial->getTechnique(0)->getPass(0)->setDepthWriteEnabled(false);
        mAtmosphereMaterial->getTechnique(0)->getPass(0)->setDepthWriteEnabled(false);
        mAtmosphereMaterial->getTechnique(0)->getPass(0)->setSceneBlending(SBT_TRANSPARENT_ALPHA);
        mCloudMaterial->getTechnique(0)->getPass(0)->setSceneBlending(SBT_TRANSPARENT_ALPHA);
        
        mCamera = pCamera;
        mCamera->setFarClipDistance(500000.f);
    }
    MWSkyManager::~MWSkyManager()
    {
        delete mSun;
        delete mMasser;
        delete mSecunda;
    }
    
    void MWSkyManager::update(float duration)
    {
        // Sync the position of the skydomes with the camera
        /// \todo for some reason this is 1 frame delayed, which causes the skydome move funnily when the camera moves
        mRootNode->_setDerivedPosition(mCamera->getParentSceneNode()->_getDerivedPosition());
        
        // UV Scroll the clouds
        mCloudMaterial->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstantFromTime("time", 1);
    }
    
    void MWSkyManager::enable()
    {
        mRootNode->setVisible(true);
    }
    
    void MWSkyManager::disable()
    {
        mRootNode->setVisible(false);
    }
    
    void MWSkyManager::setMoonColour (bool red)
    {
        mSecunda->setColour( red ? ColourValue(1.0, 0.0, 0.0)
                                : ColourValue(1.0, 1.0, 1.0));
    }

    /// Creates and connects the sky rendering component to OGRE.
    ///
    /// \return NULL on failure.
    /// 
    SkyManager* SkyManager::create (Ogre::RenderWindow* pRenderWindow, 
                                    Ogre::Camera*       pCamera,
                                    Ogre::SceneNode* pMwRoot,
                                    const boost::filesystem::path& resDir)
    {
        SkyManager* pSkyManager = NULL;

        try
        {
            //pSkyManager = new CaelumManager(pRenderWindow, pCamera, resDir);
            pSkyManager = new MWSkyManager(pMwRoot, pCamera);
        }
        catch (Ogre::Exception& e)
        {
            std::cout << "\nOGRE Exception when attempting to add sky: " 
                << e.getFullDescription().c_str() << std::endl;
        }
        catch (std::exception& e)
        {
            std::cout << "\nException when attempting to add sky: " 
                << e.what() << std::endl;
        }

        return pSkyManager;
    }
}