#include "PluginManager.h"
#include "pluginBase.h"
#include "PluginManageDialog.h"
#include "Settings/BusAPI.h"
#include "MainWindow/MainWindow.h"
#include <QApplication>
#include <QFileInfoList>
#include <QDir>
#include <QDomDocument>
#include <QDomNodeList>
#include <QDomElement>
#include <QDebug>

#ifdef Q_OS_WIN
#include <windows.h>
#include <WinBase.h>
#endif

#ifdef Q_OS_UNIX
#include <dlfcn.h>
#endif

namespace Plugins {
	PluginManager* PluginManager::_instance = nullptr;

	PluginManager* PluginManager::getInstance()
	{
		if(_instance == nullptr)
			_instance = new PluginManager;
		return _instance;
	}

	int PluginManager::getPluginsCount()
	{
		return _pluginList.size();
	}

	void PluginManager::releasePlugs()
	{
		int nplug = _pluginList.size();
		for(int i = 0; i < nplug; ++i) {
			Plugins::PluginBase* p	= _pluginList.at(i);
			bool				 ok = p->uninstall();
			if(!ok)
				continue;
			delete p;
		}
		_pluginList.clear();
	}

	void PluginManager::loadPlugs(GUI::MainWindow* m)
	{
		_mainWindow = m;
		if(m != nullptr)
			connect(this, SIGNAL(updateActionStates()), m, SIGNAL(updateActionStatesSig()));
		QStringList	  plugins = Setting::BusAPI::instance()->getPlugins();
		const QString plugdir = QApplication::applicationDirPath() + "/plugins/";
		QDir		  dir(plugdir);
		if(!dir.exists()) {
			plugins.clear();
			Setting::BusAPI::instance()->setPlugins(plugins);
			return;
		}

		for(int i = 0; i < plugins.size(); ++i) {
			QString pluginname = plugins.at(i);
			bool	ok		   = loadPlugin(pluginname);
			if(!ok)
				plugins.removeOne(pluginname);
		}
		Setting::BusAPI::instance()->setPlugins(plugins);
	}

	bool PluginManager::loadPlugin(QString pluginname)
	{
		if(isFileLoaded(pluginname))
			return false;

		QString		  lang	   = Setting::BusAPI::instance()->getLanguage();
		const QString plugdir  = QApplication::applicationDirPath() + "/plugins/";
		QString		  plugpath = plugdir + pluginname;

		qDebug() << pluginname;

		typedef void (*Reg)(GUI::MainWindow*, QList<Plugins::PluginBase*>*);
		Reg fun = nullptr;

		if(!pluginname.toLower().startsWith("plugin"))
			return false;
		if(!pluginname.toLower().endsWith(".dll"))
			return false;
		qDebug() << "loading Plugin dll : " << plugpath;
		HMODULE hmodel = LoadLibrary(LPCWSTR(plugpath.utf16()));
		qDebug()<<"Error Code :"+QString::number(GetLastError());
		if(hmodel) {
			fun = (Reg)GetProcAddress(hmodel, "Register");
			if(fun) {
				fun(_mainWindow, &_pluginList);
				Plugins::PluginBase* pls = _pluginList.last();
				qDebug() << "loading Plugin: " << pls->getDescribe();
				pls->install();
				pls->setFileName(pluginname);
				pls->setWinModule(hmodel);
				pls->reTranslate(lang);
				qDebug() << "loading Plugin finished  : " << pls->getDescribe();
			} else {
				FreeLibrary(hmodel);
				qDebug() << "do not find Register function  Plugin: " << plugpath;
				return false;
			}
		}
		else{
			qDebug() << "loading Plugin dll Failure: " << plugpath;

		}

		emit updateActionStates();
		return true;
	}

	void PluginManager::reTranslate(QString lang)
	{
		const int n = _pluginList.size();
		for(int i = 0; i < n; ++i) {
			auto p = _pluginList.at(i);
			p->reTranslate(lang);
		}
	}

	PluginBase* PluginManager::getPluginByDescribe(QString des)
	{
		for(auto p : _pluginList) {
			if(des.toLower() == p->getDescribe().toLower())
				return p;
		}
		return nullptr;
	}

	void PluginManager::manage()
	{
		PluginManageDialog dlg(_mainWindow, this);
		dlg.exec();
	}

	bool PluginManager::releasePlugin(QString name)
	{
		for(auto p : _pluginList) {
			if(name == p->getFileName()) {
				bool ok = p->uninstall();
				if(!ok)
					return false;
				delete p;
				_pluginList.removeOne(p);
				break;
			}
		}
		emit updateActionStates();
		return true;
	}

	QList<PluginBase*> PluginManager::getPluginsByType(PluginType t)
	{
		QList<PluginBase*> ps;

		for(PluginBase* p : _pluginList) {
			if(p->getType() == t)
				ps.append(p);
		}

		return ps;
	}

	QDomElement& PluginManager::writeToProjectFile(QDomDocument* doc, QDomElement* parent)
	{
		QDomElement pgsele = doc->createElement("Plugins");
		for(auto p : _pluginList)
			p->writeToProjectFile(doc, &pgsele);
		parent->appendChild(pgsele);
		return pgsele;
	}

	void PluginManager::readDataFromProjectFile(QDomElement* e)
	{
		for(auto p : _pluginList)
			p->readFromProjectFile(e);
	}

	bool PluginManager::hasInfoToSave()
	{
		for(auto p : _pluginList)
			if(p->hasInfoToSave())
				return true;

		return false;
	}

	bool PluginManager::isFileLoaded(const QString fileName)
	{
		for(auto p : _pluginList) {
			QString name = p->getFileName();
			if(name.toLower() == fileName.toLower())
				return true;
		}
		return false;
	}

} // namespace Plugins