#include <stdio.h>

#include "PluginSys.h"

#include "LibrarySys.h"

#include "sourcemm_api.h"

#include "sourcemod.h"

#include "CTextParsers.h"

CPluginManager g_PluginSys;

CPlugin::CPlugin(const char *file)

{

	static int MySerial = 0;

	m_type = PluginType_Private;

	m_status = Plugin_Uncompiled;

	m_serial = ++MySerial;

	m_plugin = NULL;

	m_funcsnum = 0;

	m_priv_funcs = NULL;

	m_pub_funcs = NULL;

	m_errormsg[256] = '\0';

	snprintf(m_filename, sizeof(m_filename), "%s", file);

}

CPlugin::~CPlugin()

{

	if (m_ctx.base)

	{

		g_pSourcePawn->FreeBaseContext(m_ctx.base);

		m_ctx.base = NULL;

	}

	if (m_ctx.ctx)

	{

		m_ctx.vm->FreeContext(m_ctx.ctx);

		m_ctx.ctx = NULL;

	}

	if (m_ctx.co)

	{

		m_ctx.vm->AbortCompilation(m_ctx.co);

		m_ctx.co = NULL;

	}

	if (m_plugin)

	{

		g_pSourcePawn->FreeFromMemory(m_plugin);

		m_plugin = NULL;

	}

	if (m_pub_funcs)

	{

		for (uint32_t i=0; i<m_plugin->info.publics_num; i++)

		{

			g_PluginSys.ReleaseFunctionToPool(m_pub_funcs[i]);

		}

		delete [] m_pub_funcs;

		m_pub_funcs = NULL;

	}

	if (m_priv_funcs)

	{

		for (unsigned int i=0; i<m_funcsnum; i++)

		{

			g_PluginSys.ReleaseFunctionToPool(m_priv_funcs[i]);

		}

		delete [] m_priv_funcs;

		m_priv_funcs = NULL;

	}

}

CPlugin *CPlugin::CreatePlugin(const char *file, char *error, size_t maxlength)

{

	char fullpath[PLATFORM_MAX_PATH+1];

	g_LibSys.PathFormat(fullpath, sizeof(fullpath), "%s/plugins/%s", g_SourceMod.GetSMBaseDir(), file);

	FILE *fp = fopen(fullpath, "rb");

	if (!fp)

	{

		if (error)

		{

			snprintf(error, maxlength, "Unable to open file");

			return NULL;

		} else {

			CPlugin *pPlugin = new CPlugin(file);

			snprintf(pPlugin->m_errormsg, sizeof(pPlugin->m_errormsg), "Unable to open file");

			pPlugin->m_status = Plugin_BadLoad;

			return pPlugin;

		}

	}

	int err;

	sp_plugin_t *pl = g_pSourcePawn->LoadFromFilePointer(fp, &err);

	if (pl == NULL)

	{

		fclose(fp);

		if (error)

		{

			snprintf(error, maxlength, "Error %d while parsing plugin", err);

			return NULL;

		} else {

			CPlugin *pPlugin = new CPlugin(file);

			snprintf(pPlugin->m_errormsg, sizeof(pPlugin->m_errormsg), "Error %d while parsing plugin", err);

			pPlugin->m_status = Plugin_BadLoad;

			return pPlugin;

		}

	}

	fclose(fp);

	CPlugin *pPlugin = new CPlugin(file);

	pPlugin->m_plugin = pl;

	return pPlugin;

}

ICompilation *CPlugin::StartMyCompile(IVirtualMachine *vm)

{

	if (!m_plugin)

	{

		return NULL;

	}

	/* :NOTICE: We will eventually need to change these natives

	 * for swapping in new contexts

	 */

	if (m_ctx.co || m_ctx.ctx)

	{

		return NULL;

	}

	m_status = Plugin_Uncompiled;

	m_ctx.vm = vm;

	m_ctx.co = vm->StartCompilation(m_plugin);

	return m_ctx.co;

}

void CPlugin::CancelMyCompile()

{

	if (!m_ctx.co)

	{

		return;

	}

	m_ctx.vm->AbortCompilation(m_ctx.co);

	m_ctx.co = NULL;

	m_ctx.vm = NULL;

}

bool CPlugin::FinishMyCompile(char *error, size_t maxlength)

{

	if (!m_ctx.co)

	{

		return false;

	}

	int err;

	m_ctx.ctx = m_ctx.vm->CompileToContext(m_ctx.co, &err);

	if (!m_ctx.ctx)

	{

		memset(&m_ctx, 0, sizeof(m_ctx));

		if (!error)

		{

			SetErrorState(Plugin_Error, "Failed to compile (error %d)", err);

		} else {

			snprintf(error, maxlength, "Failed to compile (error %d)", err);

		}

		return false;

	}

	m_ctx.base = g_pSourcePawn->CreateBaseContext(m_ctx.ctx);

	m_ctx.ctx->user[SM_CONTEXTVAR_MYSELF] = (void *)this;

	m_funcsnum = m_ctx.vm->FunctionCount(m_ctx.ctx);

	/**

	 * Note: Since the m_plugin member will never change,

	 * it is safe to assume the function count will never change

	 */

	if (m_funcsnum && m_priv_funcs == NULL)

	{

		m_priv_funcs = new CFunction *[m_funcsnum];

		memset(m_priv_funcs, 0, sizeof(CFunction *) * m_funcsnum);

	} else {

		m_priv_funcs = NULL;

	}

	if (m_plugin->info.publics_num && m_pub_funcs == NULL)

	{

		m_pub_funcs = new CFunction *[m_plugin->info.publics_num];

		memset(m_pub_funcs, 0, sizeof(CFunction *) * m_plugin->info.publics_num);

	} else {

		m_pub_funcs = NULL;

	}

	m_status = Plugin_Created;

	UpdateInfo();

	return true;

}

void CPlugin::SetErrorState(PluginStatus status, const char *error_fmt, ...)

{

	m_status = status;

	va_list ap;

	va_start(ap, error_fmt);

	vsnprintf(m_errormsg, sizeof(m_errormsg), error_fmt, ap);

	va_end(ap);

}

IPluginFunction *CPlugin::GetFunctionById(funcid_t func_id)

{

	CFunction *pFunc = NULL;

	funcid_t save = func_id;

	if (func_id & 1)

	{

		func_id >>= 1;

		if (func_id >= m_plugin->info.publics_num)

		{

			return NULL;

		}

		pFunc = m_pub_funcs[func_id];

		if (!pFunc)

		{

			pFunc = g_PluginSys.GetFunctionFromPool(save, this);

			m_pub_funcs[func_id] = pFunc;

		}

	} else {

		func_id >>= 1;

		unsigned int index;

		if (!g_pVM->FunctionLookup(m_ctx.ctx, func_id, &index))

		{

			return NULL;

		}

		pFunc = m_priv_funcs[func_id];

		if (!pFunc)

		{

			pFunc = g_PluginSys.GetFunctionFromPool(save, this);

			m_priv_funcs[func_id] = pFunc;

		}

	}

	return pFunc;

}

IPluginFunction *CPlugin::GetFunctionByName(const char *public_name)

{

	uint32_t index;

	IPluginContext *base = m_ctx.base;

	if (base->FindPublicByName(public_name, &index) != SP_ERROR_NONE)

	{

		return NULL;

	}

	CFunction *pFunc = m_pub_funcs[index];

	if (!pFunc)

	{

		sp_public_t *pub = NULL;

		base->GetPublicByIndex(index, &pub);

		if (pub)

		{

			pFunc = g_PluginSys.GetFunctionFromPool(pub->funcid, this);

			m_pub_funcs[index] = pFunc;

		}

	}

	return pFunc;

}

void CPlugin::UpdateInfo()

{

	/* Now grab the info */

	uint32_t idx;

	IPluginContext *base = GetBaseContext();

	int err = base->FindPubvarByName("myinfo", &idx);

	if (err == SP_ERROR_NONE)

	{

		struct sm_plugininfo_c_t

		{

			cell_t name;

			cell_t description;

			cell_t author;

			cell_t version;

			cell_t url;

		};

		sm_plugininfo_c_t *cinfo;

		cell_t local_addr;

		base->GetPubvarAddrs(idx, &local_addr, (cell_t **)&cinfo);

		base->LocalToString(cinfo->name, (char **)&m_info.name);

		base->LocalToString(cinfo->description, (char **)&m_info.description);

		base->LocalToString(cinfo->author, (char **)&m_info.author);

		base->LocalToString(cinfo->url, (char **)&m_info.url);

		base->LocalToString(cinfo->version, (char **)&m_info.version);

	}

	m_info.author = m_info.author ? m_info.author : "";

	m_info.description = m_info.description ? m_info.description : "";

	m_info.name = m_info.name ? m_info.name : "";

	m_info.url = m_info.url ? m_info.url : "";

	m_info.version = m_info.version ? m_info.version : "";

}

void CPlugin::Call_OnPluginInit()

{

	if (m_status != Plugin_Loaded)

	{

		return;

	}

	m_status = Plugin_Running;

	int err;

	cell_t result;

	IPluginFunction *pFunction = GetFunctionByName("OnPluginInit");

	if (!pFunction)

	{

		return;

	}

	/* :TODO: push our own handle */

	pFunction->PushCell(0);

	if ((err=pFunction->Execute(&result)) != SP_ERROR_NONE)

	{

		/* :TODO: log into debugger instead */

		SetErrorState(Plugin_Error, "Runtime error %d", err);

	}

}

bool CPlugin::Call_AskPluginLoad(char *error, size_t maxlength)

{

	if (m_status != Plugin_Created)

	{

		return false;

	}

	if (!error)

	{

		error = m_errormsg;

		maxlength = sizeof(m_errormsg);

	}

	int err;

	cell_t result;

	IPluginFunction *pFunction = GetFunctionByName("AskPluginLoad");

	if (!pFunction)

	{

		return true;

	}

	pFunction->PushCell(0);		//:TODO: handle to ourself

	pFunction->PushCell(g_PluginSys.IsLateLoadTime() ? 1 : 0);

	pFunction->PushStringEx(error, maxlength, 0, SM_PARAM_COPYBACK);

	pFunction->PushCell(maxlength);

	if ((err=pFunction->Execute(&result)) != SP_ERROR_NONE)

	{

		/* :TODO: debugging system */

		snprintf(error, maxlength, "Plugin load returned run time error %d", err);

		m_status = Plugin_Error;

		return false;

	}

	if (!result)

	{

		m_status = Plugin_Error;

		return false;

	}

	m_status = Plugin_Loaded;

	return true;

}

const sp_plugin_t *CPlugin::GetPluginStructure() const

{

	return m_plugin;

}

IPluginContext *CPlugin::GetBaseContext() const

{

	return m_ctx.base;

}

sp_context_t *CPlugin::GetContext() const

{

	return m_ctx.ctx;

}

const char *CPlugin::GetFilename() const

{

	return m_filename;

}

PluginType CPlugin::GetType() const

{

	return m_type;

}

const sm_plugininfo_t *CPlugin::GetPublicInfo() const

{

	return &m_info;

}

unsigned int CPlugin::GetSerial() const

{

	return m_serial;

}

PluginStatus CPlugin::GetStatus() const

{

	return m_status;

}

bool CPlugin::IsDebugging() const

{

	if (!m_ctx.ctx)

	{

		return false;

	}

	return ((m_ctx.ctx->flags & SP_FLAG_DEBUG) == SP_FLAG_DEBUG);

}

bool CPlugin::SetPauseState(bool paused)

{

	if (paused && GetStatus() != Plugin_Paused)

	{

		return false;

	} else if (!paused && GetStatus() != Plugin_Running) {

		return false;

	}

	/* :TODO: execute some forwards or some crap */

	return true;

}

/*******************

 * PLUGIN ITERATOR *

 *******************/

CPluginManager::CPluginIterator::CPluginIterator(List<IPlugin *> *_mylist)

{

	mylist = _mylist;

}

IPlugin *CPluginManager::CPluginIterator::GetPlugin()

{

	return (*current);

}

bool CPluginManager::CPluginIterator::MorePlugins()

{

	return (current != mylist->end());

}

void CPluginManager::CPluginIterator::NextPlugin()

{

	current++;

}

void CPluginManager::CPluginIterator::Release()

{

	g_PluginSys.ReleaseIterator(this);

}

CPluginManager::CPluginIterator::~CPluginIterator()

{

}

void CPluginManager::CPluginIterator::Reset()

{

	current = mylist->begin();

}

/******************

 * PLUGIN MANAGER *

 ******************/

CPluginManager::CPluginManager()

{

	m_LoadLookup = sm_trie_create();

	m_AllPluginsLoaded = false;

}

CPluginManager::~CPluginManager()

{

	//:TODO: we need a good way to free what we're holding

	sm_trie_destroy(m_LoadLookup);

}

void CPluginManager::LoadAll_FirstPass( const char *config, const char *basedir )

{

	/* First read in the database of plugin settings */

	SMCParseError err;

	unsigned int line, col;

	if ((err=g_TextParse.ParseFile_SMC(config, &m_PluginInfo, &line, &col)) != SMCParse_Okay)

	{

		/* :TODO: log the error, don't bail out though */

	}

	LoadPluginsFromDir(basedir, NULL);

}

void CPluginManager::LoadPluginsFromDir(const char *basedir, const char *localpath)

{

	char base_path[PLATFORM_MAX_PATH+1];

	/* Form the current path to start reading from */

	if (localpath == NULL)

	{

		g_LibSys.PathFormat(base_path, sizeof(base_path), "%s", basedir);

	} else {

		g_LibSys.PathFormat(base_path, sizeof(base_path), "%s/%s", basedir, localpath);

	}

	IDirectory *dir = g_LibSys.OpenDirectory(base_path);

	if (!dir)

	{

		//:TODO: write a logger and LOG THIS UP, BABY

		//g_LibSys.GetPlatformError(error, err_max);

		return;

	}

	while (dir->MoreFiles())

	{

		if (dir->IsEntryDirectory() 

			&& (strcmp(dir->GetEntryName(), ".") != 0)

			&& (strcmp(dir->GetEntryName(), "..") != 0)

			&& (strcmp(dir->GetEntryName(), "disabled") != 0)

			&& (strcmp(dir->GetEntryName(), "optional") != 0))

		{

			char new_local[PLATFORM_MAX_PATH+1];

			if (localpath == NULL)

			{

				/* If no path yet, don't add a former slash */

				snprintf(new_local, sizeof(new_local), "%s", dir->GetEntryName());

			} else {

				g_LibSys.PathFormat(new_local, sizeof(new_local), "%s/%s", localpath, dir->GetEntryName());

			}

			LoadPluginsFromDir(basedir, new_local);

		} else if (dir->IsEntryFile()) {

			const char *name = dir->GetEntryName();

			size_t len = strlen(name);

			if (len >= 4

				&& strcmp(&name[len-4], ".smx") == 0)

			{

				/* If the filename matches, load the plugin */

				char plugin[PLATFORM_MAX_PATH+1];

				if (localpath == NULL)

				{

					snprintf(plugin, sizeof(plugin), "%s", name);

				} else {

					g_LibSys.PathFormat(plugin, sizeof(plugin), "%s/%s", localpath, name);

				}

				LoadAutoPlugin(plugin);

			}

		}

		dir->NextEntry();

	}

	g_LibSys.CloseDirectory(dir);

}

//well i have discovered that gabe newell is very fat, so i wrote this comment now

//:TODO: remove this function, create a better wrapper for LoadPlugin()/LoadAutoPlugin()

void CPluginManager::LoadAutoPlugin(const char *file)

{

	/**

	 * Does this plugin already exist?

	 */

	CPlugin *pPlugin;

	if (sm_trie_retrieve(m_LoadLookup, file, (void **)&pPlugin))

	{

		/* First check the type */

		PluginType type = pPlugin->GetType();