#include "WriteVisitor"
#include <osgDB/WriteFile>
#include <osgDB/FileUtils>
#include <osgDB/ReadFile>
#include <osgDB/FileNameUtils>
#include <osg/UserDataContainer>
#include <osg/TextureRectangle>
#include <osg/Texture2D>
#include <osg/Texture1D>
#include <osg/Types>
#include <osg/Material>
#include <osg/BlendFunc>

#include <osgSim/ShapeAttribute>

#include <osgText/Text>

#include <osgAnimation/MorphGeometry>

#include "Base64"


osg::Array* getTangentSpaceArray(osg::Geometry& geometry) {
    for(unsigned int i = 0 ; i < geometry.getNumVertexAttribArrays() ; ++ i) {
        osg::Array* attribute = geometry.getVertexAttribArray(i);
        bool isTangentArray = false;
        if(attribute && attribute->getUserValue("tangent", isTangentArray) && isTangentArray) {
            return attribute;
        }
    }
    return 0;
}


osg::Array* getAnimationBonesArray(osgAnimation::RigGeometry& rigGeometry) {
    for(unsigned int i = 0 ; i < rigGeometry.getNumVertexAttribArrays() ; ++ i) {
        osg::Array* attribute = rigGeometry.getVertexAttribArray(i);
        bool isBones = false;
        if(attribute && attribute->getUserValue("bones", isBones) && isBones) {
            return attribute;
        }
    }
    return 0;
}


osg::Array* getAnimationWeightsArray(osgAnimation::RigGeometry& rigGeometry) {
    for(unsigned int i = 0 ; i < rigGeometry.getNumVertexAttribArrays() ; ++ i) {
        osg::Array* attribute = rigGeometry.getVertexAttribArray(i);
        bool isWeights = false;
        if(attribute && attribute->getUserValue("weights", isWeights) && isWeights) {
            return attribute;
        }
    }
    return 0;
}


osg::ref_ptr<JSONObject> buildRigBoneMap(osgAnimation::RigGeometry& rigGeometry) {
    osg::Array* bones = getAnimationBonesArray(rigGeometry);
    osg::ref_ptr<JSONObject> boneMap = new JSONObject;

    unsigned int paletteIndex = 0;
    while(true) {
        std::ostringstream oss;
        oss << "animationBone_" << paletteIndex;
        std::string boneName, palette = oss.str();
        if(!bones->getUserValue(palette, boneName)) {
            break;
        }
        boneMap->getMaps()[boneName] = new JSONValue<int>(paletteIndex);
        ++ paletteIndex;
    }

    return boneMap;
}


void translateObject(JSONObject* json, osg::Object* osg)
{
    if (!osg->getName().empty()) {
        json->getMaps()["Name"] = new JSONValue<std::string>(osg->getName());
    }

    osgSim::ShapeAttributeList* osgSim_userdata = dynamic_cast<osgSim::ShapeAttributeList* >(osg->getUserData());
    if (osgSim_userdata) {
        JSONObject* jsonUDC = new JSONObject();
        jsonUDC->addUniqueID();

        JSONArray* jsonUDCArray = new JSONArray();
        jsonUDC->getMaps()["Values"] = jsonUDCArray;
        for (unsigned int i = 0; i < osgSim_userdata->size(); i++) {
            const osgSim::ShapeAttribute& attr = (*osgSim_userdata)[i];
            JSONObject* jsonEntry = new JSONObject();
            jsonEntry->getMaps()["Name"] = new JSONValue<std::string>(attr.getName());
            osg::ref_ptr<JSONValue<std::string> > value;
            switch(attr.getType()) {
            case osgSim::ShapeAttribute::INTEGER:
            {
                std::stringstream ss;
                ss << attr.getInt();
                value = new JSONValue<std::string>(ss.str());
            }
            break;
            case osgSim::ShapeAttribute::DOUBLE:
            {
                std::stringstream ss;
                ss << attr.getDouble();
                value = new JSONValue<std::string>(ss.str());
            }
            break;
            case osgSim::ShapeAttribute::STRING:
            {
                std::stringstream ss;
                ss << attr.getString();
                value = new JSONValue<std::string>(ss.str());
            }
            break;
            case osgSim::ShapeAttribute::UNKNOWN:
            default:
                break;
            }
            jsonEntry->getMaps()["Value"] = value;
            jsonUDCArray->getArray().push_back(jsonEntry);
        }
        json->getMaps()["UserDataContainer"] = jsonUDC;

    } else if (osg->getUserDataContainer()) {
        JSONObject* jsonUDC = new JSONObject();
        jsonUDC->addUniqueID();

        if (!osg->getUserDataContainer()->getName().empty()) {
            jsonUDC->getMaps()["Name"] = new JSONValue<std::string>(osg->getUserDataContainer()->getName());
        }
        JSONArray* jsonUDCArray = new JSONArray();
        jsonUDC->getMaps()["Values"] = jsonUDCArray;
        for (unsigned int i = 0; i < osg->getUserDataContainer()->getNumUserObjects(); i++) {
            osg::Object* o = osg->getUserDataContainer()->getUserObject(i);
            std::string name, value;
            getStringifiedUserValue(o, name, value);
            if(!name.empty() && !value.empty())
            {
                JSONObject* jsonEntry = new JSONObject();
                jsonEntry->getMaps()["Name"] = new JSONValue<std::string>(name);
                jsonEntry->getMaps()["Value"] = new JSONValue<std::string>(value);
                jsonUDCArray->getArray().push_back(jsonEntry);
            }

        }
        json->getMaps()["UserDataContainer"] = jsonUDC;
    }
}


void getStringifiedUserValue(osg::Object* o, std::string& name, std::string& value) {
    if(getStringifiedUserValue<std::string>(o, name, value)) return;
    if(getStringifiedUserValue<char>(o, name, value)) return;
    if(getStringifiedUserValue<bool>(o, name, value)) return;
    if(getStringifiedUserValue<short>(o, name, value)) return;
    if(getStringifiedUserValue<unsigned short>(o, name, value)) return;
    if(getStringifiedUserValue<int>(o, name, value)) return;
    if(getStringifiedUserValue<unsigned int>(o, name, value)) return;
    if(getStringifiedUserValue<float>(o, name, value)) return;
    if(getStringifiedUserValue<double>(o, name, value)) return;
}


template<typename T>
bool getStringifiedUserValue(osg::Object* o, std::string& name, std::string& value) {
    osg::TemplateValueObject<T>* vo = dynamic_cast< osg::TemplateValueObject<T>* >(o);
    if (vo) {
        std::ostringstream oss;
        oss << vo->getValue();
        name = vo->getName();
        value = oss.str();
        return true;
    }
    return false;
}


static JSONValue<std::string>* getBlendFuncMode(GLenum mode) {
    switch (mode) {
    case osg::BlendFunc::DST_ALPHA: return new JSONValue<std::string>("DST_ALPHA");
    case osg::BlendFunc::DST_COLOR: return new JSONValue<std::string>("DST_COLOR");
    case osg::BlendFunc::ONE: return new JSONValue<std::string>("ONE");
    case osg::BlendFunc::ONE_MINUS_DST_ALPHA: return new JSONValue<std::string>("ONE_MINUS_DST_ALPHA");
    case osg::BlendFunc::ONE_MINUS_DST_COLOR: return new JSONValue<std::string>("ONE_MINUS_DST_COLOR");
    case osg::BlendFunc::ONE_MINUS_SRC_ALPHA: return new JSONValue<std::string>("ONE_MINUS_SRC_ALPHA");
    case osg::BlendFunc::ONE_MINUS_SRC_COLOR: return new JSONValue<std::string>("ONE_MINUS_SRC_COLOR");
    case osg::BlendFunc::SRC_ALPHA: return new JSONValue<std::string>("SRC_ALPHA");
    case osg::BlendFunc::SRC_ALPHA_SATURATE: return new JSONValue<std::string>("SRC_ALPHA_SATURATE");
    case osg::BlendFunc::SRC_COLOR: return new JSONValue<std::string>("SRC_COLOR");
    case osg::BlendFunc::CONSTANT_COLOR: return new JSONValue<std::string>("CONSTANT_COLOR");
    case osg::BlendFunc::ONE_MINUS_CONSTANT_COLOR: return new JSONValue<std::string>("ONE_MINUS_CONSTANT_COLOR");
    case osg::BlendFunc::CONSTANT_ALPHA: return new JSONValue<std::string>("CONSTANT_ALPHA");
    case osg::BlendFunc::ONE_MINUS_CONSTANT_ALPHA: return new JSONValue<std::string>("ONE_MINUS_CONSTANT_ALPHA");
    case osg::BlendFunc::ZERO: return new JSONValue<std::string>("ZERO");
    default:
        return new JSONValue<std::string>("ONE");
    }
}

static JSONValue<std::string>* getJSONFilterMode(osg::Texture::FilterMode mode)
{
    switch(mode) {
    case GL_LINEAR:
        return new JSONValue<std::string>("LINEAR");
    case GL_LINEAR_MIPMAP_LINEAR:
        return new JSONValue<std::string>("LINEAR_MIPMAP_LINEAR");
    case GL_LINEAR_MIPMAP_NEAREST:
        return new JSONValue<std::string>("LINEAR_MIPMAP_NEAREST");
    case GL_NEAREST:
        return new JSONValue<std::string>("NEAREST");
    case GL_NEAREST_MIPMAP_LINEAR:
        return new JSONValue<std::string>("NEAREST_MIPMAP_LINEAR");
    case GL_NEAREST_MIPMAP_NEAREST:
        return new JSONValue<std::string>("NEAREST_MIPMAP_NEAREST");
    default:
        return 0;
    }
    return 0;
}

static JSONValue<std::string>* getJSONWrapMode(osg::Texture::WrapMode mode)
{
    switch(mode) {
    case GL_CLAMP:
        // clamp does not exist in opengles 2.0
        //return new JSONValue<std::string>("CLAMP");
        return new JSONValue<std::string>("CLAMP_TO_EDGE");
    case GL_CLAMP_TO_EDGE:
        return new JSONValue<std::string>("CLAMP_TO_EDGE");
    case GL_CLAMP_TO_BORDER_ARB:
        return new JSONValue<std::string>("CLAMP_TO_BORDER");
    case GL_REPEAT:
        return new JSONValue<std::string>("REPEAT");
    case GL_MIRRORED_REPEAT_IBM:
        return new JSONValue<std::string>("MIRROR");
    default:
        return 0;
    }
    return 0;
}

static JSONValue<std::string>* getJSONAlignmentType(osgText::Text::AlignmentType type)
{
    switch(type) {
        case osgText::Text::LEFT_TOP:
            return new JSONValue<std::string>("LEFT_TOP");
        case osgText::Text::LEFT_CENTER:
            return new JSONValue<std::string>("LEFT_CENTER");
        case osgText::Text::LEFT_BOTTOM:
            return new JSONValue<std::string>("LEFT_BOTTOM");
        case osgText::Text::CENTER_TOP:
            return new JSONValue<std::string>("CENTER_TOP");
        case osgText::Text::CENTER_CENTER:
            return new JSONValue<std::string>("CENTER_CENTER");
        case osgText::Text::CENTER_BOTTOM:
            return new JSONValue<std::string>("CENTER_BOTTOM");
        case osgText::Text::RIGHT_TOP:
            return new JSONValue<std::string>("RIGHT_TOP");
        case osgText::Text::RIGHT_CENTER:
            return new JSONValue<std::string>("RIGHT_CENTER");
        case osgText::Text::RIGHT_BOTTOM:
            return new JSONValue<std::string>("RIGHT_BOTTOM");
        case osgText::Text::LEFT_BASE_LINE:
            return new JSONValue<std::string>("LEFT_BASE_LINE");
        case osgText::Text::CENTER_BASE_LINE:
            return new JSONValue<std::string>("CENTER_BASE_LINE");
        case osgText::Text::RIGHT_BASE_LINE:
            return new JSONValue<std::string>("RIGHT_BASE_LINE");
        case osgText::Text::LEFT_BOTTOM_BASE_LINE:
            return new JSONValue<std::string>("LEFT_BOTTOM_BASE_LINE");
        case osgText::Text::CENTER_BOTTOM_BASE_LINE:
            return new JSONValue<std::string>("CENTER_BOTTOM_BASE_LINE");
        case osgText::Text::RIGHT_BOTTOM_BASE_LINE:
            return new JSONValue<std::string>("RIGHT_BOTTOM_BASE_LINE");
        default:
            return 0;
    }
    return 0;
}

JSONObject* createImage(osg::Image* image, bool inlineImages, int maxTextureDimension, const std::string &baseName)
{
    if (!image) {
        osg::notify(osg::WARN) << "unknown image from texture2d " << std::endl;
        return new JSONValue<std::string>("/unknown.png");
    } else {
        std::string modelDir = osgDB::getFilePath(baseName);
        if (!image->getFileName().empty() && image->getWriteHint() != osg::Image::STORE_INLINE) {
            if(maxTextureDimension) {
                int new_s = osg::Image::computeNearestPowerOfTwo(image->s());
                int new_t = osg::Image::computeNearestPowerOfTwo(image->t());

                bool notValidPowerOf2 = false;
                if (new_s != image->s() || image->s() > maxTextureDimension) notValidPowerOf2 = true;
                if (new_t != image->t() || image->t() > maxTextureDimension) notValidPowerOf2 = true;

                if (notValidPowerOf2) {
                    image->ensureValidSizeForTexturing(maxTextureDimension);
                    if(osgDB::isAbsolutePath(image->getFileName()))
                        osgDB::writeImageFile(*image, image->getFileName());
                    else
                        osgDB::writeImageFile(*image,
                                              osgDB::concatPaths(modelDir,
                                                                 image->getFileName()));
                }
            }
        } else {
            // no image file so use this inline name image and create a file
            std::stringstream ss;
            if ( !osgDB::getFilePath(baseName).empty())
                ss << osgDB::getFilePath(baseName) << osgDB::getNativePathSeparator();
            ss << (int64_t)image << ".inline_conv_generated.png"; // write the pointer location
            std::string filename = ss.str();
            if (osgDB::writeImageFile(*image, filename)) {
                image->setFileName(filename);
            }
        }

        if (!image->getFileName().empty()) { // means that everything went ok
            if (inlineImages) {

                std::ifstream in(osgDB::findDataFile(image->getFileName()).c_str(), std::ifstream::in | std::ifstream::binary);
                if (in.is_open() && in.good())
                {
                    // read file first to iterate
                    in.seekg(0, std::ifstream::end);
                    const std::ifstream::pos_type size = in.tellg();
                    in.seekg(0, std::ifstream::beg);
                    std::vector<unsigned char> rawData;
                    rawData.resize(size);
                    in.read(reinterpret_cast<char*>(rawData.data()),size);
                    in.seekg(std::ios_base::beg);

                    std::stringstream out;
                    out << "data:image/" << osgDB::getLowerCaseFileExtension(image->getFileName()) << ";base64,";
                    base64::encode(std::istreambuf_iterator<char>(in),
                                   std::istreambuf_iterator<char>(),
                                   std::ostreambuf_iterator<char>(out), false);

                    return new JSONValue<std::string>(out.str());

                }
            }
            return new JSONValue<std::string>(image->getFileName());
        }
    }
    return 0;
}


JSONObject* WriteVisitor::createJSONBufferArray(osg::Array* array, osg::Object* parent)
{
    if (_maps.find(array) != _maps.end())
        return _maps[array]->getShadowObject();

    osg::ref_ptr<JSONBufferArray> json = new JSONBufferArray(array);
    _maps[array] = json;
    if(_mergeAllBinaryFiles) {
        setBufferName(json.get(), parent, array);
    }
    return json.get();
}

JSONObject* WriteVisitor::createJSONDrawElementsUInt(osg::DrawElementsUInt* de, osg::Object* parent)
{
    if (_maps.find(de) != _maps.end())
        return _maps[de]->getShadowObject();

    JSONDrawElements<osg::DrawElementsUInt>* json = new JSONDrawElements<osg::DrawElementsUInt>(*de);
    _maps[de] = json;
    if(_mergeAllBinaryFiles) {
        setBufferName(json, parent, de);
    }
    return json;
}

JSONObject* WriteVisitor::createJSONDrawElementsUShort(osg::DrawElementsUShort* de, osg::Object* parent)
{
    if (_maps.find(de) != _maps.end())
        return _maps[de]->getShadowObject();

    JSONDrawElements<osg::DrawElementsUShort>* json = new JSONDrawElements<osg::DrawElementsUShort>(*de);
    _maps[de] = json;
    if(_mergeAllBinaryFiles) {
        setBufferName(json, parent, de);
    }
    return json;
}

JSONObject* WriteVisitor::createJSONDrawElementsUByte(osg::DrawElementsUByte* de, osg::Object* parent)
{
    if (_maps.find(de) != _maps.end())
        return _maps[de]->getShadowObject();

    JSONDrawElements<osg::DrawElementsUByte>* json = new JSONDrawElements<osg::DrawElementsUByte>(*de);
    _maps[de] = json;
    if(_mergeAllBinaryFiles) {
        setBufferName(json, parent, de);
    }
    return json;
}

// use to convert draw array quads to draw elements triangles
JSONObject* WriteVisitor::createJSONDrawElements(osg::DrawArrays* drawArray, osg::Object* parent)
{
    if (_maps.find(drawArray) != _maps.end())
        return _maps[drawArray]->getShadowObject();

    if (drawArray->getMode() != GL_QUADS) {
        osg::notify(osg::WARN) << "" << std::endl;
        return 0;
    }

    osg::ref_ptr<osg::DrawElementsUShort> de = new osg::DrawElementsUShort(GL_TRIANGLES);

    for (int i = 0; i < drawArray->getCount()/4; ++i) {
        int base = drawArray->getFirst() + i*4;
        de->push_back(base + 0);
        de->push_back(base + 1);
        de->push_back(base + 3);

        de->push_back(base + 1);
        de->push_back(base + 2);
        de->push_back(base + 3);
    }
    JSONDrawElements<osg::DrawElementsUShort>* json = new JSONDrawElements<osg::DrawElementsUShort>(*de);
    _maps[drawArray] = json;
    if(_mergeAllBinaryFiles) {
        setBufferName(json, parent, drawArray);
    }
    return json;
}

JSONObject* WriteVisitor::createJSONDrawArray(osg::DrawArrays* da, osg::Object* parent)
{
    if (_maps.find(da) != _maps.end())
        return _maps[da]->getShadowObject();

    osg::ref_ptr<JSONDrawArray> json = new JSONDrawArray(*da);
    _maps[da] = json;
    if(_mergeAllBinaryFiles) {
        setBufferName(json.get(), parent, da);
    }
    return json.get();
}

JSONObject* WriteVisitor::createJSONDrawArrayLengths(osg::DrawArrayLengths* da, osg::Object* parent)
{
    if (_maps.find(da) != _maps.end())
        return _maps[da]->getShadowObject();

    osg::ref_ptr<JSONDrawArrayLengths> json = new JSONDrawArrayLengths(*da);
    _maps[da] = json;
    if(_mergeAllBinaryFiles) {
        setBufferName(json.get(), parent, da);
    }
    return json.get();
}


JSONObject* WriteVisitor::createJSONGeometry(osg::Geometry* geometry, osg::Object* parent)
{
    if(!parent) {
        parent = geometry;
    }

    if (_maps.find(geometry) != _maps.end())
        return _maps[geometry]->getShadowObject();

    osg::ref_ptr<JSONObject> json = new JSONObject;
    json->addUniqueID();
    _maps[geometry] = json;

    if (geometry->getStateSet())
        createJSONStateSet(json.get(), geometry->getStateSet());

    translateObject(json.get(), geometry);

    osg::ref_ptr<JSONObject> attributes = new JSONObject;

    int nbVertexes = 0;

    if (geometry->getVertexArray()) {
        nbVertexes = geometry->getVertexArray()->getNumElements();
        attributes->getMaps()["Vertex"] = createJSONBufferArray(geometry->getVertexArray(), parent);
    }
    if (geometry->getNormalArray()) {
        attributes->getMaps()["Normal"] = createJSONBufferArray(geometry->getNormalArray(), parent);
        int nb = geometry->getNormalArray()->getNumElements();
        if (nbVertexes != nb) {
            osg::notify(osg::FATAL) << "Fatal nb normals " << nb << " != " << nbVertexes << std::endl;
            error();
        }
    }
    if (geometry->getColorArray()) {
        attributes->getMaps()["Color"] = createJSONBufferArray(geometry->getColorArray(), parent);
        int nb = geometry->getColorArray()->getNumElements();
        if (nbVertexes != nb) {
            osg::notify(osg::FATAL) << "Fatal nb colors " << nb << " != " << nbVertexes << std::endl;
            error();
        }
    }

    std::stringstream ss;
    for ( int i = 0; i < 32; i++) {
        ss.str("");
        ss << "TexCoord" << i;
        //osg::notify(osg::NOTICE) << ss.str() << std::endl;
        if (geometry->getTexCoordArray(i)) {
            attributes->getMaps()[ss.str()] = createJSONBufferArray(geometry->getTexCoordArray(i), parent);
            int nb = geometry->getTexCoordArray(i)->getNumElements();
            if (nbVertexes != nb) {
                osg::notify(osg::FATAL) << "Fatal nb tex coord " << i << " " << nb << " != " << nbVertexes << std::endl;
                error();
            }
        }
    }

    osg::Array* tangents = getTangentSpaceArray(*geometry);
    if (tangents) {
        attributes->getMaps()["Tangent"] = createJSONBufferArray(tangents, parent);
        int nb = tangents->getNumElements();
        if (nbVertexes != nb) {
            osg::notify(osg::FATAL) << "Fatal nb tangent " << nb << " != " << nbVertexes << std::endl;
            error();
        }
    }

    json->getMaps()["VertexAttributeList"] = attributes;

    if (!geometry->getPrimitiveSetList().empty()) {
        osg::ref_ptr<JSONArray> primitives = new JSONArray();
        for (unsigned int i = 0; i < geometry->getNumPrimitiveSets(); ++i) {
            osg::ref_ptr<JSONObject> obj = new JSONObject;
            osg::PrimitiveSet* primitive = geometry->getPrimitiveSet(i);
            if(!primitive) continue;

            if (primitive->getType() == osg::PrimitiveSet::DrawArraysPrimitiveType) {
                osg::DrawArrays* da = dynamic_cast<osg::DrawArrays*>((primitive));
                if (da)
                {
                    primitives->getArray().push_back(obj);
                    if (da->getMode() == GL_QUADS) {
                        obj->getMaps()["DrawElementsUShort"] = createJSONDrawElements(da, parent);
                    } else {
                        obj->getMaps()["DrawArrays"] = createJSONDrawArray(da, parent);
                    }
                }
            } else if (primitive->getType() == osg::PrimitiveSet::DrawElementsUIntPrimitiveType) {
                osg::DrawElementsUInt* da = dynamic_cast<osg::DrawElementsUInt*>((primitive));
                if (da)
                {
                    primitives->getArray().push_back(obj);
                    obj->getMaps()["DrawElementsUInt"] = createJSONDrawElementsUInt(da, parent);
                }
            }  else if (primitive->getType() == osg::PrimitiveSet::DrawElementsUShortPrimitiveType) {
                osg::DrawElementsUShort* da = dynamic_cast<osg::DrawElementsUShort*>((primitive));
                if (da)
                {
                    primitives->getArray().push_back(obj);
                    obj->getMaps()["DrawElementsUShort"] = createJSONDrawElementsUShort(da, parent);
                }
            }  else if (primitive->getType() == osg::PrimitiveSet::DrawElementsUBytePrimitiveType) {
                osg::DrawElementsUByte* da = dynamic_cast<osg::DrawElementsUByte*>((primitive));
                if (da)
                {
                    primitives->getArray().push_back(obj);
                    obj->getMaps()["DrawElementsUByte"] = createJSONDrawElementsUByte(da, parent);
                }
            }  else if (primitive->getType() == osg::PrimitiveSet::DrawArrayLengthsPrimitiveType) {
                osg::DrawArrayLengths* dal = dynamic_cast<osg::DrawArrayLengths*>((primitive));
                if (dal)
                {
                    primitives->getArray().push_back(obj);
                    obj->getMaps()["DrawArrayLengths"] = createJSONDrawArrayLengths(dal, parent);
                }
            } else {
                osg::notify(osg::WARN) << "Primitive Type " << geometry->getPrimitiveSetList()[i]->getType() << " not supported, skipping" << std::endl;
            }
        }
        json->getMaps()["PrimitiveSetList"] = primitives;
    }
    if (geometry->getComputeBoundingBoxCallback()) {
           osg::ref_ptr<JSONObject> jsonObj = new JSONObject;
           jsonObj->addUniqueID();
           json->getMaps()["osg.ComputeBoundingBoxCallback"] = jsonObj;
    }
    return json.get();
}

JSONObject* WriteVisitor::createJSONRigGeometry(osgAnimation::RigGeometry* rigGeometry)
{
    //TODO : Convert data to JSONVertexArray "Float32Array"
    osg::ref_ptr<JSONObject> json = new JSONObject;
    json->addUniqueID();
    osg::ref_ptr<JSONObject> sourceGeometry = new JSONObject;

    if(osgAnimation::MorphGeometry *morphGeometry = dynamic_cast<osgAnimation::MorphGeometry*>(rigGeometry->getSourceGeometry())) {
        sourceGeometry->getMaps()["osgAnimation.MorphGeometry"] = createJSONMorphGeometry(morphGeometry, rigGeometry);
    }
    else {
        osg::Geometry *geometry  = dynamic_cast<osg::Geometry*>(rigGeometry->getSourceGeometry());
        if(geometry) {
            sourceGeometry->getMaps()["osg.Geometry"] = createJSONGeometry(geometry, rigGeometry);
        }
    }

    json->getMaps()["SourceGeometry"] = sourceGeometry.get();

    osg::Array* bones = getAnimationBonesArray(*rigGeometry);
    osg::Array* weights = getAnimationWeightsArray(*rigGeometry);
    if (bones && weights) {
        json->getMaps()["BoneMap"] = buildRigBoneMap(*rigGeometry);

        json->getMaps()["VertexAttributeList"] = new JSONObject;
        osg::ref_ptr<JSONObject> attributes = json->getMaps()["VertexAttributeList"];
        int nbVertexes = rigGeometry->getSourceGeometry()->getVertexArray()->getNumElements();

        attributes->getMaps()["Bones"] = createJSONBufferArray(bones, rigGeometry);
        attributes->getMaps()["Weights"] = createJSONBufferArray(weights, rigGeometry);
        int nb = bones->getNumElements();
        if (nbVertexes != nb) {
            osg::notify(osg::FATAL) << "Fatal nb bones " << nb << " != " << nbVertexes << std::endl;
            error();
        }
        nb = weights->getNumElements();
        if (nbVertexes != nb) {
            osg::notify(osg::FATAL) << "Fatal nb weights " << nb << " != " << nbVertexes << std::endl;
            error();
        }
    }

    return json.release();
}

JSONObject* WriteVisitor::createJSONMorphGeometry(osgAnimation::MorphGeometry* morphGeometry, osg::Object* parent)
{
    if(!parent) {
        parent = morphGeometry;
    }

    JSONObject* jsonGeometry = createJSONGeometry(morphGeometry, parent);
    osg::ref_ptr<JSONArray> targetList = new JSONArray;

    osgAnimation::MorphGeometry::MorphTargetList mTargetList = morphGeometry->getMorphTargetList();
    typedef osgAnimation::MorphGeometry::MorphTargetList::iterator TargetIterator;

    for(TargetIterator ti = mTargetList.begin(); ti != mTargetList.end(); ti++) {
        osgAnimation::MorphGeometry::MorphTarget *morphTarget = &(*ti);
        JSONObject *jsonGeometryObject = new JSONObject;
        if(osg::Geometry* geometry = dynamic_cast<osg::Geometry*>(morphTarget->getGeometry())) {
            geometry->setPrimitiveSetList(osg::Geometry::PrimitiveSetList()); //delete unused drawArray
            jsonGeometryObject->getMaps()["osg.Geometry"] = createJSONGeometry(geometry);
            targetList->asArray()->getArray().push_back(jsonGeometryObject);
        }
    }
    jsonGeometry->getMaps()["MorphTargets"] = targetList;

    return jsonGeometry;
}

JSONObject* WriteVisitor::createJSONBlendFunc(osg::BlendFunc* sa)
{
    if (_maps.find(sa) != _maps.end())
        return _maps[sa]->getShadowObject();

    osg::ref_ptr<JSONObject> json = new JSONObject;
    json->addUniqueID();
    _maps[sa] = json;

    translateObject(json.get(), sa);

    json->getMaps()["SourceRGB"] = getBlendFuncMode(sa->getSource());
    json->getMaps()["DestinationRGB"] = getBlendFuncMode(sa->getDestination());
    json->getMaps()["SourceAlpha"] = getBlendFuncMode(sa->getSourceAlpha());
    json->getMaps()["DestinationAlpha"] = getBlendFuncMode(sa->getDestinationAlpha());
    return json.release();
}

JSONObject* WriteVisitor::createJSONBlendColor(osg::BlendColor* sa)
{
    if (_maps.find(sa) != _maps.end())
        return _maps[sa]->getShadowObject();

    osg::ref_ptr<JSONObject> json = new JSONObject;
    json->addUniqueID();
    _maps[sa] = json;

    translateObject(json.get(), sa);

    json->getMaps()["ConstantColor"] = new JSONVec4Array(sa->getConstantColor());
    return json.release();
}

JSONObject* WriteVisitor::createJSONCullFace(osg::CullFace* sa)
{
    if (_maps.find(sa) != _maps.end())
        return _maps[sa]->getShadowObject();

    osg::ref_ptr<JSONObject> json = new JSONObject;
    json->addUniqueID();
    _maps[sa] = json;

    translateObject(json.get(), sa);

    osg::ref_ptr<JSONValue<std::string> > mode = new JSONValue<std::string>("BACK");
    if (sa->getMode() == osg::CullFace::FRONT) {
        mode = new JSONValue<std::string>("FRONT");
    }
    if (sa->getMode() == osg::CullFace::FRONT_AND_BACK) {
        mode = new JSONValue<std::string>("FRONT_AND_BACK");
    }
    json->getMaps()["Mode"] = mode;
    return json.release();
}



JSONObject* WriteVisitor::createJSONMaterial(osg::Material* material)
{
    if (_maps.find(material) != _maps.end())
        return _maps[material]->getShadowObject();

    osg::ref_ptr<JSONObject> jsonMaterial = new JSONMaterial;
    _maps[material] = jsonMaterial;

    translateObject(jsonMaterial.get(), material);

    jsonMaterial->getMaps()["Ambient"] = new JSONVec4Array(material->getAmbient(osg::Material::FRONT));
    jsonMaterial->getMaps()["Diffuse"] = new JSONVec4Array(material->getDiffuse(osg::Material::FRONT));
    jsonMaterial->getMaps()["Specular"] = new JSONVec4Array(material->getSpecular(osg::Material::FRONT));
    jsonMaterial->getMaps()["Emission"] = new JSONVec4Array(material->getEmission(osg::Material::FRONT));
    jsonMaterial->getMaps()["Shininess"] = new JSONValue<float>(material->getShininess(osg::Material::FRONT));

    return jsonMaterial.release();
}


JSONObject* WriteVisitor::createJSONLight(osg::Light* light)
{
    if (_maps.find(light) != _maps.end())
        return _maps[light]->getShadowObject();

    osg::ref_ptr<JSONObject> jsonLight = new JSONLight;
    _maps[light] = jsonLight;

    translateObject(jsonLight.get(), light);

    jsonLight->getMaps()["LightNum"] = new JSONValue<int>(light->getLightNum());
    jsonLight->getMaps()["Ambient"] = new JSONVec4Array(light->getAmbient());
    jsonLight->getMaps()["Diffuse"] = new JSONVec4Array(light->getDiffuse());
    jsonLight->getMaps()["Specular"] = new JSONVec4Array(light->getSpecular());
    jsonLight->getMaps()["Position"] = new JSONVec4Array(light->getPosition());
    jsonLight->getMaps()["Direction"] = new JSONVec3Array(light->getDirection());

    jsonLight->getMaps()["ConstantAttenuation"] = new JSONValue<float>(light->getConstantAttenuation());
    jsonLight->getMaps()["LinearAttenuation"] = new JSONValue<float>(light->getLinearAttenuation());
    jsonLight->getMaps()["QuadraticAttenuation"] = new JSONValue<float>(light->getQuadraticAttenuation());
    jsonLight->getMaps()["SpotExponent"] = new JSONValue<float>(light->getSpotExponent());
    jsonLight->getMaps()["SpotCutoff"] = new JSONValue<float>(light->getSpotCutoff());
    return jsonLight.release();
}

template <class T> JSONObject* createImageFromTexture(osg::Texture* texture, JSONObject* jsonTexture, bool inlineImages,
                                                      int maxTextureDimension, const std::string &baseName = "")
{
    T* text = dynamic_cast<T*>( texture);
    if (text) {
        translateObject(jsonTexture,text);
        JSONObject* image = createImage(text->getImage(), inlineImages, maxTextureDimension, baseName);
        if (image)
            jsonTexture->getMaps()["File"] = image;
        return jsonTexture;
    }
    return 0;
}

JSONObject* WriteVisitor::createJSONText(osgText::Text* text)
{
    if (_maps.find(text) != _maps.end())
        return _maps[text]->getShadowObject();

    osg::ref_ptr<JSONObject> jsonText = new JSONObject;
    jsonText->addUniqueID();
    _maps[text] = jsonText;
    jsonText->getMaps()["Text"] = new JSONValue<std::string>( text->getText().createUTF8EncodedString()  );
    jsonText->getMaps()["Position"] = new JSONVec3Array(text->getPosition());
    jsonText->getMaps()["Color"] = new JSONVec4Array(osg::Vec4(text->getColor().x(),text->getColor().y(),text->getColor().z(), text->getColor().w() ));
    jsonText->getMaps()["CharacterSize"] = new JSONValue<float>(text->getCharacterHeight() );
    jsonText->getMaps()["AutoRotateToScreen"] = new JSONValue<int>(text->getAutoRotateToScreen() );
    jsonText->getMaps()["Alignment"] = getJSONAlignmentType(text->getAlignment());

    osg::ref_ptr<JSONValue<std::string> > layout = new JSONValue<std::string>("LEFT_TO_RIGHT");
    if (text->getLayout() == osgText::Text::RIGHT_TO_LEFT) {
        layout = new JSONValue<std::string>("RIGHT_TO_LEFT");
    }
    if (text->getLayout() == osgText::Text::VERTICAL) {
        layout = new JSONValue<std::string>("VERTICAL");
    }
    jsonText->getMaps()["Layout"] = layout;
    return jsonText.release();
}


JSONObject* WriteVisitor::createJSONPagedLOD(osg::PagedLOD *plod)
{
    if (!plod) { return 0; }

    if (_maps.find(plod) != _maps.end()) {
         return _maps[plod]->getShadowObject();
    }

    osg::ref_ptr<JSONObject> jsonPlod = new JSONNode;
    _maps[plod] = jsonPlod;

    // Center Mode
    osg::ref_ptr<JSONValue<std::string> > centerMode = new JSONValue<std::string>("USE_BOUNDING_SPHERE_CENTER");
    if (plod->getCenterMode() == osg::LOD::USER_DEFINED_CENTER) {
        centerMode = new JSONValue<std::string>("USER_DEFINED_CENTER");
    } else if (plod->getCenterMode() == osg::LOD::UNION_OF_BOUNDING_SPHERE_AND_USER_DEFINED){
        centerMode = new JSONValue<std::string>("UNION_OF_BOUNDING_SPHERE_AND_USER_DEFINED");
    }
    jsonPlod->getMaps()["CenterMode"] = centerMode;
    // User defined center and radius
    jsonPlod->getMaps()["UserCenter"] = new JSONVec4Array(osg::Vec4(plod->getCenter().x(), plod->getCenter().y(),plod->getCenter().z(), plod->getRadius()));


    // Range Mode
    osg::ref_ptr<JSONValue<std::string> > rangeMode = new JSONValue<std::string>("DISTANCE_FROM_EYE_POINT");
    if (plod->getRangeMode() == osg::LOD::PIXEL_SIZE_ON_SCREEN) {
        rangeMode = new JSONValue<std::string>("PIXEL_SIZE_ON_SCREEN");
    }
    jsonPlod->getMaps()["RangeMode"] = rangeMode;
    // Range List
    osg::ref_ptr<JSONObject> rangeObject = new JSONObject;
    for (unsigned int i =0; i< plod->getRangeList().size(); i++)
    {
        std::stringstream ss;
        ss << "Range ";
        ss << i;
        std::string str = ss.str();
        rangeObject->getMaps()[str] =  new JSONVec2Array(osg::Vec2(plod->getRangeList()[i].first, plod->getRangeList()[i].second));
    }
    jsonPlod->getMaps()["RangeList"] = rangeObject;
    // File List

    osg::ref_ptr<JSONObject> fileObject = new JSONObject;
    for (unsigned int i =0; i< plod->getNumFileNames(); i++)
    {
        std::stringstream ss;
        ss << "File ";
        ss << i;
        std::string str = ss.str();
        // We need to convert first from osg format to osgjs format.
        osg::ref_ptr<osg::Node> n = osgDB::readRefNodeFile(plod->getDatabasePath() + plod->getFileName(i)+".gles");
        if (n)
        {
            std::string filename(osgDB::getNameLessExtension(plod->getFileName(i))+".osgjs");

            std::string fullFilePath(osgDB::getFilePath(_baseName) + osgDB::getNativePathSeparator() + filename);
            fileObject->getMaps()[str] =  new JSONValue<std::string>(_baseLodURL + filename);
            osgDB::makeDirectoryForFile(fullFilePath);
            if (_baseLodURL.empty())
                _baseLodURL = osgDB::getFilePath(filename) + osgDB::getNativePathSeparator() ;
            osg::ref_ptr<osgDB::Options> options =  osgDB::Registry::instance()->getOptions()->cloneOptions();
            options->setPluginStringData(std::string("baseLodURL"), _baseLodURL);

            osgDB::writeNodeFile(*n, fullFilePath, options.get());

        }
        else
            fileObject->getMaps()[str] =  new JSONValue<std::string>("");
     }
    jsonPlod->getMaps()["RangeDataList"] = fileObject;

    return jsonPlod.release();
}

JSONObject* WriteVisitor::createJSONTexture(osg::Texture* texture)
{
    if (!texture) {
        return 0;
    }

    if (_maps.find(texture) != _maps.end()) {
        return _maps[texture]->getShadowObject();
    }

    osg::ref_ptr<JSONObject> jsonTexture = new JSONObject;
    jsonTexture->addUniqueID();
    _maps[texture] = jsonTexture;

    jsonTexture->getMaps()["MagFilter"] = getJSONFilterMode(texture->getFilter(osg::Texture::MAG_FILTER));
    jsonTexture->getMaps()["MinFilter"] = getJSONFilterMode(texture->getFilter(osg::Texture::MIN_FILTER));

    jsonTexture->getMaps()["WrapS"] = getJSONWrapMode(texture->getWrap(osg::Texture::WRAP_S));
    jsonTexture->getMaps()["WrapT"] = getJSONWrapMode(texture->getWrap(osg::Texture::WRAP_T));


    {
        JSONObject* obj = createImageFromTexture<osg::Texture1D>(texture, jsonTexture.get(), this->_inlineImages,
                                                                 this->_maxTextureDimension, this->_baseName);
        if (obj) {
            return obj;
        }
    }

    {
        JSONObject* obj = createImageFromTexture<osg::Texture2D>(texture, jsonTexture.get(), this->_inlineImages,
                                                                 this->_maxTextureDimension, this->_baseName);
        if (obj) {
            return obj;
        }
    }

    {
        JSONObject* obj = createImageFromTexture<osg::TextureRectangle>(texture, jsonTexture.get(), this->_inlineImages,
                                                                        this->_maxTextureDimension, this->_baseName);
        if (obj) {
            return obj;
        }
    }

    return 0;
}

JSONObject* WriteVisitor::createJSONStateSet(osg::StateSet* stateset)
{

    if (_maps.find(stateset) != _maps.end()) {
        return _maps[stateset]->getShadowObject();
    }

    osg::ref_ptr<JSONObject> jsonStateSet = new JSONStateSet;
    _maps[stateset] = jsonStateSet;

    translateObject(jsonStateSet.get(), stateset);

    if (stateset->getRenderingHint() == osg::StateSet::TRANSPARENT_BIN) {
        jsonStateSet->getMaps()["RenderingHint"] = new JSONValue<std::string>("TRANSPARENT_BIN");
    }

    bool blendEnabled = false;
    if (stateset->getMode(GL_BLEND) == osg::StateAttribute::ON) {
        blendEnabled = true;
    }

    osg::ref_ptr<JSONArray> textureAttributeList = new JSONArray;
    int lastTextureIndex = -1;
    for (int i = 0; i < 32; ++i) {
        osg::Texture* texture = dynamic_cast<osg::Texture*>(stateset->getTextureAttribute(i,osg::StateAttribute::TEXTURE));

        JSONArray* textureUnit = new JSONArray;
        JSONObject* jsonTexture = createJSONTexture(texture);
        textureAttributeList->getArray().push_back(textureUnit);

        if (jsonTexture) {
            JSONObject* textureObject = new JSONObject;
            textureObject->getMaps()["osg.Texture"] = jsonTexture;
            textureUnit->getArray().push_back(textureObject);
            lastTextureIndex = i;
        }
    }
    if (lastTextureIndex > -1) {
        textureAttributeList->getArray().resize(lastTextureIndex+1);
        jsonStateSet->getMaps()["TextureAttributeList"] = textureAttributeList;
    }


    osg::ref_ptr<JSONArray> attributeList = new JSONArray;

    osg::Material* material = dynamic_cast<osg::Material*>(stateset->getAttribute(osg::StateAttribute::MATERIAL));
    if (material) {
        JSONObject* obj = new JSONObject;
        obj->getMaps()["osg.Material"] = createJSONMaterial(material);
        attributeList->getArray().push_back(obj);
    }

    osg::BlendFunc* blendFunc = dynamic_cast<osg::BlendFunc*>(stateset->getAttribute(osg::StateAttribute::BLENDFUNC));
    if (blendFunc) {
        JSONObject* obj = new JSONObject;
        obj->getMaps()["osg.BlendFunc"] = createJSONBlendFunc(blendFunc);
        attributeList->getArray().push_back(obj);
    } else if (blendEnabled == true) {
        JSONObject* obj = new JSONObject;
        osg::ref_ptr<osg::BlendFunc> defaultBlend = new osg::BlendFunc();
        obj->getMaps()["osg.BlendFunc"] = createJSONBlendFunc(defaultBlend.get());
        attributeList->getArray().push_back(obj);
    }

    osg::ref_ptr<osg::CullFace> cullFace = dynamic_cast<osg::CullFace*>(stateset->getAttribute(osg::StateAttribute::CULLFACE));
    osg::StateAttribute::GLModeValue cullMode = stateset->getMode(GL_CULL_FACE);
    if (cullFace || cullMode != osg::StateAttribute::INHERIT) {
        JSONObject* obj = new JSONObject;
        JSONObject* cf = 0;
        if (cullMode == osg::StateAttribute::OFF) {
            osg::ref_ptr<osg::CullFace> defaultCull = new osg::CullFace();
            cf = createJSONCullFace(defaultCull.get());
            cf->getMaps()["Mode"] = new JSONValue<std::string>("DISABLE");
            obj->getMaps()["osg.CullFace"] = cf;
            attributeList->getArray().push_back(obj);
        } else {
            if (!cullFace) {
                cullFace = new osg::CullFace();
            }
            cf = createJSONCullFace(cullFace.get());
        }
        obj->getMaps()["osg.CullFace"] = cf;
        attributeList->getArray().push_back(obj);
    }

    osg::BlendColor* blendColor = dynamic_cast<osg::BlendColor*>(stateset->getAttribute(osg::StateAttribute::BLENDCOLOR));
    if (blendColor) {
        JSONObject* obj = new JSONObject;
        obj->getMaps()["osg.BlendColor"] = createJSONBlendColor(blendColor);
        attributeList->getArray().push_back(obj);
    }

    if (!attributeList->getArray().empty()) {
        jsonStateSet->getMaps()["AttributeList"] = attributeList;
    }

    if (jsonStateSet->getMaps().empty())
        return 0;
    return jsonStateSet.release();
}