/*
  Grim's Cave
  Copyright (c) 2010, Matthias -apoc- Hecker <http://apoc.cc/>

  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef TLIBRARYLOADER_HPP
#define	TLIBRARYLOADER_HPP

#include <string>

#ifdef _WIN32
    #include <windows.h>
    #define Sys_LoadLibrary(f) (void*)LoadLibrary(f)
    #define Sys_UnloadLibrary(h) FreeLibrary((HMODULE)h)
    #define Sys_LoadProcedure(h,fn) (void*)GetProcAddress((HMODULE)h,fn)
    #define Sys_LibraryError() "unknown"
#else // if you know what other engine defines
    #include <dlfcn.h>// it this way, you win a great prize -.-
    #define Sys_LoadLibrary(f) dlopen(f,RTLD_NOW)
    #define Sys_UnloadLibrary(h) dlclose(h)
    #define Sys_LoadProcedure(h,fn) dlsym(h,fn)
    #define Sys_LibraryError() dlerror()
#endif

#include "common/Global.hpp"

#include "common/TSingleton.hpp"

namespace grims
{
namespace dlib
{

template <typename TypeImplClass, typename TypeSymbolStruct>
class TLibraryLoader : public TSingleton<TypeImplClass>
{
public:

    TLibraryLoader()
        :
        m_loaded(false),
        m_error(false),
        m_symbols(NULL),
        m_handle(NULL)
    {

    }

    TLibraryLoader(const TLibraryLoader& orig)
    {
    }

    virtual ~TLibraryLoader()
    {
        Uninitialize();
    }

    // Initialize() 
    
    void Uninitialize()
    {
        UnloadLibrary();
    }

    TypeSymbolStruct* GetSymbols()
    {
        return m_symbols;
    }

    bool IsLoaded()
    {
        return m_loaded;
    }

protected:

    bool m_loaded;
    bool m_error;

    TypeSymbolStruct* m_symbols;

    bool LoadLibraryFile(std::string filename)
    {
        if (filename == "") {
            LOGGER.Error("[TLibraryLoader] error loading shared library, no filename given");
            m_error = true;
            return false;
        }

        LOGGER.Info("[TLibraryLoader] loading shared library " + filename);

        if (m_handle) {
            LOGGER.Warn("[TLibraryLoader] library already loaded");
            return true;
        }

        m_filename = filename;
        m_handle = Sys_LoadLibrary(filename.c_str());
        if (m_handle == NULL) {
            LOGGER.ErrorFormat(
                "[TLibraryLoader] error loading shared library: %s",
                Sys_LibraryError()
            );
            m_error = true;
            return false;
        }

        m_symbols = new TypeSymbolStruct;

        return true;
    }

    void UnloadLibrary()
    {
        LOGGER.Info("[TLibraryLoader] unloading shared library " + m_filename);

        if (!m_handle) {
            LOGGER.Error("[TLibraryLoader] library handle not found");
            return;
        }

        SAFE_DESTROY(m_symbols);

        Sys_UnloadLibrary(m_handle);

        m_handle = NULL;
    }

    void* LoadProcedure(const char* symbolName)
    {
        void *symbol = NULL;

        symbol = Sys_LoadProcedure(m_handle, symbolName);

        if (symbol == NULL) {
            m_error = true;
            LOGGER.ErrorFormat(
                "[TLibraryLoader] couldn't load library procedure symbol: %s (%s)",
                symbolName, Sys_LibraryError()
            );
        }

        return symbol;
    }

private:

    void* m_handle;
    std::string m_filename;

};

} // end namespace dlib
} // end namespace grims

#endif	/* TLIBRARYLOADER_HPP */