/**

 * 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 <string.h>

#include <assert.h>

#include <ITextParsers.h>

#include "AdminCache.h"

#include "PlayerManager.h"

#include "ConCmdManager.h"

#include "Logger.h"

#include "sourcemod.h"

#include "sm_stringutil.h"

#include "sourcemm_api.h"

#include "sm_srvcmds.h"

#include "logic_bridge.h"

#define LEVEL_STATE_NONE		0

#define LEVEL_STATE_LEVELS		1

#define LEVEL_STATE_FLAGS		2

AdminCache g_Admins;

char g_ReverseFlags[26];

AdminFlag g_FlagLetters[26];

bool g_FlagSet[26];

ConVar sm_immunity_mode("sm_immunity_mode", "1", FCVAR_SPONLY, "Mode for deciding immunity protection");

/* Default flags */

AdminFlag g_DefaultFlags[26] = 

{

	Admin_Reservation, Admin_Generic, Admin_Kick, Admin_Ban, Admin_Unban,

	Admin_Slay, Admin_Changemap, Admin_Convars, Admin_Config, Admin_Chat,

	Admin_Vote, Admin_Password, Admin_RCON, Admin_Cheats, Admin_Custom1, 

	Admin_Custom2, Admin_Custom3, Admin_Custom4, Admin_Custom5, Admin_Custom6,

	Admin_Generic, Admin_Generic, Admin_Generic, Admin_Generic, Admin_Generic,

	Admin_Root

};

class FlagReader : public ITextListener_SMC

{

public:

	void LoadLevels()

	{

		if (!Parse())

		{

			memcpy(g_FlagLetters, g_DefaultFlags, sizeof(AdminFlag) * 26);

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

			{

				g_FlagSet[i] = true;

			}

			g_FlagSet[25] = true;

		}

	}

private:

	bool Parse()

	{

		SMCStates states;

		SMCError error;

		m_bFileNameLogged = false;

		g_SourceMod.BuildPath(Path_SM, m_File, sizeof(m_File), "configs/admin_levels.cfg");

		if ((error = textparsers->ParseFile_SMC(m_File, this, &states))

			!= SMCError_Okay)

		{

			const char *err_string = textparsers->GetSMCErrorString(error);

			if (!err_string)

			{

				err_string = "Unknown error";

			}

			ParseError(NULL, "Error %d (%s)", error, err_string);

			return false;

		}

		return true;

	}

	void ReadSMC_ParseStart()

	{

		m_LevelState = LEVEL_STATE_NONE;

		m_IgnoreLevel = 0;

		memset(g_FlagSet, 0, sizeof(g_FlagSet));

	}

	SMCResult ReadSMC_NewSection(const SMCStates *states, const char *name)

	{

		if (m_IgnoreLevel)

		{

			m_IgnoreLevel++;

			return SMCResult_Continue;

		}

		if (m_LevelState == LEVEL_STATE_NONE)

		{

			if (strcmp(name, "Levels") == 0)

			{

				m_LevelState = LEVEL_STATE_LEVELS;

			} 

			else 

			{

				m_IgnoreLevel++;

			}

		} else if (m_LevelState == LEVEL_STATE_LEVELS) {

			if (strcmp(name, "Flags") == 0)

			{

				m_LevelState = LEVEL_STATE_FLAGS;

			} 

			else 

			{

				m_IgnoreLevel++;

			}

		} 

		else 

		{

			m_IgnoreLevel++;

		}

		return SMCResult_Continue;

	}

	SMCResult ReadSMC_KeyValue(const SMCStates *states, const char *key, const char *value)

	{

		if (m_LevelState != LEVEL_STATE_FLAGS || m_IgnoreLevel)

		{

			return SMCResult_Continue;

		}

		unsigned char c = (unsigned)value[0];

		if (c < (unsigned)'a' || c > (unsigned)'z')

		{

			ParseError(states, "Flag \"%c\" is not a lower-case ASCII letter", c);

			return SMCResult_Continue;

		}

		c -= (unsigned)'a';

		if (!g_Admins.FindFlag(key, &g_FlagLetters[c]))

		{

			ParseError(states, "Unrecognized admin level \"%s\"", key);

			return SMCResult_Continue;

		}

		g_FlagSet[c] = true;

		return SMCResult_Continue;

	}

	SMCResult ReadSMC_LeavingSection(const SMCStates *states)

	{

		if (m_IgnoreLevel)

		{

			m_IgnoreLevel--;

			return SMCResult_Continue;

		}

		if (m_LevelState == LEVEL_STATE_FLAGS)

		{

			m_LevelState = LEVEL_STATE_LEVELS;

			return SMCResult_Halt;

		} 

		else if (m_LevelState == LEVEL_STATE_LEVELS) 

		{

			m_LevelState = LEVEL_STATE_NONE;

		}

		return SMCResult_Continue;

	}

	void ParseError(const SMCStates *states, const char *message, ...)

	{

		va_list ap;

		char buffer[256];

		va_start(ap, message);

		UTIL_FormatArgs(buffer, sizeof(buffer), message, ap);

		va_end(ap);

		if (!m_bFileNameLogged)

		{

			g_Logger.LogError("[SM] Parse error(s) detected in file \"%s\":", m_File);

			m_bFileNameLogged = true;

		}

		g_Logger.LogError("[SM] (Line %d): %s", states ? states->line : 0, buffer);

	}

private:

	bool m_bFileNameLogged;

	char m_File[PLATFORM_MAX_PATH];

	int m_LevelState;

	int m_IgnoreLevel;

} s_FlagReader;

AdminCache::AdminCache()

{

	m_pStrings = new BaseStringTable(1024);

	m_pMemory = m_pStrings->GetMemTable();

	m_FreeGroupList = m_FirstGroup = m_LastGroup = INVALID_GROUP_ID;

	m_FreeUserList = m_FirstUser = m_LastUser = INVALID_ADMIN_ID;

	m_pCacheFwd = NULL;

	m_FirstGroup = -1;

	m_InvalidatingAdmins = false;

	m_destroying = false;

}

AdminCache::~AdminCache()

{

	m_destroying = true;

	DumpAdminCache(AdminCache_Overrides, false);

	DumpAdminCache(AdminCache_Groups, false);

	List<AuthMethod *>::iterator iter;

	for (iter=m_AuthMethods.begin();

		 iter!=m_AuthMethods.end();

		 iter++)

	{

		delete *iter;

	}

	delete m_pStrings;

}

void AdminCache::OnSourceModStartup(bool late)

{

	RegisterAuthIdentType("steam");

	RegisterAuthIdentType("name");

	RegisterAuthIdentType("ip");

	NameFlag("reservation", Admin_Reservation);

	NameFlag("kick", Admin_Kick);

	NameFlag("generic", Admin_Generic);

	NameFlag("ban", Admin_Ban);

	NameFlag("unban", Admin_Unban);

	NameFlag("slay", Admin_Slay);

	NameFlag("changemap", Admin_Changemap);

	NameFlag("cvars", Admin_Convars);

	NameFlag("config", Admin_Config);

	NameFlag("chat", Admin_Chat);

	NameFlag("vote", Admin_Vote);

	NameFlag("password", Admin_Password);

	NameFlag("rcon", Admin_RCON);

	NameFlag("cheats", Admin_Cheats);

	NameFlag("root", Admin_Root);

	NameFlag("custom1", Admin_Custom1);

	NameFlag("custom2", Admin_Custom2);

	NameFlag("custom3", Admin_Custom3);

	NameFlag("custom4", Admin_Custom4);

	NameFlag("custom5", Admin_Custom5);

	NameFlag("custom6", Admin_Custom6);

}

void AdminCache::OnSourceModAllInitialized()

{

	m_pCacheFwd = forwardsys->CreateForward("OnRebuildAdminCache", ET_Ignore, 1, NULL, Param_Cell);

	sharesys->AddInterface(NULL, this);

}

void AdminCache::OnSourceModLevelChange(const char *mapName)

{

	int i;

	AdminFlag flag;

	/* For now, we only read these once per level. */

	s_FlagReader.LoadLevels();

	memset(g_ReverseFlags, '?', sizeof(g_ReverseFlags));

	for (i = 0; i < 26; i++)

	{

		if (FindFlag('a' + i, &flag))

		{

			g_ReverseFlags[flag] = 'a' + i;

		}

	}

}

void AdminCache::OnSourceModShutdown()

{

	forwardsys->ReleaseForward(m_pCacheFwd);

	m_pCacheFwd = NULL;

}

void AdminCache::OnSourceModPluginsLoaded()

{

	DumpAdminCache(AdminCache_Overrides, true);

	DumpAdminCache(AdminCache_Groups, true);

}

void AdminCache::NameFlag(const char *str, AdminFlag flag)

{

	m_LevelNames.insert(str, flag);

}

bool AdminCache::FindFlag(const char *str, AdminFlag *pFlag)

{

	return m_LevelNames.retrieve(str, pFlag);

}

void AdminCache::AddCommandOverride(const char *cmd, OverrideType type, FlagBits flags)

{

	FlagMap *map;

	if (type == Override_Command)

		map = &m_CmdOverrides;

	else if (type == Override_CommandGroup)

		map = &m_CmdGrpOverrides;

	else

		return;

	map->insert(cmd, flags);

	g_ConCmds.UpdateAdminCmdFlags(cmd, type, flags, false);

}

bool AdminCache::GetCommandOverride(const char *cmd, OverrideType type, FlagBits *pFlags)

{

	FlagMap *map;

	if (type == Override_Command)

		map = &m_CmdOverrides;

	else if (type == Override_CommandGroup)

		map = &m_CmdGrpOverrides;

	else

		return false;

	return map->retrieve(cmd, pFlags);

}

void AdminCache::UnsetCommandOverride(const char *cmd, OverrideType type)

{

	if (type == Override_Command)

	{

		return _UnsetCommandOverride(cmd);

	} else if (type == Override_CommandGroup) {

		return _UnsetCommandGroupOverride(cmd);

	}

}

void AdminCache::_UnsetCommandGroupOverride(const char *group)

{

	m_CmdGrpOverrides.remove(group);

	g_ConCmds.UpdateAdminCmdFlags(group, Override_CommandGroup, 0, true);

}

void AdminCache::_UnsetCommandOverride(const char *cmd)

{

	m_CmdOverrides.remove(cmd);

	g_ConCmds.UpdateAdminCmdFlags(cmd, Override_Command, 0, true);

}

void AdminCache::DumpCommandOverrideCache(OverrideType type)

{

	if (type == Override_Command)

		m_CmdOverrides.clear();

	else if (type == Override_CommandGroup)

		m_CmdGrpOverrides.clear();

}

AdminId AdminCache::CreateAdmin(const char *name)

{

	AdminId id;

	AdminUser *pUser;

	if (m_FreeUserList != INVALID_ADMIN_ID)

	{

		pUser = (AdminUser *)m_pMemory->GetAddress(m_FreeUserList);

		assert(pUser->magic == USR_MAGIC_UNSET);

		id = m_FreeUserList;

		m_FreeUserList = pUser->next_user;

	}

	else

	{

		id = m_pMemory->CreateMem(sizeof(AdminUser), (void **)&pUser);

		pUser->grp_size = 0;

		pUser->grp_table = -1;

	}

	pUser->flags = 0;

	pUser->eflags = 0;

	pUser->grp_count = 0;

	pUser->password = -1;

	pUser->magic = USR_MAGIC_SET;

	pUser->auth.identidx = -1;

	pUser->auth.index = 0;

	pUser->immunity_level = 0;

	pUser->serialchange = 1;

	if (m_FirstUser == INVALID_ADMIN_ID)

	{

		m_FirstUser = id;

		m_LastUser = id;

	}

	else

	{

		AdminUser *pPrev = (AdminUser *)m_pMemory->GetAddress(m_LastUser);

		pPrev->next_user = id;

		pUser->prev_user = m_LastUser;

		m_LastUser = id;

	}

	/* Since we always append to the tail, we should invalidate their next */

	pUser->next_user = -1;

	if (name && name[0] != '\0')

	{

		int nameidx = m_pStrings->AddString(name);

		pUser = (AdminUser *)m_pMemory->GetAddress(id);

		pUser->nameidx = nameidx;

	}

	else

	{

		pUser->nameidx = -1;

	}

	return id;

}

GroupId AdminCache::AddGroup(const char *group_name)

{

	if (m_Groups.contains(group_name))

		return INVALID_GROUP_ID;

	GroupId id;

	AdminGroup *pGroup;

	if (m_FreeGroupList != INVALID_GROUP_ID)

	{

		pGroup = (AdminGroup *)m_pMemory->GetAddress(m_FreeGroupList);

		assert(pGroup->magic == GRP_MAGIC_UNSET);

		id = m_FreeGroupList;

		m_FreeGroupList = pGroup->next_grp;

	} else {

		id = m_pMemory->CreateMem(sizeof(AdminGroup), (void **)&pGroup);

	}

	pGroup->immunity_level = 0;

	pGroup->immune_table = -1;

	pGroup->magic = GRP_MAGIC_SET;

	pGroup->next_grp = INVALID_GROUP_ID;

	pGroup->pCmdGrpTable = NULL;

	pGroup->pCmdTable = NULL;

	pGroup->addflags = 0;

	if (m_FirstGroup == INVALID_GROUP_ID)

	{

		m_FirstGroup = id;

		m_LastGroup = id;

		pGroup->prev_grp = INVALID_GROUP_ID;

	} else {

		AdminGroup *pPrev = (AdminGroup *)m_pMemory->GetAddress(m_LastGroup);

		assert(pPrev->magic == GRP_MAGIC_SET);

		pPrev->next_grp = id;

		pGroup->prev_grp = m_LastGroup;

		m_LastGroup = id;

	}

	int nameidx = m_pStrings->AddString(group_name);

	pGroup = (AdminGroup *)m_pMemory->GetAddress(id);

	pGroup->nameidx = nameidx;

	m_Groups.insert(group_name, id);

	return id;

}

GroupId AdminCache::FindGroupByName(const char *group_name)

{

	GroupId id;

	if (!m_Groups.retrieve(group_name, &id))

		return INVALID_GROUP_ID;

	AdminGroup *pGroup = (AdminGroup *)m_pMemory->GetAddress(id);

	if (!pGroup || pGroup->magic != GRP_MAGIC_SET)

		return INVALID_GROUP_ID;

	return id;

}

void AdminCache::SetGroupAddFlag(GroupId id, AdminFlag flag, bool enabled)

{

	AdminGroup *pGroup = (AdminGroup *)m_pMemory->GetAddress(id);

	if (!pGroup || pGroup->magic != GRP_MAGIC_SET)

	{

		return;

	}

	if (flag < Admin_Reservation || flag >= AdminFlags_TOTAL)

	{

		return;

	}

	FlagBits bits = (1<<(FlagBits)flag);

	if (enabled)

	{

		pGroup->addflags |= bits;

	} else {

		pGroup->addflags &= ~bits;

	}

}

bool AdminCache::GetGroupAddFlag(GroupId id, AdminFlag flag)

{

	AdminGroup *pGroup = (AdminGroup *)m_pMemory->GetAddress(id);

	if (!pGroup || pGroup->magic != GRP_MAGIC_SET)

	{

		return false;

	}

	if (flag < Admin_Reservation || flag >= AdminFlags_TOTAL)

	{

		return false;

	}

	FlagBits bit = 1<<(FlagBits)flag;

	return ((pGroup->addflags & bit) == bit);

}

FlagBits AdminCache::GetGroupAddFlags(GroupId id)

{

	AdminGroup *pGroup = (AdminGroup *)m_pMemory->GetAddress(id);

	if (!pGroup || pGroup->magic != GRP_MAGIC_SET)

	{

		return 0;

	}

	return pGroup->addflags;

}

const char *AdminCache::GetGroupName(GroupId gid)

{

	AdminGroup *pGroup = (AdminGroup *)m_pMemory->GetAddress(gid);

	if (!pGroup || pGroup->magic != GRP_MAGIC_SET)

	{

		return NULL;

	}

	return m_pStrings->GetString(pGroup->nameidx);

}

void AdminCache::SetGroupGenericImmunity(GroupId id, ImmunityType type, bool enabled)

{

	AdminGroup *pGroup = (AdminGroup *)m_pMemory->GetAddress(id);

	if (!pGroup || pGroup->magic != GRP_MAGIC_SET)

	{

		return;

	}

	unsigned int level = 0;

	if (enabled)

	{

		if (type == Immunity_Default)

		{

			level = 1;

		} else if (type == Immunity_Global) {