/**

 * 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;

}

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)

{

	/* 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));

	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;

}

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++;

		}

	}

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

	obj->is_free = true;

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

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

}

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);

	}

	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;

				DisplayCategory(client, (unsigned int)i, MENU_TIME_FOREVER, false);

				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;

	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)

	{

		return 0;

	}

	obj = *pObject;

	/* Ask the object to render the text for this client */

	char renderbuf[64];

	obj->callbacks->OnTopMenuDrawOption(this, client, obj->object_id, renderbuf, sizeof(renderbuf));

	/* Build the new draw info */

	ItemDrawInfo new_dr = dr;

	new_dr.display = renderbuf;

	/* Man I love the menu API.  Ask the panel to draw the item and give the position 

	 * back to Core's renderer.  This way we don't have to worry about keeping the 

	 * render buffer static!

	 */

	return panel->DrawItem(new_dr);

}

void TopMenu::OnMenuCancel(IBaseMenu *menu, int client, MenuCancelReason reason)

{

	if (reason == MenuCancel_ExitBack)

	{

		/* If the client chose exit back, they were on a category menu, and we can

		 * now display the root menu from the last known position.

		 */

		DisplayMenu(client, 0, TopMenuPosition_LastRoot);

	}

}

void TopMenu::UpdateClientRoot(int client, IGamePlayer *pGamePlayer)

{

	topmenu_player_t *pClient = &m_clients[client];

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

	/* Determine if an update is necessary */

	bool is_update_needed = false;

	if (pClient->menu_serial != m_SerialNo)

	{

		is_update_needed = true;

	}

	else if (pPlayer->GetUserId() != pClient->user_id)

	{

		is_update_needed = true;

	}

	/* If no update is needed at the root level, just leave now */

	if (!is_update_needed)

	{

		return;

	}

	/* First we need to flush the cache... */

	TearDownClient(pClient);

	/* Now, rebuild the category list, but don't create menus */

	if (m_Categories.size() == 0)

	{

		pClient->cat_count = 0;

		pClient->cats = NULL;

	}

	else

	{

		pClient->cat_count = (unsigned int)m_Categories.size();

		pClient->cats = new topmenu_player_category_t[pClient->cat_count];

		memset(pClient->cats, 0, sizeof(topmenu_player_category_t) * pClient->cat_count);

	}

	/* Re-sort the root categories if needed */

	SortCategoriesIfNeeded();

	/* Build the root menu */

	IBaseMenu *root_menu = menus->GetDefaultStyle()->CreateMenu(this, myself->GetIdentity());

	/* Add the sorted items */

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

	{

		if (m_Categories[m_SortedCats[i]]->obj_list.size() == 0)

		{

			continue;

		}

		root_menu->AppendItem(m_Categories[m_SortedCats[i]]->obj->name, ItemDrawInfo(""));

	}

	/* Now we need to handle un-sorted items.  This is slightly trickier, as we need to 

	 * pre-render each category name, and cache those names.  Phew!

	 */

	if (m_UnsortedCats.size())

	{

		obj_by_name_t *item_list = new obj_by_name_t[m_UnsortedCats.size()];

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