// 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"

// Interface includes
#include "interface_manager.h"
#include "action_handler.h"
#include "action_handler_tools.h"
#include "game_share/outpost.h"
#include "interface_expr.h"
#include "group_map.h"
#include "../sheet_manager.h"
#include "../net_manager.h"
#include "../game_context_menu.h"
#include "../user_entity.h"
#include "../entities.h"
#include "../outpost_manager.h"

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


// ***************************************************************************
// ***************************************************************************
//							OUTPOST HANDLERS
// ***************************************************************************
// ***************************************************************************

uint8 getOutpostSelection()
{
	uint8 nOutpost = 0;
	CCDBNodeLeaf *pNL = CInterfaceManager::getInstance()->getDbProp("UI:TEMP:OUTPOST:SELECTION",false);
	if (pNL != NULL)
		nOutpost = (uint8)pNL->getValue32();
	return nOutpost;
}

uint32 getOutpostSheet()
{
	uint32	sheet= 0;
	uint8	outpostSel= getOutpostSelection();
	CCDBNodeLeaf *pNL = CInterfaceManager::getInstance()->getDbProp(toString("SERVER:GUILD:OUTPOST:O%d:SHEET", outpostSel),false);
	if (pNL != NULL)
		sheet = pNL->getValue32();
	return sheet;
}

// ***************************************************************************
// Abandon an outpost
class COutpostGiveup : public IActionHandler
{
public:
	void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
	{
		CInterfaceManager	*pIM= CInterfaceManager::getInstance();

		// set confirm dialog flag
		pIM->getDbProp("UI:TEMP:OUTPOST:CONFIRM_DEL_OUTPOST")->setValueBool(true);

		// Ask if ok before.
		pIM->validMessageBox(CInterfaceManager::QuestionIconMsg, CI18N::get("uiQConfirmGiveupOutpost"),
			"outpost_do_giveup", sParams, "outpost_cancel_giveup");
	}
};
REGISTER_ACTION_HANDLER(COutpostGiveup, "outpost_giveup");

class COutpostDoGiveup : public IActionHandler
{
public:
	void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
	{
		// retrieve the sheet of this outpost
		uint32	sheet= 0;
		uint8	outpostSel;
		fromString(sParams, outpostSel);
		CCDBNodeLeaf *pNL = CInterfaceManager::getInstance()->getDbProp(toString("SERVER:GUILD:OUTPOST:O%d:SHEET", outpostSel),false);
		if (pNL == NULL)
			return;
		sheet = pNL->getValue32();

		// send msg to server
		sendMsgToServer("OUTPOST:GIVEUP_OUTPOST", sheet);

		// reset confirm dialog flag
		CInterfaceManager	*pIM= CInterfaceManager::getInstance();
		pIM->getDbProp("UI:TEMP:OUTPOST:CONFIRM_DEL_OUTPOST")->setValueBool(false);
	}
};
REGISTER_ACTION_HANDLER(COutpostDoGiveup, "outpost_do_giveup");

class COutpostCancelGiveup : public IActionHandler
{
public:
	void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
	{
		// reset confirm dialog flag
		CInterfaceManager	*pIM= CInterfaceManager::getInstance();
		pIM->getDbProp("UI:TEMP:OUTPOST:CONFIRM_DEL_OUTPOST")->setValueBool(false);
	}
};
REGISTER_ACTION_HANDLER(COutpostCancelGiveup, "outpost_cancel_giveup");

// ***************************************************************************
// Set a squad To buy (list of squad given by the server)
class COutpostSetSquad : public IActionHandler
{
public:
	void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
	{
		CInterfaceManager	*pIM= CInterfaceManager::getInstance();

		// get Squad slot Destination selected
		uint8 nSquadSlot = pIM->getDbProp("UI:TEMP:OUTPOST:SQUAD_SLOT_SELECTED")->getValue8();

		// get Squad Id to buy selected
		string sLine = getParam(sParams, "line");
		CInterfaceExprValue ievLine;
		uint8 nLine = 0;
		if (!CInterfaceExpr::eval(sLine, ievLine))
		{
			nlwarning("<COutpostBuy::execute> : Can't evaluate line");
			return;
		}
		if (ievLine.getInteger() >= 0)
			nLine = (uint8)ievLine.getInteger();

		// send msg
		sendMsgToServer("OUTPOST:SET_SQUAD", getOutpostSheet(), nSquadSlot, nLine);
	}
};
REGISTER_ACTION_HANDLER(COutpostSetSquad, "outpost_set_squad");


// ***************************************************************************
// Remove a squad To buy (list of squad given by the server)
class COutpostRemoveSquad : public IActionHandler
{
public:
	void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
	{
		CInterfaceManager	*pIM= CInterfaceManager::getInstance();

		// get Squad slot Destination selected
		uint8 nSquadSlot = pIM->getDbProp("UI:TEMP:OUTPOST:SQUAD_SLOT_SELECTED")->getValue8();

		// send msg
		sendMsgToServer("OUTPOST:REMOVE_SQUAD", getOutpostSheet(), nSquadSlot);
	}
};
REGISTER_ACTION_HANDLER(COutpostRemoveSquad, "outpost_remove_squad");

// ***************************************************************************
// Insert a squad To buy (list of squad given by the server)
class COutpostInsertSquad : public IActionHandler
{
public:
	void execute (CCtrlBase *pCaller, const std::string &sParams)
	{
		CInterfaceManager	*pIM= CInterfaceManager::getInstance();

		// get Squad slot Destination selected
		uint8 nSquadSlot = pIM->getDbProp("UI:TEMP:OUTPOST:SQUAD_SLOT_SELECTED")->getValue8();

		// send msg
		sendMsgToServer("OUTPOST:INSERT_SQUAD", getOutpostSheet(), nSquadSlot);

		// Then set the selected squad at this place
		pIM->runActionHandler("outpost_set_squad", pCaller, sParams);
	}
};
REGISTER_ACTION_HANDLER(COutpostInsertSquad, "outpost_insert_squad");

// ***************************************************************************
// Map helper
uint8 getOutpostSquadSpawnIndex()
{
	CInterfaceManager *pIM = CInterfaceManager::getInstance();

	// get Squad slot
	uint8 nSquadSlot = pIM->getDbProp("UI:TEMP:OUTPOST:SQUAD_SLOT_SELECTED")->getValue8();

	// So we can get the spawn index stored in the DB
	string sDBPath = "SERVER:GUILD:OUTPOST:O" + toString(getOutpostSelection()) + ":SQUADS:T";
	sDBPath += toString(nSquadSlot) + ":SPAWN";
	return pIM->getDbProp(sDBPath)->getValue8();
}

// ***************************************************************************
class COutpostInitSquadMap : public IActionHandler
{
public:
	void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
	{
		CInterfaceManager *pIM = CInterfaceManager::getInstance();
		CGroupMap *pMap = dynamic_cast<CGroupMap*>(pIM->getElementFromId(sParams));
		if (pMap == NULL)
			return;

		// Get the spawn index (from selected squad)
		uint8 nSpawnIndex = getOutpostSquadSpawnIndex();

		// *** Get the BBox of the outpost
		// init map with all xy that are in SERVER:GUILD:OUTPOST:O#x:SQUAD_SPAWN_ZONE (if 0,0 not present)
		string sDBPathSZ = "SERVER:GUILD:OUTPOST:O" + toString(getOutpostSelection()) + ":SQUAD_SPAWN_ZONE:";
		sint32 xMin = 0, xMax = 0, yMin = 0, yMax = 0;
		bool bInit = false;
		uint32 i;
		for (i = 0; i < OUTPOSTENUMS::OUTPOST_MAX_SPAWN_ZONE; ++i)
		{
			sint32 x = pIM->getDbProp(sDBPathSZ + toString(i) + ":X")->getValue32();
			sint32 y = pIM->getDbProp(sDBPathSZ + toString(i) + ":Y")->getValue32();
			if ((x != 0) || (y != 0))
			{
				if (!bInit)
				{
					xMin = xMax = x;
					yMin = yMax = y;
					bInit = true;
				}
				else
				{
					if (x < xMin) xMin = x;
					if (x > xMax) xMax = x;
					if (y < yMin) yMin = y;
					if (y > yMax) yMax = y;
				}
			}
		}

		// *** Find the finest map that contains the 2 points xMin,yMin and xMax,yMax
		CWorldSheet *pWorldSheet = dynamic_cast<CWorldSheet*>(SheetMngr.get(CSheetId("ryzom.world")));
		if (pWorldSheet == NULL)
			return;

		sint32 nMapFound = -1;
		for (i = 0; i < pWorldSheet->Maps.size(); ++i)
		{
			SMap &rMap = pWorldSheet->Maps[i];
			// Avoid 'world' map
			if (!rMap.ContinentName.empty())
			{
				// Is bouding box contains the 2 points ?
				if ((rMap.MinX < xMin) && (rMap.MinY < yMin) &&
					(rMap.MaxX > xMax) && (rMap.MaxY > yMax))
				{
					// Is there a map already found ?
					if (nMapFound == -1)
					{
						nMapFound = i; // No, first map found
					}
					else	// Yes we have to compare with the previous map to keep the finest
					{
						SMap &rMapFound = pWorldSheet->Maps[nMapFound];
						if ((rMap.MaxX - rMap.MinX) < (rMapFound.MaxX - rMapFound.MinX))
							nMapFound = i;
					}
				}
			}
		}

		// *** Setup the Map and zoom to outpost
		if (nMapFound != -1)
		{
			SMap &rMapFound = pWorldSheet->Maps[nMapFound];
			pMap->setMap(rMapFound.Name);
			CVector2f centerWorldCoord((xMax + xMin)/2.0f, (yMin + yMax)/2.0f);
			CVector2f centerMapCoord;
			pMap->worldToMap(centerMapCoord, centerWorldCoord);
			pMap->setScale((rMapFound.MaxX - rMapFound.MinX) / max(sint32(1), (xMax - xMin)) );
			pMap->setPlayerPos(centerMapCoord);
			pMap->centerOnPlayer();

			CRespawnPointsMsg m;
			m.NeedToReset = true;
			for (i = 0; i < OUTPOSTENUMS::OUTPOST_MAX_SPAWN_ZONE; ++i)
			{
				sint32 x = pIM->getDbProp(sDBPathSZ + toString(i) + ":X")->getValue32();
				sint32 y = pIM->getDbProp(sDBPathSZ + toString(i) + ":Y")->getValue32();
				if ((x != 0) || (y != 0))
				{
					CRespawnPointsMsg::SRespawnPoint pt;
					pt.x = x * 1000;
					pt.y = y * 1000;
					m.RespawnPoints.push_back(pt);
				}
			}
			pMap->addRespawnPoints(m);
			pMap->setRespawnSelected(nSpawnIndex);
		}
	}
};
REGISTER_ACTION_HANDLER(COutpostInitSquadMap, "outpost_init_squad_map");

// ***************************************************************************
class COutpostSquadMapSend : public IActionHandler
{
public:
	void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
	{
		CInterfaceManager *pIM = CInterfaceManager::getInstance();
		CGroupMap *pMap = dynamic_cast<CGroupMap*>(pIM->getElementFromId(sParams));
		if (pMap == NULL)
			return;

		// Get the spawn index (from selected squad)
		uint8 nSpawnIndex = getOutpostSquadSpawnIndex();

		// Get Spawn index selected by the user
		uint8 nSpawnSelected = (uint8)pMap->getRespawnSelected();

		if (nSpawnIndex != nSpawnSelected)
		{
			// get Squad slot
			uint8 nSquadSlot = pIM->getDbProp("UI:TEMP:OUTPOST:SQUAD_SLOT_SELECTED")->getValue8();

			sendMsgToServer("OUTPOST:SET_SQUAD_SPAWN", getOutpostSheet(), nSquadSlot, nSpawnSelected);
		}
	}
};
REGISTER_ACTION_HANDLER(COutpostSquadMapSend, "outpost_squad_map_send");


// ***************************************************************************
class COutpostSelectSquadCapital : public IActionHandler
{
public:
	void execute(CCtrlBase * /* pCaller */, const std::string &params)
	{
		uint32	capital;
		fromString(params, capital);
		sendMsgToServer("OUTPOST:SET_SQUAD_CAPITAL", getOutpostSheet(), capital);
	}
};
REGISTER_ACTION_HANDLER(COutpostSelectSquadCapital, "outpost_select_squad_capital");


// ***************************************************************************
static sint		localToGmt(sint hour)
{
	CInterfaceManager	*pIM= CInterfaceManager::getInstance();

	CCDBNodeLeaf	*node= pIM->getDbProp("UI:SAVE:OUTPOST:TIME_ZONE", false);
	if(node)
		hour-= node->getValue32();
	hour+= 48;
	hour%=24;

	return hour;
}
static sint		gmtToLocal(sint hour)
{
	CInterfaceManager	*pIM= CInterfaceManager::getInstance();

	CCDBNodeLeaf	*node= pIM->getDbProp("UI:SAVE:OUTPOST:TIME_ZONE", false);
	if(node)
		hour+= node->getValue32();
	hour+= 48;
	hour%=24;

	return hour;
}


// ***************************************************************************
class CAHOutpostSelectDefPeriod : public IActionHandler
{
public:
	void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
	{
		// The user change the defense period (edited in LOCAL TimeZone)
		sint defPeriod;
		fromString(sParams, defPeriod);

		// Then send request to Server
		sendMsgToServer("OUTPOST:SET_DEF_PERIOD", getOutpostSheet(), uint8(localToGmt(defPeriod)));
	}
};
REGISTER_ACTION_HANDLER(CAHOutpostSelectDefPeriod, "outpost_select_def_period");

// ***************************************************************************
class CAHOutpostSelectAttPeriod : public IActionHandler
{
public:
	void execute (CCtrlBase *pCaller, const std::string &sParams)
	{
		CInterfaceManager	*pIM= CInterfaceManager::getInstance();

		// The user change the attack period (edited in LOCAL TimeZone)
		sint attPeriod;
		fromString(sParams, attPeriod);

		// Store in local DB (in LOCAL for consistency)
		CCDBNodeLeaf	*node= pIM->getDbProp("UI:TEMP:OUTPOST:DECLARE_WAR_ATTACK_PERIOD", false);
		if(node)
			node->setValue32(localToGmt(attPeriod));

		// Nead to resend a Declare War Start (because wanted Att Hour changed)
		pIM->runActionHandler("outpost_declare_war_start", pCaller);
	}
};
REGISTER_ACTION_HANDLER(CAHOutpostSelectAttPeriod, "outpost_select_att_period");

// ***************************************************************************
class CAHOutpostDeclareWarStart : public IActionHandler
{
public:
	void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
	{
		CInterfaceManager	*pIM= CInterfaceManager::getInstance();

		// read current outpost sheet
		uint32	outpostSheet= 0;
		CCDBNodeLeaf	*node= pIM->getDbProp("SERVER:OUTPOST_SELECTED:SHEET", false);
		if(node)
			outpostSheet= node->getValue32();

		// read wanted GMT attack period
		uint8	wantedAttHour= 0;
		node= pIM->getDbProp("UI:TEMP:OUTPOST:DECLARE_WAR_ATTACK_PERIOD", false);
		if(node)
			wantedAttHour= (uint8)node->getValue32();

		// send a DECLARE_WAR_START message to server
		sendMsgToServer("OUTPOST:DECLARE_WAR_START", outpostSheet, wantedAttHour);
	}
};
REGISTER_ACTION_HANDLER(CAHOutpostDeclareWarStart, "outpost_declare_war_start");

// ***************************************************************************
class CAHOutpostDeclareWarValidate : public IActionHandler
{
public:
	void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
	{
		CInterfaceManager	*pIM= CInterfaceManager::getInstance();

		// read current outpost sheet
		uint32	outpostSheet= 0;
		CCDBNodeLeaf	*node= pIM->getDbProp("SERVER:OUTPOST_SELECTED:SHEET", false);
		if(node)
			outpostSheet= node->getValue32();

		// read wanted GMT attack period
		uint8	wantedAttHour= 0;
		node= pIM->getDbProp("UI:TEMP:OUTPOST:DECLARE_WAR_ATTACK_PERIOD", false);
		if(node)
			wantedAttHour= (uint8)node->getValue32();

		// read result Att Period Time (NB: for final server check: ensure that the user will get what it sees)
		uint32	startAttackTime= 0;
		node= pIM->getDbProp("UI:TEMP:OUTPOST:DECLARE_WAR_ACK_TIME_RANGE_ATT", false);
		if(node)
			startAttackTime= node->getValue32();

		// send a DECLARE_WAR_VALIDATE message to server
		string	sMsg= "OUTPOST:DECLARE_WAR_VALIDATE";
		CBitMemStream out;
		if(GenericMsgHeaderMngr.pushNameToStream(sMsg, out))
		{
			//nlinfo("impulseCallBack : %s %d %d %d sent", sMsg.c_str(), outpostSheet, wantedAttHour, startAttackTime);
			out.serial(outpostSheet);
			out.serial(wantedAttHour);
			out.serial(startAttackTime);
			NetMngr.push(out);
		}
		else
		{
			nlwarning("command : unknown message name : '%s'.", sMsg.c_str());
		}

	}
};
REGISTER_ACTION_HANDLER(CAHOutpostDeclareWarValidate, "outpost_declare_war_validate");

// ***************************************************************************
class CAHOutpostSelectFromBC : public IActionHandler
{
public:
	void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
	{
		CInterfaceManager	*pIM= CInterfaceManager::getInstance();

		// Copy SERVER DB to Local selection
		uint32	outpostSheet= 0;
		CCDBNodeLeaf	*node= pIM->getDbProp("LOCAL:TARGET:CONTEXT_MENU:OUTPOST");
		if(node)	outpostSheet= node->getValue32();
		node= pIM->getDbProp("UI:TEMP:OUTPOST:BOT_SELECTION");
		if(node)	node->setValue32(outpostSheet);

		// Send a msg to server
		if(outpostSheet)
		{
			string	sMsg= "OUTPOST:SELECT";
			CBitMemStream out;
			if(GenericMsgHeaderMngr.pushNameToStream(sMsg, out))
			{
				//nlinfo("impulseCallBack : %s %d sent", sMsg.c_str(), outpostSheet);
				out.serial(outpostSheet);
				NetMngr.push(out);
			}
			else
			{
				nlwarning("command : unknown message name : '%s'.", sMsg.c_str());
			}
		}
	}
};
REGISTER_ACTION_HANDLER(CAHOutpostSelectFromBC, "outpost_select_from_bc");


// ***************************************************************************
class CAHOutpostUnSelect : public IActionHandler
{
public:
	void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
	{
		// Called when the Outpost State window (the one opened from BotChat) is closed

		// Send a msg to server
		sendMsgToServer("OUTPOST:UNSELECT");
	}
};
REGISTER_ACTION_HANDLER(CAHOutpostUnSelect, "outpost_unselect");


// ***************************************************************************
class CAHOutpostPVPJoin : public IActionHandler
{
public:
	void	execute (CCtrlBase * /* pCaller */, const std::string &Params)
	{
		// parse AH
		bool	bNeutral= true;
		OUTPOSTENUMS::TPVPSide side = OUTPOSTENUMS::UnknownPVPSide;
		if(Params=="attack")
		{
			bNeutral= false;
			side= OUTPOSTENUMS::OutpostAttacker;
		}
		else if(Params=="defend")
		{
			bNeutral= false;
			side= OUTPOSTENUMS::OutpostOwner;
		}

		// validate proposal
		OutpostManager.endPvpJoinProposal(bNeutral, side);
	}
};
REGISTER_ACTION_HANDLER(CAHOutpostPVPJoin, "outpost_pvp_join");

// ***************************************************************************
class CAHOutpostBanPlayer : public IActionHandler
{
public:
	void	execute (CCtrlBase * /* pCaller */, const std::string &sParams)
	{
		CInterfaceManager	*pIM= CInterfaceManager::getInstance();

		// Ask if ok before.
		pIM->validMessageBox(CInterfaceManager::QuestionIconMsg, CI18N::get("uiQConfirmOutpostBanPlayer"),
			"outpost_do_ban_player", sParams, "");
	}
};
REGISTER_ACTION_HANDLER(CAHOutpostBanPlayer, "outpost_ban_player");

// ***************************************************************************
class CAHOutpostBanGuild : public IActionHandler
{
public:
	void	execute (CCtrlBase * /* pCaller */, const std::string &sParams)
	{
		CInterfaceManager	*pIM= CInterfaceManager::getInstance();

		// Ask if ok before.
		pIM->validMessageBox(CInterfaceManager::QuestionIconMsg, CI18N::get("uiQConfirmOutpostBanGuild"),
			"outpost_do_ban_guild", sParams, "");
	}
};
REGISTER_ACTION_HANDLER(CAHOutpostBanGuild, "outpost_ban_guild");

// ***************************************************************************
// Used also in game_context_menu
void	outpostTestUserCanBan(CCDBNodeLeaf *dbBanRight, bool &okForBanPlayer, bool &okForBanGuild)
{
	okForBanPlayer= false;
	okForBanGuild= false;

	/** A player can ban a player in a PVP outpost if:
	 *	- The player has right to ban AND his guild attack/owns the outpost the player attacks (all this is in RIGHT_BANNISH)
	 *	- The player and the target are in the same war of the outpost, and in same alliance.
	 *	- The player and the target are not in same guild
	 */
	if(dbBanRight && dbBanRight->getValueBool() && UserEntity)
	{
		CEntityCL *selection = EntitiesMngr.entity(UserEntity->selection());
		if(selection && selection->isPlayer())
		{
			// in same outpost War and Side
			if( selection->getOutpostId() == UserEntity->getOutpostId() &&
				selection->getOutpostSide() == UserEntity->getOutpostSide() )
			{
				// not in same guild
				if( selection->getGuildNameID() != UserEntity->getGuildNameID() )
				{
					okForBanPlayer= true;
					okForBanGuild= selection->getGuildNameID()!=0;
				}
			}
		}
	}
}

// ***************************************************************************
class CAHOutpostDoBanPlayer : public IActionHandler
{
public:
	void	execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
	{
		CInterfaceManager	*pIM= CInterfaceManager::getInstance();
		CCDBNodeLeaf	*dbBan = pIM->getDbProp("SERVER:CHARACTER_INFO:PVP_OUTPOST:RIGHT_TO_BANISH", false);

		// Re-Test if can ban the selection
		bool	okForBanPlayer= false;
		bool	okForBanGuild= false;
		outpostTestUserCanBan(dbBan, okForBanPlayer, okForBanGuild);

		// if still ok to ban player
		if(okForBanPlayer)
		{
			sendMsgToServer("OUTPOST:BANISH_PLAYER");
		}
	}
};
REGISTER_ACTION_HANDLER(CAHOutpostDoBanPlayer, "outpost_do_ban_player");

// ***************************************************************************
class CAHOutpostDoBanGuild : public IActionHandler
{
public:
	void	execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
	{
		CInterfaceManager	*pIM= CInterfaceManager::getInstance();
		CCDBNodeLeaf	*dbBan = pIM->getDbProp("SERVER:CHARACTER_INFO:PVP_OUTPOST:RIGHT_TO_BANISH", false);

		// Re-Test if can ban the selection
		bool	okForBanPlayer= false;
		bool	okForBanGuild= false;
		outpostTestUserCanBan(dbBan, okForBanPlayer, okForBanGuild);

		// if still ok to ban player's guild
		if(okForBanGuild)
		{
			sendMsgToServer("OUTPOST:BANISH_GUILD");
		}
	}
};
REGISTER_ACTION_HANDLER(CAHOutpostDoBanGuild, "outpost_do_ban_guild");

// ***************************************************************************
class CAHOutpostUpdateTimeZoneAuto : public IActionHandler
{
public:
	void	execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
	{
		CInterfaceManager	*pIM= CInterfaceManager::getInstance();
		CCDBNodeLeaf	*dbTZ = pIM->getDbProp("UI:SAVE:OUTPOST:TIME_ZONE", false);
		if(!dbTZ)
			return;

		// *** must update time zone, in case of user changed it during play
		tzset();

		// *** Get the difference of time => timezone
		time_t	tGmt=0, tLocal=0;
		struct tm *timeTm;
		// get current time
		time_t ltime;
		time( &ltime );
		// convert into GMT time
		timeTm = gmtime( &ltime );
		if(timeTm)
			tGmt= mktime(timeTm);
		// convert into local time
		timeTm = localtime( &ltime );
		timeTm->tm_isdst = 0;		// reset daylight saving time flag
		if(timeTm)
			tLocal= mktime(timeTm);

		// Make the difference and hence compute the time zone
		double	tzSec= difftime(tLocal, tGmt);
		sint	tzHour= (sint)floor(tzSec / 3600);
		clamp(tzHour, -12, 12);

		// set the result
		dbTZ->setValue32(tzHour);

	}
};
REGISTER_ACTION_HANDLER(CAHOutpostUpdateTimeZoneAuto, "outpost_update_time_zone_auto");