#include "osg/Notify"
#include "osg/Object"
#include "osg/Image"
#include "osg/Node"
#include "osg/Group"
#include "osg/Geode"

#include "osgDB/Registry"
#include "osgDB/FileUtils"
#include "osgDB/FileNameUtils"

#include <stdio.h>

#include <algorithm>
#include <set>

using namespace osg;
using namespace osgDB;


class RegistryPtr
{
    public:
        RegistryPtr() : _ptr(0L) {}
        RegistryPtr(Registry* t): _ptr(t) {}
        RegistryPtr(const RegistryPtr& rp):_ptr(rp._ptr) { }
        ~RegistryPtr() { if (_ptr) delete _ptr; _ptr=0L; }

        inline Registry* get() { return _ptr; }

        Registry* _ptr;
};

// definition of the Registry
Registry::Registry()
{
    notify(INFO) << "Constructing osg::Registry"<<endl;

    _createNodeFromImage = true;
    _openingLibrary = false;

    osgDB::initFilePath();

    // register file extension alias.
    addFileExtensionAlias("rgba", "rgb");
    addFileExtensionAlias("int",  "rgb");
    addFileExtensionAlias("inta", "rgb");
    addFileExtensionAlias("bw",   "rgb");
    
    addFileExtensionAlias("jpg",  "jpeg");
    addFileExtensionAlias("jpe",  "jpeg");

    addFileExtensionAlias("tif",  "tiff");

    addFileExtensionAlias("geo",  "lwo");
    addFileExtensionAlias("lw",   "lwo");
}


Registry::~Registry()
{
}


Registry* Registry::instance()
{
    static RegistryPtr s_nodeFactory = new Registry();
    return s_nodeFactory.get();
}

void Registry::addDotOsgWrapper(DotOsgWrapper* wrapper)
{
    if (wrapper==0L) return;

    if (_openingLibrary) notify(INFO) << "Opening Library : "<<endl;

    notify(INFO) << "osg::Registry::addDotOsgWrapper("<<wrapper->getName()<<")"<<endl;
    const DotOsgWrapper::Associates& assoc = wrapper->getAssociates();
    
    for(DotOsgWrapper::Associates::const_iterator itr=assoc.begin();
                                                  itr!=assoc.end();
                                                  ++itr)
    {
        notify(INFO) << "    ("<<*itr<<")"<<endl;
    }

    const std::string& name = wrapper->getName();
    const osg::Object* proto = wrapper->getPrototype();

    _objectWrapperMap[name] = wrapper;
   
    if (proto)
    {
        if (wrapper->getReadWriteMode()==DotOsgWrapper::READ_AND_WRITE) _classNameWrapperMap[proto->className()] = wrapper;

       if (dynamic_cast<const Image*>(proto))          _imageWrapperMap[name] = wrapper;
       if (dynamic_cast<const Drawable*>(proto))       _drawableWrapperMap[name] = wrapper;
       if (dynamic_cast<const StateAttribute*>(proto)) _stateAttrWrapperMap[name] = wrapper;
       if (dynamic_cast<const Node*>(proto))           _nodeWrapperMap[name] = wrapper;
    }
}

#define EraseMacro(WL,W) \
{ \
    DotOsgWrapperMap::iterator itr = WL.find(W->getName()); \
    if (itr!=WL.end() && itr->second.get()==W) WL.erase(itr); \
}
    
void Registry::removeDotOsgWrapper(DotOsgWrapper* wrapper)
{
    if (wrapper==0L) return;

////    notify(INFO) << "osg::Registry::removeReaderWriter();"<<endl;

    EraseMacro(_objectWrapperMap,wrapper);
    EraseMacro(_classNameWrapperMap,wrapper);
    EraseMacro(_imageWrapperMap,wrapper);
    EraseMacro(_drawableWrapperMap,wrapper);
    EraseMacro(_stateAttrWrapperMap,wrapper);
    EraseMacro(_nodeWrapperMap,wrapper);
}

#undef EraseMaroc

void Registry::addReaderWriter(ReaderWriter* rw)
{
    if (rw==0L) return;

    if (_openingLibrary) notify(INFO) << "Opening Library : "<<endl;

    notify(INFO) << "osg::Registry::addReaderWriter("<<rw->className()<<")"<<endl;

    _rwList.push_back(rw);

}


void Registry::removeReaderWriter(ReaderWriter* rw)
{
    if (rw==0L) return;

//    notify(INFO) << "osg::Registry::removeReaderWriter();"<<endl;

    ReaderWriterList::iterator rwitr = std::find(_rwList.begin(),_rwList.end(),rw);
    if (rwitr!=_rwList.end())
    {
        _rwList.erase(rwitr);
    }

}


void Registry::addFileExtensionAlias(const std::string mapExt, const std::string toExt)
{
    if (mapExt!=toExt) _extAliasMap[mapExt] = toExt;
}

std::string Registry::createLibraryNameForFile(const std::string& fileName)
{
    std::string ext = getLowerCaseFileExtension(fileName);
    return createLibraryNameForExt(ext);
}


std::string Registry::createLibraryNameForExt(const std::string& ext)
{

    ExtensionAliasMap::iterator itr=_extAliasMap.find(ext);
    if (itr!=_extAliasMap.end()) return createLibraryNameForExt(itr->second);

#ifdef WIN32
#   ifdef _DEBUG
    return "osgdb_"+ext+"d.dll";
#   else
    return "osgdb_"+ext+".dll";
#   endif
#elif macintosh
    return "osgdb_"+ext;
#else
    return "osgdb_"+ext+".so";
#endif

}


bool Registry::loadLibrary(const std::string& fileName)
{
    DynamicLibrary* dl = getLibrary(fileName);
    if (dl) return false;

    _openingLibrary=true;

    dl = DynamicLibrary::loadLibrary(fileName);
    _openingLibrary=false;

    if (dl)
    {
        dl->ref();
        _dlList.push_back(dl);
        return true;
    }
    return false;
}


bool Registry::closeLibrary(const std::string& fileName)
{
    DynamicLibraryList::iterator ditr = getLibraryItr(fileName);
    if (ditr!=_dlList.end())
    {
        _dlList.erase(ditr);
        return true;
    }
    return false;
}


Registry::DynamicLibraryList::iterator Registry::getLibraryItr(const std::string& fileName)
{
    DynamicLibraryList::iterator ditr = _dlList.begin();
    for(;ditr!=_dlList.end();++ditr)
    {
        if ((*ditr)->getName()==fileName) return ditr;
    }
    return _dlList.end();
}


DynamicLibrary* Registry::getLibrary(const std::string& fileName)
{
    DynamicLibraryList::iterator ditr = getLibraryItr(fileName);
    if (ditr!=_dlList.end()) return ditr->get();
    else return NULL;
}

osg::Object* Registry::readObjectOfType(const osg::Object& compObj,Input& fr)
{
    const char *str = fr[0].getStr();
    if (str==NULL) return NULL;

    if (fr[0].matchWord("Use"))
    {
        if (fr[1].isString())
        {
            Object* obj = fr.getObjectForUniqueID(fr[1].getStr());
            if (compObj.isSameKindAs(obj)) fr+=2;
            return obj;
        }
        else return NULL;

    }

    std::string name = str;
    DotOsgWrapperMap::iterator itr = _objectWrapperMap.find(name);
    if (itr!=_objectWrapperMap.end() && fr[1].isOpenBracket())
    {
    
        DotOsgWrapper* wrapper = itr->second.get();
        const osg::Object* proto = wrapper->getPrototype();
        if (proto==NULL)
        {
            osg::notify(osg::WARN)<<"Token "<<fr[0].getStr()<<" read, but has no prototype, cannot load."<<endl;
            return NULL;
        }
        
        if (!compObj.isSameKindAs(proto))
        {
            return NULL;
        }

        // record the number of nested brackets move the input iterator
        // over the name { tokens.
        int entry = fr[0].getNoNestedBrackets();
        fr+=2;

        const DotOsgWrapper::Associates& assoc = wrapper->getAssociates();
        osg::Object* obj = proto->clone();

        while(!fr.eof() && fr[0].getNoNestedBrackets()>entry)
        {
            bool iteratorAdvanced = false;
            if (fr[0].matchWord("UniqueID") && fr[1].isString())
            {
                fr.regisiterUniqueIDForObject(fr[1].getStr(),obj);
                fr += 2;
                iteratorAdvanced = true;
            }

            // read the local data by iterating through the associate
            // list, mapping the associate names to DotOsgWrapper's which
            // in turn have the appropriate functions.
            for(DotOsgWrapper::Associates::const_iterator aitr=assoc.begin();
                                                          aitr!=assoc.end();
                                                          ++aitr)
            {
                DotOsgWrapperMap::iterator mitr = _objectWrapperMap.find(*aitr);
                if (mitr!=_objectWrapperMap.end())
                {
                    // get the function to read the data...
                    DotOsgWrapper::ReadFunc rf = mitr->second->getReadFunc();
                    if (rf && (*rf)(*obj,fr)) iteratorAdvanced = true;
                }

            }

            if (!iteratorAdvanced) ++fr;
        }
        ++fr;                        // step over trailing '}'
        
        return obj;
        
    }

    return 0L;
    
}

//
// read object from input iterator.
//
osg::Object* Registry::readObject(DotOsgWrapperMap& dowMap,Input& fr)
{
    const char *str = fr[0].getStr();
    if (str==NULL) return NULL;

    std::string name = str;
    DotOsgWrapperMap::iterator itr = dowMap.find(name);
    if (itr!=dowMap.end() && fr[1].isOpenBracket())
    {
    
        DotOsgWrapper* wrapper = itr->second.get();
        const osg::Object* proto = wrapper->getPrototype();
        if (proto==NULL)
        {
            osg::notify(osg::WARN)<<"Token "<<fr[0].getStr()<<" read, but has no prototype, cannot load."<<endl;
            return NULL;
        }

        // record the number of nested brackets move the input iterator
        // over the name { tokens.
        int entry = fr[0].getNoNestedBrackets();
        fr+=2;

        const DotOsgWrapper::Associates& assoc = wrapper->getAssociates();
        osg::Object* obj = proto->clone();

        while(!fr.eof() && fr[0].getNoNestedBrackets()>entry)
        {
            bool iteratorAdvanced = false;
            if (fr[0].matchWord("UniqueID") && fr[1].isString())
            {
                fr.regisiterUniqueIDForObject(fr[1].getStr(),obj);
                fr += 2;
                iteratorAdvanced = true;
            }

            // read the local data by iterating through the associate
            // list, mapping the associate names to DotOsgWrapper's which
            // in turn have the appropriate functions.
            for(DotOsgWrapper::Associates::const_iterator aitr=assoc.begin();
                                                          aitr!=assoc.end();
                                                          ++aitr)
            {
                DotOsgWrapperMap::iterator mitr = _objectWrapperMap.find(*aitr);
                if (mitr!=_objectWrapperMap.end())
                {
                    // get the function to read the data...
                    DotOsgWrapper::ReadFunc rf = mitr->second->getReadFunc();
                    if (rf && (*rf)(*obj,fr)) iteratorAdvanced = true;
                }

            }

            if (!iteratorAdvanced) ++fr;
        }
        ++fr;                        // step over trailing '}'
        
        return obj;
        
    }

    return 0L;
}

//
// read object from input iterator.
//
Object* Registry::readObject(Input& fr)
{
    if (fr[0].matchWord("Use"))
    {
        if (fr[1].isString())
        {
            Object* obj = fr.getObjectForUniqueID(fr[1].getStr());
            if (obj) fr+=2;
            return obj;
        }
        else return NULL;

    }

    return readObject(_objectWrapperMap,fr);
}


//
// read image from input iterator.
//
Image* Registry::readImage(Input& fr)
{
    if (fr[0].matchWord("Use"))
    {
        if (fr[1].isString())
        {
            Image* image = dynamic_cast<Image*>(fr.getObjectForUniqueID(fr[1].getStr()));
            if (image) fr+=2;
            return image;
        }
        else return NULL;

    }

    return dynamic_cast<Image*>(readObject(_imageWrapperMap,fr));
}


//
// read drawable from input iterator.
//
Drawable* Registry::readDrawable(Input& fr)
{
    if (fr[0].matchWord("Use"))
    {
        if (fr[1].isString())
        {
            Drawable* drawable = dynamic_cast<Drawable*>(fr.getObjectForUniqueID(fr[1].getStr()));
            if (drawable) fr+=2;
            return drawable;
        }
        else return NULL;

    }

    return dynamic_cast<Drawable*>(readObject(_drawableWrapperMap,fr));
}

//
// read drawable from input iterator.
//
StateAttribute* Registry::readStateAttribute(Input& fr)
{

    if (fr[0].matchWord("Use"))
    {
        if (fr[1].isString())
        {
            StateAttribute* attribute = dynamic_cast<StateAttribute*>(fr.getObjectForUniqueID(fr[1].getStr()));
            if (attribute) fr+=2;
            return attribute;
        }
        else return NULL;

    }

    return dynamic_cast<StateAttribute*>(readObject(_stateAttrWrapperMap,fr));
}

//
// read node from input iterator.
//
Node* Registry::readNode(Input& fr)
{
    if (fr[0].matchWord("Use"))
    {
        if (fr[1].isString())
        {
            Node* node = dynamic_cast<Node*>(fr.getObjectForUniqueID(fr[1].getStr()));
            if (node) fr+=2;
            return node;
        }
        else return NULL;

    }

    return dynamic_cast<Node*>(readObject(_nodeWrapperMap,fr));
}

//
// Write object to output 
//
bool Registry::writeObject(const osg::Object& obj,Output& fw)
{

    if (obj.referenceCount()>1)
    {
        std::string uniqueID;
        if (fw.getUniqueIDForObject(&obj,uniqueID))
        {
            fw.indent() << "Use " << uniqueID << endl;
            return true;
        }
    }

    std::string classname = obj.className();
    DotOsgWrapperMap::iterator itr = _classNameWrapperMap.find(classname);
    if (itr!=_classNameWrapperMap.end())
    {
    
    
        DotOsgWrapper* wrapper = itr->second.get();
        const DotOsgWrapper::Associates& assoc = wrapper->getAssociates();

        fw.indent() << wrapper->getName() << " {"<<endl;
        fw.moveIn();


        // write out the unique ID if required.
        if (obj.referenceCount()>1)
        {
            std::string uniqueID;
            fw.createUniqueIDForObject(&obj,uniqueID);
            fw.registerUniqueIDForObject(&obj,uniqueID);
            fw.indent() << "UniqueID " << uniqueID << endl;
        }

        // read the local data by iterating through the associate
        // list, mapping the associate names to DotOsgWrapper's which
        // in turn have the appropriate functions.
        for(DotOsgWrapper::Associates::const_iterator aitr=assoc.begin();
                                                      aitr!=assoc.end();
                                                      ++aitr)
        {
            DotOsgWrapperMap::iterator mitr = _objectWrapperMap.find(*aitr);
            if (mitr!=_objectWrapperMap.end())
            {
                // get the function to read the data...
                DotOsgWrapper::WriteFunc wf = mitr->second->getWriteFunc();
                if (wf) (*wf)(obj,fw);
            }

        }

        fw.moveOut();
        fw.indent() << "}"<<endl;

        return true;
    }

    return false;
}

//
// read object from specified file.
//
Object* Registry::readObject(const std::string& fileName)
{
    char *file = findFile( fileName.c_str() );
    if (file==NULL) return NULL;

    // record the existing reader writer.
    std::set<ReaderWriter*> rwOriginal;

    // first attempt to load the file from existing ReaderWriter's
    for(ReaderWriterList::iterator itr=_rwList.begin();
        itr!=_rwList.end();
        ++itr)
    {
        rwOriginal.insert(itr->get());
        Object* obj = (*itr)->readObject(file);
        if (obj) return obj;
    }

    // now look for a plug-in to load the file.
    std::string libraryName = createLibraryNameForFile(fileName);
    if (Registry::instance()->loadLibrary(libraryName))
    {
        for(ReaderWriterList::iterator itr=_rwList.begin();
            itr!=_rwList.end();
            ++itr)
        {
            if (rwOriginal.find(itr->get())==rwOriginal.end())
            {
                Object* obj = (*itr)->readObject(file);
                if (obj) return obj;
            }
        }
    }
    else
    {
        notify(NOTICE)<<"Warning: Could not find plugin to read file with extension ."
            <<getLowerCaseFileExtension(fileName)<<endl;
    }
    notify(NOTICE)<<"Warning: Unable to read file "<<fileName<<endl;

    return NULL;
}


bool Registry::writeObject(const Object& obj,const std::string& fileName)
{
    // record the existing reader writer.
    std::set<ReaderWriter*> rwOriginal;

    // first attempt to load the file from existing ReaderWriter's
    for(ReaderWriterList::iterator itr=_rwList.begin();
        itr!=_rwList.end();
        ++itr)
    {
        rwOriginal.insert(itr->get());
        if ((*itr)->writeObject(obj,fileName)) return true;
    }

    // now look for a plug-in to save the file.
    std::string libraryName = createLibraryNameForFile(fileName);
    if (loadLibrary(libraryName))
    {
        for(ReaderWriterList::iterator itr=_rwList.begin();
            itr!=_rwList.end();
            ++itr)
        {
            if (rwOriginal.find(itr->get())==rwOriginal.end())
            {
                if ((*itr)->writeObject(obj,fileName)) return true;
            }
        }
    }
    else
    {
        notify(NOTICE)<<"Warning: Could not find plugin to write file with extension ."
            <<getLowerCaseFileExtension(fileName)<<endl;
    }
    notify(NOTICE)<<"Warning: Unable to write file "<<fileName<<endl;

    return false;
}



Image* Registry::readImage(const std::string& fileName)
{
    char *file = findFile( fileName.c_str() );
    if (file==NULL) return NULL;

    // record the existing reader writer.
    std::set<ReaderWriter*> rwOriginal;

    // first attempt to load the file from existing ReaderWriter's
    for(ReaderWriterList::iterator itr=_rwList.begin();
        itr!=_rwList.end();
        ++itr)
    {
        rwOriginal.insert(itr->get());
        Image* image = (*itr)->readImage(file);
        if (image) return image;
    }

    // now look for a plug-in to load the file.
    std::string libraryName = createLibraryNameForFile(fileName);
    if (loadLibrary(libraryName))
    {
        for(ReaderWriterList::iterator itr=_rwList.begin();
            itr!=_rwList.end();
            ++itr)
        {
            if (rwOriginal.find(itr->get())==rwOriginal.end())
            {
                Image* image = (*itr)->readImage(file);
                if (image) return image;
            }
        }
    }
    else
    {
        notify(NOTICE)<<"Warning: Could not find plugin to read file with extension ."
            <<getLowerCaseFileExtension(fileName)<<endl;
    }
    notify(NOTICE)<<"Warning: Unable to read file "<<fileName<<endl;

    return NULL;
}


bool Registry::writeImage(const Image& image,const std::string& fileName)
{
    // record the existing reader writer.
    std::set<ReaderWriter*> rwOriginal;

    // first attempt to load the file from existing ReaderWriter's
    for(ReaderWriterList::iterator itr=_rwList.begin();
        itr!=_rwList.end();
        ++itr)
    {
        rwOriginal.insert(itr->get());
        if ((*itr)->writeImage(image,fileName)) return true;
    }

    // now look for a plug-in to save the file.
    std::string libraryName = createLibraryNameForFile(fileName);
    if (loadLibrary(libraryName))
    {
        for(ReaderWriterList::iterator itr=_rwList.begin();
            itr!=_rwList.end();
            ++itr)
        {
            if (rwOriginal.find(itr->get())==rwOriginal.end())
            {
                if ((*itr)->writeImage(image,fileName)) return true;
            }
        }
    }
    else
    {
        notify(NOTICE)<<"Warning: Could not find plugin to write file with extension ."
            <<getLowerCaseFileExtension(fileName)<<endl;
    }
    notify(NOTICE)<<"Warning: Unable to write file "<<fileName<<endl;

    return false;
}


Node* Registry::readNode(const std::string& fileName)
{

    char *file = findFile( fileName.c_str() );
    if (file==NULL) return NULL;

    // record the existing reader writer.
    std::set<ReaderWriter*> rwOriginal;

    // first attempt to load the file from existing ReaderWriter's
    for(ReaderWriterList::iterator itr=_rwList.begin();
        itr!=_rwList.end();
        ++itr)
    {
        rwOriginal.insert(itr->get());
        Node* node = (*itr)->readNode(file);
        if (node) return node;
    }

    bool couldNotFindPlugin = false;

    // now look for a plug-in to load the file.
    std::string libraryName = createLibraryNameForFile(fileName);
    notify(INFO) << "Now checking for plug-in "<<libraryName<<endl;
    if (loadLibrary(libraryName))
    {
        for(ReaderWriterList::iterator itr=_rwList.begin();
            itr!=_rwList.end();
            ++itr)
        {
            if (rwOriginal.find(itr->get())==rwOriginal.end())
            {
                Node* node = (*itr)->readNode(file);
                if (node) return node;
            }
        }
    }
    else
    {
        couldNotFindPlugin = true;
    }

    if (_createNodeFromImage)
    {
        ref_ptr<Image> image = readImage(fileName);
        if (image.valid())
        {
            return createGeodeForImage(image.get());
        }
    }

    if (couldNotFindPlugin)
    {
        notify(NOTICE)<<"Warning: Could not find plugin to read file with extension ."
            <<getLowerCaseFileExtension(fileName)<<endl;
    }

    notify(NOTICE)<<"Warning: Unable to read file "<<fileName<<endl;

    return NULL;
}


bool Registry::writeNode(const Node& node,const std::string& fileName)
{
    // record the existing reader writer.
    std::set<ReaderWriter*> rwOriginal;

    // first attempt to write the file from existing ReaderWriter's
    for(ReaderWriterList::iterator itr=_rwList.begin();
        itr!=_rwList.end();
        ++itr)
    {
        rwOriginal.insert(itr->get());
        if ((*itr)->writeNode(node,fileName)) return true;
    }

    // now look for a plug-in to save the file.
    std::string libraryName = createLibraryNameForFile(fileName);
    if (Registry::instance()->loadLibrary(libraryName))
    {
        for(ReaderWriterList::iterator itr=_rwList.begin();
            itr!=_rwList.end();
            ++itr)
        {
            if (rwOriginal.find(itr->get())==rwOriginal.end())
            {
                if ((*itr)->writeNode(node,fileName)) return true;
            }
        }
    }
    else
    {
        notify(NOTICE)<<"Warning: Could not find plugin to write file with extension ."
            <<getLowerCaseFileExtension(fileName)<<endl;
    }
    notify(NOTICE)<<"Warning: Unable to write file "<<fileName<<endl;

    return false;
}