// Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net) - EQ2Emulator License

#pragma once

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <iostream>
#include <sstream>
#include <string>
#include <thread>
#include <chrono>
#include <map>
#include <vector>
#include <condition_variable>
#include <mutex>

#include <boost/algorithm/string.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/json_parser.hpp>
#include <boost/beast/http.hpp>

#include "net.hpp"
#include "client.hpp"
#include "login_opcodes.hpp"
#include "login_structs.hpp"
#include "login_database.hpp"
#include "packet_headers.hpp"
#include "../common/log.hpp"
#include "../common/tcp.hpp"
#include "../common/unix.hpp"
#include "../common/timer.hpp"
#include "../common/types.hpp"
#include "../common/queue.hpp"
#include "../common/debug.hpp"
#include "../common/servertalk.hpp"
#include "../common/linked_list.hpp"
#include "../common/config_reader.hpp"
#include "../common/packet/packet_dump.hpp"
#include "../WorldServer/MutexList.h"
#include "../WorldServer/MutexMap.h"

namespace beast = boost::beast;
namespace http = beast::http;

using namespace std;

#define ERROR_BADPASSWORD			"Bad password"
#define	INVALID_ACCOUNT				"Invalid Server Account."
#define ERROR_BADVERSION			"Incorrect version"
#define ERROR_UNNAMED				"Unnamed servers not allowed to connect to full login servers"
#define ERROR_NOTMASTER				"Not a master server"
#define ERROR_NOTMESH				"Not a mesh server"
#define ERROR_GHOST					"Ghost kick"
#define ERROR_UnknownServerType		"Unknown Server Type"
#define ERROR_BADNAME_SERVER		"Bad server name, name may not contain the word \"Server\" (case sensitive)"
#define ERROR_BADNAME				"Bad server name. Unknown reason."
#define WORLD_NAME_SUFFIX			" Server"
#define MAX_UPDATE_COUNT			20
#define MAX_LOGIN_APPEARANCE_COUNT	100
#define SOCKET_ERROR				-1
#define INVALID_SOCKET				-1

extern int errno;

enum ConType { UnknownW, World, Chat, Login };

// Forward declarations
class LWorld;
class LWorldList;
class ClientList;
class NetConnection;
class LoginDatabase;
class ConfigReader;

extern ClientList client_list;
extern NetConnection net;
extern LWorldList world_list;
extern LoginDatabase database;
extern ConfigReader configReader;
extern volatile bool RunLoops;

void* ServerUpdateLoop(void* tmp);

// Represents a login world server connection and manages communication
class LWorld
{
public:
	// Constructor for incoming TCP connections from world servers
	LWorld(TCPConnection* in_con, bool OutgoingLoginUplink = false, int32 iIP = 0, int16 iPort = 0, bool iNeverKick = false);
	
	// Constructor for placeholder world entries from database
	LWorld(int32 in_accountid, char* in_accountname, char* in_worldname, int32 in_admin_id);
	
	// Constructor for remote world server connections via mesh networking
	LWorld(TCPConnection* in_RemoteLink, int32 in_ip, int32 in_RemoteID, int32 in_accountid, char* in_accountname, char* in_worldname, char* in_address, sint32 in_status, int32 in_adminid, bool in_showdown, int8 in_authlevel, bool in_placeholder, int32 iLinkWorldID);
	
	~LWorld();

	// Validates server name format and character restrictions
	static bool CheckServerName(const char* name);
	
	// Main processing loop - handles incoming packets and connection state
	bool Process();
	
	// Sends a server packet to this world server
	void SendPacket(ServerPacket* pack);
	
	// Sends a formatted message to a specific player on this world server
	void Message(const char* to, const char* message, ...);

	// Authenticates and configures the world server connection
	bool SetupWorld(char* in_worldname, char* in_worldaddress, char* in_account, char* in_password, char* in_version);
	
	// Updates the world server's status information and triggers world list refresh if changed
	void UpdateStatus(sint32 in_status, sint32 in_players, sint32 in_zones, int8 in_level)
	{
		if (status != in_status || num_players != in_players || num_zones != in_zones || world_max_level != in_level) {
			status = in_status;
			num_players = in_players;
			num_zones = in_zones;
			world_max_level = in_level;
			UpdateWorldList();
		}
	}
	
	// Triggers a world list update notification
	void UpdateWorldList(LWorld* to = 0);
	
	// Sets remote server information for mesh networking
	void SetRemoteInfo(int32 in_ip, int32 in_accountid, char* in_account, char* in_name, char* in_address, int32 in_status, int32 in_adminid, sint32 in_players, sint32 in_zones);

	// Accessor methods
	inline bool IsPlaceholder() { return pPlaceholder; }
	inline int32 GetAccountID() { return accountid; }
	inline char* GetAccount() { return account; }
	inline char* GetAddress() { return address; }
	inline int16 GetClientPort() { return pClientPort; }
	inline bool IsAddressIP() { return isaddressip; }
	inline char* GetName() { return worldname; }
	inline sint32 GetStatus() { return status; }
	inline bool IsLocked() { return status == -2; }
	inline int32 GetIP() { return ip; }
	inline int16 GetPort() { return port; }
	inline int32 GetID() { return ID; }
	inline int32 GetAdmin() { return admin_id; }
	inline bool ShowDown() { return pshowdown; }
	inline bool ShowDownActive() { return show_down_active; }
	inline bool Connected() { return pConnected; }
	inline bool IsKicked() { return kicked; }
	inline bool IsNeverKick() { return pNeverKick; }
	inline ConType GetType() { return ptype; }
	inline bool IsOutgoingUplink() { return OutgoingUplink; }
	inline TCPConnection* GetLink() { return Link; }
	inline int32 GetRemoteID() { return RemoteID; }
	inline int32 GetLinkWorldID() { return LinkWorldID; }
	inline sint32 GetZoneNum() { return num_zones; }
	inline sint32 GetPlayerNum() { return num_players; }
	inline int8 GetMaxWorldLevel() { return world_max_level; }
	inline bool IsDevelServer() { return devel_server; }

	// Mutator methods
	inline void ShowDownActive(bool show) { show_down_active = show; }
	inline void ShowDown(bool show) { pshowdown = show; }
	inline void SetID(int32 new_id) { ID = new_id; }

	// Returns world status for client display (0=up, 1=dev, 2=locked)
	int8 GetWorldStatus();

	// Converts active world to offline placeholder
	void ChangeToPlaceholder();
	
	// Disconnects the world server with optional error message
	void Kick(const char* message = ERROR_GHOST, bool iSetKickedFlag = true);
	
	// Sends character deletion notification to world server
	void SendDeleteCharacter(int32 char_id, int32 account_id);

	bool IsInit; // Public flag indicating if world is fully initialized

protected:
	friend class LWorldList;
	TCPConnection* Link;	// TCP connection to world server
	Timer* pReconnectTimer;	// Timer for reconnection attempts
	Timer* pStatsTimer;		// Timer for stats updates

private:
	int32 ID;				// Unique world server ID
	int32 ip;				// IP address of world server
	char IPAddr[64];		// String representation of IP
	int16 port;				// Port number of world server
	bool kicked;			// Flag indicating if server was kicked
	bool pNeverKick;		// Flag preventing automatic kicks
	bool pPlaceholder;		// Flag indicating placeholder entry
	bool devel_server;		// Flag indicating development server
	int32 accountid;		// Database account ID
	char account[30];		// Account name
	char address[250];		// Server address string
	bool isAuthenticated;	// Authentication status
	int16 pClientPort;		// Client connection port
	bool isaddressip;		// Flag indicating if address is IP
	char worldname[200];	// Display name of world server
	sint32 status;			// Current server status
	int32 admin_id;			// Administrator account ID
	bool pshowdown;			// Show server as down flag
	bool show_down_active;	// Active showdown state
	ConType ptype;			// Connection type
	bool OutgoingUplink;	// Outgoing connection flag
	bool pConnected;		// Connection state flag
	sint32 num_players;		// Current player count
	sint32 num_zones;		// Current zone count
	int32 RemoteID;			// Remote server ID for mesh
	int32 LinkWorldID;		// Linked world ID for mesh
	int8 world_max_level;	// Maximum character level
};

// Manages list of world servers and handles server discovery/communication
class LWorldList
{
public:
	LWorldList();
	~LWorldList();

	// Search methods for finding world servers
	LWorld* FindByID(int32 WorldID);
	LWorld* FindByIP(int32 ip);
	LWorld* FindByAddress(char* address);
	LWorld* FindByLink(TCPConnection* in_link, int32 in_id);
	LWorld* FindByAccount(int32 in_accountid, ConType in_type = World);

	// World server management
	void Add(LWorld* worldserver);
	void AddInitiateWorld(LWorld* world);
	void Process();
	void ReceiveData();
	
	// Packet distribution methods
	void SendPacket(ServerPacket* pack, LWorld* butnotme = 0);
	void SendPacketLocal(ServerPacket* pack, LWorld* butnotme = 0);
	void SendPacketLogin(ServerPacket* pack, LWorld* butnotme = 0);
	
	// World list maintenance
	void SendWorldChanged(int32 server_id, bool sendtoallclients = false, Client* sendto = 0);
	vector<PacketStruct*>* GetServerListUpdate(int16 version);
	EQ2Packet* MakeServerListPacket(int8 lsadmin, int16 version);
	void UpdateWorldList(LWorld* to = 0);
	void UpdateWorldStats();
	
	// Connection management
	void KickGhost(ConType in_type, int32 in_accountid = 0, LWorld* ButNotMe = 0);
	void KickGhostIP(int32 ip, LWorld* NotMe = 0, int16 iClientPort = 0);
	void RemoveByLink(TCPConnection* in_link, int32 in_id = 0, LWorld* ButNotMe = 0);
	void RemoveByID(int32 in_id);

	// Administrative functions
	void SendWorldStatus(LWorld* chat, char* adminname);
	void ConnectUplink();
	bool Init();
	void InitWorlds();
	void Shutdown();
	bool WriteXML();
	
	// Statistics and information
	int32 GetCount(ConType type);
	void PopulateWorldList(http::response<http::string_body>& res);
	void ListWorldsToConsole();
	
	// Zone and equipment update handling
	void AddServerEquipmentUpdates(LWorld* world, map<int32, LoginEquipmentUpdate> updates);
	void ProcessLSEquipUpdates();
	void RequestServerEquipUpdates(LWorld* world);
	void ProcessServerUpdates();
	void RequestServerUpdates(LWorld* world);
	void AddServerZoneUpdates(LWorld* world, map<int32, LoginZoneUpdate> updates);

	// Thread control
	void SetUpdateServerList(bool var) { UpdateServerList = var; }
	bool ContinueServerUpdates() { return server_update_thread; }
	void ResetServerUpdates() { server_update_thread = true; }

protected:
	friend class LWorld;
	int32 GetNextID() { return NextID++; }

private:
	Mutex MWorldMap;													// Mutex for thread-safe world map access
	map<int32, map<int32, bool>> zone_updates_already_used;			// DOS prevention for zone updates
	MutexMap<int32, int32> zone_update_timeouts;					// Zone update timeout tracking
	MutexMap<int32, int32> awaiting_zone_update;					// Pending zone update tracking
	MutexMap<LWorld*, int32> last_updated;							// Last update time per world
	MutexMap<int32, map<int32, LoginZoneUpdate>> server_zone_updates; // Zone update data
	bool server_update_thread;										// Thread control flag
	int32 NextID;													// Next available world ID
	LinkedList<LWorld*> list;										// Initialization world list
	map<int32, LWorld*> worldmap;									// Active world server map
	TCPServer* tcplistener;											// TCP server for connections
	TCPConnection* OutLink;											// Outgoing connection for slave mode
	map<int32, map<int32, bool>> equip_updates_already_used;		// Equipment update DOS prevention
	MutexMap<int32, int32> equip_update_timeouts;					// Equipment update timeouts
	MutexMap<int32, int32> awaiting_equip_update;					// Pending equipment updates
	MutexMap<LWorld*, int32> last_equip_updated;					// Last equipment update time
	MutexMap<int32, map<int32, LoginEquipmentUpdate>> server_equip_updates; // Equipment update data
	map<int32, EQ2Packet*> ServerListData;							// Cached server list packets
	bool UpdateServerList;											// Server list update flag
};

// Implementation

// Constructor for incoming TCP connections
LWorld::LWorld(TCPConnection* in_con, bool in_OutgoingLoginUplink, int32 iIP, int16 iPort, bool iNeverKick)
{
	Link = in_con;
	RemoteID = 0;
	LinkWorldID = 0;
	
	if (iIP)
		ip = iIP;
	else
		ip = in_con->GetrIP();

	struct in_addr in;
	in.s_addr = in_con->GetrIP();
	char* ipadd = inet_ntoa(in);
	if (ipadd)
		strncpy(IPAddr, ipadd, 64);

	if (iPort)
		port = iPort;
	else
		port = in_con->GetrPort();
		
	ID = 0;
	pClientPort = 0;
	memset(account, 0, sizeof(account));
	memset(address, 0, sizeof(address));
	memset(worldname, 0, sizeof(worldname));
	status = 0;
	accountid = 0;
	admin_id = 0;
	IsInit = false;
	kicked = false;
	pNeverKick = iNeverKick;
	pPlaceholder = false;
	pshowdown = false;
	pConnected = in_con->Connected();
	pReconnectTimer = 0;
	pStatsTimer = NULL;
	isAuthenticated = false;

	if (in_OutgoingLoginUplink) {
		pClientPort = port;
		ptype = Login;
		OutgoingUplink = true;
		if (net.GetLoginMode() == Mesh) {
			pReconnectTimer = new Timer(INTERSERVER_TIMER);
			pReconnectTimer->Trigger();
		}
	} else {
		ptype = UnknownW;
		OutgoingUplink = false;
	}

	in.s_addr = GetIP();
	strcpy(address, inet_ntoa(in));
	isaddressip = true;
	num_players = 0;
	num_zones = 0;
}

// Constructor for placeholder entries
LWorld::LWorld(int32 in_accountid, char* in_accountname, char* in_worldname, int32 in_admin_id)
{
	pPlaceholder = true;
	Link = 0;
	ip = 0;
	port = 0;
	ID = 0;
	strcpy(IPAddr, "");
	pClientPort = 0;
	memset(account, 0, sizeof(account));
	memset(address, 0, sizeof(address));
	memset(worldname, 0, sizeof(worldname));
	status = 0;
	accountid = in_accountid;
	admin_id = in_admin_id;
	IsInit = false;
	kicked = false;
	pNeverKick = false;
	pshowdown = true;
	RemoteID = 0;
	LinkWorldID = 0;
	OutgoingUplink = false;
	pReconnectTimer = 0;
	pConnected = false;
	pStatsTimer = NULL;
	ptype = World;
	
	strcpy(account, in_accountname);
	strcpy(worldname, in_worldname);
	strcpy(address, "none");
	isaddressip = true;
	num_players = 0;
	num_zones = 0;
}

// Constructor for remote connections
LWorld::LWorld(TCPConnection* in_RemoteLink, int32 in_ip, int32 in_RemoteID, int32 in_accountid, char* in_accountname, char* in_worldname, char* in_address, sint32 in_status, int32 in_adminid, bool in_showdown, int8 in_authlevel, bool in_placeholder, int32 iLinkWorldID)
{
	Link = in_RemoteLink;
	RemoteID = in_RemoteID;
	LinkWorldID = iLinkWorldID;
	ip = in_ip;
	
	struct in_addr in;
	if (in_RemoteLink)
		in.s_addr = in_RemoteLink->GetrIP();
	else if (in_ip)
		in.s_addr = in_ip;
	char* ipadd = inet_ntoa(in);
	if (ipadd)
		strncpy(IPAddr, ipadd, 64);

	port = 0;
	ID = 0;
	pClientPort = 0;
	memset(account, 0, sizeof(account));
	memset(address, 0, sizeof(address));
	memset(worldname, 0, sizeof(worldname));
	status = in_status;
	accountid = in_accountid;
	admin_id = in_adminid;
	IsInit = true;
	kicked = false;
	pNeverKick = false;
	pPlaceholder = in_placeholder;
	pshowdown = in_showdown;
	OutgoingUplink = false;
	pReconnectTimer = 0;
	pConnected = true;
	pStatsTimer = NULL;
	ptype = World;
	
	strcpy(account, in_accountname);
	strcpy(worldname, in_worldname);
	strcpy(address, in_address);
	isaddressip = false;
	num_players = 0;
	num_zones = 0;
}

// Destructor - cleanup resources and notify other servers
LWorld::~LWorld()
{
	safe_delete(pStatsTimer);
	num_zones = 0;
	num_players = 0;
	database.UpdateWorldServerStats(this, -4);

	if (ptype == World && RemoteID == 0) {
		if (net.GetLoginMode() != Mesh || (!pPlaceholder && IsInit)) {
			ServerPacket* pack = new ServerPacket(ServerOP_WorldListRemove, sizeof(int32));
			*((int32*) pack->pBuffer) = GetID();
			world_list.SendPacketLogin(pack);
			delete pack;
		}
	}

	if (Link != 0 && RemoteID == 0) {
		world_list.RemoveByLink(Link, 0, this);
		if (OutgoingUplink)
			delete Link;
		else
			Link->Free();
	}
	Link = 0;
	safe_delete(pReconnectTimer);
	world_list.RemoveByID(this->GetID());
}

// Main packet processing loop
bool LWorld::Process()
{
	bool ret = true;
	if (Link == 0)
		return true;
		
	if (Link->Connected()) {
		if (!pConnected)
			pConnected = true;
	} else {
		pConnected = false;
		if (pReconnectTimer) {
			if (pReconnectTimer->Check() && Link->ConnectReady())
				pReconnectTimer->Start(pReconnectTimer->GetTimerTime() + (rand() % 15000), false);
			return true;
		}
		return false;
	}
	
	if (RemoteID != 0)
		return true;

	// Check for authentication and ban status periodically
	if (pStatsTimer && pStatsTimer->Check()) {
		if (isAuthenticated && (database.IsServerAccountDisabled(account) || database.IsIPBanned(IPAddr))) {
			this->Kick(ERROR_BADPASSWORD);
			return false;
		}
		database.UpdateWorldServerStats(this, GetStatus());
	}

	ServerPacket* pack = 0;
	while (ret && (pack = Link->PopPacket())) {
		// Require authentication before processing most packets
		if (!isAuthenticated && pack->opcode != ServerOP_LSInfo) {
			Kick("This connection has not authenticated.");
			break;
		}

		switch (pack->opcode) {
		case 0:
			break;
			
		case ServerOP_KeepAlive:
			// Ignore keepalive packets
			break;
			
		case ServerOP_LSFatalError:
			net.Uplink_WrongVersion = true;
			ret = false;
			kicked = true;
			break;
			
		case ServerOP_CharacterCreate: {
			WorldCharNameFilterResponse_Struct* wcnfr = (WorldCharNameFilterResponse_Struct*) pack->pBuffer;
			Client* client = client_list.FindByLSID(wcnfr->account_id);
			if (!client) {
				if (wcnfr->account_id == 0)
					client_list.FindByCreateRequest();
				break;
			}
			if (wcnfr->response == 1)
				client->CharacterApproved(GetID(), wcnfr->char_id);
			else
				client->CharacterRejected(wcnfr->response);
			break;
		}
		
		case ServerOP_UsertoWorldReq: {
			UsertoWorldRequest_Struct* ustwr = (UsertoWorldRequest_Struct*) pack->pBuffer;
			if (ustwr->ToID) {
				LWorld* world = world_list.FindByID(ustwr->ToID);
				if (!world || this->GetType() != Login)
					break;
				ustwr->FromID = this->GetID();
				world->SendPacket(pack);
			}
			break;
		}
		
		case ServerOP_UsertoWorldResp: {
			if (pack->size != sizeof(UsertoWorldResponse_Struct))
				break;
			UsertoWorldResponse_Struct* seps = (UsertoWorldResponse_Struct*) pack->pBuffer;
			if (seps->ToID) {
				LWorld* world = world_list.FindByID(seps->ToID);
				if (this->GetType() != Login)
					break;
				if (world) {
					seps->ToID = world->GetRemoteID();
					world->SendPacket(pack);
				}
			} else {
				Client* client = client_list.FindByLSID(seps->lsaccountid);
				if (client == 0 || (this->GetID() != seps->worldid && this->GetType() != Login))
					break;
				client->WorldResponse(GetID(), seps->response, seps->ip_address, seps->port, seps->access_key);
			}
			break;
		}
		
		case ServerOP_CharTimeStamp: {
			if (pack->size != sizeof(CharacterTimeStamp_Struct))
				break;
			CharacterTimeStamp_Struct* cts = (CharacterTimeStamp_Struct*) pack->pBuffer;
			if (!database.UpdateCharacterTimeStamp(cts->account_id, cts->char_id, cts->unix_timestamp, GetAccountID()))
				printf("TimeStamp update error with character id %i of account id %i on server %i\n", cts->char_id, cts->account_id, GetAccountID());
			break;
		}
		
		case ServerOP_GetTableData:
		case ServerOP_GetTableQuery:
		case ServerOP_GetLatestTables:
			Kick("This is not an update server.");
			break;
			
		case ServerOP_ZoneUpdate: {
			if (pack->size > CHARZONESTRUCT_MAXSIZE)
				break;
			CharZoneUpdate_Struct* czu = (CharZoneUpdate_Struct*)pack->pBuffer;
			database.UpdateCharacterZone(czu->account_id, czu->char_id, czu->zone_id, GetAccountID());
			break;
		}
		
		case ServerOP_RaceUpdate: {
			if (pack->size != sizeof(RaceUpdate_Struct))
				break;
			RaceUpdate_Struct* ru = (RaceUpdate_Struct*) pack->pBuffer;
			database.UpdateCharacterRace(ru->account_id, ru->char_id, ru->model_type, ru->race, this->GetAccountID());
			break;
		}
		
		case ServerOP_BasicCharUpdate: {
			if (pack->size != sizeof(CharDataUpdate_Struct))
				break;
			CharDataUpdate_Struct* cdu = (CharDataUpdate_Struct*) pack->pBuffer;
			switch (cdu->update_field) {
			case LEVEL_UPDATE_FLAG:
				database.UpdateCharacterLevel(cdu->account_id, cdu->char_id, cdu->update_data, this->GetAccountID());
				break;
			case CLASS_UPDATE_FLAG:
				database.UpdateCharacterClass(cdu->account_id, cdu->char_id, cdu->update_data, this->GetAccountID());
				break;
			case GENDER_UPDATE_FLAG:
				database.UpdateCharacterGender(cdu->account_id, cdu->char_id, cdu->update_data, this->GetAccountID());
				break;
			case DELETE_UPDATE_FLAG:
				if (cdu->update_field == 1)
					database.DeleteCharacter(cdu->account_id, cdu->char_id, this->GetAccountID());
				break;
			}
			break;
		}
		
		case ServerOP_NameCharUpdate: {
			CharNameUpdate_Struct* cnu = (CharNameUpdate_Struct*) pack->pBuffer;
			if (cnu->name_length > 0 && cnu->name_length < 64) {
				char name_buffer[64];
				strncpy(name_buffer, cnu->new_name, cnu->name_length);
				name_buffer[cnu->name_length] = '\0';
				database.UpdateCharacterName(cnu->account_id, cnu->char_id, name_buffer, this->GetAccountID());
			}
			break;
		}
		
		case ServerOP_LSInfo: {
			if (pack->size != sizeof(ServerLSInfo_Struct)) {
				this->Kick(ERROR_BADVERSION);
				ret = false;
			} else {
				ServerLSInfo_Struct* lsi = (ServerLSInfo_Struct*) pack->pBuffer;
				if (strcmp(lsi->protocolversion, EQEMU_PROTOCOL_VERSION) != 0 || !database.CheckVersion(lsi->serverversion)) {
					cout << "ERROR - KICK BAD VERSION: Got versions: protocol: '" << lsi->protocolversion << "', database version: " << lsi->serverversion << endl;
					cout << "To allow all world server versions to login, run query on your login database (alternatively replacing * with the database version if preferred): insert into login_versions set version = '*';" << endl;
					this->Kick(ERROR_BADVERSION);
					ret = false;
				} else if (!SetupWorld(lsi->name, lsi->address, lsi->account, lsi->password, lsi->serverversion)) {
					this->Kick(ERROR_BADPASSWORD);
					ret = false;
				} else {
					isAuthenticated = true;
					devel_server = (lsi->servertype == 4);
				}
			}
			break;
		}
		
		case ServerOP_LSStatus: {
			ServerLSStatus_Struct* lss = (ServerLSStatus_Struct*) pack->pBuffer;
			if (lss->num_players > 5000 || lss->num_zones > 500) {
				this->Kick("Your server has exceeded a number of players and/or zone limit.");
				ret = false;
				break;
			}
			UpdateStatus(lss->status, lss->num_players, lss->num_zones, lss->world_max_level);
			break;
		}
		
		case ServerOP_SystemwideMessage: {
			if (this->GetType() == Login) {
				// Prevent message loops
			} else if (this->GetType() == Chat) {
				world_list.SendPacket(pack);
			}
			break;
		}
		
		case ServerOP_ListWorlds: {
			if (pack->size <= 1 || pack->pBuffer[pack->size - 1] != 0)
				break;
			world_list.SendWorldStatus(this, (char*) pack->pBuffer);
			break;
		}
		
		case ServerOP_WorldListUpdate:
			break;
			
		case ServerOP_WorldListRemove: {
			if (this->GetType() != Login || pack->size != sizeof(int32))
				break;
			cout << "Got world remove for remote #" << *((int32*) pack->pBuffer) << endl;
			if ((*((int32*) pack->pBuffer)) > 0) {
				LWorld* world = world_list.FindByLink(this->GetLink(), *((int32*) pack->pBuffer));
				if (world && world->GetRemoteID() != 0) {
					*((int32*) pack->pBuffer) = world->GetID();
					if (net.GetLoginMode() != Mesh)
						world_list.SendPacketLogin(pack, this);
					world_list.RemoveByID(*((int32*) pack->pBuffer));
				}
			}
			break;
		}
		
		case ServerOP_TriggerWorldListRefresh: {
			world_list.UpdateWorldList();
			if (net.GetLoginMode() != Mesh)
				world_list.SendPacketLogin(pack, this);
			break;
		}
		
		case ServerOP_ZoneUpdates: {
			pack->Inflate();
			ZoneUpdateList_Struct* updates = 0;
			if (pack->size >= sizeof(ZoneUpdateList_Struct) && ((ZoneUpdateList_Struct*)pack->pBuffer)->total_updates <= MAX_UPDATE_COUNT) {
				updates = (ZoneUpdateList_Struct*)pack->pBuffer;
				ZoneUpdate_Struct* zone = 0;
				int32 pos = sizeof(ZoneUpdateList_Struct);
				sint16 num_updates = 0;
				map<int32, LoginZoneUpdate> zone_updates;
				LoginZoneUpdate update;
				
				while (pos < pack->size && num_updates < updates->total_updates) {
					zone = (ZoneUpdate_Struct*)(pack->pBuffer + pos);
					if ((pos + zone->zone_name_length + zone->zone_desc_length + sizeof(ZoneUpdate_Struct)) <= pack->size) {
						update.name = string(zone->data, zone->zone_name_length);
						update.description = string(zone->data + zone->zone_name_length, zone->zone_desc_length);
						pos += sizeof(ZoneUpdate_Struct) + zone->zone_name_length + zone->zone_desc_length;
						num_updates++;
						zone_updates[zone->zone_id] = update;
					} else {
						break;
					}
				}
				
				if (zone_updates.size() == updates->total_updates)
					world_list.AddServerZoneUpdates(this, zone_updates);
				else
					cout << "Error processing zone updates for server: " << GetAccount() << endl;
			} else {
				Kick("Possible Hacking Attempt");
			}
			break;
		}

		case ServerOP_LoginEquipment: {
			LogWrite(OPCODE__DEBUG, 1, "Opcode", "Opcode %04X (%i): ServerOP_LoginEquipment", pack->opcode, pack->opcode);
			pack->Inflate();
			EquipmentUpdateList_Struct* updates = 0;
			
			if (pack->size >= sizeof(EquipmentUpdateList_Struct) && ((EquipmentUpdateList_Struct*)pack->pBuffer)->total_updates <= MAX_LOGIN_APPEARANCE_COUNT) {
				updates = (EquipmentUpdateList_Struct*)pack->pBuffer;
				EquipmentUpdate_Struct* equip = 0;
				int32 pos = sizeof(EquipmentUpdateList_Struct);
				sint16 num_updates = 0;
				map<int32, LoginEquipmentUpdate> equip_updates;
				LoginEquipmentUpdate update;
				
				while (pos < pack->size && num_updates < updates->total_updates) {
					equip = (EquipmentUpdate_Struct*)(pack->pBuffer + pos);
					update.world_char_id = equip->world_char_id;
					update.equip_type = equip->equip_type;
					update.red = equip->red;
					update.green = equip->green;
					update.blue = equip->blue;
					update.highlight_red = equip->highlight_red;
					update.highlight_green = equip->highlight_green;
					update.highlight_blue = equip->highlight_blue;
					update.slot = equip->slot;
					pos += sizeof(EquipmentUpdate_Struct);
					num_updates++;
					equip_updates[equip->id] = update;
				}

				LogWrite(LOGIN__DEBUG, 1, "Login", "Processing %i Login Appearance Updates...", num_updates);
				if (equip_updates.size() == updates->total_updates) {
					world_list.AddServerEquipmentUpdates(this, equip_updates);
				} else {
					LogWrite(LOGIN__ERROR, 0, "Login", "Error processing login appearance updates for server: %s\n\t%s, function %s, line %i", GetAccount(), __FILE__, __FUNCTION__, __LINE__);
				}
			} else {
				LogWrite(LOGIN__ERROR, 0, "Login", "World ID '%i', Possible Hacking Attempt (func: %s, line: %i", GetAccountID(), __FUNCTION__, __LINE__);
				Kick("Possible Hacking Attempt");
			}
			break;
		}
		
		case ServerOP_BugReport: {
			if (pack->size == sizeof(BugReport)) {
				BugReport* report = (BugReport*)pack->pBuffer;
				database.SaveBugReport(GetAccountID(), report->category, report->subcategory, report->causes_crash, report->reproducible, report->summary, report->description, report->version, report->player, report->account_id, report->spawn_name, report->spawn_id, report->zone_id);
			}
			break;
		}
		
		case ServerOP_EncapPacket: {
			if (this->GetType() != Login)
				break;
			ServerEncapPacket_Struct* seps = (ServerEncapPacket_Struct*) pack->pBuffer;
			if (seps->ToID == 0xFFFFFFFF) { // Broadcast
				ServerPacket* inpack = new ServerPacket(seps->opcode);
				inpack->size = seps->size;
				inpack->pBuffer = seps->data;
				world_list.SendPacketLocal(inpack, this);
				inpack->pBuffer = 0;
				delete inpack;
			} else {
				LWorld* world = world_list.FindByID(seps->ToID);
				if (world) {
					ServerPacket* inpack = new ServerPacket(seps->opcode);
					inpack->size = seps->size;
					inpack->pBuffer = seps->data;
					world->SendPacket(inpack);
					inpack->pBuffer = 0;
					delete inpack;
				}
			}
			if (net.GetLoginMode() != Mesh)
				world_list.SendPacketLogin(pack, this);
			break;
		}
		
		default: {
			cout << "Unknown LoginSOPcode: 0x" << hex << (int)pack->opcode << dec;
			cout << " size:" << pack->size << " from " << GetAccount() << endl;
			DumpPacket(pack->pBuffer, pack->size);
			break;
		}
		}
		delete pack;
	}
	return ret;
}

// Send packet to world server, encapsulating if remote connection
void LWorld::SendPacket(ServerPacket* pack)
{
	if (Link == 0)
		return;
		
	if (RemoteID) {
		ServerPacket* outpack = new ServerPacket(ServerOP_EncapPacket, sizeof(ServerEncapPacket_Struct) + pack->size);
		ServerEncapPacket_Struct* seps = (ServerEncapPacket_Struct*) outpack->pBuffer;
		seps->ToID = RemoteID;
		seps->opcode = pack->opcode;
		seps->size = pack->size;
		memcpy(seps->data, pack->pBuffer, pack->size);
		Link->SendPacket(outpack);
		delete outpack;
	} else {
		Link->SendPacket(pack);
	}
}

// Send formatted message to player on world server
void LWorld::Message(const char* to, const char* message, ...)
{
	va_list argptr;
	char buffer[256];

	va_start(argptr, message);
	vsnprintf(buffer, 256, message, argptr);
	va_end(argptr);

	ServerPacket* pack = new ServerPacket(ServerOP_EmoteMessage, sizeof(ServerEmoteMessage_Struct) + strlen(buffer) + 1);
	ServerEmoteMessage_Struct* sem = (ServerEmoteMessage_Struct*) pack->pBuffer;
	strcpy(sem->to, to);
	strcpy(sem->message, buffer);
	SendPacket(pack);
	delete pack;
}

// Disconnect world server with error message
void LWorld::Kick(const char* message, bool iSetKickedFlag)
{
	if (iSetKickedFlag)
		kicked = true;
		
	if (message) {
		ServerPacket* pack = new ServerPacket(ServerOP_LSFatalError, strlen(message) + 1);
		strcpy((char*) pack->pBuffer, message);
		SendPacket(pack);
		delete pack;
	}
	
	if (Link && GetRemoteID() == 0)
		Link->Disconnect();
}

// Validate server name format
bool LWorld::CheckServerName(const char* name)
{
	if (strlen(name) < 10)
		return false;
		
	for (size_t i = 0; i < strlen(name); i++) {
		if (!((name[i] >= 'a' && name[i] <= 'z') || (name[i] >= 'A' && name[i] <= 'Z') || 
			  (name[i] >= '0' && name[i] <= '9') || name[i] == ' ' || name[i] == '\'' || 
			  name[i] == '-' || name[i] == '(' || name[i] == ')' || name[i] == '[' || 
			  name[i] == ']' || name[i] == '/' || name[i] == '.' || name[i] == ',' || 
			  name[i] == '_' || name[i] == '+' || name[i] == '=' || name[i] == ':' || name[i] == '~'))
			return false;
	}
	return true;
}

// Authenticate and setup world server connection
bool LWorld::SetupWorld(char* in_worldname, char* in_worldaddress, char* in_account, char* in_password, char* in_version)
{
	if (strlen(in_worldaddress) > 3) {
		isaddressip = false;
		strcpy(address, in_worldaddress);
	}
	
	if (strlen(in_worldname) > 3) {
		char tmpAccount[30];
		memcpy(tmpAccount, in_account, 29);
		tmpAccount[29] = '\0';

		int32 id = database.CheckServerAccount(tmpAccount, in_password);
		if (id == 0 || database.IsServerAccountDisabled(tmpAccount) || 
			database.IsIPBanned(IPAddr) || (isaddressip && database.IsIPBanned(address)))
			return false;

		LWorld* world = world_list.FindByID(id);
		if (world)
			world->Kick("Ghost Kick!");

		ID = id;
		accountid = id;
		strncpy(account, tmpAccount, 30);
		
		char* name = database.GetServerAccountName(id);
		if (name) {
			snprintf(worldname, (sizeof(worldname)) - 1, "%s", name);
		} else {
			account[0] = 0;
			IsInit = false;
			this->Kick("Could not load server information.");
			return false;
		}
		
		IsInit = true;
		ptype = World;
		world_list.SendWorldChanged(id, true);
	} else {
		account[0] = 0;
		IsInit = false;
		return false;
	}

	database.UpdateWorldVersion(GetAccountID(), in_version);
	pStatsTimer = new Timer(60000);
	pStatsTimer->Start(60000);
	return true;
}

// Send world status change notification
void LWorldList::SendWorldChanged(int32 server_id, bool sendtoallclients, Client* sendto)
{
	EQ2Packet* outapp = new EQ2Packet(OP_WorldStatusChangeMsg, 0, sizeof(LS_WorldStatusChanged));
	LS_WorldStatusChanged* world_changed = (LS_WorldStatusChanged*)outapp->pBuffer;

	world_changed->server_id = server_id;
	LWorld* world = world_list.FindByID(server_id);
	if (!world || world->ShowDown())
		world_changed->up = 0;
	else
		world_changed->up = 1;
		
	if (sendtoallclients || sendto == 0)
		client_list.SendPacketToAllClients(outapp);
	else
		sendto->QueuePacket(outapp);
		
	world_list.SetUpdateServerList(true);
}

// Trigger world list update
void LWorld::UpdateWorldList(LWorld* to)
{
	world_list.SetUpdateServerList(true);
}

// Convert active world to offline placeholder
void LWorld::ChangeToPlaceholder()
{
	ip = 0;
	status = -1;
	pPlaceholder = true;
	if (Link != 0 && RemoteID == 0)
		Link->Disconnect();
	UpdateWorldList();
}

// Set remote world server information
void LWorld::SetRemoteInfo(int32 in_ip, int32 in_accountid, char* in_account, char* in_name, char* in_address, int32 in_status, int32 in_adminid, sint32 in_players, sint32 in_zones)
{
	ip = in_ip;
	accountid = in_accountid;
	strcpy(worldname, in_name);
	strcpy(address, in_address);
	status = in_status;
	admin_id = in_adminid;
	num_players = in_players;
	num_zones = in_zones;
}

// Get display status for world (0=up, 1=dev, 2=locked)
int8 LWorld::GetWorldStatus()
{
	if (IsDevelServer() && IsLocked() == false)
		return 1;
	else if (IsInit && IsLocked() == false)
		return 0;
	else
		return 2;
}

// Send character deletion notification to world server
void LWorld::SendDeleteCharacter(int32 char_id, int32 account_id)
{
	ServerPacket* outpack = new ServerPacket(ServerOP_BasicCharUpdate, sizeof(CharDataUpdate_Struct));
	CharDataUpdate_Struct* cdu = (CharDataUpdate_Struct*)outpack->pBuffer;
	cdu->account_id = account_id;
	cdu->char_id = char_id;
	cdu->update_field = DELETE_UPDATE_FLAG;
	cdu->update_data = 1;
	SendPacket(outpack);
}

// LWorldList constructor - initialize server and threading
LWorldList::LWorldList()
{
	server_update_thread = true;
	NextID = 1;
	tcplistener = new TCPServer(net.GetPort(), true);
	
	if (net.GetLoginMode() == Slave)
		OutLink = new TCPConnection(true);
	else
		OutLink = 0;

	UpdateServerList = true;
	
	// Start server update thread
	std::thread update_thread(ServerUpdateLoop, this);
	update_thread.detach();
}

// LWorldList destructor
LWorldList::~LWorldList()
{
	server_update_thread = false;
	while (!server_update_thread) {
		std::this_thread::sleep_for(std::chrono::milliseconds(100));
	}
	safe_delete(tcplistener);
	safe_delete(OutLink);
}

// Shutdown all world connections
void LWorldList::Shutdown()
{
	LinkedListIterator<LWorld*> iterator(list);
	iterator.Reset();
	while (iterator.MoreElements())
		iterator.RemoveCurrent();
	safe_delete(tcplistener);
}

// Add world server to active list
void LWorldList::Add(LWorld* worldserver)
{
	LWorld* worldExist = FindByID(worldserver->GetID());
	if (worldExist) {
		worldExist->Kick();
		MWorldMap.writelock();
		worldmap.erase(worldExist->GetID());
		MWorldMap.releasewritelock();
		safe_delete(worldExist);
	}
	
	MWorldMap.writelock();
	worldmap[worldserver->GetID()] = worldserver;
	MWorldMap.releasewritelock();
	
	database.ResetWorldServerStatsConnectedTime(worldserver);
	database.UpdateWorldIPAddress(worldserver->GetID(), worldserver->GetIP());
}

// Add world server to initialization list
void LWorldList::AddInitiateWorld(LWorld* world)
{
	list.Insert(world);
}

// Remove ghost connections by IP address
void LWorldList::KickGhostIP(int32 ip, LWorld* NotMe, int16 iClientPort)
{
	if (ip == 0)
		return;

	map<int32, LWorld*>::iterator map_list;
	MWorldMap.readlock();
	for (map_list = worldmap.begin(); map_list != worldmap.end(); map_list++) {
		LWorld* world = map_list->second;
		if (!world->IsKicked() && world->GetIP() == ip && world != NotMe) {
			if ((iClientPort == 0 && world->GetType() == World) || 
				(iClientPort != 0 && world->GetClientPort() == iClientPort)) {
				struct in_addr in;
				in.s_addr = world->GetIP();
				if (!world->Connected()) {
					if (NotMe) {
						in.s_addr = NotMe->GetIP();
						cout << "NotMe(" << NotMe->GetID() << ") = " << inet_ntoa(in) << ":" << NotMe->GetPort() << " (" << NotMe->GetClientPort() << ")" << endl;
					}
					world->Kick("Ghost IP kick");
				}
			}
		}
	}
	MWorldMap.releasereadlock();
}

// Remove ghost connections by type and account
void LWorldList::KickGhost(ConType in_type, int32 in_accountid, LWorld* ButNotMe)
{
	map<int32, LWorld*>::iterator map_list;
	MWorldMap.readlock();
	for (map_list = worldmap.begin(); map_list != worldmap.end(); map_list++) {
		LWorld* world = map_list->second;
		if (!world->IsKicked() && world->GetType() == in_type && world != ButNotMe && 
			(in_accountid == 0 || world->GetAccountID() == in_accountid)) {
			if (world->GetType() == Login && world->IsOutgoingUplink())
				world->Kick("Ghost Acc Kick", false);
			else
				world->Kick("Ghost Acc Kick");
		}
	}
	MWorldMap.releasereadlock();
}

// Update statistics for all world servers
void LWorldList::UpdateWorldStats()
{
	map<int32, LWorld*>::iterator map_list;
	MWorldMap.readlock();
	for (map_list = worldmap.begin(); map_list != worldmap.end(); map_list++) {
		LWorld* world = map_list->second;
		if (world && world->GetAccountID() > 0)
			database.UpdateWorldServerStats(world, world->GetStatus());
	}
	MWorldMap.releasereadlock();
}

// Main processing loop for world list
void LWorldList::Process()
{
	TCPConnection* newtcp = 0;
	LWorld* newworld = 0;

	// Process initialization list
	LinkedListIterator<LWorld*> iterator(list);
	iterator.Reset();
	while (iterator.MoreElements()) {
		if (iterator.GetData()->GetID() > 0) {
			LWorld* world = iterator.GetData();
			iterator.RemoveCurrent(false);
			Add(world);
		} else {
			if (!iterator.GetData()->Process())
				iterator.RemoveCurrent();
			else
				iterator.Advance();
		}
	}

	// Handle new connections
	while ((newtcp = tcplistener->NewQueuePop())) {
		newworld = new LWorld(newtcp);
		newworld->SetID(0);
		AddInitiateWorld(newworld);
		
		struct in_addr in;
		in.s_addr = newtcp->GetrIP();
		LogWrite(LOGIN__INFO, 0, "Login", "New Server connection: %s port %i", inet_ntoa(in), ntohs(newtcp->GetrPort()));
		net.numservers++;
		net.UpdateWindowTitle();
		world_list.UpdateWorldList();
	}

	// Process active world servers
	map<int32, LWorld*>::iterator map_list;
	for (map_list = worldmap.begin(); map_list != worldmap.end(); ) {
		LWorld* world = map_list->second;
		int32 account_id = world->GetAccountID();

		if (world->IsKicked() && !world->IsNeverKick()) {
			map_list++;
			worldmap.erase(account_id);
			net.numservers--;
			net.UpdateWindowTitle();
			safe_delete(world);
			continue;
		} else if (!world->Process()) {
			if (world->GetAccountID() == 0 || !(world->ShowDown()) || world->GetType() == Chat) {
				map_list++;
				worldmap.erase(account_id);
				net.numservers--;
				net.UpdateWindowTitle();
				
				if (account_id > 0) {
					LWorld* world2 = FindByID(account_id);
					if (world2)
						world2->ShowDownActive(true);
				}
				SendWorldChanged(account_id, true);
				safe_delete(world);
				continue;
			} else {
				world->ChangeToPlaceholder();
			}
		}
		map_list++;
	}
}

// Send packet to all world and chat servers
void LWorldList::SendPacket(ServerPacket* pack, LWorld* butnotme)
{
	map<int32, LWorld*>::iterator map_list;
	for (map_list = worldmap.begin(); map_list != worldmap.end(); map_list++) {
		LWorld* world = map_list->second;
		if (world != butnotme) {
			if (world->GetType() == Login) {
				ServerPacket* outpack = new ServerPacket(ServerOP_EncapPacket, sizeof(ServerEncapPacket_Struct) + pack->size);
				ServerEncapPacket_Struct* seps = (ServerEncapPacket_Struct*) outpack->pBuffer;
				seps->ToID = 0xFFFFFFFF;
				seps->opcode = pack->opcode;
				seps->size = pack->size;
				memcpy(seps->data, pack->pBuffer, pack->size);
				world->SendPacket(outpack);
				delete outpack;
			} else if (world->GetRemoteID() == 0) {
				world->SendPacket(pack);
			}
		}
	}
}

// Send packet to all local TCP connections
void LWorldList::SendPacketLocal(ServerPacket* pack, LWorld* butnotme)
{
	map<int32, LWorld*>::iterator map_list;
	for (map_list = worldmap.begin(); map_list != worldmap.end(); map_list++) {
		LWorld* world = map_list->second;
		if (world != butnotme && world->GetRemoteID() == 0)
			world->SendPacket(pack);
	}
}

// Send packet to all login servers
void LWorldList::SendPacketLogin(ServerPacket* pack, LWorld* butnotme)
{
	map<int32, LWorld*>::iterator map_list;
	for (map_list = worldmap.begin(); map_list != worldmap.end(); map_list++) {
		LWorld* world = map_list->second;
		if (world != butnotme && world->GetType() == Login)
			world->SendPacket(pack);
	}
}

// Trigger world list update for all servers
void LWorldList::UpdateWorldList(LWorld* to)
{
	map<int32, LWorld*>::iterator map_list;
	for (map_list = worldmap.begin(); map_list != worldmap.end(); map_list++) {
		LWorld* world = map_list->second;
		if (net.GetLoginMode() != Mesh || world->GetRemoteID() == 0)
			world->UpdateWorldList(to);
	}
}

// Find world server by ID
LWorld* LWorldList::FindByID(int32 LWorldID)
{
	if (worldmap.count(LWorldID) > 0)
		return worldmap[LWorldID];
	return 0;
}

// Find world server by IP address
LWorld* LWorldList::FindByIP(int32 ip)
{
	map<int32, LWorld*>::iterator map_list;
	LWorld* world = 0;
	LWorld* ret = 0;
	MWorldMap.readlock();
	for (map_list = worldmap.begin(); map_list != worldmap.end(); map_list++) {
		world = map_list->second;
		if (world->GetIP() == ip) {
			ret = world;
			break;
		}
	}
	MWorldMap.releasereadlock();
	return ret;
}

// Find world server by address string
LWorld* LWorldList::FindByAddress(char* address)
{
	map<int32, LWorld*>::iterator map_list;
	LWorld* world = 0;
	LWorld* ret = 0;
	MWorldMap.readlock();
	for (map_list = worldmap.begin(); map_list != worldmap.end(); map_list++) {
		world = map_list->second;
		if (strcasecmp(world->GetAddress(), address) == 0) {
			ret = world;
			break;
		}
	}
	MWorldMap.releasereadlock();
	return ret;
}

// Find world server by TCP connection and ID
LWorld* LWorldList::FindByLink(TCPConnection* in_link, int32 in_id)
{
	if (in_link == 0)
		return 0;
		
	LWorld* world = 0;
	LWorld* ret = 0;
	map<int32, LWorld*>::iterator map_list;
	MWorldMap.readlock();
	for (map_list = worldmap.begin(); map_list != worldmap.end(); map_list++) {
		world = map_list->second;
		if (world->GetLink() == in_link && world->GetRemoteID() == in_id) {
			ret = world;
			break;
		}
	}
	MWorldMap.releasereadlock();
	return ret;
}

// Find world server by account ID and type
LWorld* LWorldList::FindByAccount(int32 in_accountid, ConType in_type)
{
	if (in_accountid == 0)
		return 0;
		
	LWorld* world = 0;
	LWorld* ret = 0;
	map<int32, LWorld*>::iterator map_list;
	MWorldMap.readlock();
	for (map_list = worldmap.begin(); map_list != worldmap.end(); map_list++) {
		world = map_list->second;
		if (world->GetAccountID() == in_accountid && world->GetType() == in_type) {
			ret = world;
			break;
		}
	}
	MWorldMap.releasereadlock();
	return ret;
}

// Get server list update packets for specific client version
vector<PacketStruct*>* LWorldList::GetServerListUpdate(int16 version)
{
	vector<PacketStruct*>* ret = new vector<PacketStruct*>;
	map<int32, LWorld*>::iterator map_list;
	PacketStruct* packet = 0;
	
	MWorldMap.readlock();
	for (map_list = worldmap.begin(); map_list != worldmap.end(); map_list++) {
		LWorld* world = map_list->second;
		if ((world->IsInit || (world->ShowDown() && world->ShowDownActive())) && world->GetType() == World) {
			packet = configReader.getStruct("LS_WorldUpdate", version);
			if (packet) {
				packet->setDataByName("server_id", world->GetID());
				packet->setDataByName("up", 1);
				if (world->IsLocked())
					packet->setDataByName("locked", 1);
				ret->push_back(packet);
			}
		}
	}
	MWorldMap.releasereadlock();
	return ret;
}

// Create server list packet for client
EQ2Packet* LWorldList::MakeServerListPacket(int8 lsadmin, int16 version)
{
	MWorldMap.readlock();
	if (!UpdateServerList && ServerListData.count(version)) {
		MWorldMap.releasereadlock();
		return ServerListData[version];
	}

	uint32 tmpCount = 0;
	map<int32, LWorld*>::iterator map_list;
	for (map_list = worldmap.begin(); map_list != worldmap.end(); map_list++) {
		LWorld* world = map_list->second;
		if ((world->IsInit || (world->ShowDown() && world->ShowDownActive())) && world->GetType() == World)
			tmpCount++;
	}

	PacketStruct* packet = configReader.getStruct("LS_WorldList", version);
	packet->setArrayLengthByName("num_worlds", tmpCount);

	int32 ServerNum = 0;
	for (map_list = worldmap.begin(); map_list != worldmap.end(); map_list++) {
		LWorld* world = map_list->second;
		if ((world->IsInit || (world->ShowDown() && world->ShowDownActive())) && world->GetType() == World) {
			ServerNum++;
			packet->setArrayDataByName("id", world->GetID(), ServerNum - 1);

			if (version <= 283) {
				packet->setArrayDataByName("name", world->GetName(), ServerNum - 1);
				if (!world->ShowDown())
					packet->setArrayDataByName("online", 1, ServerNum - 1);
				if (world->IsLocked())
					packet->setArrayDataByName("locked", 1, ServerNum - 1);
				packet->setArrayDataByName("unknown2", 1, ServerNum - 1);
				packet->setArrayDataByName("unknown3", 1, ServerNum - 1);
				packet->setArrayDataByName("load", world->GetWorldStatus(), ServerNum - 1);
			} else {
				if (version < 1212)
					packet->setArrayDataByName("allowed_races", 0xFFFFFFFF, ServerNum - 1);
				else if (version < 60006)
					packet->setArrayDataByName("allowed_races", 0x000FFFFF, ServerNum - 1); // + Freeblood
				else
					packet->setArrayDataByName("allowed_races", 0x001FFFFF, ServerNum - 1); // + Aerakyn

				packet->setArrayDataByName("number_online_flag", 1, ServerNum - 1);
				packet->setArrayDataByName("num_players", world->GetPlayerNum(), ServerNum - 1);
				packet->setArrayDataByName("name", world->GetName(), ServerNum - 1);
				packet->setArrayDataByName("name2", world->GetName(), ServerNum - 1);
				packet->setArrayDataByName("feature_set", 0, ServerNum - 1);
				packet->setArrayDataByName("load", world->GetWorldStatus(), ServerNum - 1);
				
				if (world->IsLocked())
					packet->setArrayDataByName("locked", 1, ServerNum - 1);
				if (world->ShowDown())
					packet->setArrayDataByName("tag", 0, ServerNum - 1);
				else
					packet->setArrayDataByName("tag", 1, ServerNum - 1);
				if (version < 1212)
					packet->setArrayDataByName("unknown", ServerNum, ServerNum - 1);
			}
		}
	}

	EQ2Packet* pack = packet->serialize();
	
	if (ServerListData.count(version)) {
		map<int32, EQ2Packet*>::iterator it = ServerListData.find(version);
		EQ2Packet* tmpPack = ServerListData[version];
		safe_delete(tmpPack);
		ServerListData.erase(it);
	}
	ServerListData.insert(make_pair(version, pack));
	MWorldMap.releasereadlock();

	SetUpdateServerList(false);
	return ServerListData[version];
}

// Send world status information to admin
void LWorldList::SendWorldStatus(LWorld* chat, char* adminname)
{
	struct in_addr in;
	int32 count = 0;
	
	map<int32, LWorld*>::iterator map_list;
	for (map_list = worldmap.begin(); map_list != worldmap.end(); map_list++) {
		LWorld* world = map_list->second;
		if (world->GetIP() != 0 && world->GetType() == World) {
			chat->Message(adminname, "Name: %s", world->GetName());
			in.s_addr = world->GetIP();
			
			if (world->GetAccountID() != 0)
				chat->Message(adminname, "   Account:           %s", world->GetAccount());
			chat->Message(adminname, "   Number of Zones:   %i", world->GetZoneNum());
			chat->Message(adminname, "   Number of Players: %i", world->GetPlayerNum());
			chat->Message(adminname, "   IP:                %s", inet_ntoa(in));
			
			if (!world->IsAddressIP())
				chat->Message(adminname, "   Address:			%s", world->GetAddress());
			count++;
		}
	}
	chat->Message(adminname, "%i worlds listed.", count);
}

// Remove world servers by TCP connection
void LWorldList::RemoveByLink(TCPConnection* in_link, int32 in_id, LWorld* ButNotMe)
{
	if (in_link == 0)
		return;
		
	map<int32, LWorld*>::iterator map_list;
	for (map_list = worldmap.begin(); map_list != worldmap.end(); map_list++) {
		LWorld* world = map_list->second;
		if (world != ButNotMe && world->GetLink() == in_link && 
			(in_id == 0 || world->GetRemoteID() == in_id)) {
			map_list++;
			worldmap.erase(world->GetID());
			safe_delete(world);
			continue;
		}
	}
}

// Remove world server by ID
void LWorldList::RemoveByID(int32 in_id)
{
	if (in_id == 0)
		return;

	LWorld* existWorld = FindByID(in_id);
	if (existWorld != NULL) {
		MWorldMap.writelock();
		worldmap.erase(in_id);
		MWorldMap.releasewritelock();
		safe_delete(existWorld);
	}
}

// Initialize TCP listener
bool LWorldList::Init()
{
	database.ResetWorldStats();
	if (!tcplistener->IsOpen())
		return tcplistener->Open(net.GetPort());
	return false;
}

// Initialize placeholder worlds from database
void LWorldList::InitWorlds()
{
	vector<LWorld*> server_list;
	database.GetServerAccounts(&server_list);
	
	vector<LWorld*>::iterator iter;
	int i = 0;
	for (iter = server_list.begin(); iter != server_list.end(); iter++, i++) {
		LWorld* world = FindByID(server_list[i]->GetAccountID());
		if (!world) {
			server_list[i]->ShowDown(true);
			server_list[i]->ShowDownActive(true);
			server_list[i]->SetID(server_list[i]->GetAccountID());
			Add(server_list[i]);
		}
	}
}

// Get count of servers by type
int32 LWorldList::GetCount(ConType type)
{
	int32 count = 0;
	map<int32, LWorld*>::iterator map_list;
	for (map_list = worldmap.begin(); map_list != worldmap.end(); map_list++) {
		LWorld* world = map_list->second;
		if (world->GetType() == type)
			count++;
	}
	return count;
}

// List all worlds to console
void LWorldList::ListWorldsToConsole()
{
	struct in_addr in;
	cout << "World List:" << endl;
	cout << "============================" << endl;
	
	map<int32, LWorld*>::iterator map_list;
	for (map_list = worldmap.begin(); map_list != worldmap.end(); map_list++) {
		LWorld* world = map_list->second;
		in.s_addr = world->GetIP();
		
		if (world->GetType() == World) {
			if (world->GetRemoteID() == 0)
				cout << "ID: " << world->GetID() << ", Name: " << world->GetName() << ", Local, IP: " << inet_ntoa(in) << ":" << world->GetPort() << ", Status: " << world->GetStatus() << ", AccID: " << world->GetAccountID() << endl;
			else
				cout << "ID: " << world->GetID() << ", Name: " << world->GetName() << ", RemoteID: " << world->GetRemoteID() << ", LinkWorldID: " << world->GetLinkWorldID() << ", IP: " << inet_ntoa(in) << ":" << world->GetPort() << ", Status: " << world->GetStatus() << ", AccID: " << world->GetAccountID() << endl;
		} else if (world->GetType() == Chat) {
			cout << "ID: " << world->GetID() << ", Chat Server, IP: " << inet_ntoa(in) << ":" << world->GetPort() << ", AccID: " << world->GetAccountID() << endl;
		} else if (world->GetType() == Login) {
			if (world->IsOutgoingUplink()) {
				if (world->Connected())
					cout << "ID: " << world->GetID() << ", Login Server (out), IP: " << inet_ntoa(in) << ":" << world->GetPort() << ", AccID: " << world->GetAccountID() << endl;
				else
					cout << "ID: " << world->GetID() << ", Login Server (nc), IP: " << inet_ntoa(in) << ":" << world->GetPort() << ", AccID: " << world->GetAccountID() << endl;
			} else {
				cout << "ID: " << world->GetID() << ", Login Server (in), IP: " << inet_ntoa(in) << ":" << world->GetPort() << " (" << world->GetClientPort() << "), AccID: " << world->GetAccountID() << endl;
			}
		} else {
			cout << "ID: " << world->GetID() << ", Unknown Type, Name: " << world->GetName() << ", IP: " << inet_ntoa(in) << ":" << world->GetPort() << ", AccID: " << world->GetAccountID() << endl;
		}
	}
	cout << "============================" << endl;
}

// Add zone updates from world server
void LWorldList::AddServerZoneUpdates(LWorld* world, map<int32, LoginZoneUpdate> updates)
{
	int32 server_id = world->GetID();
	map<int32, LoginZoneUpdate>::iterator itr;
	
	for (itr = updates.begin(); itr != updates.end(); itr++) {
		if (zone_updates_already_used.size() >= 1500 || zone_updates_already_used[server_id].count(itr->first) > 0) {
			world->Kick("Hacking attempt.");
			return;
		}
		zone_updates_already_used[server_id][itr->first] = true;
	}
	server_zone_updates.Put(server_id, updates);
}

// Add equipment updates from world server
void LWorldList::AddServerEquipmentUpdates(LWorld* world, map<int32, LoginEquipmentUpdate> updates)
{
	int32 server_id = world->GetID();
	map<int32, LoginEquipmentUpdate>::iterator itr;
	
	for (itr = updates.begin(); itr != updates.end(); itr++) {
		LogWrite(MISC__TODO, 1, "TODO", "JA: Until we learn what this does, can't risk worlds being kicked performing login appearance updates...\n%s, func: %s, line: %i", __FILE__, __FUNCTION__, __LINE__);
		equip_updates_already_used[server_id][itr->first] = true;
	}
	server_equip_updates.Put(server_id, updates);
}

// Request zone updates from world server
void LWorldList::RequestServerUpdates(LWorld* world)
{
	if (world) {
		ServerPacket* pack = new ServerPacket(ServerOP_ZoneUpdates, sizeof(ZoneUpdateRequest_Struct));
		ZoneUpdateRequest_Struct* request = (ZoneUpdateRequest_Struct*)pack->pBuffer;
		request->max_per_batch = MAX_UPDATE_COUNT;
		world->SendPacket(pack);
		delete pack;
		zone_update_timeouts.Put(world->GetID(), Timer::GetCurrentTime2() + 30000);
	}
}

// Process server zone and equipment updates
void LWorldList::ProcessServerUpdates()
{
	// Process zone updates
	MutexMap<int32, map<int32, LoginZoneUpdate>>::iterator itr = server_zone_updates.begin();
	while (itr.Next()) {
		if (itr->second.size() > 0) {
			database.SetServerZoneDescriptions(itr->first, itr->second);
			if (itr->second.size() == MAX_UPDATE_COUNT)
				awaiting_zone_update.Put(itr->first, Timer::GetCurrentTime2() + 10000);
			server_zone_updates.erase(itr->first);
		}
		if (zone_update_timeouts.count(itr->first) == 0 || zone_update_timeouts.Get(itr->first) <= Timer::GetCurrentTime2()) {
			zone_update_timeouts.erase(itr->first);
			server_zone_updates.erase(itr->first);
		}
	}
	
	LWorld* world = 0;
	MWorldMap.readlock();
	map<int32, LWorld*>::iterator map_itr;
	for (map_itr = worldmap.begin(); map_itr != worldmap.end(); map_itr++) {
		world = map_itr->second;
		if (world && world->GetID()) {
			if (last_updated.count(world) == 0 || last_updated.Get(world) <= Timer::GetCurrentTime2()) {
				zone_updates_already_used[world->GetID()].clear();
				RequestServerUpdates(world);
				last_updated.Put(world, Timer::GetCurrentTime2() + 21600000);
			}
			if (awaiting_zone_update.count(world->GetID()) > 0 && awaiting_zone_update.Get(world->GetID()) <= Timer::GetCurrentTime2()) {
				awaiting_zone_update.erase(world->GetID());
				RequestServerUpdates(world);
			}
		}
	}
	ProcessLSEquipUpdates();
	MWorldMap.releasereadlock();
}

// Request equipment updates from world server
void LWorldList::RequestServerEquipUpdates(LWorld* world)
{
	if (world) {
		ServerPacket* pack_equip = new ServerPacket(ServerOP_LoginEquipment, sizeof(EquipmentUpdateRequest_Struct));
		EquipmentUpdateRequest_Struct* request_equip = (EquipmentUpdateRequest_Struct*)pack_equip->pBuffer;
		request_equip->max_per_batch = MAX_LOGIN_APPEARANCE_COUNT;
		LogWrite(LOGIN__DEBUG, 1, "Login", "Sending equipment update requests to world: (%s)... (Batch Size: %i)", world->GetName(), request_equip->max_per_batch);
		world->SendPacket(pack_equip);
		delete pack_equip;
		equip_update_timeouts.Put(world->GetID(), Timer::GetCurrentTime2() + 30000);
	}
}

// Process login equipment updates
void LWorldList::ProcessLSEquipUpdates()
{
	MutexMap<int32, map<int32, LoginEquipmentUpdate>>::iterator itr_equip = server_equip_updates.begin();
	while (itr_equip.Next()) {
		if (itr_equip->second.size() > 0) {
			LogWrite(LOGIN__DEBUG, 1, "Login", "Setting Login Appearances...");
			database.SetServerEquipmentAppearances(itr_equip->first, itr_equip->second);
			if (itr_equip->second.size() == MAX_LOGIN_APPEARANCE_COUNT)
				awaiting_equip_update.Put(itr_equip->first, Timer::GetCurrentTime2() + 10000);
			server_equip_updates.erase(itr_equip->first);
		}
		if (equip_update_timeouts.count(itr_equip->first) == 0 || equip_update_timeouts.Get(itr_equip->first) <= Timer::GetCurrentTime2()) {
			LogWrite(LOGIN__DEBUG, 1, "Login", "Clearing Login Appearances Update Timers...");
			equip_update_timeouts.erase(itr_equip->first);
			server_equip_updates.erase(itr_equip->first);
		}
	}
	
	LWorld* world = 0;
	MWorldMap.readlock();
	map<int32, LWorld*>::iterator map_itr;
	for (map_itr = worldmap.begin(); map_itr != worldmap.end(); map_itr++) {
		world = map_itr->second;
		if (world && world->GetID()) {
			if (last_equip_updated.count(world) == 0 || last_equip_updated.Get(world) <= Timer::GetCurrentTime2()) {
				LogWrite(LOGIN__DEBUG, 1, "Login", "Clearing Login Appearances Update Counters...");
				equip_updates_already_used[world->GetID()].clear();
				RequestServerEquipUpdates(world);
				last_equip_updated.Put(world, Timer::GetCurrentTime2() + 900000); // every 15 mins
			}
			if (awaiting_equip_update.count(world->GetID()) > 0 && awaiting_equip_update.Get(world->GetID()) <= Timer::GetCurrentTime2()) {
				LogWrite(LOGIN__DEBUG, 1, "Login", "Erase awaiting equip updates...");
				awaiting_equip_update.erase(world->GetID());
				RequestServerEquipUpdates(world);
			}
		}
	}
	MWorldMap.releasereadlock();
}

// Server update thread main loop
void* ServerUpdateLoop(void* tmp)
{
	if (tmp == 0) {
		ThrowError("ServerUpdateLoop(): tmp = 0!");
		return NULL;
	}
	
	LWorldList* worldList = (LWorldList*) tmp;
	while (worldList->ContinueServerUpdates()) {
		std::this_thread::sleep_for(std::chrono::seconds(1));
		worldList->ProcessServerUpdates();
	}
	worldList->ResetServerUpdates();
	return NULL;
}