#include "tpluginmanager.h"

#include "tsystem.h"

#include "tconvert.h"

#include "tlogger.h"

#ifdef _WIN32

#include <windows.h></windows.h>

#else

// QUALE DI QUESTI SERVE VERAMENTE??

#include <grp.h></grp.h>

#include <utime.h></utime.h>

#include <sys param.h=""></sys>

#include <unistd.h></unistd.h>

#include <sys types.h=""></sys>

#include <sys timeb.h=""> // for ftime</sys>

#include <stdio.h></stdio.h>

#include <unistd.h></unistd.h>

#include <dirent.h></dirent.h>

#include <sys dir.h=""></sys>

#include <sys param.h=""> // for getfsstat</sys>

#ifdef MACOSX

#include <sys ucred.h=""></sys>

#endif

#include <sys mount.h=""></sys>

#include <pwd.h></pwd.h>

#include <dlfcn.h></dlfcn.h>

#endif

//-----------------------------------------------------------------------------

class TPluginManager::Plugin

{

public:

#ifdef _WIN32

	typedef HINSTANCE Handle;

#else

	typedef void *Handle;

#endif

private:

	Handle m_handle;

	TPluginInfo m_info;

public:

	Plugin(Handle handle)

		: m_handle(handle)

	{

	}

	Handle getHandle() const { return m_handle; }

	const TPluginInfo &getInfo() const { return m_info; }

	void setInfo(const TPluginInfo &info) { m_info = info; }

	std::string getName() const { return m_info.getName(); }

};

//-----------------------------------------------------------------------------

typedef const TPluginInfo *TnzLibMainProcType();

//--------------------------------------------------------------

namespace

{

const char *TnzLibMainProcName = "TLibMain";

#if !defined(_WIN32)

const char *TnzLibMainProcName2 = "_TLibMain";

#endif

}

//=============================================================================

TPluginManager::TPluginManager()

{

	m_ignoreList.insert("tnzimagevector");

}

//-----------------------------------------------------------------------------

TPluginManager::~TPluginManager()

{

	//   try { unloadPlugins(); } catch(...) {}

}

//-----------------------------------------------------------------------------

TPluginManager *TPluginManager::instance()

{

	static TPluginManager _instance;

	return &_instance;

}

//-----------------------------------------------------------------------------

bool TPluginManager::isIgnored(std::string name) const

{

	return m_ignoreList.count(toLower(name)) > 0;

}

//-----------------------------------------------------------------------------

void TPluginManager::unloadPlugins()

{

	for (PluginTable::iterator it = m_pluginTable.begin();

		 it != m_pluginTable.end(); ++it) {

		Plugin::Handle handle = (*it)->getHandle();

#ifndef LINUX

#ifdef _WIN32

		FreeLibrary(handle);

#else

		dlclose(handle);

#endif

#endif

		delete (*it);

	}

	m_pluginTable.clear();

}

//--------------------------------------------------------------

void TPluginManager::loadPlugin(const TFilePath &fp)

{

	if ((int)m_loadedPlugins.count(fp) > 0) {

		TLogger::debug() << "Already loaded " << fp;

		return;

	}

	std::string name = fp.getName();

	if (isIgnored(name)) {

		TLogger::debug() << "Ignored " << fp;

		return;

	}

	TLogger::debug() << "Loading " << fp;

#ifdef _WIN32

	Plugin::Handle handle = LoadLibraryW(fp.getWideString().c_str());

#else

	std::wstring str_fp = fp.getWideString();

	Plugin::Handle handle = dlopen(toString(str_fp).c_str(), RTLD_NOW); // RTLD_LAZY

#endif

	if (!handle) {

		// non riesce a caricare la libreria;

		TLogger::warning() << "Unable to load " << fp;

#ifdef _WIN32

		std::wstring getFormattedMessage(DWORD lastError);

		TLogger::warning() << toString(getFormattedMessage(GetLastError()));

#else

		TLogger::warning() << dlerror();

#endif

	} else {

		m_loadedPlugins.insert(fp);

		Plugin *plugin = new Plugin(handle);

		m_pluginTable.push_back(plugin);

		//cout << "loaded" << endl;

		TnzLibMainProcType *tnzLibMain = 0;

#ifdef _WIN32

		tnzLibMain = (TnzLibMainProcType *)

			GetProcAddress(handle, TnzLibMainProcName);

#else

		tnzLibMain = (TnzLibMainProcType *)

			dlsym(handle, TnzLibMainProcName);

		if (!tnzLibMain) //provo _ come prefisso

			tnzLibMain = (TnzLibMainProcType *)dlsym(handle, TnzLibMainProcName2);

#endif

		if (!tnzLibMain) {

			// La libreria non esporta TLibMain;

			TLogger::warning() << "Corrupted " << fp;

#ifdef _WIN32

			FreeLibrary(handle);

#else

			dlclose(handle);

#endif

		} else {

			const TPluginInfo *info = tnzLibMain();

			if (info)

				plugin->setInfo(*info);

		}

	}

}

//--------------------------------------------------------------

void TPluginManager::loadPlugins(const TFilePath &dir)

{

#if defined(_WIN32)

	const std::string extension = "dll";

#elif defined(LINUX) || defined(__sgi)

	const std::string extension = "so";

#elif defined(MACOSX)

	const std::string extension = "dylib";

#endif

	TFilePathSet dirContent = TSystem::readDirectory(dir, false);

	if (dirContent.empty())

		return;

	for (TFilePathSet::iterator it = dirContent.begin();

		 it != dirContent.end(); it++) {

		TFilePath fp = *it;

		if (fp.getType() != extension)

			continue;

		std::wstring fullpath = fp.getWideString();

#ifdef _WIN32

		bool isDebugLibrary = (fullpath.find(L".d.") == fullpath.size() - (extension.size() + 3));

#ifdef _DEBUG

		if (!isDebugLibrary)

#else

		if (isDebugLibrary)

#endif

			continue;

#endif

		try {

			loadPlugin(fp);

		} catch (...) {

			TLogger::warning() << "unexpected error loading " << fp;

		}

	}

}

//--------------------------------------------------------------

void TPluginManager::loadStandardPlugins()

{

	TFilePath pluginsDir = TSystem::getDllDir() + "plugins";

	//loadPlugins(pluginsDir + "io");

	loadPlugins(pluginsDir + "fx");

}

//--------------------------------------------------------------

void TPluginManager::setIgnoredList(const std::set<std::string> &names)</std::string>

{

	m_ignoreList.clear();

	for (std::set<std::string>::const_iterator it = names.begin(); it != names.end(); ++it)</std::string>

		m_ignoreList.insert(toLower(*it));

}