#include "stdafx.h"
#include "stdafx.h"
#include "ArenaMenuSystem.h"
#include "CommonUtil.h"
//#include "KUIControl.h"
#include "SStringDB.h"

#define ARENA_MENU_ITEM_HEIGHT	21

struct sFoldFunctor
{
	template <typename T>
	void operator ()(T* t)
	{
		t->fold();
	}
};

template <typename TYPE, typename T>
void safeStlPointerDelete(T& t)
{
	TYPE::iterator it = t.begin();
	for (; it != t.end(); ++it)
	{
		SAFE_DELETE(*it);
	}
	t.clear();
}

sArenaMenuItemControl::sArenaMenuItemControl(KUIControl* control, int offsetY) : m_offsetY(offsetY)
{
	m_control = control;
	if (m_control)
	{
		m_control->SetEnableColor("<#ffffff>");
		m_control->SetDisableColor("<#a0a0a0>");
		m_control->SetEnableOption(true);
	}
}

sArenaMenuItem::~sArenaMenuItem()
{
	m_controlList.clear();
}

void sArenaMenuItem::addControl(KUIControl* control, int offsetY)
{
	m_controlList.push_back(sArenaMenuItemControl(control, offsetY));
}

void sArenaMenuItem::fold()
{
	setShow(false);
}

void sArenaMenuItem::unFold(int y)
{
	struct sItemControlUnFoldFunctor
	{
		sItemControlUnFoldFunctor(int y) : m_y(y) {}
		void operator ()(sArenaMenuItemControl& itemControl)
		{
			int x = itemControl.m_control->GetRect().left;
			itemControl.m_control->SetShow(true);
			itemControl.m_control->MovePos(x, m_y + itemControl.m_offsetY);
		}
		int m_y;
	};

	std::for_each(m_controlList.begin(), m_controlList.end(), sItemControlUnFoldFunctor(y));
}

void sArenaMenuItem::setShow(bool show)
{
	struct sItemControlVisibleFunctor
	{
		sItemControlVisibleFunctor(bool show) : m_show(show) {}
		void operator ()(sArenaMenuItemControl& itemControl)
		{
			itemControl.m_control->SetShow(m_show);
		}

		bool m_show;
	};

	std::for_each(m_controlList.begin(), m_controlList.end(), sItemControlVisibleFunctor(show));
}

void sArenaMenuItem::setEnable(bool enable)
{
	struct sItemControlEnableFunctor
	{
		sItemControlEnableFunctor(bool enable) : m_enable(enable) {}
		void operator ()(sArenaMenuItemControl& itemControl)
		{
			if (m_enable)
				itemControl.m_control->Enable();
			else
				itemControl.m_control->Disable();
		}

		bool m_enable;
	};

	std::for_each(m_controlList.begin(), m_controlList.end(), sItemControlEnableFunctor(enable));
}

void sArenaMenuItem::move(int y)
{
	struct sItemControlMoveFunctor
	{
		sItemControlMoveFunctor(int y) : m_y(y) {}
		void operator ()(sArenaMenuItemControl& itemControl)
		{
			int x = itemControl.m_control->GetRect().left;
			itemControl.m_control->MovePos(x, m_y + itemControl.m_offsetY);
		}
		int m_y;
	};

	std::for_each(m_controlList.begin(), m_controlList.end(), sItemControlMoveFunctor(y));
}

sArenaSubMenu::~sArenaSubMenu()
{
	SAFE_DELETE(m_item);
}

void sArenaSubMenu::setItem(sArenaMenuItem* item)
{
	SAFE_DELETE(m_item);
	m_item = item;
}

void sArenaSubMenu::fold()
{
	if (NULL == m_item)
	{
		assert(!m_item && "m_item is null");
		return ;
	}
	m_item->fold();
}

void sArenaSubMenu::unFold(int y)
{
	if (NULL == m_item)
	{
		assert(!m_item && "m_item is null");
		return ;
	}
	m_item->unFold(y);
}

void sArenaSubMenu::setEnable(bool enable)
{
	if (NULL == m_item)
	{
		assert(!m_item && "m_item is null");
		return ;
	}
	m_item->setEnable(enable);
}

char const* sArenaSubMenu::getName()
{
	if (0 > m_nameId)
		return "";
	return S(m_nameId);
}

sArenaMainMenu::sArenaMainMenu() : m_isSelect(false),
											    m_isFold(false),
												m_foldButton(NULL),
												m_selectNameControl(NULL),
												m_nextMainMenu(NULL),
												m_selectSubMenuId(-1)
{
}

sArenaMainMenu::~sArenaMainMenu()
{
	safeStlPointerDelete<std::vector<sArenaSubMenu*> >(m_subMenuList);
}

void sArenaMainMenu::setFoldButton(KUIWnd* control)
{
	assert(!control && "fold button control is null");
	m_foldButton = dynamicCast<KUIControl*>(control);
}

void sArenaMainMenu::addSubMenu(SUIWnd* wnd, int subMenuId, char const* basisControlId, int tooltipStringId, int selectNameStringId, int itemCount, ...)
{
	/// sub menu
	sArenaSubMenu* subMenu = new sArenaSubMenu;
	subMenu->setNameId(selectNameStringId);
	subMenu->setId(subMenuId);

	KUIControl* basisControl = dynamicCast<KUIControl*>(wnd->GetChild(basisControlId));
	int basisY = basisControl->GetRect().top;

	if (0 <= tooltipStringId)
		basisControl->SetTooltip(S(tooltipStringId));

	/// item
	sArenaMenuItem* item = new sArenaMenuItem;
	va_list args;
	va_start(args, itemCount);
	for (int i = 0; i < itemCount; ++i)
	{		
		KUIControl* control = dynamicCast<KUIControl*>(wnd->GetChild(va_arg(args, char*)));
		control->SetEnableColor("<#ffffff>");
		control->SetDisableColor("<#a0a0a0>");
		int offsetY = control->GetRect().top - basisY;
		item->addControl(control, offsetY);
	}
	va_end(args);
	subMenu->setItem(item);

	addSubMenu(subMenu);
}
void sArenaMainMenu::addSubMenu(sArenaSubMenu* subMenu)
{
	m_subMenuList.push_back(subMenu);
}

void sArenaMainMenu::addItemControl(SUIWnd* wnd, char const* basisControlId, int selectStatus, int itemCount, ...)
{
	KUIWnd* basisControl = wnd->GetChild(basisControlId);
	int basisY = basisControl->GetRect().top;

	va_list args;
	va_start(args, itemCount);
	for (int i = 0; i < itemCount; ++i)
	{
		KUIControl* control = dynamicCast<KUIControl*>(wnd->GetChild(va_arg(args, char*)));
		addItemControl(control, basisY, selectStatus);
	}
	va_end(args);
}

void sArenaMainMenu::addItemControl(KUIControl* control, int basisY, int selectStatus)
{
	int offsetY = control->GetRect().top - basisY;
	m_item[selectStatus].addControl(control, offsetY);
}

void sArenaMainMenu::unfold(int& y)
{
	m_isFold = false;

	itemUnFold(y);
	subMenuUnFold(y);	
	checkFoldButtonStatus();
}

void sArenaMainMenu::itemUnFold(int& y)
{
	for (int i = 0; i < MAX_ITEM; ++i)
	{
		/// show = true가 되면 안되기 때문에 move를 호출해 준다
		m_item[i].move(y);
	}
	y += ARENA_MENU_ITEM_HEIGHT;
}

void sArenaMainMenu::subMenuUnFold(int &y)
{
	std::vector<sArenaSubMenu*>::iterator it = m_subMenuList.begin();
	for (; it != m_subMenuList.end(); ++it)
	{
		(*it)->unFold(y);
		y += ARENA_MENU_ITEM_HEIGHT;
	}
}

void sArenaMainMenu::fold(int& y)
{
	m_isFold = true;

	itemFold(y);
	subMenuFold();
	checkFoldButtonStatus();
}

void sArenaMainMenu::itemFold(int& y)
{
	/// 이동되고 보여야 되기 때문에 fold()가 아니고 move를 호출 한다.
	for (int i = 0; i < MAX_ITEM; ++i)
	{
		m_item[i].move(y);
	}
	y += ARENA_MENU_ITEM_HEIGHT;
}

void sArenaMainMenu::subMenuFold()
{
	std::for_each(m_subMenuList.begin(), m_subMenuList.end(), sFoldFunctor());
}

void sArenaMainMenu::checkFoldButtonStatus()
{
	char const* aniName;
	bool enable;
	int tooltipId;
	if (m_isSelect)
	{
		tooltipId = 2377;
		enable = true;
		aniName = "common_button_copper_left";
	}
	else
	{
		if (m_isFold)
		{
			tooltipId = 2375;
			enable = true;
			aniName = "common_button_copper_unfold";
		}
		else
		{
			tooltipId = 2376;
			enable = false;
			aniName = "common_button_copper_fold";
		}
	}

	m_foldButton->SetAniName(aniName);
	m_foldButton->SetTooltip(S(tooltipId));
	setEnableFold(enable);
}

void sArenaMainMenu::setSelect(int subMenuId, bool select)
{
	m_isSelect = select;
	setSelectSubMenuId(subMenuId);
	setSelectSubMenuName(subMenuId);

	if (m_isSelect)
	{
		m_item[SELECT_ITEM].setShow(true);
		m_item[NONSELECT_ITEM].setShow(false);
	}
	else
	{
		m_item[SELECT_ITEM].setShow(false);
		m_item[NONSELECT_ITEM].setShow(true);
	}
	checkFoldButtonStatus();
}

void sArenaMainMenu::setEnableSubMenu(int subMenuId, bool enable)
{
	sArenaSubMenu* subMenu = getSubMenu(subMenuId);
	if (!subMenu)
		return ;

	subMenu->setEnable(enable);
}

void sArenaMainMenu::syncFoldButtonAniName()
{
	char const* aniName = NULL;
	if (m_isSelect)
	{
		aniName = "common_button_copper_left";
	}
	else
	{
		if (m_isFold)
		{
			aniName = "common_button_copper_fold";
		}
		else
		{
			aniName = "common_button_copper_unfold";
		}
	}

	assert(!aniName && "aniname is null");
	m_foldButton->SetAniName(aniName);
}

void sArenaMainMenu::setEnableFold(bool enable)
{
	if (enable)
		m_foldButton->Enable();
	else
		m_foldButton->Disable();
}

void sArenaMainMenu::setSelectSubMenuName(int subMenuId)
{
	sArenaSubMenu* subMenu = getSubMenu(subMenuId);
	if (!subMenu)
		return ;
	if (!m_selectNameControl)
	{
		assert(0 && "m_selectNameControl is null");
		return ;
	}

	std::string name = "<font:font_01><size:9><#898989><b><right>";
	name += subMenu->getName();
	m_selectNameControl->SetCaption(name.c_str());
}

sArenaSubMenu* sArenaMainMenu::getSubMenu(int subMenuId)
{
	if (0 > subMenuId)
		return NULL;

	int subMenuSize = (int)m_subMenuList.size();
	if (subMenuSize <= subMenuId)
	{
		assert(0 && "failed getSubMenu : invalid sub menui id");
		return NULL;
	}
	for (int i = 0; i < subMenuSize; ++i)
	{
		if (m_subMenuList[i]->getId() == subMenuId)
			return m_subMenuList[i];
	}
	return NULL;
}

sArenaMenuSystem::~sArenaMenuSystem()
{
	safeStlPointerDelete<std::list<sArenaMainMenu*> >(m_mainMenuList);
}

void sArenaMenuSystem::addMainMenu(sArenaMainMenu* mainMenu)
{
	if (!m_mainMenuList.empty())
	{
		m_mainMenuList.back()->setNextMainMenu(mainMenu);
	}

	m_mainMenuList.push_back(mainMenu);
}

void sArenaMenuSystem::unfold(int mainMenuId)
{
	int y = getBasisY();

	std::list<sArenaMainMenu*>::iterator it = m_mainMenuList.begin();
	for (; it != m_mainMenuList.end(); ++it)
	{
		sArenaMainMenu* mainMenu = *it;
		if (mainMenu->getId() == mainMenuId)
		{
			mainMenu->unfold(y);
		}
		else
		{
			mainMenu->fold(y);
		}
	}
}

void sArenaMenuSystem::allFold()
{
	int y = getBasisY();
	std::list<sArenaMainMenu*>::iterator it = m_mainMenuList.begin();
	for (; it != m_mainMenuList.end(); ++it)
	{
		(*it)->fold(y);
	}
}

void sArenaMenuSystem::setEnableFold(int mainMenuId, bool enable)
{
	sArenaMainMenu* mainMenu = findMainMenu(mainMenuId);
	if (NULL == mainMenu)
		return ;
	mainMenu->setEnableFold(enable);
}

void sArenaMenuSystem::setSelect(int mainMenuId, int subMenuId, bool select)
{
	sArenaMainMenu* mainMenu = findMainMenu(mainMenuId);
	if (NULL == mainMenu)
		return ;
	mainMenu->setSelect(subMenuId, select);
}

void sArenaMenuSystem::setSelectMenuItem(int mainMenuId, int subMenuId, bool& _isAllSelected)
{
	setSelect(mainMenuId, subMenuId, true);
	if (isAllSelected())
	{
		_isAllSelected = true;
		allFold();
	}
	else
	{
		_isAllSelected = false;
		setNextUnFold(mainMenuId);
	}
}

void sArenaMenuSystem::setEnableMenuItem(int mainMenuId, int subMenuId, bool enable)
{
	sArenaMainMenu* mainMenu = findMainMenu(mainMenuId);
	if (NULL == mainMenu)
		return ;
	mainMenu->setEnableSubMenu(subMenuId, enable);
}

void sArenaMenuSystem::setNextUnFold(int mainMenuId)
{
	sArenaMainMenu* mainMenu = findMainMenu(mainMenuId);
	if (NULL == mainMenu)
		return ;

	sArenaMainMenu* nextMainMenu = mainMenu->getNextMainMenu();
	if (nextMainMenu)
	{
		if (nextMainMenu->isSelected())
		{
			setUnSelectedToUnFold();
		}
		else
		{
			unfold(nextMainMenu->getId());
		}
	}
	else
	{
		setUnSelectedToUnFold();
	}
}

void sArenaMenuSystem::setUnSelectedToUnFold()
{
	std::list<sArenaMainMenu*>::iterator it = m_mainMenuList.begin();
	for (; it != m_mainMenuList.end(); ++it)
	{
		sArenaMainMenu* mainMenu = *it;
		if (!mainMenu->isSelected())
		{
			unfold(mainMenu->getId());
			return ;
		}
	}
}

sArenaMainMenu* sArenaMenuSystem::findMainMenu(int mainMenuId) const
{
	std::list<sArenaMainMenu*>::const_iterator it = m_mainMenuList.begin();
	for (; it != m_mainMenuList.end(); ++it)
	{
		sArenaMainMenu* mainMenu = *it;
		if (mainMenu->getId() == mainMenuId)
		{
			return mainMenu;
		}
	}
	assert(0 && "failed find main menu");
	return NULL;
}

bool sArenaMenuSystem::isAllSelected() const
{
	std::list<sArenaMainMenu*>::const_iterator it = m_mainMenuList.begin();
	for (; it != m_mainMenuList.end(); ++it)
	{
		if (!(*it)->isSelected())
			return false;
	}
	return true;
}

bool sArenaMenuSystem::isSelected(int mainMenuId) const
{
	sArenaMainMenu* mainMenu = findMainMenu(mainMenuId);
	if (NULL == mainMenu)
		return false;
	return mainMenu->isSelected();
}

void sArenaMenuSystem::initMenu(int unfoldMainMenuId)
{
	int y = getBasisY();

	std::list<sArenaMainMenu*>::iterator it = m_mainMenuList.begin();
	for (; it != m_mainMenuList.end(); ++it)
	{
		sArenaMainMenu* mainMenu = *it;
		if (mainMenu->getId() == unfoldMainMenuId)
		{
			mainMenu->unfold(y);
		}
		else
		{
			mainMenu->fold(y);
		}
		mainMenu->setSelect(-1, false);
	}
}

int sArenaMenuSystem::getBasisY() const
{
	if (!m_basisYControl)
	{
		assert(!m_basisYControl && "m_basisYControl is null");
		return 0;
	}
	return m_basisYControl->GetRect().top;
}

int sArenaMenuSystem::getSelectSubMenuId(int mainMenuId) const
{
	sArenaMainMenu* mainMenu = findMainMenu(mainMenuId);
	if (NULL == mainMenu)
		return -1;
	return mainMenu->getSelectSubMenuId();
}