// ======================================================================
//
// GuildInterface.cpp
//
// Copyright 2002 Sony Online Entertainment
//
// ======================================================================

#include "serverGame/FirstServerGame.h"
#include "serverGame/GuildInterface.h"

#include "UnicodeUtils.h"
#include "serverGame/Chat.h"
#include "serverGame/ConfigServerGame.h"
#include "serverGame/CreatureObject.h"
#include "serverGame/GameServer.h"
#include "serverGame/GuildObject.h"
#include "serverGame/GuildStringParser.h"
#include "serverGame/ServerUniverse.h"
#include "serverScript/ScriptParameters.h"
#include "serverUtility/ServerClock.h"
#include "sharedFoundation/CalendarTime.h"
#include "sharedFoundation/FormattedString.h"
#include "sharedNetworkMessages/ChatRoomData.h"

#include <unordered_map>

// ======================================================================

namespace GuildInterfaceNamespace
{
	// ----------------------------------------------------------------------
	const std::string s_empty;
	uint32 const s_guildChannelLimit = 400;

	int const s_maxInactiveGuildWarsTracked = 100;
	std::string const s_objvarInactiveGuildWarsPrefix("guildWarsEnded");
	std::string const s_objvarInactiveGuildWarsMostRecentIndex = s_objvarInactiveGuildWarsPrefix + std::string(".mostRecentIndex");

	std::map<int, std::vector<int> > s_guildEnemiesAToB;
	std::map<int, std::map<int, std::pair<int, time_t> > > s_guildEnemiesAToBKillInfo;
	std::map<int, std::vector<int> > s_guildEnemiesBToA;
	bool s_needEnemiesRebuild;

	// dictionary containing the table showing all active guild wars with at least 1 kill
	ScriptParams * s_activeGuildWars = NULL;
	bool s_activeGuildWarsNeedRebuild = true;

	// dictionary containing the table showing the 100 most recently ended guild wars with at least 1 kill
	ScriptParams * s_inactiveGuildWars = NULL;
	int s_inactiveGuildWarsMostRecentUpdateIndex = 0;

	typedef std::map<std::string, NetworkId> PendingChannelAddList; //using a map to make it easier to prevent redundant entries
	typedef std::map<std::string,PendingChannelAddList> PendingChannelAddMap;
	PendingChannelAddMap s_pendingChannelAdds;

	// ----------------------------------------------------------------------

	std::string const &getChatRoomPrefix()
	{ //lint !e1929 // returning a reference makes sense here.
		static std::string const prefix = std::string("SWG.") + GameServer::getInstance().getClusterName().c_str() + ".guild.";
		return prefix;
	}

	// ----------------------------------------------------------------------

	std::string const &getChatRoomSuffix()
	{ //lint !e1929 // returning a reference makes sense here.
		static std::string const suffix("." + ChatRoomTypes::ROOM_GUILD);
		return suffix;
	}

	// ----------------------------------------------------------------------

	std::string getChatRoomPath(int guildId)
	{
		char buf[256];
		snprintf(buf, 256, "%s%d%s", getChatRoomPrefix().c_str(), guildId, getChatRoomSuffix().c_str());
		return std::string(buf);
	}

	// ----------------------------------------------------------------------

	std::string getChatRoomTitle(int guildId)
	{
		char buf[32];
		snprintf(buf, 32, "%d", guildId);
		return std::string(buf);
	}

	// ----------------------------------------------------------------------

	std::string const & getVoiceChatDisplayName()
	{
		return ChatRoomTypes::ROOM_GUILD;
	}

	// ----------------------------------------------------------------------

	const char * makeCopyOfString(const char * rhs)
	{
		char * lhs = NULL;
		if (rhs)
		{
			lhs = new char[strlen(rhs) + 1];
			strcpy(lhs, rhs);
		}
		else
		{
			lhs = new char[1];
			lhs[0] = '\0';
		}

		return lhs;
	}
}
using namespace GuildInterfaceNamespace;

// ======================================================================

void GuildInterface::update()
{
	if (ServerUniverse::getInstance().isUniverseLoaded())
	{
		GuildObject *masterGuildObject = ServerUniverse::getInstance().getMasterGuildObject();
		if (masterGuildObject)
		{
			if (s_needEnemiesRebuild)
				buildEnemies(*masterGuildObject);
		}
	}
}

// ----------------------------------------------------------------------

void GuildInterface::touchEnemies()
{
	s_needEnemiesRebuild = true;
}

// ----------------------------------------------------------------------

void GuildInterface::buildEnemies(GuildObject const &guildObject)
{
	PROFILER_AUTO_BLOCK_DEFINE("GuildInterface::buildEnemies");

	s_needEnemiesRebuild = false;
	s_activeGuildWarsNeedRebuild = true;

	// potential pvp updates for every guilded creature
	std::vector<PvpUpdateObserver*> pvpUpdateObservers;
	{
		CreatureObject::AllCreaturesSet const &creatureList = CreatureObject::getAllCreatures();
		for (CreatureObject::AllCreaturesSet::const_iterator i = creatureList.begin(); i != creatureList.end(); ++i)
			if ((*i)->getGuildId())
				pvpUpdateObservers.push_back(new PvpUpdateObserver(*i, Archive::ADOO_generic));
	}

	s_guildEnemiesAToB.clear();
	s_guildEnemiesAToBKillInfo.clear();
	s_guildEnemiesBToA.clear();

	std::set<std::string> const &enemies = guildObject.getGuildEnemies();
	for (std::set<std::string>::const_iterator i = enemies.begin(); i != enemies.end(); ++i)
	{
		int guildId, enemyId, killCount, lastUpdateTime;
		if (GuildStringParser::parseEnemyInfo(*i, guildId, enemyId, killCount, lastUpdateTime))
		{
			s_guildEnemiesAToB[guildId].push_back(enemyId);

			std::pair<std::map<int, std::pair<int, time_t> >::iterator, bool> result = s_guildEnemiesAToBKillInfo[guildId].insert(std::make_pair(enemyId, std::make_pair(killCount, static_cast<time_t>(lastUpdateTime))));
			if (!result.second)
			{
				// multiple A->B guild enemy entries, so consolidate into one entry
				result.first->second.first += killCount;
				result.first->second.second = std::max(result.first->second.second, static_cast<time_t>(lastUpdateTime));
			}

			s_guildEnemiesBToA[enemyId].push_back(guildId);
		}
	}

	// destroy pvp update observers
	{
		for (std::vector<PvpUpdateObserver *>::iterator i = pvpUpdateObservers.begin(); i != pvpUpdateObservers.end(); ++i)
			delete (*i);
	}
}

// ----------------------------------------------------------------------

int GuildInterface::getGuildId(NetworkId const &memberId)
{
	return ServerUniverse::getInstance().getMasterGuildObject()->getGuildId(memberId);
}

// ----------------------------------------------------------------------

int GuildInterface::getGuildIdForSponsored(NetworkId const &memberId)
{
	return ServerUniverse::getInstance().getMasterGuildObject()->getGuildIdForSponsored(memberId);
}

// ----------------------------------------------------------------------

int GuildInterface::getGuildIdForGuildLeader(NetworkId const &leaderId)
{
	return ServerUniverse::getInstance().getMasterGuildObject()->getGuildIdForGuildLeader(leaderId);
}

// ----------------------------------------------------------------------

void GuildInterface::getAllGuildIds(std::vector<int> &results)
{
	ServerUniverse::getInstance().getMasterGuildObject()->getAllGuildIds(results);
}

// ----------------------------------------------------------------------


int GuildInterface::findGuild(std::string const &name)
{
	return ServerUniverse::getInstance().getMasterGuildObject()->findGuild(name);
}

// ----------------------------------------------------------------------

bool GuildInterface::guildExists(int guildId)
{
	return ServerUniverse::getInstance().getMasterGuildObject()->guildExists(guildId);
}

// ----------------------------------------------------------------------

std::pair<int, time_t> const *GuildInterface::hasDeclaredWarAgainst(int actorGuildId, int targetGuildId)
{
	if (actorGuildId && targetGuildId)
	{
		std::map<int, std::map<int, std::pair<int, time_t> > >::const_iterator const iterFindA = s_guildEnemiesAToBKillInfo.find(actorGuildId);
		if (iterFindA != s_guildEnemiesAToBKillInfo.end())
		{
			std::map<int, std::pair<int, time_t> >::const_iterator const iterFindB = iterFindA->second.find(targetGuildId);
			if (iterFindB != iterFindA->second.end())
				return &(iterFindB->second);
		}
	}

	return NULL;
}

// ----------------------------------------------------------------------

GuildInfo const * GuildInterface::getGuildInfo(int guildId)
{
	return ServerUniverse::getInstance().getMasterGuildObject()->getGuildInfo(guildId);
}

// ----------------------------------------------------------------------

std::string const &GuildInterface::getGuildName(int guildId)
{
	GuildInfo const * const gi = ServerUniverse::getInstance().getMasterGuildObject()->getGuildInfo(guildId);
	if (gi)
		return gi->m_name;

	return s_empty;
}

// ----------------------------------------------------------------------

std::string const &GuildInterface::getGuildAbbrev(int guildId)
{
	GuildInfo const * const gi = ServerUniverse::getInstance().getMasterGuildObject()->getGuildInfo(guildId);
	if (gi)
		return gi->m_abbrev;
	
	return s_empty;
}

// ----------------------------------------------------------------------

NetworkId const &GuildInterface::getGuildLeaderId(int guildId)
{
	GuildInfo const * const gi = ServerUniverse::getInstance().getMasterGuildObject()->getGuildInfo(guildId);
	if (gi)
		return gi->m_leaderId;

	return NetworkId::cms_invalid;
}

// ----------------------------------------------------------------------

int GuildInterface::getGuildElectionPreviousEndTime(int guildId)
{
	GuildInfo const * const gi = ServerUniverse::getInstance().getMasterGuildObject()->getGuildInfo(guildId);
	if (gi)
		return gi->m_guildElectionPreviousEndTime;

	return 0;
}

// ----------------------------------------------------------------------

int GuildInterface::getGuildElectionNextEndTime(int guildId)
{
	GuildInfo const * const gi = ServerUniverse::getInstance().getMasterGuildObject()->getGuildInfo(guildId);
	if (gi)
		return gi->m_guildElectionNextEndTime;

	return 0;
}

// ----------------------------------------------------------------------

uint32 GuildInterface::getGuildCurrentFaction(int guildId)
{
	GuildInfo const * const gi = ServerUniverse::getInstance().getMasterGuildObject()->getGuildInfo(guildId);
	if (gi)
		return getGuildCurrentFaction(*gi);

	return 0;
}

// ----------------------------------------------------------------------

uint32 GuildInterface::getGuildCurrentFaction(GuildInfo const & gi)
{
	if (gi.m_timeLeftGuildFaction <= 0)
		return gi.m_guildFaction;

	return 0;
}

// ----------------------------------------------------------------------

uint32 GuildInterface::getGuildPreviousFaction(int guildId)
{
	GuildInfo const * const gi = ServerUniverse::getInstance().getMasterGuildObject()->getGuildInfo(guildId);
	if (gi)
		return getGuildPreviousFaction(*gi);

	return 0;
}

// ----------------------------------------------------------------------

uint32 GuildInterface::getGuildPreviousFaction(GuildInfo const & gi)
{
	if (gi.m_timeLeftGuildFaction > 0)
		return gi.m_guildFaction;

	return 0;
}

// ----------------------------------------------------------------------

int GuildInterface::getTimeLeftGuildPreviousFaction(int guildId)
{
	GuildInfo const * const gi = ServerUniverse::getInstance().getMasterGuildObject()->getGuildInfo(guildId);
	if (gi)
		return getTimeLeftGuildPreviousFaction(*gi);

	return 0;
}

// ----------------------------------------------------------------------

int GuildInterface::getTimeLeftGuildPreviousFaction(GuildInfo const & gi)
{
	if (gi.m_timeLeftGuildFaction > 0)
		return gi.m_timeLeftGuildFaction;

	return 0;
}

// ----------------------------------------------------------------------

std::string const & GuildInterface::getGuildCurrentGcwDefenderRegion(int guildId)
{
	GuildInfo const * const gi = ServerUniverse::getInstance().getMasterGuildObject()->getGuildInfo(guildId);
	if (gi)
		return getGuildCurrentGcwDefenderRegion(*gi);

	return s_empty;
}

// ----------------------------------------------------------------------

std::string const &GuildInterface::getGuildCurrentGcwDefenderRegion(GuildInfo const & gi)
{
	if (gi.m_timeLeftGuildGcwDefenderRegion <= 0)
		return gi.m_guildGcwDefenderRegion;

	return s_empty;
}

// ----------------------------------------------------------------------

int GuildInterface::getTimeJoinedGuildCurrentGcwDefenderRegion(int guildId)
{
	GuildInfo const * const gi = ServerUniverse::getInstance().getMasterGuildObject()->getGuildInfo(guildId);
	if (gi)
		return getTimeJoinedGuildCurrentGcwDefenderRegion(*gi);

	return 0;
}

// ----------------------------------------------------------------------

int GuildInterface::getTimeJoinedGuildCurrentGcwDefenderRegion(GuildInfo const & gi)
{
	if (gi.m_timeLeftGuildGcwDefenderRegion <= 0)
		return gi.m_timeJoinedGuildGcwDefenderRegion;

	return 0;
}

// ----------------------------------------------------------------------

std::string const & GuildInterface::getGuildPreviousGcwDefenderRegion(int guildId)
{
	GuildInfo const * const gi = ServerUniverse::getInstance().getMasterGuildObject()->getGuildInfo(guildId);
	if (gi)
		return getGuildPreviousGcwDefenderRegion(*gi);

	return s_empty;
}

// ----------------------------------------------------------------------

std::string const & GuildInterface::getGuildPreviousGcwDefenderRegion(GuildInfo const & gi)
{
	if (gi.m_timeLeftGuildGcwDefenderRegion > 0)
		return gi.m_guildGcwDefenderRegion;

	return s_empty;
}

// ----------------------------------------------------------------------

int GuildInterface::getTimeLeftGuildPreviousGcwDefenderRegion(int guildId)
{
	GuildInfo const * const gi = ServerUniverse::getInstance().getMasterGuildObject()->getGuildInfo(guildId);
	if (gi)
		return getTimeLeftGuildPreviousGcwDefenderRegion(*gi);

	return 0;
}

// ----------------------------------------------------------------------

int GuildInterface::getTimeLeftGuildPreviousGcwDefenderRegion(GuildInfo const & gi)
{
	if (gi.m_timeLeftGuildGcwDefenderRegion > 0)
		return gi.m_timeLeftGuildGcwDefenderRegion;

	return 0;
}

// ----------------------------------------------------------------------

std::map<std::pair<std::string, int>, uint32> const & GuildInterface::getGcwRegionDefenderGuilds()
{
	return ServerUniverse::getInstance().getMasterGuildObject()->getGcwRegionDefenderGuilds();
}

// ----------------------------------------------------------------------

std::map<std::string, std::pair<int, int> > const & GuildInterface::getGcwRegionDefenderGuildsCount()
{
	return ServerUniverse::getInstance().getMasterGuildObject()->getGcwRegionDefenderGuildsCount();
}

// ----------------------------------------------------------------------

int GuildInterface::getGcwRegionDefenderGuildsVersion()
{
	return ServerUniverse::getInstance().getMasterGuildObject()->getGcwRegionDefenderGuildsVersion();
}

// ----------------------------------------------------------------------

void GuildInterface::getGuildMemberIds(int guildId, std::vector<NetworkId> &results)
{
	ServerUniverse::getInstance().getMasterGuildObject()->getGuildMemberIds(guildId, results);
}

// ----------------------------------------------------------------------

void GuildInterface::getGuildMemberIdsWithPermissions(int guildId, int permissions, std::vector<NetworkId> &results)
{
	ServerUniverse::getInstance().getMasterGuildObject()->getMemberIdsWithPermissions(guildId, permissions, results);
}

// ----------------------------------------------------------------------

int GuildInterface::getGuildCountMembersOnly(int guildId)
{
	GuildInfo const * const gi = ServerUniverse::getInstance().getMasterGuildObject()->getGuildInfo(guildId);
	if (gi)
		return gi->getCountMembersOnly();

	return 0;
}

// ----------------------------------------------------------------------

int GuildInterface::getGuildCountSponsoredOnly(int guildId)
{
	GuildInfo const * const gi = ServerUniverse::getInstance().getMasterGuildObject()->getGuildInfo(guildId);
	if (gi)
		return gi->getCountSponsoredOnly();

	return 0;
}

// ----------------------------------------------------------------------

int GuildInterface::getGuildCountMembersAndSponsored(int guildId)
{
	GuildInfo const * const gi = ServerUniverse::getInstance().getMasterGuildObject()->getGuildInfo(guildId);
	if (gi)
		return gi->getCountMembersAndSponsored();

	return 0;
}

// ----------------------------------------------------------------------

int GuildInterface::getGuildCountMembersGuildWarPvPEnabled(int guildId)
{
	GuildInfo const * const gi = ServerUniverse::getInstance().getMasterGuildObject()->getGuildInfo(guildId);
	if (gi)
		return gi->getCountMembersGuildWarPvPEnabled();

	return 0;
}

// ----------------------------------------------------------------------

GuildMemberInfo const * GuildInterface::getGuildMemberInfo(int guildId, NetworkId const &memberId)
{
	return ServerUniverse::getInstance().getMasterGuildObject()->getGuildMemberInfo(guildId, memberId);
}

// ----------------------------------------------------------------------

bool GuildInterface::getGuildMemberGuildWarEnabled(int guildId, NetworkId const &memberId)
{
	if (guildId == 0)
		return false;

	GuildInfo const * const gi = ServerUniverse::getInstance().getMasterGuildObject()->getGuildInfo(guildId);
	if (!gi)
		return false;

	GuildMemberInfo const * const gmi = ServerUniverse::getInstance().getMasterGuildObject()->getGuildMemberInfo(guildId, memberId);
	if (!gmi)
		return false;

	// if guild is using guild war inclusion list, only members
	// with GuildInterface::WarInclusion is enabled for guild war
	if (gi->m_guildWarInclusionCount)
		return (gmi->m_permissions & GuildInterface::WarInclusion);

	// if guild is not using guild war inclusion list, only members
	// with GuildInterface::WarExclusion is disabled for guild war
	return (!(gmi->m_permissions & GuildInterface::WarExclusion));
}

// ----------------------------------------------------------------------

std::vector<int> const &GuildInterface::getGuildEnemies(int guildId)
{
	static std::vector<int> empty;

	std::map<int, std::vector<int> >::const_iterator iterFind =  s_guildEnemiesAToB.find(guildId);
	if (iterFind != s_guildEnemiesAToB.end())
		return iterFind->second;

	return empty;
}

// ----------------------------------------------------------------------

std::map<int, std::pair<int, time_t> > const &GuildInterface::getGuildEnemiesKillInfo(int guildId)
{
	static std::map<int, std::pair<int, time_t> > empty;

	std::map<int, std::map<int, std::pair<int, time_t> > >::const_iterator iterFind = s_guildEnemiesAToBKillInfo.find(guildId);
	if (iterFind != s_guildEnemiesAToBKillInfo.end())
		return iterFind->second;

	return empty;
}

// ----------------------------------------------------------------------

std::pair<int, time_t> const &GuildInterface::getGuildEnemyKillInfo(int guildIdA, int guildIdB)
{
	static std::pair<int, time_t> empty = std::make_pair(0, 0);

	std::map<int, std::map<int, std::pair<int, time_t> > >::const_iterator iterFindA = s_guildEnemiesAToBKillInfo.find(guildIdA);
	if (iterFindA != s_guildEnemiesAToBKillInfo.end())
	{
		std::map<int, std::pair<int, time_t> >::const_iterator iterFindB = iterFindA->second.find(guildIdB);
		if (iterFindB != iterFindA->second.end())
			return iterFindB->second;
	}

	return empty;
}

// ----------------------------------------------------------------------

std::vector<int> const &GuildInterface::getGuildsAtWarWith(int guildId)
{
	static std::vector<int> empty;

	std::map<int, std::vector<int> >::const_iterator iterFind =  s_guildEnemiesBToA.find(guildId);
	if (iterFind != s_guildEnemiesBToA.end())
		return iterFind->second;

	return empty;
}

// ----------------------------------------------------------------------

ScriptParams const *GuildInterface::getMasterGuildWarTableDictionary()
{
	if (s_activeGuildWarsNeedRebuild)
	{
		// build list of guild wars with at least 1 kill, ordered by most recent update time, with the guild with more kills appearing first
		std::multimap<time_t, std::pair<std::pair<int, int>, std::pair<int, int> > > guildMutuallyAtWarWithKillSummary;

		{
			for (std::map<int, std::map<int, std::pair<int, time_t> > >::const_iterator iter1 = s_guildEnemiesAToBKillInfo.begin(); iter1 != s_guildEnemiesAToBKillInfo.end(); ++iter1)
			{
				for (std::map<int, std::pair<int, time_t> >::const_iterator iter2 = iter1->second.upper_bound(iter1->first); iter2 != iter1->second.end(); ++iter2)
				{
					// we know A has declared war on B, so see if B has declared on A to make it a guild war
					std::pair<int, time_t> const * killInfoBtoA = hasDeclaredWarAgainst(iter2->first, iter1->first);
					if (killInfoBtoA)
					{
						// we have a guild war, store it if there is at least one kill
						if ((iter2->second.first <= 0) && (killInfoBtoA->first <= 0))
							continue;

						// guild with more kills appears first, and if guilds have the same
						// number of kills, guild with more recent kill appears first
						if (iter2->second.first > killInfoBtoA->first)
							guildMutuallyAtWarWithKillSummary.insert(std::make_pair(-std::max(iter2->second.second, killInfoBtoA->second), std::make_pair(std::make_pair(iter1->first, iter2->second.first), std::make_pair(iter2->first, killInfoBtoA->first))));
						else if (killInfoBtoA->first > iter2->second.first)
							guildMutuallyAtWarWithKillSummary.insert(std::make_pair(-std::max(iter2->second.second, killInfoBtoA->second), std::make_pair(std::make_pair(iter2->first, killInfoBtoA->first), std::make_pair(iter1->first, iter2->second.first))));
						else if (iter2->second.second > killInfoBtoA->second)
							guildMutuallyAtWarWithKillSummary.insert(std::make_pair(-std::max(iter2->second.second, killInfoBtoA->second), std::make_pair(std::make_pair(iter1->first, iter2->second.first), std::make_pair(iter2->first, killInfoBtoA->first))));
						else
							guildMutuallyAtWarWithKillSummary.insert(std::make_pair(-std::max(iter2->second.second, killInfoBtoA->second), std::make_pair(std::make_pair(iter2->first, killInfoBtoA->first), std::make_pair(iter1->first, iter2->second.first))));
					}
				}
			}
		}

		delete s_activeGuildWars;
		s_activeGuildWars = NULL;

		// build the table
		if (!guildMutuallyAtWarWithKillSummary.empty())
		{
			// column header
			static const char * s_scriptParamsColumnHeadersText[9] = 
			{
				"Name - Guild A",
				"Abbrev - Guild A",
				"Kill Count - Guild A",
				"Guild War PvP Enabled Count - Guild A",
				"Name - Guild B",
				"Abbrev - Guild B",
				"Kill Count - Guild B",
				"Guild War PvP Enabled Count - Guild B",
				"Last Updated"
			};
			static std::vector<const char *> s_scriptParamsColumnHeaders(s_scriptParamsColumnHeadersText, s_scriptParamsColumnHeadersText + (sizeof(s_scriptParamsColumnHeadersText) / sizeof(const char *)));

			// column type
			static const char * s_scriptParamsColumnTypeText[9] = 
			{
				"text",
				"text",
				"integer",
				"integer",
				"text",
				"text",
				"integer",
				"integer",
				"text"
			};
			static std::vector<const char *> s_scriptParamsColumnType(s_scriptParamsColumnTypeText, s_scriptParamsColumnTypeText + (sizeof(s_scriptParamsColumnTypeText) / sizeof(const char *)));

			s_activeGuildWars = new ScriptParams();
			std::vector<const char *> * scriptParamsGuildAName = new std::vector<const char *>;
			std::vector<const char *> * scriptParamsGuildAAbbrev = new std::vector<const char *>;
			std::vector<const char *> * scriptParamsGuildAKillCount = new std::vector<const char *>;
			std::vector<const char *> * scriptParamsGuildAPvpEnabledCount = new std::vector<const char *>;
			std::vector<const char *> * scriptParamsGuildBName = new std::vector<const char *>;
			std::vector<const char *> * scriptParamsGuildBAbbrev = new std::vector<const char *>;
			std::vector<const char *> * scriptParamsGuildBKillCount = new std::vector<const char *>;
			std::vector<const char *> * scriptParamsGuildBPvpEnabledCount = new std::vector<const char *>;
			std::vector<const char *> * scriptParamsLastUpdated = new std::vector<const char *>;

			size_t const size = guildMutuallyAtWarWithKillSummary.size();
			scriptParamsGuildAName->reserve(size);
			scriptParamsGuildAAbbrev->reserve(size);
			scriptParamsGuildAKillCount->reserve(size);
			scriptParamsGuildAPvpEnabledCount->reserve(size);
			scriptParamsGuildBName->reserve(size);
			scriptParamsGuildBAbbrev->reserve(size);
			scriptParamsGuildBKillCount->reserve(size);
			scriptParamsGuildBPvpEnabledCount->reserve(size);
			scriptParamsLastUpdated->reserve(size);

			char buffer[128];
			for (std::multimap<time_t, std::pair<std::pair<int, int>, std::pair<int, int> > >::const_iterator iter = guildMutuallyAtWarWithKillSummary.begin(); iter != guildMutuallyAtWarWithKillSummary.end(); ++iter)
			{
				GuildInfo const * gi = ServerUniverse::getInstance().getMasterGuildObject()->getGuildInfo(iter->second.first.first);
				if (!gi)
					continue;

				GuildInfo const & guildA = *gi;

				gi = ServerUniverse::getInstance().getMasterGuildObject()->getGuildInfo(iter->second.second.first);
				if (!gi)
					continue;

				GuildInfo const & guildB = *gi;

				scriptParamsGuildAName->push_back(makeCopyOfString(guildA.m_name.c_str()));
				scriptParamsGuildAAbbrev->push_back(makeCopyOfString(guildA.m_abbrev.c_str()));

				snprintf(buffer, sizeof(buffer), "%d", iter->second.first.second);
				scriptParamsGuildAKillCount->push_back(makeCopyOfString(buffer));

				snprintf(buffer, sizeof(buffer), "%d", guildA.getCountMembersGuildWarPvPEnabled());
				scriptParamsGuildAPvpEnabledCount->push_back(makeCopyOfString(buffer));

				scriptParamsGuildBName->push_back(makeCopyOfString(guildB.m_name.c_str()));
				scriptParamsGuildBAbbrev->push_back(makeCopyOfString(guildB.m_abbrev.c_str()));

				snprintf(buffer, sizeof(buffer), "%d", iter->second.second.second);
				scriptParamsGuildBKillCount->push_back(makeCopyOfString(buffer));

				snprintf(buffer, sizeof(buffer), "%d", guildB.getCountMembersGuildWarPvPEnabled());
				scriptParamsGuildBPvpEnabledCount->push_back(makeCopyOfString(buffer));

				scriptParamsLastUpdated->push_back(makeCopyOfString(CalendarTime::convertEpochToTimeStringLocal_YYYYMMDDHHMMSS(-iter->first).c_str()));
			}

			s_activeGuildWars->addParam(s_scriptParamsColumnHeaders, "column", false);
			s_activeGuildWars->addParam(s_scriptParamsColumnType, "columnType", false);
			s_activeGuildWars->addParam(*scriptParamsGuildAName, "column0", true);
			s_activeGuildWars->addParam(*scriptParamsGuildAAbbrev, "column1", true);
			s_activeGuildWars->addParam(*scriptParamsGuildAKillCount, "column2", true);
			s_activeGuildWars->addParam(*scriptParamsGuildAPvpEnabledCount, "column3", true);
			s_activeGuildWars->addParam(*scriptParamsGuildBName, "column4", true);
			s_activeGuildWars->addParam(*scriptParamsGuildBAbbrev, "column5", true);
			s_activeGuildWars->addParam(*scriptParamsGuildBKillCount, "column6", true);
			s_activeGuildWars->addParam(*scriptParamsGuildBPvpEnabledCount, "column7", true);
			s_activeGuildWars->addParam(*scriptParamsLastUpdated, "column8", true);
		}

		s_activeGuildWarsNeedRebuild = false;
	}

	return s_activeGuildWars;
}

// ----------------------------------------------------------------------

void GuildInterface::updateInactiveGuildWarTrackingInfo(GuildObject &masterGuildObject, int guildAId, int guildAKillCount, int guildBId, int guildBKillCount)
{
	if (!masterGuildObject.isAuthoritative())
		return;

	if ((guildAKillCount <= 0) && (guildBKillCount <= 0))
		return;

	GuildInfo const * giA = ServerUniverse::getInstance().getMasterGuildObject()->getGuildInfo(guildAId);
	if (!giA)
		return;

	if (giA->m_name.empty() || giA->m_abbrev.empty())
		return;

	GuildInfo const * giB = ServerUniverse::getInstance().getMasterGuildObject()->getGuildInfo(guildBId);
	if (!giB)
		return;

	if (giB->m_name.empty() || giB->m_abbrev.empty())
		return;

	// the information is stored as objvars on the master guild object as a circular
	// list of the 100 most recently ended guild wars with at least 1 kill
	int nextIndex = 0;
	if (!masterGuildObject.getObjVars().getItem(s_objvarInactiveGuildWarsMostRecentIndex, nextIndex))
		nextIndex = 0;

	++nextIndex;
	if (nextIndex > s_maxInactiveGuildWarsTracked)
		nextIndex = 1;

	// guild with higher kill count appears first
	if (guildAKillCount > guildBKillCount)
		IGNORE_RETURN(masterGuildObject.setObjVarItem(FormattedString<32>().sprintf("%s.%d", s_objvarInactiveGuildWarsPrefix.c_str(), nextIndex), FormattedString<512>().sprintf("%s~%s~%d~%s~%s~%d~%ld", giA->m_name.c_str(), giA->m_abbrev.c_str(), guildAKillCount, giB->m_name.c_str(), giB->m_abbrev.c_str(), guildBKillCount, ::time(NULL))));
	else
		IGNORE_RETURN(masterGuildObject.setObjVarItem(FormattedString<32>().sprintf("%s.%d", s_objvarInactiveGuildWarsPrefix.c_str(), nextIndex), FormattedString<512>().sprintf("%s~%s~%d~%s~%s~%d~%ld", giB->m_name.c_str(), giB->m_abbrev.c_str(), guildBKillCount, giA->m_name.c_str(), giA->m_abbrev.c_str(), guildAKillCount, ::time(NULL))));

	IGNORE_RETURN(masterGuildObject.setObjVarItem(s_objvarInactiveGuildWarsMostRecentIndex, nextIndex));
}

// ----------------------------------------------------------------------

ScriptParams const *GuildInterface::getInactiveGuildWarTableDictionary()
{
	// update the table if necessary
	GuildObject const * const masterGuildObject = ServerUniverse::getInstance().getMasterGuildObject();
	if (!masterGuildObject)
		return s_inactiveGuildWars;

	DynamicVariableList const & objVars = masterGuildObject->getObjVars();
	int mostRecentIndex = 0;
	if (!objVars.getItem(s_objvarInactiveGuildWarsMostRecentIndex, mostRecentIndex))
		return s_inactiveGuildWars;

	if ((mostRecentIndex <= 0) || (mostRecentIndex > s_maxInactiveGuildWarsTracked))
		return s_inactiveGuildWars;

	// no new update since we last updated the table
	if (mostRecentIndex == s_inactiveGuildWarsMostRecentUpdateIndex)
		return s_inactiveGuildWars;

	// new update since we last updated the table, recreate the table
	s_inactiveGuildWarsMostRecentUpdateIndex = mostRecentIndex;

	std::vector<const Unicode::String *> * scriptParamsGuildAName = new std::vector<const Unicode::String *>;
	std::vector<const Unicode::String *> * scriptParamsGuildAAbbrev = new std::vector<const Unicode::String *>;
	std::vector<const Unicode::String *> * scriptParamsGuildAKillCount = new std::vector<const Unicode::String *>;
	std::vector<const Unicode::String *> * scriptParamsGuildBName = new std::vector<const Unicode::String *>;
	std::vector<const Unicode::String *> * scriptParamsGuildBAbbrev = new std::vector<const Unicode::String *>;
	std::vector<const Unicode::String *> * scriptParamsGuildBKillCount = new std::vector<const Unicode::String *>;
	std::vector<const char *> * scriptParamsLastUpdated = new std::vector<const char *>;

	scriptParamsGuildAName->reserve(s_maxInactiveGuildWarsTracked);
	scriptParamsGuildAAbbrev->reserve(s_maxInactiveGuildWarsTracked);
	scriptParamsGuildAKillCount->reserve(s_maxInactiveGuildWarsTracked);
	scriptParamsGuildBName->reserve(s_maxInactiveGuildWarsTracked);
	scriptParamsGuildBAbbrev->reserve(s_maxInactiveGuildWarsTracked);
	scriptParamsGuildBKillCount->reserve(s_maxInactiveGuildWarsTracked);
	scriptParamsLastUpdated->reserve(s_maxInactiveGuildWarsTracked);

	// the information is stored as objvars on the master guild object as a circular
	// list of the 100 most recently ended guild wars with at least 1 kill, so get
	// each one, ordered by the most recent one first
	static Unicode::String const delimiters(Unicode::narrowToWide("~"));
	Unicode::UnicodeStringVector tokens;
	Unicode::String guildWarData;
	int currentIndex = mostRecentIndex;
	while (true)
	{
		if (!objVars.getItem(FormattedString<32>().sprintf("%s.%d", s_objvarInactiveGuildWarsPrefix.c_str(), currentIndex), guildWarData))
			break;

		if (!Unicode::tokenize(guildWarData, tokens, &delimiters, NULL) || (tokens.size() != 7))
			break;

		scriptParamsGuildAName->push_back(new Unicode::String(tokens[0]));
		scriptParamsGuildAAbbrev->push_back(new Unicode::String(tokens[1]));
		scriptParamsGuildAKillCount->push_back(new Unicode::String(tokens[2]));

		scriptParamsGuildBName->push_back(new Unicode::String(tokens[3]));
		scriptParamsGuildBAbbrev->push_back(new Unicode::String(tokens[4]));
		scriptParamsGuildBKillCount->push_back(new Unicode::String(tokens[5]));

		scriptParamsLastUpdated->push_back(makeCopyOfString(CalendarTime::convertEpochToTimeStringLocal_YYYYMMDDHHMMSS(static_cast<time_t>(::atol(Unicode::wideToNarrow(tokens[6]).c_str()))).c_str()));

		--currentIndex;
		if (currentIndex <= 0)
			currentIndex = s_maxInactiveGuildWarsTracked;

		if (currentIndex == mostRecentIndex)
			break;
	}

	delete s_inactiveGuildWars;
	s_inactiveGuildWars = NULL;

	if (!scriptParamsGuildAName->empty())
	{
		// column header
		static const char * s_scriptParamsColumnHeadersText[7] = 
		{
			"Name - Guild A",
			"Abbrev - Guild A",
			"Kill Count - Guild A",
			"Name - Guild B",
			"Abbrev - Guild B",
			"Kill Count - Guild B",
			"Time Ended"
		};
		static std::vector<const char *> s_scriptParamsColumnHeaders(s_scriptParamsColumnHeadersText, s_scriptParamsColumnHeadersText + (sizeof(s_scriptParamsColumnHeadersText) / sizeof(const char *)));

		// column type
		static const char * s_scriptParamsColumnTypeText[7] = 
		{
			"text",
			"text",
			"integer",
			"text",
			"text",
			"integer",
			"text"
		};
		static std::vector<const char *> s_scriptParamsColumnType(s_scriptParamsColumnTypeText, s_scriptParamsColumnTypeText + (sizeof(s_scriptParamsColumnTypeText) / sizeof(const char *)));

		s_inactiveGuildWars = new ScriptParams();
		s_inactiveGuildWars->addParam(s_scriptParamsColumnHeaders, "column", false);
		s_inactiveGuildWars->addParam(s_scriptParamsColumnType, "columnType", false);
		s_inactiveGuildWars->addParam(*scriptParamsGuildAName, "column0", true);
		s_inactiveGuildWars->addParam(*scriptParamsGuildAAbbrev, "column1", true);
		s_inactiveGuildWars->addParam(*scriptParamsGuildAKillCount, "column2", true);
		s_inactiveGuildWars->addParam(*scriptParamsGuildBName, "column3", true);
		s_inactiveGuildWars->addParam(*scriptParamsGuildBAbbrev, "column4", true);
		s_inactiveGuildWars->addParam(*scriptParamsGuildBKillCount, "column5", true);
		s_inactiveGuildWars->addParam(*scriptParamsLastUpdated, "column6", true);
	}
	else
	{
		delete scriptParamsGuildAName;
		delete scriptParamsGuildAAbbrev;
		delete scriptParamsGuildAKillCount;
		delete scriptParamsGuildBName;
		delete scriptParamsGuildBAbbrev;
		delete scriptParamsGuildBKillCount;
		delete scriptParamsLastUpdated;
	}

	return s_inactiveGuildWars;
}

// ----------------------------------------------------------------------

bool GuildInterface::isValidGuildName(std::string const &guildName)
{
	if (guildName.empty() || guildName.length() > 25)
		return false;
	// TODO RAD: add obscenity checking here
	return true;
}

// ----------------------------------------------------------------------

bool GuildInterface::isValidGuildAbbrev(std::string const &guildAbbrev)
{
	if (guildAbbrev.length() > 5)
		return false;
	return isValidGuildName(guildAbbrev);
}

// ----------------------------------------------------------------------

int GuildInterface::createGuild(std::string const &guildName, std::string const &guildAbbrev)
{
	if (!isValidGuildName(guildName) || !isValidGuildAbbrev(guildAbbrev))
		return 0;
	int guildId = ServerUniverse::getInstance().getMasterGuildObject()->createGuild(guildName, guildAbbrev);
	Chat::requestGetChannel(getChatRoomPath(guildId), false, true, s_guildChannelLimit);
	return guildId;
}

// ----------------------------------------------------------------------
void GuildInterface::disbandGuild(int guildId)
{
	Chat::requestDestroyChannel(getChatRoomPath(guildId));
	ServerUniverse::getInstance().getMasterGuildObject()->disbandGuild(guildId);
}

// ----------------------------------------------------------------------

void GuildInterface::removeGuildMember(int guildId, NetworkId const &memberId)
{
	ServerUniverse::getInstance().getMasterGuildObject()->removeGuildMember(guildId, memberId);
}

// ----------------------------------------------------------------------

void GuildInterface::addGuildCreatorMember(int guildId, NetworkId const &memberId)
{
	ServerUniverse::getInstance().getMasterGuildObject()->addGuildCreatorMember(guildId, memberId, std::string(), std::string(), 0);
}

// ----------------------------------------------------------------------

void GuildInterface::addGuildSponsorMember(int guildId, NetworkId const &memberId)
{
	ServerUniverse::getInstance().getMasterGuildObject()->addGuildSponsorMember(guildId, memberId, std::string(), std::string(), 0);
}

// ----------------------------------------------------------------------

void GuildInterface::setGuildMemberPermission(int guildId, NetworkId const &memberId, int permissions)
{
	ServerUniverse::getInstance().getMasterGuildObject()->setGuildMemberPermission(guildId, memberId, permissions);
}

// ----------------------------------------------------------------------

void GuildInterface::setGuildMemberTitle(int guildId, NetworkId const &memberId, std::string const &title)
{
	ServerUniverse::getInstance().getMasterGuildObject()->setGuildMemberTitle(guildId, memberId, title);
}

// ----------------------------------------------------------------------

void GuildInterface::setGuildMemberAllegiance(int guildId, NetworkId const &memberId, NetworkId const &allegiance)
{
	ServerUniverse::getInstance().getMasterGuildObject()->setGuildMemberAllegiance(guildId, memberId, allegiance);
}

// ----------------------------------------------------------------------

void GuildInterface::setGuildMemberPermissionAndAllegiance(int guildId, NetworkId const &memberId, int permissions, NetworkId const &allegiance)
{
	ServerUniverse::getInstance().getMasterGuildObject()->setGuildMemberPermissionAndAllegiance(guildId, memberId, permissions, allegiance);
}

// ----------------------------------------------------------------------

void GuildInterface::setGuildMemberProfessionInfo(int guildId, NetworkId const &memberId, std::string const &memberProfessionSkillTemplate, int memberLevel)
{
	ServerUniverse::getInstance().getMasterGuildObject()->setGuildMemberProfessionInfo(guildId, memberId, memberProfessionSkillTemplate, memberLevel);
}

// ----------------------------------------------------------------------

void GuildInterface::addGuildMemberRank(int guildId, NetworkId const &memberId, std::string const &rankName)
{
	ServerUniverse::getInstance().getMasterGuildObject()->addGuildMemberRank(guildId, memberId, rankName);
}

// ----------------------------------------------------------------------

void GuildInterface::removeGuildMemberRank(int guildId, NetworkId const &memberId, std::string const &rankName)
{
	ServerUniverse::getInstance().getMasterGuildObject()->removeGuildMemberRank(guildId, memberId, rankName);
}

// ----------------------------------------------------------------------

bool GuildInterface::hasGuildMemberRank(int guildId, NetworkId const &memberId, std::string const &rankName)
{
	return ServerUniverse::getInstance().getMasterGuildObject()->hasGuildMemberRank(guildId, memberId, rankName);
}

// ----------------------------------------------------------------------

void GuildInterface::getGuildMemberRank(int guildId, NetworkId const &memberId, std::vector<std::string> &ranks)
{
	ServerUniverse::getInstance().getMasterGuildObject()->getGuildMemberRank(guildId, memberId, ranks);
}

// ----------------------------------------------------------------------

void GuildInterface::setGuildLeader(int guildId, NetworkId const &leaderId)
{
	ServerUniverse::getInstance().getMasterGuildObject()->setGuildLeader(guildId, leaderId);
}

// ----------------------------------------------------------------------

void GuildInterface::setGuildElectionEndTime(int guildId, int electionPreviousEndTime, int electionNextEndTime)
{
	ServerUniverse::getInstance().getMasterGuildObject()->setGuildElectionEndTime(guildId, electionPreviousEndTime, electionNextEndTime);
}

// ----------------------------------------------------------------------

void GuildInterface::setGuildFaction(int guildId, uint32 guildFaction)
{
	ServerUniverse::getInstance().getMasterGuildObject()->setGuildFaction(guildId, guildFaction);
}

// ----------------------------------------------------------------------

void GuildInterface::setGuildGcwDefenderRegion(int guildId, std::string const &guildGcwDefenderRegion)
{
	ServerUniverse::getInstance().getMasterGuildObject()->setGuildGcwDefenderRegion(guildId, guildGcwDefenderRegion);
}

// ----------------------------------------------------------------------

void GuildInterface::setGuildEnemy(int guildId, int enemyId)
{
	ServerUniverse::getInstance().getMasterGuildObject()->setGuildEnemy(guildId, enemyId);
}

// ----------------------------------------------------------------------

void GuildInterface::removeGuildEnemy(int guildId, int enemyId)
{
	ServerUniverse::getInstance().getMasterGuildObject()->removeGuildEnemy(guildId, enemyId);
}

// ----------------------------------------------------------------------

void GuildInterface::updateGuildWarKillTracking(CreatureObject const &killer, CreatureObject const &victim)
{
	if (killer.getGuildId()
	 && victim.getGuildId()
	 && killer.getGuildWarEnabled()
	 && victim.getGuildWarEnabled()
	 && hasDeclaredWarAgainst(killer.getGuildId(), victim.getGuildId())
	 && hasDeclaredWarAgainst(victim.getGuildId(), killer.getGuildId()))
	{
		ServerUniverse::getInstance().getMasterGuildObject()->modifyGuildWarKillTracking(killer.getGuildId(), victim.getGuildId(), 1, static_cast<int>(::time(NULL)));
	}
}

// ----------------------------------------------------------------------

void GuildInterface::setGuildName(int guildId, std::string const &newName)
{
	ServerUniverse::getInstance().getMasterGuildObject()->setGuildName(guildId, newName);
}

// ----------------------------------------------------------------------

void GuildInterface::setGuildAbbrev(int guildId, std::string const &newAbbrev)
{
	ServerUniverse::getInstance().getMasterGuildObject()->setGuildAbbrev(guildId, newAbbrev);
}

// ----------------------------------------------------------------------

void GuildInterface::onGuildIdSet(CreatureObject const &who)
{
	int const guildId = who.getGuildId();
	NetworkId const & whoId = who.getNetworkId();
	std::string const objectName = Unicode::wideToNarrow(who.getAssignedObjectName());

	GuildMemberInfo const * const memberInfo = ServerUniverse::getInstance().getMasterGuildObject()->getGuildMemberInfo(guildId, whoId);
	if (memberInfo)
	{
		bool const fixName = (!objectName.empty() && (memberInfo->m_name != objectName));
		bool const fixGuildLeaderPermissions = ((getGuildLeaderId(guildId) == whoId) && ((memberInfo->m_permissions & GuildInterface::AllAdministrativePermissions) != GuildInterface::AllAdministrativePermissions));

		WARNING(fixName, ("Fixing guild (%d) member (%s) name (%s) which doesn't match object name (%s)", guildId, whoId.getValueString().c_str(), memberInfo->m_name.c_str(), objectName.c_str()));
		WARNING(fixGuildLeaderPermissions, ("Fixing guild (%d) leader (%s) permission from (%d) to (%d)", guildId, whoId.getValueString().c_str(), memberInfo->m_permissions, (memberInfo->m_permissions | GuildInterface::AllAdministrativePermissions)));

		if (fixName || fixGuildLeaderPermissions)
		{
			ServerUniverse::getInstance().getMasterGuildObject()->setGuildMemberNameAndPermision(
				guildId,
				whoId,
				(fixName ? objectName : memberInfo->m_name),
				(fixGuildLeaderPermissions ? (memberInfo->m_permissions | GuildInterface::AllAdministrativePermissions) : memberInfo->m_permissions));
		}
	}
	else if ((getGuildLeaderId(guildId) == whoId) && !objectName.empty())
	{
		// handle the case where a guild leader somehow
		// is no longer a member of the guild
		WARNING(true, ("Guild (%d) leader (%s, %s) is currently not a guild member, so making the guild leader a guild member", guildId, whoId.getValueString().c_str(), objectName.c_str()));

		addGuildCreatorMember(guildId, whoId);
	}

	enterGuildChatRoom(who);
	enterGuildVoiceChatRoom(who);
}

// ----------------------------------------------------------------------

void GuildInterface::onAboutToClearGuildId(CreatureObject const &who)
{
	leaveGuildChatRoom(who);
}

// ----------------------------------------------------------------------

void GuildInterface::verifyGuildMemberName(NetworkId const &memberId, std::string const &memberName)
{
	int guildId = getGuildId(memberId);
	if (guildId <= 0)
		guildId = getGuildIdForSponsored(memberId);

	if (guildId <= 0)
		return;

	GuildMemberInfo const * const memberInfo = getGuildMemberInfo(guildId, memberId);
	if (!memberInfo)	
		return;

	if (memberInfo->m_name == memberName)
		return;

	ServerUniverse::getInstance().getMasterGuildObject()->setGuildMemberNameAndPermision(
		guildId,
		memberId,
		memberName,
		memberInfo->m_permissions);
}

// ----------------------------------------------------------------------

void GuildInterface::enterGuildChatRoom(CreatureObject const &who)
{
	int guildId = who.getGuildId();
	if (guildId)
	{
		Chat::createRoom("System", false, getChatRoomPath(guildId), getChatRoomTitle(guildId));
		std::string firstName;
		size_t pos = 0;
		IGNORE_RETURN(Unicode::getFirstToken(Unicode::wideToNarrow(who.getObjectName()), 0, pos, firstName));
		Chat::invite(firstName, getChatRoomPath(guildId));
		Chat::enterRoom(firstName, getChatRoomPath(guildId), false, false);
	}
}

// ----------------------------------------------------------------------

void GuildInterface::reenterGuildChatRoom(CreatureObject const &who)
{
	int guildId = who.getGuildId();
	if (guildId)
	{
		std::string firstName;
		size_t pos = 0;
		IGNORE_RETURN(Unicode::getFirstToken(Unicode::wideToNarrow(who.getObjectName()), 0, pos, firstName));

		std::string const guildChatRoomPath = getChatRoomPath(guildId);
		Chat::exitRoom(firstName, guildChatRoomPath);
		Chat::uninvite(firstName, guildChatRoomPath);
		Chat::invite(firstName, guildChatRoomPath);
		Chat::enterRoom(firstName, guildChatRoomPath, false, false);
	}
}

// ----------------------------------------------------------------------

void GuildInterface::enterGuildVoiceChatRoom(CreatureObject const &who)
{
	int guildId = who.getGuildId();
	if (guildId)
	{
		std::string firstName;
		size_t pos = 0;
		IGNORE_RETURN(Unicode::getFirstToken(Unicode::wideToNarrow(who.getObjectName()), 0, pos, firstName));

		std::string roomPath = getChatRoomPath(guildId);

		PendingChannelAddMap::iterator entryItr = s_pendingChannelAdds.find(roomPath);
		if(entryItr == s_pendingChannelAdds.end()) //not currently pending
		{
			Chat::requestGetChannel(roomPath, false, true, s_guildChannelLimit);
			s_pendingChannelAdds[roomPath].insert(std::make_pair(firstName, who.getNetworkId()));
			//DEBUG_WARNING(true,("Created channel and differed add for %s %s %s", roomPath.c_str(), who.getNetworkId().getValueString().c_str(), firstName.c_str()));

		}
		else //already have a request out
		{
			entryItr->second[firstName] = who.getNetworkId();
			//DEBUG_WARNING(true,("added differed add for %s %s %s", roomPath.c_str(), who.getNetworkId().getValueString().c_str(), firstName.c_str()));
		}
	}
}


// ----------------------------------------------------------------------

void GuildInterface::leaveGuildChatRoom(CreatureObject const &who)
{
	int guildId = who.getGuildId();
	if (guildId)
	{
		std::string firstName;
		size_t pos = 0;
		IGNORE_RETURN(Unicode::getFirstToken(Unicode::wideToNarrow(who.getObjectName()), 0, pos, firstName));
		Chat::exitRoom(firstName, getChatRoomPath(guildId));
		Chat::uninvite(firstName, getChatRoomPath(guildId));
	}
}

// ----------------------------------------------------------------------

void GuildInterface::leaveGuildVoiceChatRoom(NetworkId const & playerNetworkId, std::string const & firstName, int guildId)
{
	PendingChannelAddMap::iterator channelAddList = s_pendingChannelAdds.find(getChatRoomPath(guildId));
	if(channelAddList != s_pendingChannelAdds.end())
	{
		PendingChannelAddList::iterator creatureEntry = channelAddList->second.find(firstName);
		if(creatureEntry != channelAddList->second.end())
		{
			channelAddList->second.erase(creatureEntry);
		}
	}

	Chat::requestRemoveClientFromChannel(playerNetworkId, firstName, getChatRoomPath(guildId));
}

// ----------------------------------------------------------------------

void GuildInterface::sendGuildChat(CreatureObject const &who, Unicode::String const &text)
{
	int guildId = who.getGuildId();
	if (guildId)
	{
		std::string firstName;
		size_t pos = 0;
		IGNORE_RETURN(Unicode::getFirstToken(Unicode::wideToNarrow(who.getObjectName()), 0, pos, firstName));
		Chat::sendToRoom(firstName, getChatRoomPath(guildId), text, Unicode::String());
	}
}

// ---------------------------------------------------------------------

void GuildInterface::onChatRoomCreate(std::string const &path)
{
	std::string const &prefix = getChatRoomPrefix();
	if (!path.compare(0, prefix.length(), prefix))
	{
		int guildId = atoi(path.c_str()+prefix.length());
		if (guildId)
		{
			std::vector<ServerObject *> players;
			GameServer::getInstance().getObjectsWithClients(players);
			for (std::vector<ServerObject *>::const_iterator i = players.begin(); i != players.end(); ++i)
			{
				if ((*i)->isAuthoritative() && (*i)->isPlayerControlled())
				{
					CreatureObject const *playerCreature = (*i)->asCreatureObject();
					if (playerCreature && playerCreature->getGuildId() == guildId)
						enterGuildChatRoom(*playerCreature);
				}
			}
		}
	}
}

void GuildInterface::onVoiceChatRoomCreate(std::string const &roomPath)
{
	//DEBUG_WARNING(true, ("onVoiceChatRoomCreate path %s", roomPath.c_str()));
	PendingChannelAddMap::iterator entry = s_pendingChannelAdds.find(roomPath);
	if(entry != s_pendingChannelAdds.end())
	{
		std::string const & path = entry->first;
		PendingChannelAddList const & pendingAdds = entry->second;
		for(PendingChannelAddList::const_iterator i = pendingAdds.begin(); i != pendingAdds.end(); ++i)
		{
			//DEBUG_WARNING(true,("Requesting add for %s %s %s", path.c_str(), i->second.getValueString().c_str(), i->first.c_str()));
			Chat::requestAddClientToChannel(i->second, i->first, path, true);
		}
		s_pendingChannelAdds.erase(entry);
	}
}

// ----------------------------------------------------------------------

void GuildInterface::createAllGuildChatRooms()
{
	std::set<int> guildIds;
	std::vector<ServerObject *> players;
	GameServer::getInstance().getObjectsWithClients(players);
	for (std::vector<ServerObject *>::const_iterator i = players.begin(); i != players.end(); ++i)
	{
		if ((*i)->isAuthoritative() && (*i)->isPlayerControlled())
		{
			CreatureObject const *playerCreature = (*i)->asCreatureObject();
			if (playerCreature && playerCreature->getGuildId())
				IGNORE_RETURN(guildIds.insert(playerCreature->getGuildId()));
		}
	}
	for (std::set<int>::const_iterator j = guildIds.begin(); j != guildIds.end(); ++j)
	{
		Chat::createRoom("System", false, getChatRoomPath(*j), getChatRoomTitle(*j));

		//TODO: temporary separation of voice and text, this should be rolled into the createRoom call above
		//We create the chat room when a guild member logs in, it will save us $$ to not
		//create it here.
		//Chat::requestGetChannel(getVoiceChatRoomPath(*j), false, false);
	}
}

// ----------------------------------------------------------------------
// returns the number of guild members, guild name, and guild abbrev that the
// mail was sent to or -1 if insufficient permission to send mail to guild members
std::pair<int, std::pair<std::string, std::string> > GuildInterface::mailToGuild(CreatureObject const &who, Unicode::String const &subject, Unicode::String const &message, Unicode::String const &oob)
{
	int count = -1;
	std::string guildName, guildAbbrev;
	int const guildId = who.getGuildId();
	GuildInfo const * const gi = ServerUniverse::getInstance().getMasterGuildObject()->getGuildInfo(guildId);
	if (gi)
	{
		GuildMemberInfo const * const mailerInfo = ServerUniverse::getInstance().getMasterGuildObject()->getGuildMemberInfo(guildId, who.getNetworkId());
		if (mailerInfo && ((mailerInfo->m_permissions & GuildInterface::Mail) || (gi->m_leaderId == who.getNetworkId())))
		{
			guildName = gi->m_name;
			guildAbbrev = gi->m_abbrev;
			count = 0;
			std::vector<NetworkId> memberIds;
			ServerUniverse::getInstance().getMasterGuildObject()->getGuildMemberIds(guildId, memberIds);
			for (std::vector<NetworkId>::const_iterator i = memberIds.begin(); i != memberIds.end(); ++i)
			{
				GuildMemberInfo const * const memberInfo = ServerUniverse::getInstance().getMasterGuildObject()->getGuildMemberInfo(guildId, *i);
				if (memberInfo && (memberInfo->m_permissions & GuildInterface::Member))
				{
					Chat::sendPersistentMessage(Unicode::wideToNarrow(who.getEncodedObjectName()), memberInfo->m_name, subject, message, oob);
					++count;
				}
			}
		}
	}

	return std::make_pair(count, std::make_pair(guildName, guildAbbrev));
}

// ----------------------------------------------------------------------
// returns the number of guild members, guild name, and guild abbrev that the
// mail was sent to or -1 if insufficient permission to send mail to guild members
std::pair<int, std::pair<std::string, std::string> > GuildInterface::mailToGuild(int guildId, Unicode::String const &subject, Unicode::String const &message, Unicode::String const &oob)
{
	int count = -1;
	std::string guildName, guildAbbrev;
	GuildInfo const * const gi = ServerUniverse::getInstance().getMasterGuildObject()->getGuildInfo(guildId);
	if (gi)
	{
		guildName = gi->m_name;
		guildAbbrev = gi->m_abbrev;
		count = 0;
		std::vector<NetworkId> memberIds;
		ServerUniverse::getInstance().getMasterGuildObject()->getGuildMemberIds(guildId, memberIds);
		for (std::vector<NetworkId>::const_iterator i = memberIds.begin(); i != memberIds.end(); ++i)
		{
			GuildMemberInfo const * const memberInfo = ServerUniverse::getInstance().getMasterGuildObject()->getGuildMemberInfo(guildId, *i);
			if (memberInfo && (memberInfo->m_permissions & GuildInterface::Member))
			{
				Chat::sendPersistentMessage(guildName, memberInfo->m_name, subject, message, oob);
				++count;
			}
		}
	}

	return std::make_pair(count, std::make_pair(guildName, guildAbbrev));
}

// ----------------------------------------------------------------------
// returns the number of guild members, guild name, and guild abbrev that the
// mail was sent to or -1 if insufficient permission to send mail to guild members
std::pair<int, std::pair<std::string, std::string> > GuildInterface::mailToGuildRank(CreatureObject const &who, int guildRankSlotId, Unicode::String const &subject, Unicode::String const &message, Unicode::String const &oob)
{
	int count = -1;
	std::string guildName, guildAbbrev;
	int const guildId = who.getGuildId();
	GuildInfo const * const gi = ServerUniverse::getInstance().getMasterGuildObject()->getGuildInfo(guildId);
	if (gi)
	{
		GuildMemberInfo const * const mailerInfo = ServerUniverse::getInstance().getMasterGuildObject()->getGuildMemberInfo(guildId, who.getNetworkId());
		if (mailerInfo && ((mailerInfo->m_permissions & GuildInterface::Mail) || (gi->m_leaderId == who.getNetworkId())))
		{
			guildName = gi->m_name;
			guildAbbrev = gi->m_abbrev;
			count = 0;
			std::vector<NetworkId> memberIds;
			ServerUniverse::getInstance().getMasterGuildObject()->getGuildMemberIds(guildId, memberIds);
			for (std::vector<NetworkId>::const_iterator i = memberIds.begin(); i != memberIds.end(); ++i)
			{
				GuildMemberInfo const * const memberInfo = ServerUniverse::getInstance().getMasterGuildObject()->getGuildMemberInfo(guildId, *i);
				if (memberInfo && (memberInfo->m_permissions & GuildInterface::Member) && memberInfo->m_rank.testBit(guildRankSlotId))
				{
					Chat::sendPersistentMessage(Unicode::wideToNarrow(who.getEncodedObjectName()), memberInfo->m_name, subject, message, oob);
					++count;
				}
			}
		}
	}

	return std::make_pair(count, std::make_pair(guildName, guildAbbrev));
}

// ======================================================================