/**

 * vim: set ts=4 :

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

 * SourceMod

 * Copyright (C) 2004-2007 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 "AdminCache.h"

#include "ShareSys.h"

#include "ForwardSys.h"

#include "PlayerManager.h"

#include "ConCmdManager.h"

AdminCache g_Admins;

AdminCache::AdminCache()

{

	m_pCmdOverrides = sm_trie_create();

	m_pCmdGrpOverrides = sm_trie_create();

	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_pGroups = sm_trie_create();

	m_pCacheFwd = NULL;

	m_FirstGroup = -1;

	m_pAuthTables = sm_trie_create();

	m_InvalidatingAdmins = false;

	m_destroying = false;

}

AdminCache::~AdminCache()

{

	m_destroying = true;

	DumpAdminCache(AdminCache_Overrides, false);

	DumpAdminCache(AdminCache_Groups, false);

	sm_trie_destroy(m_pCmdGrpOverrides);

	sm_trie_destroy(m_pCmdOverrides);

	if (m_pGroups)

	{

		sm_trie_destroy(m_pGroups);

	}

	List<AuthMethod>::iterator iter;

	for (iter=m_AuthMethods.begin();

		 iter!=m_AuthMethods.end();

		 iter++)

	{

		sm_trie_destroy((*iter).table);

	}

	sm_trie_destroy(m_pAuthTables);

	delete m_pStrings;

}

void AdminCache::OnSourceModStartup(bool late)

{

	RegisterAuthIdentType("steam");

	RegisterAuthIdentType("name");

	RegisterAuthIdentType("ip");

}

void AdminCache::OnSourceModAllInitialized()

{

	m_pCacheFwd = g_Forwards.CreateForward("OnRebuildAdminCache", ET_Ignore, 1, NULL, Param_Cell);

	g_ShareSys.AddInterface(NULL, this);

}

void AdminCache::OnSourceModShutdown()

{

	g_Forwards.ReleaseForward(m_pCacheFwd);

	m_pCacheFwd = NULL;

}

void AdminCache::OnSourceModPluginsLoaded()

{

	DumpAdminCache(AdminCache_Overrides, true);

	DumpAdminCache(AdminCache_Groups, true);

}

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

{

	Trie *pTrie = NULL;

	if (type == Override_Command)

	{

		pTrie = m_pCmdOverrides;

	} else if (type == Override_CommandGroup) {

		pTrie = m_pCmdGrpOverrides;

	} else {

		return;

	}

	sm_trie_insert(pTrie, cmd, (void *)(unsigned int)flags);

	g_ConCmds.UpdateAdminCmdFlags(cmd, type, flags);

}

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

{

	Trie *pTrie = NULL;

	if (type == Override_Command)

	{

		pTrie = m_pCmdOverrides;

	} else if (type == Override_CommandGroup) {

		pTrie = m_pCmdGrpOverrides;

	} else {

		return false;

	}

	void *object;

	if (sm_trie_retrieve(pTrie, cmd, &object))

	{

		if (pFlags)

		{

			*pFlags = (FlagBits)object;

		}

		return true;

	}

	return false;

}

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)

{

	if (!m_pCmdGrpOverrides)

	{

		return;

	}

	sm_trie_delete(m_pCmdGrpOverrides, group);

	g_ConCmds.UpdateAdminCmdFlags(group, Override_CommandGroup, 0);

}

void AdminCache::_UnsetCommandOverride(const char *cmd)

{

	if (!m_pCmdOverrides)

	{

		return;

	}

	sm_trie_delete(m_pCmdOverrides, cmd);

	g_ConCmds.UpdateAdminCmdFlags(cmd, Override_Command, 0);

}

void AdminCache::DumpCommandOverrideCache(OverrideType type)

{

	if (type == Override_Command && m_pCmdOverrides)

	{

		sm_trie_clear(m_pCmdOverrides);

	} else if (type == Override_CommandGroup && m_pCmdGrpOverrides) {

		sm_trie_clear(m_pCmdGrpOverrides);

	}

}

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->immune_default = false;

	pUser->immune_global = false;

	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;

	}

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

	{

		pUser->nameidx = m_pStrings->AddString(name);

	}

	return id;

}

GroupId AdminCache::AddGroup(const char *group_name)

{

	if (sm_trie_retrieve(m_pGroups, group_name, NULL))

	{

		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->immune_default = false;

	pGroup->immune_global = false;

	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;

	}

	pGroup->nameidx = m_pStrings->AddString(group_name);

	sm_trie_insert(m_pGroups, group_name, (void *)id);

	return id;

}

GroupId AdminCache::FindGroupByName(const char *group_name)

{

	void *object;

	if (!sm_trie_retrieve(m_pGroups, group_name, &object))

	{

		return INVALID_GROUP_ID;

	}

	GroupId id = (GroupId)object;

	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;

}

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

{

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

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

	{

		return;

	}

	if (type == Immunity_Default)

	{

		pGroup->immune_default = enabled;

	} else if (type == Immunity_Global) {

		pGroup->immune_global = enabled;

	} 

}

bool AdminCache::GetGroupGenericImmunity(GroupId id, ImmunityType type)

{

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

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

	{

		return false;

	}

	if (type == Immunity_Default)

	{

		return pGroup->immune_default;

	} else if (type == Immunity_Global) {

		return pGroup->immune_global;

	}

	return false;

}

void AdminCache::AddGroupImmunity(GroupId id, GroupId other_id)

{

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

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

	{

		return;

	}

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

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

	{

		return;

	}

	/* We always need to resize the immunity table */

	int *table, tblidx;

	if (pOther->immune_table == -1)

	{

		tblidx = m_pMemory->CreateMem(sizeof(int) * 2, (void **)&table);

		table[0] = 0;

	} else {

		int *old_table = (int *)m_pMemory->GetAddress(pOther->immune_table);

		/* Break out if this group is already in the list */

		for (int i=0; i<old_table[0]; i++)

		{

			if (old_table[1+i] == other_id)

			{

				return;

			}

		}

		tblidx = m_pMemory->CreateMem(sizeof(int) * (old_table[0] + 2), (void **)&table);

		/* Get the old address again in case of resize */

		old_table = (int *)m_pMemory->GetAddress(pOther->immune_table);

		table[0] = old_table[0];

		for (unsigned int i=1; i<=(unsigned int)old_table[0]; i++)

		{

			table[i] = old_table[i];

		}

	}

	/* Assign */

	pOther->immune_table = tblidx;

	/* Add to the array */

	table[0]++;

	table[table[0]] = other_id;

}

unsigned int AdminCache::GetGroupImmunityCount(GroupId id)

{

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

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

	{

		return 0;

	}

	if (pGroup->immune_table == -1)

	{

		return 0;

	}

	int *table = (int *)m_pMemory->GetAddress(pGroup->immune_table);

	return table[0];

}

GroupId AdminCache::GetGroupImmunity(GroupId id, unsigned int number)

{

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

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

	{

		return INVALID_GROUP_ID;

	}

	if (pGroup->immune_table == -1)

	{

		return INVALID_GROUP_ID;

	}

	int *table = (int *)m_pMemory->GetAddress(pGroup->immune_table);

	if (number >= (unsigned int)table[0])

	{

		return INVALID_GROUP_ID;

	}

	return table[1 + number];

}

void AdminCache::AddGroupCommandOverride(GroupId id, const char *name, OverrideType type, OverrideRule rule)

{

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

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

	{

		return;

	}

	Trie *pTrie = NULL;

	if (type == Override_Command)

	{

		if (pGroup->pCmdTable == NULL)

		{

			pGroup->pCmdTable = sm_trie_create();

		}

		pTrie = pGroup->pCmdTable;

	} else if (type == Override_CommandGroup) {

		if (pGroup->pCmdGrpTable == NULL)

		{

			pGroup->pCmdGrpTable = sm_trie_create();

		}

		pTrie = pGroup->pCmdGrpTable;

	} else {

		return;

	}

	sm_trie_insert(pTrie, name, (void *)(int)rule);

}

bool AdminCache::GetGroupCommandOverride(GroupId id, const char *name, OverrideType type, OverrideRule *pRule)

{

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

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

	{

		return false;

	}

	Trie *pTrie = NULL;

	if (type == Override_Command)

	{

		if (pGroup->pCmdTable == NULL)

		{

			return false;

		}

		pTrie = pGroup->pCmdTable;

	} else if (type == Override_CommandGroup) {

		if (pGroup->pCmdGrpTable == NULL)

		{

			return false;

		}

		pTrie = pGroup->pCmdGrpTable;

	} else {

		return false;

	}

	void *object;

	if (!sm_trie_retrieve(pTrie, name, &object))

	{

		return false;

	}

	if (pRule)

	{

		*pRule = (OverrideRule)(int)object;

	}

	return true;

}

Trie *AdminCache::GetMethodByIndex(unsigned int index)

{

	List<AuthMethod>::iterator iter;

	for (iter=m_AuthMethods.begin();

		 iter!=m_AuthMethods.end();

		 iter++)

	{

		if (index-- == 0)

		{

			return (*iter).table;

		}

	}

	return NULL;

}

bool AdminCache::InvalidateAdmin(AdminId id)