/**

 * vim: set ts=4 :

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

 * SourceMod Sample Extension

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

#include <stdarg.h>

#include "TopMenu.h"

struct obj_by_name_t

{

	unsigned int obj_index;

	char name[64];

};

int _SortObjectNamesDescending(const void *ptr1, const void *ptr2);

unsigned int strncopy(char *dest, const char *src, size_t count);

size_t UTIL_Format(char *buffer, size_t maxlength, const char *fmt, ...);

TopMenu::TopMenu(ITopMenuObjectCallbacks *callbacks)

{

	m_clients = NULL;

	m_SerialNo = 1;

	m_pTitle = callbacks;

	m_max_clients = 0;

	if (playerhelpers->IsServerActivated())

	{

		CreatePlayers(playerhelpers->GetMaxClients());

	}

}

TopMenu::~TopMenu()

{

	/* Delete all categories */

	while (m_Categories.size())

	{

		RemoveFromMenu(m_Categories[0]->obj->object_id);

	}

	/* Remove all objects */

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

	{

		assert(m_Objects[i]->is_free == true);

		delete m_Objects[i];

	}

	m_pTitle->OnTopMenuObjectRemoved(this, 0);

	/* Delete all cached config entries */

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

	{

		delete m_Config.cats[i];

	}

	/* Sweep players */

	for (size_t i = 0; i <= (size_t)m_max_clients; i++)

	{

		TearDownClient(&m_clients[i]);

	}

	delete [] m_clients;

}

unsigned int TopMenu::CalcMemUsage()

{

	unsigned int size = sizeof(TopMenu);

	size += m_Config.strings.GetMemTable()->MemUsage();

	size += (m_Config.cats.size() * sizeof(int));

	size += (sizeof(topmenu_player_t) * m_max_clients);

	size += (m_SortedCats.size() * sizeof(unsigned int));

	size += (m_UnsortedCats.size() * sizeof(unsigned int));

	size += (m_Categories.size() * (sizeof(topmenu_category_t *) + sizeof(topmenu_category_t)));

	size += (m_Objects.size() * (sizeof(topmenu_object_t *) + sizeof(topmenu_object_t)));

	size += m_ObjLookup.mem_usage();

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

	{

		size += m_Categories[i]->obj_list.size() * sizeof(topmenu_object_t *);

		size += m_Categories[i]->sorted.size() * sizeof(topmenu_object_t *);

		size += m_Categories[i]->unsorted.size() * sizeof(topmenu_object_t *);

	}

	return size;

}

void TopMenu::OnClientConnected(int client)

{

	if (m_clients == NULL)

	{

		return;

	}

	topmenu_player_t *player = &m_clients[client];

	TearDownClient(player);

}

void TopMenu::OnClientDisconnected(int client)

{

	if (m_clients == NULL)

	{

		return;

	}

	topmenu_player_t *player = &m_clients[client];

	TearDownClient(player);

}

void TopMenu::OnServerActivated(int max_clients)

{

	if (m_clients == NULL)

	{

		CreatePlayers(max_clients);

	}

}

unsigned int TopMenu::AddToMenu(const char *name,

								TopMenuObjectType type,

								ITopMenuObjectCallbacks *callbacks,

								IdentityToken_t *owner,

								const char *cmdname,

								FlagBits flags,

								unsigned int parent)

{

	return AddToMenu2(name, type, callbacks, owner, cmdname, flags, parent, NULL);

}

unsigned int TopMenu::AddToMenu2(const char *name,

								 TopMenuObjectType type,

								 ITopMenuObjectCallbacks *callbacks,

								 IdentityToken_t *owner,

								 const char *cmdname,

								 FlagBits flags,

								 unsigned int parent,

								 const char *info_string)

{

	/* Sanity checks */

	if (type == TopMenuObject_Category && parent != 0)

	{

		return 0;

	}

	else if (type == TopMenuObject_Item && parent == 0)

	{

		return 0;

	}

	else if (m_ObjLookup.retrieve(name) != NULL)

	{

		return 0;

	}

	else if (type != TopMenuObject_Item && type != TopMenuObject_Category)

	{

		return 0;

	}

	/* If we're adding an item, make sure the parent is valid, 

	 * and that the parent is a category.

	 */

	topmenu_object_t *parent_obj = NULL;

	topmenu_category_t *parent_cat = NULL;

	if (type == TopMenuObject_Item)

	{

		/* Check parent index.  Note it will be >= 1 here. */

		if (parent > m_Objects.size() || m_Objects[parent - 1]->is_free)

		{

			return 0;

		}

		parent_obj = m_Objects[parent - 1];

		/* Find an equivalent pointer in the category array. */

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

		{

			if (m_Categories[i]->obj == parent_obj)

			{

				parent_cat = m_Categories[i];

				break;

			}

		}

		/* If none was found, leave. */

		if (parent_cat == NULL)

		{

			return 0;

		}

	}

	/* Re-use an old object pointer if we can. */

	topmenu_object_t *obj = NULL;

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

	{

		if (m_Objects[i]->is_free == true)

		{

			obj = m_Objects[i];

			break;

		}

	}

	/* Otherwise, allocate a new one. */

	if (obj == NULL)

	{

		obj = new topmenu_object_t;

		obj->object_id = ((unsigned int)m_Objects.size()) + 1;

		m_Objects.push_back(obj);

	}

	/* Initialize the object's properties. */

	obj->callbacks = callbacks;

	obj->flags = flags;

	obj->owner = owner;

	obj->type = type;

	obj->is_free = false;

	obj->parent = parent_obj;

	strncopy(obj->name, name, sizeof(obj->name));

	strncopy(obj->cmdname, cmdname ? cmdname : "", sizeof(obj->cmdname));

	strncopy(obj->info, info_string ? info_string : "", sizeof(obj->info));

	if (obj->type == TopMenuObject_Category)

	{

		/* Create a new category entry */

		topmenu_category_t *cat = new topmenu_category_t;

		cat->obj = obj;

		cat->reorder = false;

		cat->serial = 1;

		/* Add it, then update our serial change number. */

		m_Categories.push_back(cat);

		m_SerialNo++;

		/* Updating sorting info */

		m_bCatsNeedResort = true;

	}

	else if (obj->type == TopMenuObject_Item)

	{

		/* Update the category, mark it as needing changes */

		parent_cat->obj_list.push_back(obj);

		parent_cat->reorder = true;

		parent_cat->serial++;

		/* If the category just went from 0 to 1 items, mark it as 

		 * changed, so clients get the category drawn.

		 */

		if (parent_cat->obj_list.size() == 1)

		{

			m_SerialNo++;

		}

	}

	m_ObjLookup.insert(name, obj);

	return obj->object_id;

}

const char *TopMenu::GetObjectInfoString(unsigned int object_id)

{

	if (object_id == 0 

		|| object_id > m_Objects.size() 

		|| m_Objects[object_id - 1]->is_free)

	{

		return NULL;

	}

	topmenu_object_t *obj = m_Objects[object_id - 1];

	return obj->info;

}

const char *TopMenu::GetObjectName(unsigned int object_id)

{

	if (object_id == 0 

		|| object_id > m_Objects.size() 

		|| m_Objects[object_id - 1]->is_free)

	{

		return NULL;

	}

	topmenu_object_t *obj = m_Objects[object_id - 1];

	return obj->name;

}

void TopMenu::RemoveFromMenu(unsigned int object_id)

{

	if (object_id == 0 

		|| object_id > m_Objects.size() 

		|| m_Objects[object_id - 1]->is_free)

	{

		return;

	}

	topmenu_object_t *obj = m_Objects[object_id - 1];

	m_ObjLookup.remove(obj->name);

	if (obj->type == TopMenuObject_Category)

	{

		/* Find it in the category list. */

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

		{

			if (m_Categories[i]->obj == obj)

			{

				/* Mark all children as removed + free.  Note we could

				 * call into RemoveMenuItem() for this, but it'd be very 

				 * inefficient!

				 */

				topmenu_category_t *cat = m_Categories[i];

				for (size_t j = 0; j < m_Categories[i]->obj_list.size(); j++)

				{

					cat->obj_list[j]->callbacks->OnTopMenuObjectRemoved(this, cat->obj_list[j]->object_id);

					cat->obj_list[j]->is_free = true;

				}

				/* Remove the category from the list, then delete it. */

				m_Categories.erase(m_Categories.iterAt(i));

				delete cat;

				break;

			}

		}

		/* Update the root as changed. */

		m_SerialNo++;

		m_bCatsNeedResort = true;

	}

	else if (obj->type == TopMenuObject_Item)

	{

		/* Find the category this item is in. */

		topmenu_category_t *parent_cat = NULL;

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

		{

			if (m_Categories[i]->obj == obj->parent)

			{

				parent_cat = m_Categories[i];

				break;

			}

		}

		/* Erase it from the category's lists. */

		if (parent_cat)

		{

			for (size_t i = 0; i < parent_cat->obj_list.size(); i++)

			{

				if (parent_cat->obj_list[i] == obj)

				{

					parent_cat->obj_list.erase(parent_cat->obj_list.iterAt(i));

					/* If this category now has no items, mark root as changed 

					 * so clients won't get the category drawn anymore.

					 */

					if (parent_cat->obj_list.size() == 0)

					{

						m_SerialNo++;

					}

					break;

				}

			}

			/* Update the category as changed. */

			parent_cat->reorder = true;

			parent_cat->serial++;

		}

	}

	/* The callbacks pointer is still valid, so fire away! */

	obj->callbacks->OnTopMenuObjectRemoved(this, object_id);

	/* Finally, mark the object as free. */

	obj->is_free = true;

}

bool TopMenu::DisplayMenu(int client, unsigned int hold_time, TopMenuPosition position)

{

	if (m_clients == NULL)

	{

		return false;

	}

	IGamePlayer *pPlayer = playerhelpers->GetGamePlayer(client);

	if (!pPlayer->IsInGame())

	{

		return false;

	}

	UpdateClientRoot(client, pPlayer);

	topmenu_player_t *pClient = &m_clients[client];

	if (pClient->root == NULL)

	{

		return false;

	}

	bool return_value = false;

	if (position == TopMenuPosition_LastCategory && 

		pClient->last_category < m_Categories.size())

	{

		return_value = DisplayCategory(client, pClient->last_category, hold_time, true);

		if (!return_value)

		{

			return_value = pClient->root->DisplayAtItem(client, hold_time, pClient->last_root_pos);

		}

	}

	else if (position == TopMenuPosition_LastRoot)

	{

		pClient->root->DisplayAtItem(client, hold_time, pClient->last_root_pos);

	}

	else if (position == TopMenuPosition_Start)

	{

		pClient->last_position = 0;

		pClient->last_category = 0;

		return_value = pClient->root->Display(client, hold_time);

	}

	return return_value;

}

bool TopMenu::DisplayCategory(int client, unsigned int category, unsigned int hold_time, bool last_position)

{

	UpdateClientCategory(client, category);

	topmenu_player_t *pClient = &m_clients[client];

	if (category >= pClient->cat_count

		|| pClient->cats[category].menu == NULL)

	{

		return false;

	}

	bool return_value = false;

	topmenu_player_category_t *player_cat = &(pClient->cats[category]);

	pClient->last_category = category;

	if (last_position)

	{

		return_value = player_cat->menu->DisplayAtItem(client, hold_time, pClient->last_position);

	}

	else

	{

		return_value = player_cat->menu->Display(client, hold_time);

	}

	return return_value;

}

void TopMenu::OnMenuSelect2(IBaseMenu *menu, int client, unsigned int item, unsigned int item_on_page)

{

	const char *item_name = menu->GetItemInfo(item, NULL);

	if (!item_name)

	{

		return;

	}

	topmenu_object_t *obj;

	topmenu_player_t *pClient = &m_clients[client];

	topmenu_object_t **pObject = m_ObjLookup.retrieve(item_name);

	if (pObject == NULL)

	{

		return;

	}

	obj = *pObject;

	/* We now have the object... what do we do with it? */

	if (obj->type == TopMenuObject_Category)

	{

		/* If it's a category, the user wants to view it.. */

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

		{

			if (m_Categories[i]->obj == obj)

			{

				pClient->last_root_pos = item_on_page;

				if (!DisplayCategory(client, (unsigned int)i, MENU_TIME_FOREVER, false))

				{

					/* If we can't display the category, re-display the root menu */

					DisplayMenu(client, MENU_TIME_FOREVER, TopMenuPosition_LastRoot);

				}

				break;

			}

		}

	}

	else

	{

		pClient->last_position = item_on_page;

		/* Re-check access in case this user had their credentials revoked */

		if (obj->cmdname[0] != '\0' && !adminsys->CheckAccess(client, obj->cmdname, obj->flags, false))

		{

			DisplayMenu(client, 0, TopMenuPosition_LastCategory);

			return;

		}

		/* Pass the information on to the callback */

		obj->callbacks->OnTopMenuSelectOption(this, client, obj->object_id);

	}

}

void TopMenu::OnMenuDrawItem(IBaseMenu *menu, int client, unsigned int item, unsigned int &style)

{

	const char *item_name = menu->GetItemInfo(item, NULL);

	if (!item_name)

	{

		return;

	}

	topmenu_object_t *obj;

	topmenu_object_t **pObject = m_ObjLookup.retrieve(item_name);

	if (pObject == NULL)

	{

		return;

	}

	obj = *pObject;

	style = obj->callbacks->OnTopMenuDrawOption(this, client, obj->object_id);

	if (style != ITEMDRAW_DEFAULT)

	{

		return;

	}

	if (obj->cmdname[0] == '\0')

	{

		return;

	}

	if (!adminsys->CheckAccess(client, obj->cmdname, obj->flags, false))

	{

		style = ITEMDRAW_IGNORE;

	}

}

unsigned int TopMenu::OnMenuDisplayItem(IBaseMenu *menu,

								int client,

								IMenuPanel *panel,

								unsigned int item,

								const ItemDrawInfo &dr)

{

	const char *item_name = menu->GetItemInfo(item, NULL);

	if (!item_name)

	{

		return 0;

	}

	topmenu_object_t *obj;

	topmenu_object_t **pObject = m_ObjLookup.retrieve(item_name);

	if (pObject == NULL)