/**

 * vim: set ts=4 sw=4 tw=99 noet :

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

 * 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 "HalfLife2.h"

#include "sourcemod.h"

#include "sourcemm_api.h"

#include "UserMessages.h"

#include "PlayerManager.h"

#include "sm_stringutil.h"

#include <IGameConfigs.h>

#include <compat_wrappers.h>

#include <Logger.h>

#include "LibrarySys.h"

#include "logic_bridge.h"

#include <tier0/mem.h>

#if SOURCE_ENGINE == SE_DOTA

#include <game/shared/protobuf/usermessages.pb.h>

#elif SOURCE_ENGINE == SE_CSGO

#include <cstrike15_usermessages.pb.h>

#endif

typedef ICommandLine *(*FakeGetCommandLine)();

#if defined _WIN32

#define TIER0_NAME			"tier0.dll"

#define VSTDLIB_NAME		"vstdlib.dll"

#elif defined __APPLE__

#define TIER0_NAME			"libtier0.dylib"

#define VSTDLIB_NAME		"libvstdlib.dylib"

#elif defined __linux__

#if SOURCE_ENGINE == SE_HL2DM || SOURCE_ENGINE == SE_DODS || SOURCE_ENGINE == SE_CSS || SOURCE_ENGINE == SE_TF2 \

	|| SOURCE_ENGINE == SE_SDK2013 || SOURCE_ENGINE == SE_LEFT4DEAD2 || SOURCE_ENGINE == SE_NUCLEARDAWN

#define TIER0_NAME			"libtier0_srv.so"

#define VSTDLIB_NAME		"libvstdlib_srv.so"

#elif SOURCE_ENGINE >= SE_LEFT4DEAD

#define TIER0_NAME			"libtier0.so"

#define VSTDLIB_NAME		"libvstdlib.so"

#else

#define TIER0_NAME			"tier0_i486.so"

#define VSTDLIB_NAME		"vstdlib_i486.so"

#endif

#endif

CHalfLife2 g_HL2;

ConVar *sv_lan = NULL;

static void *g_EntList = NULL;

static void **g_pEntInfoList = NULL;

static int entInfoOffset = -1;

static CEntInfo *EntInfoArray()

{

	if (g_EntList != NULL)

	{

		return (CEntInfo *)((intp)g_EntList + entInfoOffset);

	}

	else if (g_pEntInfoList)

	{

		return *(CEntInfo **)g_pEntInfoList;

	}

	return NULL;

}

CHalfLife2::CHalfLife2()

{

	m_Maps.init();

	m_pGetCommandLine = NULL;

}

CHalfLife2::~CHalfLife2()

{

	for (NameHashSet<DataTableInfo *>::iterator iter = m_Classes.iter(); !iter.empty(); iter.next())

		delete *iter;

	for (DataTableMap::iterator iter = m_Maps.iter(); !iter.empty(); iter.next())

		delete iter->value;

}

#if SOURCE_ENGINE != SE_DARKMESSIAH

CSharedEdictChangeInfo *g_pSharedChangeInfo = NULL;

#endif

#if !defined METAMOD_PLAPI_VERSION || PLAPI_VERSION < 11

bool is_original_engine = false;

#endif

void CHalfLife2::OnSourceModStartup(bool late)

{

#if SOURCE_ENGINE != SE_DARKMESSIAH

	/* The Ship currently is the only known game to use an older version of the engine */

#if defined METAMOD_PLAPI_VERSION || PLAPI_VERSION >= 11

	if (g_SMAPI->GetSourceEngineBuild() == SOURCE_ENGINE_ORIGINAL)

#else

	if (strcasecmp(g_SourceMod.GetGameFolderName(), "ship") == 0)

#endif

	{

		is_original_engine = true;

	}

	else if (g_pSharedChangeInfo == NULL)

	{

		g_pSharedChangeInfo = engine->GetSharedEdictChangeInfo();

	}

#endif

}

void CHalfLife2::OnSourceModAllInitialized()

{

	m_MsgTextMsg = g_UserMsgs.GetMessageIndex("TextMsg");

	m_HinTextMsg = g_UserMsgs.GetMessageIndex("HintText");

	m_SayTextMsg = g_UserMsgs.GetMessageIndex("SayText");

	m_VGUIMenu = g_UserMsgs.GetMessageIndex("VGUIMenu");

	sharesys->AddInterface(NULL, this);

}

void CHalfLife2::OnSourceModAllInitialized_Post()

{

	InitLogicalEntData();

	InitCommandLine();

}

void CHalfLife2::InitLogicalEntData()

{

	char *addr = NULL;

	/*

	 * gEntList and/or g_pEntityList

	 *

	 * First try to lookup pointer directly for platforms with symbols.

	 * If symbols aren't present (Windows or stripped Linux/Mac), 

	 * attempt find via LevelShutdown + offset

	 */

	if (g_pGameConf->GetMemSig("gEntList", (void **)&addr))

	{

#if !defined PLATFORM_WINDOWS

		if (!addr)

		{

			// Key exists so notify if lookup fails, but try other method.

			g_Logger.LogError("Failed lookup of gEntList directly - Reverting to lookup via LevelShutdown");

		}

		else

		{

#endif

			g_EntList = reinterpret_cast<void *>(addr);

#if !defined PLATFORM_WINDOWS

		}

#endif

	}

	if (!g_EntList)

	{

		if (g_pGameConf->GetMemSig("LevelShutdown", (void **) &addr) && addr)

		{

			int offset;

			if (!g_pGameConf->GetOffset("gEntList", &offset))

			{

				g_Logger.LogError("Logical Entities not supported by this mod (gEntList) - Reverting to networkable entities only");

				return;

			}

			g_EntList = *reinterpret_cast<void **>(addr + offset);

		}

	}

	// If we have g_EntList from either of the above methods, make sure we can get the offset from it to EntInfo as well

	if (g_EntList && !g_pGameConf->GetOffset("EntInfo", &entInfoOffset))

	{

		g_Logger.LogError("Logical Entities not supported by this mod (EntInfo) - Reverting to networkable entities only");

		g_EntList = NULL;

		return;

	}

	// If we don't have g_EntList or have it but don't know where EntInfo is on it, use fallback.

	if (!g_EntList || entInfoOffset == -1)

	{

		g_pGameConf->GetAddress("EntInfosPtr", (void **)&g_pEntInfoList);

	}

	if (!g_EntList && !g_pEntInfoList)

	{

		g_Logger.LogError("Failed lookup of gEntList - Reverting to networkable entities only");

		return;

	}

}

void CHalfLife2::InitCommandLine()

{

	char error[256];

	if (!is_original_engine)

	{

		ke::AutoPtr<ILibrary> lib(g_LibSys.OpenLibrary(TIER0_NAME, error, sizeof(error)));

		if (lib == NULL)

		{

			g_Logger.LogError("Could not load %s: %s", TIER0_NAME, error);

			return;

		}

		m_pGetCommandLine = lib->GetSymbolAddress("CommandLine_Tier0");

		/* '_Tier0' dropped on Alien Swarm version */

		if (m_pGetCommandLine == NULL)

		{

			m_pGetCommandLine = lib->GetSymbolAddress("CommandLine");

		}

	}

	else

	{

		ke::AutoPtr<ILibrary> lib(g_LibSys.OpenLibrary(VSTDLIB_NAME, error, sizeof(error)));

		if (lib == NULL)

		{

			g_Logger.LogError("Could not load %s: %s", VSTDLIB_NAME, error);

			return;

		}

		m_pGetCommandLine = lib->GetSymbolAddress("CommandLine");

	}

	if (m_pGetCommandLine == NULL)

	{

		g_Logger.LogError("Could not locate any command line functionality");

	}

}

ICommandLine *CHalfLife2::GetValveCommandLine()

{

	if (!m_pGetCommandLine)

		return NULL;

	return ((FakeGetCommandLine)((FakeGetCommandLine *)m_pGetCommandLine))();

}

#if !defined METAMOD_PLAPI_VERSION || PLAPI_VERSION < 11

bool CHalfLife2::IsOriginalEngine()

{

	return is_original_engine;

}

#endif

#if SOURCE_ENGINE != SE_DARKMESSIAH

IChangeInfoAccessor *CBaseEdict::GetChangeAccessor()

{

#if SOURCE_ENGINE == SE_DOTA

	return engine->GetChangeAccessor( IndexOfEdict((const edict_t *)this) );

#else

	return engine->GetChangeAccessor( (const edict_t *)this );

#endif

}

#endif

bool UTIL_FindInSendTable(SendTable *pTable, 

						  const char *name,

						  sm_sendprop_info_t *info,

						  unsigned int offset)

{

	const char *pname;

	int props = pTable->GetNumProps();

	SendProp *prop;

	for (int i=0; i<props; i++)

	{

		prop = pTable->GetProp(i);

		pname = prop->GetName();

		if (pname && strcmp(name, pname) == 0)

		{

			info->prop = prop;

			info->actual_offset = offset + info->prop->GetOffset();

			return true;

		}

		if (prop->GetDataTable())

		{

			if (UTIL_FindInSendTable(prop->GetDataTable(), 

				name,

				info,

				offset + prop->GetOffset())

				)

			{

				return true;

			}

		}

	}

	return false;

}

bool UTIL_FindDataMapInfo(datamap_t *pMap, const char *name, sm_datatable_info_t *pDataTable)

{

	while (pMap)

	{

		for (int i = 0; i < pMap->dataNumFields; ++i)

		{

			if (pMap->dataDesc[i].fieldName == NULL)

			{

				continue;

			}

			if (strcmp(name, pMap->dataDesc[i].fieldName) == 0)

			{

				pDataTable->prop = &(pMap->dataDesc[i]);

				pDataTable->actual_offset = GetTypeDescOffs(pDataTable->prop);

				return true;

			}

			if (pMap->dataDesc[i].td == NULL || !UTIL_FindDataMapInfo(pMap->dataDesc[i].td, name, pDataTable))

			{

				continue;

			}

			pDataTable->actual_offset += GetTypeDescOffs(&(pMap->dataDesc[i]));

			return true;

		}

		pMap = pMap->baseMap;

	}

	return false; 

}

ServerClass *CHalfLife2::FindServerClass(const char *classname)

{

	DataTableInfo *pInfo = _FindServerClass(classname);

	if (!pInfo)

		return NULL;

	return pInfo->sc;

}

DataTableInfo *CHalfLife2::_FindServerClass(const char *classname)

{

	DataTableInfo *pInfo = NULL;

	if (!m_Classes.retrieve(classname, &pInfo))

	{

		ServerClass *sc = gamedll->GetAllServerClasses();

		while (sc)

		{

			if (strcmp(classname, sc->GetName()) == 0)

			{

				pInfo = new DataTableInfo(sc);

				m_Classes.insert(classname, pInfo);

				break;

			}

			sc = sc->m_pNext;

		}

		if (!pInfo)

			return NULL;

	}

	return pInfo;

}

bool CHalfLife2::FindSendPropInfo(const char *classname, const char *offset, sm_sendprop_info_t *info)

{

	DataTableInfo *pInfo;

	if ((pInfo = _FindServerClass(classname)) == NULL)

	{

		return false;

	}

	if (!pInfo->lookup.retrieve(offset, info))

	{

		sm_sendprop_info_t temp_info;

		if (!UTIL_FindInSendTable(pInfo->sc->m_pTable, offset, &temp_info, 0))

		{

			return false;

		}

		pInfo->lookup.insert(offset, temp_info);

		*info = temp_info;

	}

	return true;

}

SendProp *CHalfLife2::FindInSendTable(const char *classname, const char *offset)

{

	sm_sendprop_info_t info;

	if (!FindSendPropInfo(classname, offset, &info))

	{

		return NULL;

	}

	return info.prop;

}

typedescription_t *CHalfLife2::FindInDataMap(datamap_t *pMap, const char *offset)

{

	sm_datatable_info_t dt_info;

	if (!(this->FindDataMapInfo(pMap, offset, &dt_info)))

	{

		return NULL;

	}

	return dt_info.prop;

}

bool CHalfLife2::FindDataMapInfo(datamap_t *pMap, const char *offset, sm_datatable_info_t *pDataTable)

{

	DataTableMap::Insert i = m_Maps.findForAdd(pMap);

	if (!i.found())

		m_Maps.add(i, pMap, new DataMapCache());

	DataMapCache *cache = i->value;

	if (!cache->retrieve(offset, pDataTable))

	{

		if (!UTIL_FindDataMapInfo(pMap, offset, pDataTable))

			return false;

		cache->insert(offset, *pDataTable);

	}

	return true;

}

void CHalfLife2::SetEdictStateChanged(edict_t *pEdict, unsigned short offset)

{

#if SOURCE_ENGINE != SE_DARKMESSIAH

	if (g_pSharedChangeInfo != NULL)

	{

		if (offset)

		{

			pEdict->StateChanged(offset);

		}

		else

		{

			pEdict->StateChanged();

		}

	}

	else

#endif

	{

		pEdict->m_fStateFlags |= FL_EDICT_CHANGED;

	}

}

bool CHalfLife2::TextMsg(int client, int dest, const char *msg)

{

#ifndef USE_PROTOBUF_USERMESSAGES

	bf_write *pBitBuf = NULL;

#endif

	cell_t players[] = {client};

	if (dest == HUD_PRINTTALK)

	{

		const char *chat_saytext = g_pGameConf->GetKeyValue("ChatSayText");

		/* Use SayText user message instead */

		if (chat_saytext != NULL && strcmp(chat_saytext, "yes") == 0)

		{

			char buffer[192];

			UTIL_Format(buffer, sizeof(buffer), "%s\1\n", msg);

#if SOURCE_ENGINE == SE_DOTA

			CUserMsg_SayText *pMsg;

			if ((pMsg = (CUserMsg_SayText *)g_UserMsgs.StartProtobufMessage(m_SayTextMsg, players, 1, USERMSG_RELIABLE)) == NULL)

			{

				return false;

			}

			pMsg->set_client(0);

			pMsg->set_text(buffer);

			pMsg->set_chat(false);

#elif SOURCE_ENGINE == SE_CSGO

			CCSUsrMsg_SayText *pMsg;

			if ((pMsg = (CCSUsrMsg_SayText *)g_UserMsgs.StartProtobufMessage(m_SayTextMsg, players, 1, USERMSG_RELIABLE)) == NULL)

			{

				return false;

			}

			pMsg->set_ent_idx(0);

			pMsg->set_text(buffer);

			pMsg->set_chat(false);

#else

			if ((pBitBuf = g_UserMsgs.StartBitBufMessage(m_SayTextMsg, players, 1, USERMSG_RELIABLE)) == NULL)

			{

				return false;

			}

			pBitBuf->WriteByte(0);

			pBitBuf->WriteString(buffer);

			pBitBuf->WriteByte(1);

#endif

			g_UserMsgs.EndMessage();

			return true;

		}

	}

#if SOURCE_ENGINE == SE_DOTA

	CUserMsg_TextMsg *pMsg;

	if ((pMsg = (CUserMsg_TextMsg *)g_UserMsgs.StartProtobufMessage(m_MsgTextMsg, players, 1, USERMSG_RELIABLE)) == NULL)

	{

		return false;

	}

	pMsg->set_dest(dest);

	pMsg->add_param(msg);

#elif SOURCE_ENGINE == SE_CSGO

	CCSUsrMsg_TextMsg *pMsg;

	if ((pMsg = (CCSUsrMsg_TextMsg *)g_UserMsgs.StartProtobufMessage(m_MsgTextMsg, players, 1, USERMSG_RELIABLE)) == NULL)

	{

		return false;

	}

	// Client tries to read all 5 'params' and will crash if less

	pMsg->set_msg_dst(dest);

	pMsg->add_params(msg);

	pMsg->add_params("");

	pMsg->add_params("");

	pMsg->add_params("");

	pMsg->add_params("");

#else

	if ((pBitBuf = g_UserMsgs.StartBitBufMessage(m_MsgTextMsg, players, 1, USERMSG_RELIABLE)) == NULL)

	{

		return false;

	}

	pBitBuf->WriteByte(dest);

	pBitBuf->WriteString(msg);

#endif

	g_UserMsgs.EndMessage();

	return true;

}

bool CHalfLife2::HintTextMsg(int client, const char *msg)

{

	cell_t players[] = {client};

#if SOURCE_ENGINE == SE_DOTA

	CUserMsg_HintText *pMsg;

	if ((pMsg = (CUserMsg_HintText *)g_UserMsgs.StartProtobufMessage(m_HinTextMsg, players, 1, USERMSG_RELIABLE)) == NULL)

	{

		return false;

	}

	pMsg->set_message(msg);

#elif SOURCE_ENGINE == SE_CSGO

	CCSUsrMsg_HintText *pMsg;

	if ((pMsg = (CCSUsrMsg_HintText *)g_UserMsgs.StartProtobufMessage(m_HinTextMsg, players, 1, USERMSG_RELIABLE)) == NULL)

	{

		return false;

	}

	pMsg->set_text(msg);

#else

	bf_write *pBitBuf = NULL;

	if ((pBitBuf = g_UserMsgs.StartBitBufMessage(m_HinTextMsg, players, 1, USERMSG_RELIABLE)) == NULL)

	{

		return false;

	}

	const char *pre_byte = g_pGameConf->GetKeyValue("HintTextPreByte");

	if (pre_byte != NULL && strcmp(pre_byte, "yes") == 0)

	{

		pBitBuf->WriteByte(1);

	}

	pBitBuf->WriteString(msg);

#endif

	g_UserMsgs.EndMessage();

	return true;

}

bool CHalfLife2::HintTextMsg(cell_t *players, int count, const char *msg)

{

#if SOURCE_ENGINE == SE_DOTA

	CUserMsg_HintText *pMsg;

	if ((pMsg = (CUserMsg_HintText *)g_UserMsgs.StartProtobufMessage(m_HinTextMsg, players, count, USERMSG_RELIABLE)) == NULL)

	{

		return false;

	}

	pMsg->set_message(msg);