/*
 * Copyright 2006 Sony Computer Entertainment Inc.
 *
 * Licensed under the SCEA Shared Source License, Version 1.0 (the "License"); you may not use this 
 * file except in compliance with the License. You may obtain a copy of the License at:
 * http://research.scea.com/scea_shared_source_license.html
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License 
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 
 * implied. See the License for the specific language governing permissions and limitations under the 
 * License. 
 */

#include "daeReader.h"
#include <dae.h>
#include <dae/domAny.h>
#include <dom/domCOLLADA.h>

#include <osg/Switch>
#include <osg/LightSource>
#include <osg/Geode>
#include <osg/ShapeDrawable>
#include <osg/LOD>
#include <osg/Billboard>
#include <osgSim/MultiSwitch>
#include <osg/Sequence>
#include <osg/CameraView>
#include <osg/LightModel>

using namespace osgDAE;

osg::Group* daeReader::processOsgMultiSwitch(domTechnique* teq)
{
    osgSim::MultiSwitch* msw = new osgSim::MultiSwitch;

    domAny* any = daeSafeCast<domAny>(teq->getChild("ActiveSwitchSet"));
    if (any)
    {
        msw->setActiveSwitchSet(parseString<unsigned int>(any->getValue()));
    }
    else
    {
        OSG_WARN << "Expected element 'ActiveSwitchSet' not found" << std::endl;
    }
    
    any = daeSafeCast<domAny>(teq->getChild("ValueLists"));
    if (any)
    {
        unsigned int numChildren = any->getChildren().getCount();
        for (unsigned int currChild = 0; currChild < numChildren; currChild++)
        {
            domAny* child = daeSafeCast<domAny>(any->getChildren()[currChild]);
            if (child)
            {
                if (strcmp(child->getElementName(), "ValueList" ) == 0 )
                {
                    std::list<std::string> stringValues;
                    osgSim::MultiSwitch::ValueList values;

                    cdom::tokenize(child->getValue(), " ", stringValues);
                    cdom::tokenIter iter = stringValues.begin();
                    
                    while (iter != stringValues.end())
                    {
                        values.push_back(parseString<bool>(*iter));
                        ++iter;
                    }
                    
                    msw->setValueList(currChild, values);
                }
                else
                {
                    OSG_WARN << "Child of element 'ValueLists' is not of type 'ValueList'" << std::endl;
                }
            }
            else
            {
                OSG_WARN << "Element 'ValueLists' does not contain expected elements." << std::endl;
            }
        }
    }
    else
    {
        OSG_WARN << "Expected element 'ValueLists' not found" << std::endl;
    }
    return msw;
}

osg::Group* daeReader::processOsgSwitch(domTechnique* teq)
{
    osg::Switch* sw = new osg::Switch;

    domAny* any = daeSafeCast< domAny >(teq->getChild("ValueList"));
    if (any)
    {
        std::list<std::string> stringValues;

        cdom::tokenize(any->getValue(), " ", stringValues);
        cdom::tokenIter iter = stringValues.begin();

        int pos = 0;
        while (iter != stringValues.end())
        {
            sw->setValue(pos++, parseString<bool>(*iter));
            ++iter;
        }
    }
    else
    {
        OSG_WARN << "Expected element 'ValueList' not found" << std::endl;
    }
    return sw;
}

osg::Group* daeReader::processOsgSequence(domTechnique* teq)
{
    osg::Sequence* sq = new osg::Sequence;

    domAny* any = daeSafeCast< domAny >(teq->getChild("FrameTime"));
    if (any)
    {
        std::list<std::string> stringValues;

        cdom::tokenize(any->getValue(), " ", stringValues);
        cdom::tokenIter iter = stringValues.begin();

        int frame = 0;
        while (iter != stringValues.end())
        {
            sq->setTime(frame++, parseString<double>(*iter));
            ++iter;
        }
    }
    else
    {
        OSG_WARN << "Expected element 'FrameTime' not found" << std::endl;
    }

    any = daeSafeCast< domAny >(teq->getChild("LastFrameTime"));
    if (any)
    {
        sq->setLastFrameTime(parseString<double>(any->getValue()));
    }
    else
    {
        OSG_WARN << "Expected element 'LastFrameTime' not found" << std::endl;
    }

    osg::Sequence::LoopMode loopmode = osg::Sequence::LOOP;
    any = daeSafeCast< domAny >(teq->getChild("LoopMode"));
    if (any)
    {
        loopmode = (osg::Sequence::LoopMode)parseString<int>(any->getValue());
    }
    else
    {
        OSG_WARN << "Expected element 'LoopMode' not found" << std::endl;
    }
    
    int begin=0;
    any = daeSafeCast< domAny >(teq->getChild("IntervalBegin"));
    if (any)
    {
        begin = parseString<int>(any->getValue());
    }
    else
    {
        OSG_WARN << "Expected element 'IntervalBegin' not found" << std::endl;
    }
    
    int end=-1;
    any = daeSafeCast< domAny >(teq->getChild("IntervalEnd"));
    if (any)
    {
        end = parseString<int>(any->getValue());
    }
    else
    {
        OSG_WARN << "Expected element 'IntervalEnd' not found" << std::endl;
    }

    sq->setInterval(loopmode, begin, end);

    float speed = 0;
    any = daeSafeCast< domAny >(teq->getChild("DurationSpeed"));
    if (any)
    {
        speed = parseString<float>(any->getValue());
    }
    else
    {
        OSG_WARN << "Expected element 'DurationSpeed' not found" << std::endl;
    }
    
    int nreps = -1;
    any = daeSafeCast< domAny >(teq->getChild("DurationNReps"));
    if (any)
    {
        nreps = parseString<int>(any->getValue());
    }
    else
    {
        OSG_WARN << "Expected element 'DurationNReps' not found" << std::endl;
    }

    sq->setDuration(speed, nreps);

    any = daeSafeCast< domAny >(teq->getChild("SequenceMode"));
    if (any)
    {
        sq->setMode((osg::Sequence::SequenceMode)parseString<int>(any->getValue()));
    }
    else
    {
        OSG_WARN << "Expected element 'SequenceMode' not found" << std::endl;
    }

    return sq;
}


osg::Group* daeReader::processOsgLOD(domTechnique* teq)
{
    osg::LOD* lod = new osg::LOD;

    domAny* any = daeSafeCast< domAny >(teq->getChild("Center"));
    if (any)
    {
        // If a center is specified
        lod->setCenterMode(osg::LOD::USER_DEFINED_CENTER);
        lod->setCenter(parseVec3String(any->getValue()));

        any = daeSafeCast< domAny >(teq->getChild("Radius"));
        if (any)
        {
            lod->setRadius(parseString<osg::LOD::value_type>(any->getValue()));
        }
        else
        {
            OSG_WARN << "Expected element 'Radius' not found" << std::endl;
        }
    }

    any = daeSafeCast< domAny >(teq->getChild("RangeMode"));
    if (any)
    {
        lod->setRangeMode((osg::LOD::RangeMode)parseString<int>(any->getValue()));
    }
    else
    {
        OSG_WARN << "Expected element 'RangeMode' not found" << std::endl;
    }

    any = daeSafeCast< domAny >(teq->getChild("RangeList"));
    if (any)
    {
        osg::LOD::RangeList rangelist;

        unsigned int numChildren = any->getChildren().getCount();
        for (unsigned int currChild = 0; currChild < numChildren; currChild++)
        {
            domAny* child = daeSafeCast<domAny>(any->getChildren()[currChild]);
            if (child)
            {
                if (strcmp(child->getElementName(), "MinMax" ) == 0 )
                {
                    std::list<std::string> stringValues;
                    osg::LOD::MinMaxPair minMaxPair;
        
                    cdom::tokenize(child->getValue(), " ", stringValues);
                    cdom::tokenIter iter = stringValues.begin();
                    
                    if (iter != stringValues.end())
                    {
                        minMaxPair.first = parseString<float>(*iter);
                        ++iter;
                    }
                    else
                    {
                        OSG_WARN << "'MinMax' does not contain a valid minimum value" << std::endl;
                    }

                    if (iter != stringValues.end())
                    {
                        minMaxPair.second = parseString<float>(*iter);
                    }
                    else
                    {
                        OSG_WARN << "'MinMax' does not contain a valid maximum value" << std::endl;
                    }

                    rangelist.push_back(minMaxPair);
                }
                else
                {
                    OSG_WARN << "Child of element 'RangeList' is not of type 'MinMax'" << std::endl;
                }
            }
            else
            {
                OSG_WARN << "Element 'RangeList' does not contain expected elements." << std::endl;
            }
        }

        lod->setRangeList(rangelist);
    }
    else
    {
        OSG_WARN << "Expected element 'RangeList' not found" << std::endl;
    }

    return lod;
}

// <light>
// attributes:
// id, name
// elements:
// 0..1 <asset>
// 1    <technique_common>
//        1    <ambient>, <directional>, <point>, <spot>
// 0..* <technique>
// 0..* <extra>
osg::Node* daeReader::processLight( domLight *dlight )
{
    if (_numlights >= 7)
    {
        OSG_WARN << "More than 8 lights may not be supported by OpenGL driver." << std::endl;
    }

    //do light processing here.
    domLight::domTechnique_common::domAmbient *ambient;
    domLight::domTechnique_common::domDirectional *directional;
    domLight::domTechnique_common::domPoint *point;
    domLight::domTechnique_common::domSpot *spot;

    if ( dlight->getTechnique_common() == NULL || 
         dlight->getTechnique_common()->getContents().getCount() == 0 )
    {
        OSG_WARN << "Invalid content for light" << std::endl;
        return NULL;
    }

    osg::Light* light = new osg::Light();
    light->setPosition(osg::Vec4(0,0,0,1));
    light->setLightNum(_numlights);

    // Enable OpenGL lighting
    _rootStateSet->setMode(GL_LIGHTING, osg::StateAttribute::ON);
    // Enable this OpenGL light
    _rootStateSet->setMode(GL_LIGHT0 + _numlights++, osg::StateAttribute::ON);
    
    // Set ambient of lightmodel to zero
    // Ambient lights are added as separate lights with only an ambient term
    osg::LightModel* lightmodel = new osg::LightModel;
    lightmodel->setAmbientIntensity(osg::Vec4(0.0f,0.0f,0.0f,1.0f));
    _rootStateSet->setAttributeAndModes(lightmodel, osg::StateAttribute::ON); 

    osg::LightSource* lightsource = new osg::LightSource();
    lightsource->setLight(light);
    lightsource->setName(dlight->getId());

    daeElement *el = dlight->getTechnique_common()->getContents()[0];
    ambient = daeSafeCast< domLight::domTechnique_common::domAmbient >( el );
    directional = daeSafeCast< domLight::domTechnique_common::domDirectional >( el );
    point = daeSafeCast< domLight::domTechnique_common::domPoint >( el );
    spot = daeSafeCast< domLight::domTechnique_common::domSpot >( el );
    if ( ambient != NULL )
    {
        if ( ambient->getColor() == NULL ) 
        {
            OSG_WARN << "Invalid content for ambient light" << std::endl;
            return NULL;
        }

        light->setAmbient(    osg::Vec4(    ambient->getColor()->getValue()[0],
                                        ambient->getColor()->getValue()[1], 
                                        ambient->getColor()->getValue()[2], 1.0f ) );
        light->setDiffuse(    osg::Vec4(    0, 0, 0, 0));
        light->setSpecular(    osg::Vec4(    0, 0, 0, 0));
        
        // Tell OpenGL to make it a directional light (w=0)
        light->setPosition(    osg::Vec4(0,0,0,0));
    }
    else if ( directional != NULL )
    {
        if ( directional->getColor() == NULL ) 
        {
            OSG_WARN << "Invalid content for directional light" << std::endl;
            return NULL;
        }
        light->setAmbient(    osg::Vec4(    0, 0, 0, 0));
        light->setDiffuse(    osg::Vec4(    directional->getColor()->getValue()[0], 
                                        directional->getColor()->getValue()[1], 
                                        directional->getColor()->getValue()[2], 1.0f ) );
        light->setSpecular( osg::Vec4(    directional->getColor()->getValue()[0],
                                        directional->getColor()->getValue()[1], 
                                        directional->getColor()->getValue()[2], 1.0f ) );
        
        light->setDirection(osg::Vec3(0,0,-1));

        // Tell OpenGL it is a directional light (w=0)
        light->setPosition(    osg::Vec4(0,0,1,0));
    }
    else if ( point != NULL )
    {
        if ( point->getColor() == NULL ) 
        {
            OSG_WARN << "Invalid content for point light" << std::endl;
            return NULL;
        }
        light->setAmbient(    osg::Vec4(    0, 0, 0, 0));
        light->setDiffuse(    osg::Vec4(    point->getColor()->getValue()[0], 
                                        point->getColor()->getValue()[1], 
                                        point->getColor()->getValue()[2], 1.0f ) );
        light->setSpecular( osg::Vec4(    point->getColor()->getValue()[0], 
                                        point->getColor()->getValue()[1], 
                                        point->getColor()->getValue()[2], 1.0f ) );

        if ( point->getConstant_attenuation() != NULL )
        {
            light->setConstantAttenuation( point->getConstant_attenuation()->getValue() );
        }
        else
        {
            light->setConstantAttenuation( 1.0 );
        }
        if ( point->getLinear_attenuation() != NULL )
        {
            light->setLinearAttenuation( point->getLinear_attenuation()->getValue() );
        }
        else
        {
            light->setLinearAttenuation( 0.0 );
        }
        if ( point->getQuadratic_attenuation() != NULL )
        {
            light->setQuadraticAttenuation( point->getQuadratic_attenuation()->getValue() );
        }
        else
        {
            light->setQuadraticAttenuation( 0.0 );
        }

        // Tell OpenGL this is an omni directional light
        light->setDirection(osg::Vec3(0, 0, 0));
    }
    else if ( spot != NULL )
    {
        if ( spot->getColor() == NULL ) 
        {
            OSG_WARN << "Invalid content for spot light" << std::endl;
            return NULL;
        }
        light->setAmbient(    osg::Vec4(    0, 0, 0, 0));
        light->setDiffuse(    osg::Vec4(    spot->getColor()->getValue()[0], 
                                        spot->getColor()->getValue()[1], 
                                        spot->getColor()->getValue()[2], 1.0f ) );
        light->setSpecular( osg::Vec4(    spot->getColor()->getValue()[0], 
                                        spot->getColor()->getValue()[1], 
                                        spot->getColor()->getValue()[2], 1.0f ) );

        if ( spot->getConstant_attenuation() != NULL )
        {
            light->setConstantAttenuation( spot->getConstant_attenuation()->getValue() );
        }
        else
        {
            light->setConstantAttenuation( 1.0f );
        }
        if ( spot->getLinear_attenuation() != NULL )
        {
            light->setLinearAttenuation( spot->getLinear_attenuation()->getValue() );
        }
        else
        {
            light->setLinearAttenuation( 0.0f );
        }
        if ( spot->getQuadratic_attenuation() != NULL )
        {
            light->setQuadraticAttenuation( spot->getQuadratic_attenuation()->getValue() );
        }
        else
        {
            light->setQuadraticAttenuation( 0.0f );
        }
        // OpenGL range [0, 90] (degrees) or 180 (omni)
        if ( spot->getFalloff_angle() != NULL )
        {
            float falloffAngle = spot->getFalloff_angle()->getValue();
            if (falloffAngle != 180)
            {
                falloffAngle = osg::clampTo<float>(falloffAngle, 0, 90);
            }
            light->setSpotCutoff(falloffAngle);
        }
        else
        {
            light->setSpotCutoff( 180.0f );
        }
        // OpenGL range [0, 128], where 0 means hard edge, and 128 means soft edge
        if ( spot->getFalloff_exponent() != NULL )
        {
            float falloffExponent = spot->getFalloff_exponent()->getValue();
            falloffExponent = osg::clampTo<float>(falloffExponent, 0, 128);
            light->setSpotExponent(falloffExponent);
        }
        else
        {
            light->setSpotExponent( 0.0f );
        }
        light->setDirection(osg::Vec3(0, 0, -1));
    }

    return lightsource;
}

// <camera>
// attributes:
// id, name
// elements:
// 0..1 <asset>
// 1    <optics>
//        1       <technique_common>
//                1        <orthographic>, <perspective>
//        0..*    <technique>
//        0..*    <extra>
// 0..* <imager>
//        1       <technique>
//        0..*    <extra>
// 0..* <extra>
osg::Node* daeReader::processCamera( domCamera * dcamera )
{
    osg::CameraView* pOsgCameraView = new osg::CameraView;
    pOsgCameraView->setName(dcamera->getId());

    domCamera::domOptics::domTechnique_common *pDomTechniqueCommon = dcamera->getOptics()->getTechnique_common();
    domCamera::domOptics::domTechnique_common::domPerspective *pDomPerspective = pDomTechniqueCommon->getPerspective();
    domCamera::domOptics::domTechnique_common::domOrthographic *pDomOrthographic = pDomTechniqueCommon->getOrthographic();
    if (pDomPerspective)
    {
        // <perspective>
        // 1    <xfov>, <yfov>, <xfov> and <yfov>, <xfov> and <aspect_ratio>, <yfov> and <aspect_ratio>
        // 1    <znear>
        // 1    <zfar>
        domTargetableFloat *pXfov = daeSafeCast< domTargetableFloat >(pDomPerspective->getXfov());
        domTargetableFloat *pYfov = daeSafeCast< domTargetableFloat >(pDomPerspective->getYfov());
        domTargetableFloat *pAspectRatio = daeSafeCast< domTargetableFloat >(pDomPerspective->getAspect_ratio());

        if (pXfov)
        {
            if (pYfov)
            {
                // <xfov> and <yfov>
                pOsgCameraView->setFieldOfView(pXfov->getValue());
                pOsgCameraView->setFieldOfViewMode(osg::CameraView::HORIZONTAL);
                
                if (pAspectRatio)
                {
                    OSG_WARN << "Unexpected <aspectratio> in <camera> '" << dcamera->getId() << "'" << std::endl;
                }
            }
            else if (pAspectRatio)
            {
                // <xfov> and <aspect_ratio>
                pOsgCameraView->setFieldOfView(pXfov->getValue() * pAspectRatio->getValue());
                pOsgCameraView->setFieldOfViewMode(osg::CameraView::HORIZONTAL);
            }
            else 
            {
                // <xfov>
                pOsgCameraView->setFieldOfView(pXfov->getValue());
                pOsgCameraView->setFieldOfViewMode(osg::CameraView::HORIZONTAL);
            }
        }
        else if (pYfov)
        {
            if (pAspectRatio)
            {
                // <yfov> and <aspect_ratio>
                pOsgCameraView->setFieldOfView(pYfov->getValue() / pAspectRatio->getValue());
                pOsgCameraView->setFieldOfViewMode(osg::CameraView::VERTICAL);
            }
            else
            {
                // <yfov>
                pOsgCameraView->setFieldOfView(pYfov->getValue());
                pOsgCameraView->setFieldOfViewMode(osg::CameraView::VERTICAL);
            }
        }
        else
        {
            // xfov or yfov expected
            OSG_WARN << "Expected <xfov> or <yfov> in <camera> '" << dcamera->getId() << "'" << std::endl;
        }

        //domTargetableFloat *pZnear = daeSafeCast< domTargetableFloat >(pDomPerspective->getZnear());
        //domTargetableFloat *pZfar = daeSafeCast< domTargetableFloat >(pDomPerspective->getZfar());

        // TODO The current osg::CameraView does not support storage of near far
    }
    else if (pDomOrthographic)
    {
        // <orthographic> 
        // 1    <xmag>, <ymag>, <xmag> and <ymag>, <xmag> and <aspect_ratio>, <ymag> and <aspect_ratio>
        // 1    <znear>
        // 1    <zfar>
        
        //domTargetableFloat *pXmag = daeSafeCast< domTargetableFloat >(pDomOrthographic->getXmag());
        //domTargetableFloat *pYmag = daeSafeCast< domTargetableFloat >(pDomOrthographic->getYmag());
        //domTargetableFloat *pAspectRatio = daeSafeCast< domTargetableFloat >(pDomOrthographic->getAspect_ratio());

        // TODO The current osg::CameraView does not support an orthographic view
        OSG_WARN << "Orthographic in <camera> '" << dcamera->getId() << "' not supported" << std::endl;

        //domTargetableFloat *pZnear = daeSafeCast< domTargetableFloat >(pDomOrthographic->getZnear());
        //domTargetableFloat *pZfar = daeSafeCast< domTargetableFloat >(pDomOrthographic->getZfar());    

        // TODO The current osg::CameraView does not support storage of near far
    }

    return pOsgCameraView;
}