/**

 * vim: set ts=4 :

 * =============================================================================

 * SourceMod

 * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.

 * =============================================================================

 *

 * This program is free software; you can redistribute it and/or modify it under

 * the terms of the GNU General Public License, version 3.0, as published by the

 * Free Software Foundation.

 * 

 * 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/>.

 *

 * As a special exception, AlliedModders LLC gives you permission to link the

 * code of this program (as well as its derivative works) to "Half-Life 2," the

 * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software

 * by the Valve Corporation.  You must obey the GNU General Public License in

 * all respects for all other code used.  Additionally, AlliedModders LLC grants

 * this exception to all derivative works.  AlliedModders LLC defines further

 * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),

 * or <http://www.sourcemod.net/license.php>.

 *

 * Version: $Id$

 */

#include <stdio.h>

#include "PluginSys.h"

#include "ShareSys.h"

#include "LibrarySys.h"

#include "HandleSys.h"

#include "ForwardSys.h"

#include "sourcemm_api.h"

#include "sourcemod.h"

#include "TextParsers.h"

#include "Logger.h"

#include "ExtensionSys.h"

#include "sm_srvcmds.h"

#include "sm_stringutil.h"

#include "ConCmdManager.h"

#include "PlayerManager.h"

#include "CoreConfig.h"

#include "Translator.h"

CPluginManager g_PluginSys;

HandleType_t g_PluginType = 0;

IdentityType_t g_PluginIdent = 0;

CPlugin::CPlugin(const char *file)

{

	static int MySerial = 0;

	m_type = PluginType_Private;

	m_status = Plugin_Uncompiled;

	m_serial = ++MySerial;

	m_plugin = NULL;

	m_errormsg[256] = '\0';

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

	m_handle = 0;

	m_ident = NULL;

	m_pProps = sm_trie_create();

	m_FakeNativesMissing = false;

	m_LibraryMissing = false;

	m_bGotAllLoaded = false;

	m_pPhrases = g_Translator.CreatePhraseCollection();

}

CPlugin::~CPlugin()

{

	if (m_handle)

	{

		HandleSecurity sec;

		sec.pOwner = g_PluginSys.GetIdentity();

		sec.pIdentity = sec.pOwner;

		g_HandleSys.FreeHandle(m_handle, &sec);

		g_ShareSys.DestroyIdentity(m_ident);

	}

	if (m_ctx.base)

	{

		delete 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_pProps)

	{

		sm_trie_destroy(m_pProps);

	}

	for (size_t i=0; i<m_configs.size(); i++)

	{

		delete m_configs[i];

	}

	m_configs.clear();

	if (m_pPhrases != NULL)

	{

		m_pPhrases->Destroy();

		m_pPhrases = NULL;

	}

}

void CPlugin::InitIdentity()

{

	if (!m_handle)

	{

		m_ident = g_ShareSys.CreateIdentity(g_PluginIdent, this);

		m_handle = g_HandleSys.CreateHandle(g_PluginType, this, g_PluginSys.GetIdentity(), g_PluginSys.GetIdentity(), NULL);

		m_ctx.base->SetIdentity(m_ident);

	}

}

unsigned int CPlugin::CalcMemUsage()

{

	unsigned int base_size = 

		sizeof(CPlugin) 

		+ sizeof(IdentityToken_t)

		+ (m_configs.size() * (sizeof(AutoConfig *) + sizeof(AutoConfig)))

		+ sm_trie_mem_usage(m_pProps);

	for (unsigned int i = 0; i < m_configs.size(); i++)

	{

		base_size += m_configs[i]->autocfg.size();

		base_size += m_configs[i]->folder.size();

	}

	for (List<String>::iterator i = m_Libraries.begin();

		 i != m_Libraries.end();

		 i++)

	{

		base_size += (*i).size();

	}

	for (List<String>::iterator i = m_RequiredLibs.begin();

		 i != m_RequiredLibs.end();

		 i++)

	{

		base_size += (*i).size();

	}

	if (m_plugin != NULL)

	{

		base_size += sizeof(sp_plugin_t);

		base_size += m_plugin->data_size;

		base_size += m_plugin->pcode_size;

		base_size += (m_plugin->info.natives_num * sizeof(sp_file_natives_t));

		base_size += (m_plugin->info.publics_num * sizeof(sp_file_publics_t));

		base_size += (m_plugin->info.pubvars_num * sizeof(sp_file_pubvars_t));

		base_size += (m_plugin->debug.files_num * sizeof(sp_fdbg_file_t));

		base_size += (m_plugin->debug.lines_num * sizeof(sp_fdbg_line_t));

		base_size += (m_plugin->debug.syms_num * sizeof(sp_fdbg_symbol_t));

		/* We can't get strtab size, oh well. */

	}

	if (m_ctx.base != NULL)

	{

		base_size += sizeof(BaseContext);

		base_size += m_ctx.base->GetPublicsNum() * sizeof(CFunction);

	}

	if (m_ctx.ctx != NULL)

	{

		base_size += m_ctx.ctx->mem_size;

		base_size += (m_plugin->debug.files_num * sizeof(sp_debug_file_t));

		base_size += (m_plugin->debug.lines_num * sizeof(sp_debug_line_t));

		base_size += (m_plugin->debug.syms_num * sizeof(sp_debug_symbol_t));

		base_size += (m_plugin->info.pubvars_num * sizeof(sp_pubvar_t));

		base_size += (m_plugin->info.publics_num * sizeof(sp_public_t));

		base_size += (m_plugin->info.natives_num * sizeof(sp_native_t));

		/* We also don't know the JIT code size, oh well. */

	}

	return base_size;

}

Handle_t CPlugin::GetMyHandle()

{

	return m_handle;

}

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

{

	char fullpath[PLATFORM_MAX_PATH];

	g_SourceMod.BuildPath(Path_SM, fullpath, sizeof(fullpath), "plugins/%s", file);

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

	CPlugin *pPlugin = new CPlugin(file);

	if (!fp)

	{

		if (error)

		{

			snprintf(error, maxlength, "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);

		}

		pPlugin->m_status = Plugin_BadLoad;

		return pPlugin;

	}

	fclose(fp);

	pPlugin->m_plugin = pl;

	return pPlugin;

}

bool CPlugin::GetProperty(const char *prop, void **ptr, bool remove/* =false */)

{

	bool exists = sm_trie_retrieve(m_pProps, prop, ptr);

	if (exists && remove)

	{

		sm_trie_delete(m_pProps, prop);

	}

	return exists;

}

bool CPlugin::SetProperty(const char *prop, void *ptr)

{

	return sm_trie_insert(m_pProps, prop, ptr);

}

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)

		{

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

		}

		return false;

	}

	m_ctx.base = new BaseContext(m_ctx.ctx);

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

	m_status = Plugin_Created;

	m_ctx.co = NULL;

	UpdateInfo();

	return true;

}

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

{

	PluginStatus old_status = m_status;

	m_status = status;

	if (old_status == Plugin_Running)

	{

		/* Tell everyone we're now paused */

		g_PluginSys._SetPauseState(this, true);

	}

	va_list ap;

	va_start(ap, error_fmt);

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

	va_end(ap);

	if (m_ctx.ctx)

	{

		m_ctx.ctx->flags |= SPFLAG_PLUGIN_PAUSED;

	}

}

void CPlugin::UpdateInfo()

{

	/* Now grab the info */

	uint32_t idx;

	IPluginContext *base = GetBaseContext();

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

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

	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 : "";

	if ((err = base->FindPubvarByName("__version", &idx)) == SP_ERROR_NONE)

	{

		struct __version_info

		{

			cell_t version;

			cell_t filevers;

			cell_t date;

			cell_t time;

		};

		__version_info *info;

		cell_t local_addr;

		const char *pDate, *pTime;

		pDate = "";

		pTime = "";

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

		m_FileVersion = info->version;

		if (m_FileVersion >= 3)

		{

			base->LocalToString(info->date, (char **)&pDate);

			base->LocalToString(info->time, (char **)&pTime);

			UTIL_Format(m_DateTime, sizeof(m_DateTime), "%s %s", pDate, pTime);

		}

	}

	else

	{

		m_FileVersion = 0;

	}

}

void CPlugin::Call_OnPluginStart()

{

	if (m_status != Plugin_Loaded)

	{

		return;

	}

	m_status = Plugin_Running;

	cell_t result;

	IPluginFunction *pFunction = m_ctx.base->GetFunctionByName("OnPluginStart");

	if (!pFunction)

	{

		return;

	}

	int err;

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

	{

		SetErrorState(Plugin_Error, "Error detected in plugin startup (see error logs)");

	}

}

void CPlugin::Call_OnPluginEnd()

{

	if (m_status > Plugin_Paused)

	{

		return;

	}

	cell_t result;

	IPluginFunction *pFunction = m_ctx.base->GetFunctionByName("OnPluginEnd");

	if (!pFunction)

	{

		return;

	}

	pFunction->Execute(&result);

}

void CPlugin::Call_OnAllPluginsLoaded()

{

	if (m_status > Plugin_Paused)

	{

		return;

	}

	if (m_bGotAllLoaded)

	{

		return;

	}

	m_bGotAllLoaded = true;

	cell_t result;

	IPluginFunction *pFunction = m_ctx.base->GetFunctionByName("OnAllPluginsLoaded");

	if (pFunction != NULL)

	{

		pFunction->Execute(&result);

	}

	if (g_OnMapStarted)

	{

		if ((pFunction = m_ctx.base->GetFunctionByName("OnMapStart")) != NULL)

		{

			pFunction->Execute(NULL);

		}

	}

	if (SM_AreConfigsExecuted())

	{

		SM_ExecuteForPlugin(GetBaseContext());

	}

}

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

{

	if (m_status != Plugin_Created)

	{

		return false;

	}

	m_status = Plugin_Loaded;

	int err;

	cell_t result;

	IPluginFunction *pFunction = m_ctx.base->GetFunctionByName("AskPluginLoad");

	if (!pFunction)

	{

		return true;

	}

	pFunction->PushCell(m_handle);

	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)

	{

		return false;

	}

	if (!result || m_status != Plugin_Loaded)

	{

		return false;

	}

	return true;

}

const sp_plugin_t *CPlugin::GetPluginStructure()

{

	return m_plugin;

}

IPluginContext *CPlugin::GetBaseContext()

{

	return m_ctx.base;

}

sp_context_t *CPlugin::GetContext()

{

	return m_ctx.ctx;

}

const char *CPlugin::GetFilename()

{

	return m_filename;

}

PluginType CPlugin::GetType()

{

	return m_type;

}

const sm_plugininfo_t *CPlugin::GetPublicInfo()

{

	return &m_info;

}

unsigned int CPlugin::GetSerial()

{

	return m_serial;

}

PluginStatus CPlugin::GetStatus()

{

	return m_status;

}

bool CPlugin::IsDebugging()

{

	if (!m_ctx.ctx)

	{

		return false;

	}

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

}

void CPlugin::LibraryActions(bool dropping)

{

	List<String>::iterator iter;

	for (iter = m_Libraries.begin();

		iter != m_Libraries.end();

		iter++)

	{

		g_PluginSys.OnLibraryAction((*iter).c_str(), true, dropping);

	}

}

bool CPlugin::SetPauseState(bool paused)

{

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

	{

		return false;

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

		return false;

	}

	if (paused)