// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010  Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#include "stdpch.h"

#include "action_handler_misc.h"
#include "interface_manager.h"
#include "ctrl_button.h"
#include "group_container.h"
#include "group_editbox.h"
#include "people_interraction.h"
#include "nel/misc/algo.h"
#include "interface_expr.h"
#include "interface_link.h"
#include "../client_chat_manager.h"
#include "../motion/user_controls.h"
#include "../entity_cl.h"
#include "../client_cfg.h"
#include "../fog_map.h"
#include "../sky_render.h"
#include "../continent_manager.h"
#include "../main_loop.h"
#include "../misc.h"

using namespace std;
using namespace NLMISC;
using namespace NL3D;

////////////
// EXTERN //
////////////

extern CClientChatManager		ChatMngr;
extern UScene					*SceneRoot;
extern UScene					*SkyScene;
extern UScene					*Scene;
extern CFogState				MainFogState;
extern CFogState				RootFogState;
extern CLightCycleManager		LightCycleManager;
extern UCamera					MainCam;
extern CContinentManager		ContinentMngr;
extern NLMISC::CLog				g_log;

////////////
// static //
////////////
//static CCDBNodeLeaf *MenuColorWidgetValue = NULL; // db entry for the color menu widget (Red)


static const string ScreenshotsDirectory("screenshots/");	// don't forget the final /

void preRenderNewSky ();

// ***************************************************************************
class CAHCommand : public IActionHandler
{
public:

	virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
	{
		ICommand::execute(Params, g_log);
	}
};
REGISTER_ACTION_HANDLER (CAHCommand, "command");

// ***************************************************************************
// ***************************************************************************
// class CActionHandlerShowOne
// ***************************************************************************
// ***************************************************************************


// ***************************************************************************
REGISTER_ACTION_HANDLER (CActionHandlerShowOne, "show_one");

// ***************************************************************************
void CActionHandlerShowOne::execute (CCtrlBase * /* pCaller */, const std::string &params)
{
	CInterfaceManager	*mngr= CInterfaceManager::getInstance();
	string wndListValue= getParam(params, "list");
	string wndShow= getParam(params, "show");

	// get the list
	vector<string>	wndList;
	splitString(wndListValue, ",", wndList);

	// hide all window from the list.
	for(uint i=0;i<wndList.size();i++)
	{
		CInterfaceElement	*wnd= mngr->getElementFromId(wndList[i]);
		if(wnd)
			wnd->setActive(false);
	}

	// show the one needed
	CInterfaceElement	*wnd= mngr->getElementFromId(wndShow);
	if(wnd)
		wnd->setActive(true);
}


// ***************************************************************************
REGISTER_ACTION_HANDLER (CActionHandlerActive, "set_active");
// ***************************************************************************
void CActionHandlerActive::execute (CCtrlBase * /* pCaller */, const std::string &params)
{
	std::string active = getParam(params, "active");
	std::string target = getParam(params, "target");
	CInterfaceExprValue activeValue;
	if (CInterfaceExpr::eval(active, activeValue, NULL))
	{
		if (!activeValue.toBool())
		{
			nlwarning("<CActionHandlerActive::execute> The 'active' param must be convertible to a boolean");
			return;
		}
		CInterfaceManager	*mngr = CInterfaceManager::getInstance();
		CInterfaceElement	*wnd = mngr->getElementFromId(target);
		if(!wnd)
		{
			nlwarning("<CActionHandlerActive::execute> Can't get window %s", target.c_str());
			return;
		}
		wnd->setActive(activeValue.getBool());
	}
	else
	{
		nlwarning("<CActionHandlerActive::execute> can't parse the 'active' param");
		return;
	}
}

// ***************************************************************************
REGISTER_ACTION_HANDLER (CActionHandlerSetOpen, "set_open");
// ***************************************************************************
void CActionHandlerSetOpen::execute (CCtrlBase * /* pCaller */, const std::string &params)
{
	std::string open   = getParam(params, "open");
	std::string target = getParam(params, "target");
	CInterfaceExprValue activeValue;
	if (CInterfaceExpr::eval(open, activeValue, NULL))
	{
		if (!activeValue.toBool())
		{
			nlwarning("<CActionHandlerActive::execute> The 'active' param must be co,vertible to a boolean");
			return;
		}
		CInterfaceManager	*mngr = CInterfaceManager::getInstance();
		CGroupContainer		*wnd = dynamic_cast<CGroupContainer*>(mngr->getElementFromId(target));
		if(!wnd)
		{
			nlwarning("<CActionHandlerActive::execute> Can't get window %s", target.c_str());
			return;
		}
		wnd->setOpen(activeValue.getBool());
	}
	else
	{
		nlwarning("<CActionHandlerActive::execute> can't parse the 'active' param");
		return;
	}
}

// ***************************************************************************
// ***************************************************************************
// CActionHandlerHideClose
// ***************************************************************************
// ***************************************************************************

// ***************************************************************************
REGISTER_ACTION_HANDLER (CActionHandlerHideClose, "hide_close");

// ***************************************************************************
void CActionHandlerHideClose::execute (CCtrlBase * /* pCaller */, const std::string &params)
{
	CInterfaceManager	*mngr= CInterfaceManager::getInstance();
	string hideValue= getParam(params, "hide");
	string closeValue= getParam(params, "close");

	// get the list
	vector<string>	hideList;
	splitString(hideValue, ",", hideList);
	vector<string>	closeList;
	splitString(closeValue, ",", closeList);

	// hide all window from the hide list.
	uint i;
	for(i=0;i<hideList.size();i++)
	{
		CInterfaceElement	*wnd= mngr->getElementFromId(hideList[i]);
		if(wnd)
			wnd->setActive(false);
	}

	// close all containers from the hide list.
	for(i=0;i<closeList.size();i++)
	{
		// get a container if possible
		CInterfaceElement	*wnd= mngr->getElementFromId(closeList[i]);
		CGroupContainer		*pIC = dynamic_cast<CGroupContainer*>(wnd);
		if(pIC)
			pIC->close();
	}

}


// ***************************************************************************
// ***************************************************************************
// Misc
// ***************************************************************************
// ***************************************************************************


// ***************************************************************************
REGISTER_ACTION_HANDLER (CActionHandlerEnterModal, "enter_modal");
REGISTER_ACTION_HANDLER (CActionHandlerPushModal, "push_modal");
REGISTER_ACTION_HANDLER (CActionHandlerLeaveModal, "leave_modal");

// ***************************************************************************
void	CActionHandlerEnterModal::execute(CCtrlBase *pCaller, const std::string &params)
{
	CInterfaceManager	*pIM= CInterfaceManager::getInstance();

	// get the group from param
	string	groupName= getParam(params, "group");
	CInterfaceGroup	*group= dynamic_cast<CInterfaceGroup*>( pIM->getElementFromId(groupName) );
	if(group)
	{
		UserControls.stopFreeLook();

		// enable the modal
		pIM->enableModalWindow(pCaller, group);
	}
	else
	{
		nlwarning("<CActionHandlerEnterModal::execute> Couldn't find group %s", groupName.c_str());
	}
}

// ***************************************************************************
void	CActionHandlerPushModal::execute(CCtrlBase *pCaller, const std::string &params)
{
	CInterfaceManager	*mngr= CInterfaceManager::getInstance();

	// get the group from param
	string	groupName= getParam(params, "group");
	CInterfaceGroup	*group= dynamic_cast<CInterfaceGroup*>( mngr->getElementFromId(groupName) );
	if(group)
	{
		// enable the modal
		mngr->pushModalWindow(pCaller, group);
	}
	else
	{
		nlwarning("<CActionHandlerPushModal::execute> Couldn't find group %s", groupName.c_str());
	}
}


// ***************************************************************************
void	CActionHandlerLeaveModal::execute(CCtrlBase * /* pCaller */, const std::string &/* params */)
{
	CInterfaceManager	*mngr= CInterfaceManager::getInstance();

	// quit the modal
	mngr->popModalWindow();
}


// ***************************************************************************
// proc
// ***************************************************************************
class CActionHandlerProc : public IActionHandler
{
public:
	virtual void execute (CCtrlBase *pCaller, const std::string &params)
	{
		CInterfaceManager	*mngr= CInterfaceManager::getInstance();

		// split the parameters
		vector<string>		paramList;
		splitString(params, "|", paramList);
		if(paramList.empty())
			return;

		// execute the procedure
		mngr->runProcedure(paramList[0], pCaller, paramList);
	}
};
REGISTER_ACTION_HANDLER (CActionHandlerProc, "proc");


/** Confirm that a group container can be deactivated
  */
class CActionHandlerConfirmCanDeactivate : public IActionHandler
{
public:
	virtual void execute (CCtrlBase * /* pCaller */, const std::string &/* params */)
	{
		CGroupContainer::validateCanDeactivate(true);
	}
};
REGISTER_ACTION_HANDLER (CActionHandlerConfirmCanDeactivate, "confirm_can_deactivate");

/** Cancel a group container deactivation
  */
class CActionHandlerCancelCanDeactivate : public IActionHandler
{
public:
	virtual void execute (CCtrlBase * /* pCaller */, const std::string &/* params */)
	{
		CGroupContainer::validateCanDeactivate(false);
	}
};
REGISTER_ACTION_HANDLER (CActionHandlerCancelCanDeactivate, "cancel_can_deactivate");





// ***************************************************************************
// ***************************************************************************
// EditBox
// ***************************************************************************
// ***************************************************************************


// ***************************************************************************
class CActionHandlerEditBoxNumber : public IActionHandler
{
public:
	virtual void execute (CCtrlBase *pCaller, const std::string &params)
	{
		CGroupEditBox		*pEditBox= dynamic_cast<CGroupEditBox*>(pCaller);
		if(!pEditBox)
			return;



		// get the dblink dest
		string	dblink= getParam(params, "value");
		if(dblink.empty())
			return;

		// get the value
		sint64	val= pEditBox->getInputStringAsInt64();

		string valueStr;
		// see if a max value has been set
		valueStr = getParam(params, "max_value");
		if (!valueStr.empty())
		{
			CInterfaceExprValue maxValue;
			if (!CInterfaceExpr::eval(valueStr, maxValue) || !maxValue.toInteger())
			{
				nlwarning("<CActionHandlerEditBoxNumber::execute> Can't eval maxValue, or can't convert to integer : %s", valueStr.c_str());
				return;
			}
			val = std::min(maxValue.getInteger(), val);
		}
		// see if a min value has been set
		valueStr = getParam(params, "min_value");
		if (!valueStr.empty())
		{
			CInterfaceExprValue minValue;
			if (!CInterfaceExpr::eval(valueStr, minValue) || !minValue.toInteger())
			{
				nlwarning("<CActionHandlerEditBoxNumber::execute> Can't eval minValue, or can't convert to integer : %s", valueStr.c_str());
				return;
			}
			val = std::max(minValue.getInteger(), val);
		}
		// set in the database
		CInterfaceProperty	prop;
		prop.link(dblink.c_str());
		prop.setSInt64(val);
		string	updateText = getParam(params, "update_text");
		bool    mustUpdate = updateText.empty() ? true : CInterfaceElement::convertBool(updateText.c_str());

		if (mustUpdate)
		{
			// replace the editbox string
			pEditBox->setInputStringAsInt64(val);
			pEditBox->setSelectionAll();
		}
	}
};
REGISTER_ACTION_HANDLER (CActionHandlerEditBoxNumber, "editbox_number");

// ***************************************************************************
// Dynamic creation of interface links
// ***************************************************************************
/** Add a link to an interface element
  */
class CActionHandlerAddLink : public IActionHandler
{
	virtual void execute (CCtrlBase *pCaller, const std::string &params)
	{
		std::string expr	= getParam(params, "expr");
		std::string targets = getParam(params, "target");
		std::string id		= getParam(params, "id");
		std::string ah		= getParam(params, "action");
		std::string ahparam	= getParam(params, "params");
		std::string ahcond	= getParam(params, "cond");
		if (id.empty())
		{
			nlwarning("<CActionHandlerAddLink> Must specify a link's id");
			return;
		}
		CInterfaceGroup *parentGroup = dynamic_cast<CInterfaceGroup *>(pCaller);
		if (!parentGroup)
		{
			if (pCaller) parentGroup = pCaller->getParent();
		}

		std::vector<CInterfaceLink::CTargetInfo> targetsVect;
		bool result = CInterfaceParser::splitLinkTargets(targets, parentGroup, targetsVect);
		if (!result)
		{
			nlwarning("<CActionHandlerAddLink> Couldn't parse all links");
		}
		// add the link
		CInterfaceLink *il = new CInterfaceLink;
		il->init(targetsVect, expr, ah, ahparam, ahcond, parentGroup);
		CInterfaceManager *im = CInterfaceManager::getInstance();
		im->addLink(il, id);
		il->update();
	}
};
REGISTER_ACTION_HANDLER (CActionHandlerAddLink, "add_link");

/** Remove a link from an interface element
  */
class CActionHandlerRemoveLink : public IActionHandler
{
	virtual void execute (CCtrlBase * /* pCaller */, const std::string &params)
	{
		std::string id     = getParam(params, "id");
		if (id.empty())
		{
			nlwarning("<CActionHandlerRemoveLink> Must specify a link's id");
			return;
		}
		CInterfaceManager *im = CInterfaceManager::getInstance();
		im->removeLink(id);
	}
};
REGISTER_ACTION_HANDLER (CActionHandlerRemoveLink, "remove_link");

// ***************************************************************************
REGISTER_ACTION_HANDLER (CActionHandlerEvalExpr, "eval_expr");
// ***************************************************************************
void CActionHandlerEvalExpr::execute(CCtrlBase * /* pCaller */, const std::string &params)
{
	std::string expr = getParam(params, "expr");
	if (expr.empty())
	{
		nlwarning("<CActionHandlerEvalExpr::execute> 'expr' parameter not found or empty.");
		return;
	}
	CInterfaceExprValue dummyResult; // result not used
	if (!CInterfaceExpr::eval(expr, dummyResult))
	{
		nlwarning("<CActionHandlerEvalExpr::execute> Couldn't eval expression");
	}
	return;
}

// ***************************************************************************
CInterfaceGroup *createMenuColorWidget(const string &colDbEntry,
									   const string &toolTipTextID,
									   const string &ccdTitle)
{
	CInterfaceManager *im = CInterfaceManager::getInstance();
	pair<string, string> params[3] =
	{
		make_pair(string("col_db_entry"), colDbEntry),
		make_pair(string("tooltip"), toolTipTextID),
		make_pair(string("ccd_title"), ccdTitle),
	};
	return im->createGroupInstance("menu_color_widget", "", params, 3);
}

// ***************************************************************************
struct CCameraBackup
{
	CViewport Viewport;
	CFrustum  Frustum;
};


// *********************************************************
CCameraBackup setupCameraForScreenshot(UScene &scene, uint left, uint right, uint top, uint bottom, uint screenShotWidth, uint screenShotHeight)
{
	CCameraBackup cb;
	cb.Frustum = scene.getCam().getFrustum();
	cb.Viewport = scene.getViewport();
	// Build a frustum
	CFrustum frustumPart;
	frustumPart.Left = cb.Frustum.Left+(cb.Frustum.Right-cb.Frustum.Left)*((float)left/(float)screenShotWidth);
	frustumPart.Right = cb.Frustum.Left+(cb.Frustum.Right-cb.Frustum.Left)*((float)right/(float)screenShotWidth);
	frustumPart.Top = cb.Frustum.Top+(cb.Frustum.Bottom-cb.Frustum.Top)*((float)top/(float)screenShotHeight);
	frustumPart.Bottom = cb.Frustum.Top+(cb.Frustum.Bottom-cb.Frustum.Top)*((float)bottom/(float)screenShotHeight);
	frustumPart.Near = cb.Frustum.Near;
	frustumPart.Far = cb.Frustum.Far;
	frustumPart.Perspective = cb.Frustum.Perspective;

	// Build a viewport
	CViewport viewport;
	viewport.init (0, 0, (float)(right-left)/Driver->getWindowWidth(), (float)(bottom-top)/Driver->getWindowHeight());

	// Activate all this
	scene.getCam().setFrustum (frustumPart);
	scene.setViewport (viewport);

	return cb;
}


// *********************************************************
static void restoreCamera(UScene &scene, const CCameraBackup &backup)
{
	scene.getCam().setFrustum (backup.Frustum);
	scene.setViewport(backup.Viewport);
}

// ***************************************************************************
void renderSceneScreenShot (uint left, uint right, uint top, uint bottom, uint screenShotWidth, uint screenShotHeight)
{
	CCameraBackup cbScene = setupCameraForScreenshot(*Scene, left, right, top, bottom, screenShotWidth, screenShotHeight);
	CCameraBackup cbCanopy = setupCameraForScreenshot(*SceneRoot, left, right, top, bottom, screenShotWidth, screenShotHeight);
	// sky setup are copied from main scene before rendering so no setup done here
	renderAll(ClientCfg.ScreenShotFullDetail);
	restoreCamera(*Scene, cbScene);
	restoreCamera(*SceneRoot, cbCanopy);
}

// ***************************************************************************

void getBuffer (CBitmap &btm)
{
	//
	if (ClientCfg.ScreenShotWidth && ClientCfg.ScreenShotHeight)
	{
		// Destination image
		CBitmap temp;
		btm.resize (ClientCfg.ScreenShotWidth, ClientCfg.ScreenShotHeight, CBitmap::RGBA);

		uint top;
		uint bottom = std::min (Driver->getWindowHeight (), ClientCfg.ScreenShotHeight);
		for (top=0; top<ClientCfg.ScreenShotHeight; top+=Driver->getWindowHeight ())
		{
			uint left;
			uint right = std::min (Driver->getWindowWidth (), ClientCfg.ScreenShotWidth);
			for (left=0; left<ClientCfg.ScreenShotWidth; left+=Driver->getWindowWidth ())
			{
				Driver->clearBuffers (CRGBA::Black);
				renderSceneScreenShot (left, right, top, bottom, ClientCfg.ScreenShotWidth, ClientCfg.ScreenShotHeight);
				// Get the bitmap
				Driver->getBuffer (temp);
				Driver->swapBuffers ();
				btm.blit (temp, 0, Driver->getWindowHeight ()-(bottom-top), right-left, bottom-top, left, top);

				// Next
				right = std::min (right+Driver->getWindowWidth (), ClientCfg.ScreenShotWidth);
			}

			// Next
			bottom = std::min (bottom+Driver->getWindowHeight (), ClientCfg.ScreenShotHeight);
		}
	}
	else
	{
		Driver->getBuffer(btm);
	}
}

void displayScreenShotSavedInfo(const string &filename)
{
	CInterfaceManager *pIM = CInterfaceManager::getInstance();
	ucstring msg("'" + filename + "' " + CI18N::get("uiScreenshotSaved"));
	pIM->displaySystemInfo(msg);
}

void initScreenshot()
{
	if (!CFile::isExists(ScreenshotsDirectory)) CFile::createDirectory(ScreenshotsDirectory);
}

void screenShotTGA()
{
	CBitmap btm;
	getBuffer (btm);

	string filename = CFile::findNewFile (ScreenshotsDirectory+"screenshot.tga");
	COFile fs(filename);
	btm.writeTGA(fs, 24, false);
	nlinfo("Screenshot '%s' saved in tga format (%dx%d)", filename.c_str(), (int) ClientCfg.ScreenShotWidth, (int) ClientCfg.ScreenShotHeight);
	displayScreenShotSavedInfo(filename);
};

void screenShotPNG()
{
	CBitmap btm;
	getBuffer (btm);

	string filename = CFile::findNewFile (ScreenshotsDirectory+"screenshot.png");
	COFile fs(filename);
	if (!btm.writePNG(fs, 24))
	{
		// PNG file has been incorrectly written (mainly because libpng1x.dll was not found)
		// so close and delete it
		fs.close();
		CFile::deleteFile(filename);
		return;
	}

	nlinfo("Screenshot '%s' saved in png format (%dx%d)", filename.c_str(), (int) ClientCfg.ScreenShotWidth, (int) ClientCfg.ScreenShotHeight);
	displayScreenShotSavedInfo(filename);
};

void screenShotJPG()
{
	CBitmap btm;
	getBuffer (btm);

	string filename = CFile::findNewFile (ScreenshotsDirectory+"screenshot.jpg");
	COFile fs(filename);
	btm.writeJPG(fs);
	nlinfo("Screenshot '%s' saved in jpg format (%dx%d)", filename.c_str(), (int) ClientCfg.ScreenShotWidth, (int) ClientCfg.ScreenShotHeight);
	displayScreenShotSavedInfo(filename);
};

// ***************************************************************************

class CAHScreenShot : public IActionHandler
{
	void execute(CCtrlBase * /* pCaller */, const std::string &/* params */)
	{
		// if custom screenshot size is asked, then do it right now
		if (ClientCfg.ScreenShotWidth && ClientCfg.ScreenShotHeight)
		{
			// Custom screen shot ?
			screenShotTGA();
		}
		else
		{
			// post screenshot request
			ScreenshotRequest = ScreenshotRequestTGA;
		}
	}
};

// ***************************************************************************
REGISTER_ACTION_HANDLER (CAHScreenShot, "screen_shot");

// ***************************************************************************
class CAHScreenShotJPG : public IActionHandler
{
	void execute(CCtrlBase * /* pCaller */, const std::string &/* params */)
	{
		// if custom screenshot size is asked, then do it right now
		if (ClientCfg.ScreenShotWidth && ClientCfg.ScreenShotHeight)
		{
			screenShotJPG();
		}
		else
		{
			// post screenshot request
			ScreenshotRequest = ScreenshotRequestJPG;
		}
	}
};
// ***************************************************************************
REGISTER_ACTION_HANDLER (CAHScreenShotJPG, "screen_shot_jpg");

// ***************************************************************************
class CAHScreenShotPNG : public IActionHandler
{
	void execute(CCtrlBase * /* pCaller */, const std::string &/* params */)
	{
		// if custom screenshot size is asked, then do it right now
		if (ClientCfg.ScreenShotWidth && ClientCfg.ScreenShotHeight)
		{
			screenShotPNG();
		}
		else
		{
			// post screenshot request
			ScreenshotRequest = ScreenshotRequestPNG;
		}
	}
};
// ***************************************************************************
REGISTER_ACTION_HANDLER (CAHScreenShotPNG, "screen_shot_png");


// ***************************************************************************
// Reply to the last people who talked in the chat -> this change the target of the main chat to the name of the last teller
class CAHReplyTeller : public IActionHandler
{
	void execute(CCtrlBase * /* pCaller */, const std::string &/* params */)
	{
		if (!PeopleInterraction.LastSenderName.empty())
		{
			CChatWindow *w = PeopleInterraction.ChatGroup.Window;
			if (w)
			{
				w->setKeyboardFocus();
				w->enableBlink(1);
				PeopleInterraction.ChatGroup.Filter.setTargetPlayer(CEntityCL::removeTitleAndShardFromName(PeopleInterraction.LastSenderName));
				CGroupEditBox *eb = w->getEditBox();
				if (eb != NULL)
				{
					eb->bypassNextKey();
				}

			}
		}
	}
};
REGISTER_ACTION_HANDLER (CAHReplyTeller, "reply_teller")

// ***************************************************************************
// Reply to the last people who talked in the chat only once (display '/tell name' in the last activated chat window)
class CAHReplyTellerOnce : public IActionHandler
{
	void execute(CCtrlBase * /* pCaller */, const std::string &/* params */)
	{
		// display a /tell command in the main chat
		if (!PeopleInterraction.LastSenderName.empty())
		{
			CChatWindow *w = PeopleInterraction.ChatGroup.Window;
			if (w)
			{
				w->setKeyboardFocus();
				w->enableBlink(1);
				w->setCommand(ucstring("tell ") + CEntityCL::removeTitleAndShardFromName(PeopleInterraction.LastSenderName) + ucstring(" "), false);
				CGroupEditBox *eb = w->getEditBox();
				if (eb != NULL)
				{
					eb->bypassNextKey();
				}
			}
		}
	}
};
REGISTER_ACTION_HANDLER (CAHReplyTellerOnce, "reply_teller_once")

// ***************************************************************************
/** Cycle through the last people on which a 'tell' has been done.
  * Focus must be in a window with a target (main chat or user chat), otherwise the main chat is used
  */
class CAHCycleTell : public IActionHandler
{
	void execute(CCtrlBase * /* pCaller */, const std::string &/* params */)
	{
		CInterfaceManager *im = CInterfaceManager::getInstance();
		if (!im->isInGame()) return;
		const ucstring *lastTellPeople = ChatMngr.cycleLastTell();
		if (!lastTellPeople) return;
		// just popup the main chat
		//CChatWindow *w = PeopleInterraction.MainChat.Window;
		CChatWindow *w = PeopleInterraction.ChatGroup.Window;
		if (w)
		{
			w->setKeyboardFocus();
			w->enableBlink(1);
			//PeopleInterraction.MainChat.Filter.setTargetPlayer(*lastTellPeople);
			PeopleInterraction.ChatGroup.Filter.setTargetPlayer(*lastTellPeople);
		}
	}
};
REGISTER_ACTION_HANDLER (CAHCycleTell, "cycle_tell")




// temp for test : set last sender name
NLMISC_COMMAND(slsn, "Temp : set the name of the last sender.", "<name>")
{
	if (args.size() != 1) return false;
	PeopleInterraction.LastSenderName = ucstring(args[0]);
	return true;
}

// ***************************************************************************
bool CStringPostProcessRemoveName::cbIDStringReceived(ucstring &inOut)
{
	// extract the replacement id
	std::string strNewTitle = CEntityCL::getTitleFromName(inOut);

	// retrieve the translated string
	if (!strNewTitle.empty())
		inOut = STRING_MANAGER::CStringManagerClient::getTitleLocalizedName(strNewTitle,Woman);
	else
		inOut = "";

	return true;
}

// ***************************************************************************
bool CStringPostProcessRemoveTitle::cbIDStringReceived(ucstring &inOut)
{
	inOut = CEntityCL::removeTitleAndShardFromName(inOut);
	return true;
}

// ***************************************************************************
bool CStringPostProcessNPCRemoveTitle::cbIDStringReceived(ucstring &inOut)
{
	ucstring sOut = CEntityCL::removeTitleAndShardFromName(inOut);
	if (sOut.empty())
	{
		CStringPostProcessRemoveName SPPRM;
		SPPRM.cbIDStringReceived(inOut);
	}
	else
	{
		inOut = sOut;
	}
	return true;
}