package com.massivecraft.factions.integration.dynmap;

import com.massivecraft.factions.*;
import com.massivecraft.factions.integration.Econ;
import com.massivecraft.factions.struct.Role;
import com.massivecraft.factions.zcore.persist.MemoryBoard;

import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.plugin.Plugin;
import org.dynmap.DynmapAPI;
import org.dynmap.markers.*;
import org.dynmap.utils.TileFlags;

import java.awt.Point;
import java.util.*;
import java.util.Map.Entry;

// This source code is a heavily modified version of mikeprimms plugin Dynmap-Factions.
public class EngineDynmap
{

	/**
	 * @author FactionsUUID Team
	 */

	// -------------------------------------------- //
	// CONSTANTS
	// -------------------------------------------- //

	public final static int BLOCKS_PER_CHUNK = 16;

	public final static String DYNMAP_INTEGRATION = "\u00A7dDynmap Integration: \u00A7e";

	public final static String FACTIONS = "factions";
	public final static String FACTIONS_ = FACTIONS + "_";

	public final static String FACTIONS_MARKERSET = FACTIONS_ + "markerset";

	public final static String FACTIONS_HOME = FACTIONS_ + "home";
	public final static String FACTIONS_HOME_ = FACTIONS_HOME + "_";

	public final static String FACTIONS_PLAYERSET = FACTIONS_ + "playerset";
	public final static String FACTIONS_PLAYERSET_ = FACTIONS_PLAYERSET + "_";

	// -------------------------------------------- //
	// INSTANCE & CONSTRUCT
	// -------------------------------------------- //

	private static final EngineDynmap i = new EngineDynmap();
	public DynmapAPI dynmapApi;
	public MarkerAPI markerApi;
	public MarkerSet markerset;

	List<List<Point>> polyLine = new ArrayList<List<Point>>();

	private EngineDynmap()
	{
	}

	public static EngineDynmap getInstance()
	{
		return i;
	}

	public static String getHtmlPlayerString(Collection<FPlayer> playersOfficersList)
	{
		StringBuilder ret = new StringBuilder();
		for (FPlayer fplayer : playersOfficersList)
		{
			if (ret.length() > 0)
			{
				ret.append(", ");
			}
			ret.append(getHtmlPlayerName(fplayer));
		}
		return ret.toString();
	}

	public static String getHtmlPlayerName(FPlayer fplayer)
	{
		return fplayer != null ? escapeHtml(fplayer.getName()) : "none";
	}

	public static String escapeHtml(String string)
	{
		if (string == null)
		{
			return "";
		}
		StringBuilder out = new StringBuilder(Math.max(16, string.length()));
		for (int i = 0; i < string.length(); i++)
		{
			char c = string.charAt(i);
			if (c > 127 || c == '"' || c == '<' || c == '>' || c == '&')
			{
				out.append("&#").append((int) c).append(';');
			}
			else
			{
				out.append(c);
			}
		}
		return out.toString();
	}

	// Thread Safe / Asynchronous: Yes
	public static void info(String msg)
	{
		System.out.println(DYNMAP_INTEGRATION + msg);
	}

	// -------------------------------------------- //
	// UPDATE: HOMES
	// -------------------------------------------- //

	// Thread Safe / Asynchronous: Yes
	public static void severe(String msg)
	{
		System.out.println(DYNMAP_INTEGRATION + ChatColor.RED.toString() + msg);
	}

	public void init()
	{
		Plugin dynmap = Bukkit.getServer().getPluginManager().getPlugin("dynmap");

		if (dynmap == null || !dynmap.isEnabled())
		{
			return;
		}

		// Should we even use dynmap?
		if (!Conf.dynmapUse)
		{
			if (this.markerset != null)
			{
				this.markerset.deleteMarkerSet();
				this.markerset = null;
			}
			return;
		}

		// Shedule non thread safe sync at the end!
		Bukkit.getScheduler().scheduleSyncRepeatingTask(FactionsPlugin.getInstance(), () ->
		{

			final Map<String, TempMarker> homes = createHomes();
			final Map<String, TempAreaMarker> areas = createAreas();
			final Map<String, TempPolyLineMarker> polys = createPolys(areas);
			final Map<String, Set<String>> playerSets = createPlayersets();

			if (!updateCore())
			{
				return;
			}

			// createLayer() is thread safe but it makes use of fields set in updateCore() so we must have it after.
			if (!updateLayer(createLayer()))
			{
				return;
			}

			updateHomes(homes);
			updateAreas(areas);
			updatePolys(polys);
			updatePlayersets(playerSets);
		}, 100L, 100L);
	}

	// -------------------------------------------- //
	// UPDATE: AREAS
	// -------------------------------------------- //

	// Thread Safe / Asynchronous: No
	public boolean updateCore()
	{
		// Get DynmapAPI
		this.dynmapApi = (DynmapAPI) Bukkit.getPluginManager().getPlugin("dynmap");
		if (this.dynmapApi == null)
		{
			severe("Could not retrieve the DynmapAPI.");
			return false;
		}

		// Get MarkerAPI
		this.markerApi = this.dynmapApi.getMarkerAPI();
		if (this.markerApi == null)
		{
			severe("Could not retrieve the MarkerAPI.");
			return false;
		}

		return true;
	}

	// Thread Safe / Asynchronous: Yes
	public TempMarkerSet createLayer()
	{
		TempMarkerSet ret = new TempMarkerSet();
		ret.label = Conf.dynmapLayerName;
		ret.minimumZoom = Conf.dynmapLayerMinimumZoom;
		ret.priority = Conf.dynmapLayerPriority;
		ret.hideByDefault = !Conf.dynmapLayerVisible;
		return ret;
	}

	// Thread Safe / Asynchronous: No
	public boolean updateLayer(TempMarkerSet temp)
	{
		this.markerset = this.markerApi.getMarkerSet(FACTIONS_MARKERSET);
		if (this.markerset == null)
		{
			this.markerset = temp.create(this.markerApi, FACTIONS_MARKERSET);
			if (this.markerset == null)
			{
				severe("Could not create the Faction Markerset/Layer");
				return false;
			}
		}
		else
		{
			temp.update(this.markerset);
		}
		return true;
	}

	// Thread Safe / Asynchronous: Yes
	public Map<String, TempMarker> createHomes()
	{
		Map<String, TempMarker> ret = new HashMap<>();

		// Loop current factions
		for (Faction faction : Factions.getInstance().getAllFactions())
		{
			Location ps = faction.getHome();
			if (ps == null)
			{
				continue;
			}

			DynmapStyle style = getStyle(faction);

			String markerId = FACTIONS_HOME_ + faction.getId();

			TempMarker temp = new TempMarker();
			temp.label = ChatColor.stripColor(faction.getTag());
			temp.world = ps.getWorld().toString();
			temp.x = ps.getX();
			temp.y = ps.getY();
			temp.z = ps.getZ();
			temp.iconName = style.getHomeMarker();
			temp.description = getDescription(faction);

			ret.put(markerId, temp);
		}

		return ret;
	}

	// Thread Safe / Asynchronous: No
	// This method places out the faction home markers into the factions markerset.
	public void updateHomes(Map<String, TempMarker> homes)
	{
		// Put all current faction markers in a map
		Map<String, Marker> markers = new HashMap<>();
		for (Marker marker : this.markerset.getMarkers())
		{
			markers.put(marker.getMarkerID(), marker);
		}

		// Loop homes
		for (Entry<String, TempMarker> entry : homes.entrySet())
		{
			String markerId = entry.getKey();
			TempMarker temp = entry.getValue();

			// Get Creative
			// NOTE: I remove from the map created just in the beginning of this method.
			// NOTE: That way what is left at the end will be outdated markers to remove.
			Marker marker = markers.remove(markerId);
			if (marker == null)
			{
				marker = temp.create(this.markerApi, this.markerset, markerId);
				marker = temp.create(this.markerApi, this.markerset, markerId);
				if (marker == null)
				{
					EngineDynmap.severe("Could not get/create the home marker " + markerId);
				}
			}
			else
			{
				temp.update(this.markerApi, marker);
			}
		}

		// Delete Deprecated Markers
		// Only old markers should now be left
		for (Marker marker : markers.values())
		{
			marker.deleteMarker();
		}
	}

	// -------------------------------------------- //
	// UPDATE: PLAYERSET
	// -------------------------------------------- //

	// Thread Safe: YES

	public Map<String, TempPolyLineMarker> createPolys(Map<String, TempAreaMarker> areas)
	{
		Map<String, TempPolyLineMarker> ret = new HashMap<String, TempPolyLineMarker>();
		for (Entry<String, TempAreaMarker> entry : areas.entrySet())
		{
			String markerID = entry.getKey();
			TempAreaMarker area = entry.getValue();

			int counter = 0;
			for (List<Point> points : area.getPolyLine())
			{
				markerID = markerID + "_poly_" + counter;
				TempPolyLineMarker tempPoly = new TempPolyLineMarker();
				tempPoly.polyLine = points;
				tempPoly.lineColor = area.lineColor;
				tempPoly.lineOpacity = area.lineOpacity;
				tempPoly.lineWeight = area.lineWeight;
				tempPoly.world = area.world;
				ret.put(markerID, tempPoly);
				counter++;
			}
		}
		return ret;
	}

	public Map<String, TempAreaMarker> createAreas()
	{
		Map<String, Map<Faction, Set<FLocation>>> worldFactionChunks = createWorldFactionChunks();
		return createAreas(worldFactionChunks);
	}

	// Thread Safe: YES
	public Map<String, Map<Faction, Set<FLocation>>> createWorldFactionChunks()
	{
		// Create map "world name --> faction --> set of chunk coords"
		Map<String, Map<Faction, Set<FLocation>>> worldFactionChunks = new HashMap<>();

		// Note: The board is the world. The board id is the world name.
		MemoryBoard board = (MemoryBoard) Board.getInstance();

		for (Entry<FLocation, String> entry : board.flocationIds.entrySet())
		{
			String world = entry.getKey().getWorldName();
			Faction chunkOwner = Factions.getInstance().getFactionById(entry.getValue());

			Map<Faction, Set<FLocation>> factionChunks = worldFactionChunks.get(world);
			if (factionChunks == null)
			{
				factionChunks = new HashMap<>();
				worldFactionChunks.put(world, factionChunks);
			}

			Set<FLocation> factionTerritory = factionChunks.get(chunkOwner);
			if (factionTerritory == null)
			{
				factionTerritory = new HashSet<>();
				factionChunks.put(chunkOwner, factionTerritory);
			}

			factionTerritory.add(entry.getKey());
		}

		return worldFactionChunks;
	}

	// Thread Safe: YES
	public Map<String, TempAreaMarker> createAreas(Map<String, Map<Faction, Set<FLocation>>> worldFactionChunks)
	{
		Map<String, TempAreaMarker> ret = new HashMap<>();

		// For each world
		for (Entry<String, Map<Faction, Set<FLocation>>> entry : worldFactionChunks.entrySet())
		{
			String world = entry.getKey();
			Map<Faction, Set<FLocation>> factionChunks = entry.getValue();

			// For each faction and its chunks in that world
			for (Entry<Faction, Set<FLocation>> entry1 : factionChunks.entrySet())
			{
				Faction faction = entry1.getKey();
				Set<FLocation> chunks = entry1.getValue();
				Map<String, TempAreaMarker> worldFactionMarkers = createAreas(world, faction, chunks);
				ret.putAll(worldFactionMarkers);
			}
		}

		return ret;
	}

	// Thread Safe: YES
	// Handle specific faction on specific world
	// "handle faction on world"
	public Map<String, TempAreaMarker> createAreas(String world, Faction faction, Set<FLocation> chunks)
	{
		Map<String, TempAreaMarker> ret = new HashMap<>();

		// If the faction is visible ...
		if (!isVisible(faction, world))
		{
			return ret;
		}

		// ... and has any chunks ...
		if (chunks.isEmpty())
		{
			return ret;
		}

		// Index of polygon for given faction
		int markerIndex = 0;

		// Create the info window
		String description = getDescription(faction);

		// Fetch Style
		DynmapStyle style = this.getStyle(faction);

		// Loop through chunks: set flags on chunk map
		TileFlags allChunkFlags = new TileFlags();
		LinkedList<FLocation> allChunks = new LinkedList<>();
		for (FLocation chunk : chunks)
		{
			allChunkFlags.setFlag((int) chunk.getX(), (int) chunk.getZ(), true); // Set flag for chunk
			allChunks.addLast(chunk);
		}

		// Loop through until we don't find more areas
		while (allChunks != null)
		{

			TileFlags ourChunkFlags = null;
			LinkedList<FLocation> ourChunks = null;
			LinkedList<FLocation> newChunks = null;

			for (FLocation chunk : allChunks)
			{
				int chunkX = (int) chunk.getX();
				int chunkZ = (int) chunk.getZ();

				// If we need to start shape, and this block is not part of one yet
				if (ourChunkFlags == null && allChunkFlags.getFlag(chunkX, chunkZ))
				{
					ourChunkFlags = new TileFlags(); // Create map for shape
					ourChunks = new LinkedList<>();
					floodFillTarget(allChunkFlags, ourChunkFlags, chunkX, chunkZ); // Copy shape
					ourChunks.add(chunk); // Add it to our chunk list
				}
				// If shape found, and we're in it, add to our node list
				else if (ourChunkFlags != null && ourChunkFlags.getFlag(chunkX, chunkZ))
				{
					ourChunks.add(chunk);
				}
				// Else, keep it in the list for the next polygon
				else
				{
					if (newChunks == null)
					{
						newChunks = new LinkedList<>();
					}
					newChunks.add(chunk);
				}
			}

			// Replace list (null if no more to process)
			allChunks = newChunks;
			if (ourChunkFlags == null)
			{
				continue;
			}
			List<TempLine> outputLines = new ArrayList<TempLine>();
			Map<TempLine, Integer> lines = new HashMap<TempLine, Integer>();

			if (ourChunks == null)
			{
				continue;
			}

			for (FLocation loc : ourChunks)
			{
				int x = loc.getChunk().getX();
				int z = loc.getChunk().getZ();

				TempLine line = new TempLine(new Point(x * 16, z * 16), new Point(x * 16 + 16, z * 16));
				if (lines.containsKey(line))
				{
					lines.put(line, lines.get(line) + 1);
				}
				else
				{
					lines.put(line, 1);
				}

				line = new TempLine(new Point(x * 16 + 16, z * 16), new Point(x * 16 + 16, z * 16 + 16));
				if (lines.containsKey(line))
				{
					lines.put(line, lines.get(line) + 1);
				}
				else
				{
					lines.put(line, 1);
				}

				line = new TempLine(new Point(x * 16 + 16, z * 16 + 16), new Point(x * 16, z * 16 + 16));
				if (lines.containsKey(line))
				{
					lines.put(line, lines.get(line) + 1);
				}
				else
				{
					lines.put(line, 1);
				}

				line = new TempLine(new Point(x * 16, z * 16 + 16), new Point(x * 16, z * 16));
				if (lines.containsKey(line))
				{
					lines.put(line, lines.get(line) + 1);
				}
				else
				{
					lines.put(line, 1);
				}
			}

			Iterator<Entry<TempLine, Integer>> iterator = lines.entrySet().iterator();

			List<TempLine> lineList = new ArrayList<TempLine>();
			lineList.addAll(lines.keySet());

			while (iterator.hasNext())
			{
				Entry<TempLine, Integer> entry = iterator.next();
				if (entry.getValue() > 1)
				{
					lineList.remove(entry.getKey());
				}
			}

			// Find the leftmost MCRWPoint

			TempLine l = null;
			for (Iterator<TempLine> it = lineList.iterator(); it.hasNext();)
			{
				TempLine tl = it.next();
				if (l == null || tl.getP1().x < l.getP1().x)
					l = tl;
			}

			for (Iterator<TempLine> it = lineList.iterator(); it.hasNext();)
			{
				TempLine tl = it.next();
				if (tl.getP2().x < l.getP2().x)
					l = tl;
			}

			outputLines.add(l);
			lineList.remove(l);
			while (lineList.size() > 0)
			{
				// MCRWPoint targetp = new MCRWPoint((int) lastLine.x1, (int) lastLine.y1);
				// MCRWPointWLines.get(targetp);

				TempLine nextLine = null;
				for (Iterator<TempLine> it = lineList.iterator(); it.hasNext();)
				{
					TempLine line = it.next();
					if (l.getP2().x == line.getP1().x && l.getP2().y == line.getP1().y)
					{

						nextLine = line;
					}

				}

				if (nextLine != null)
				{
					outputLines.add(nextLine);
					lineList.remove(nextLine);
					l = nextLine;
				}
				else
				{
					outputLines.get(outputLines.size() - 1).addAdditionLines(CamScan1(lineList));
					break;
				}

			}
			List<Point> outputPoints = new ArrayList<Point>();

			List<Point> polyPoints = new ArrayList<Point>();

			for (int i = 0; i < outputLines.size(); i++)
			{
				Point p = new Point(outputLines.get(i).getP1().x, outputLines.get(i).getP1().y);
				outputPoints.add(p);
				polyPoints.add(p);
				if (outputLines.get(i).getConnectedLines().size() > 0)
				{

					outputPoints.addAll(addRecursivePoints(new Point((int) outputLines.get(i).getP1().x, (int) outputLines.get(i).getP1().y), outputLines.get(i)));
				}
				p = new Point((int) outputLines.get(i).getP2().x, (int) outputLines.get(i).getP2().y);
				outputPoints.add(p);
				polyPoints.add(p);
			}
			polyLine.add(polyPoints);

			// Build information for specific area
			double[] x = new double[outputPoints.size()];
			double[] z = new double[outputPoints.size()];

			for (int i = 0; i < outputPoints.size(); i++)
			{
				x[i] = outputPoints.get(i).x;
				z[i] = outputPoints.get(i).y;
			}

			String markerId = FACTIONS_ + world + "__" + faction.getId() + "__" + markerIndex;

			TempAreaMarker temp = new TempAreaMarker();
			temp.label = faction.getTag();
			temp.world = world;
			temp.x = x;
			temp.z = z;
			temp.description = description;

			temp.lineColor = style.getLineColor();
			temp.lineOpacity = style.getLineOpacity();
			temp.lineWeight = style.getLineWeight();

			temp.fillColor = style.getFillColor();
			temp.fillOpacity = style.getFillOpacity();

			temp.boost = style.getBoost();
			temp.setPolyLine(polyLine);

			ret.put(markerId, temp);
			polyLine.clear();

			markerIndex++;
		}

		return ret;
	}

	public List<Point> addRecursivePoints(Point returnPoint, TempLine line)
	{
		List<Point> ret = new ArrayList<Point>();
		boolean shouldReturn = false;
		List<TempLine> connectedLines = line.getConnectedLines();
		List<Point> polyPoints = new ArrayList<Point>();
		for (TempLine line2 : connectedLines)
		{
			Point p = new Point((int) line2.getP1().x, (int) line2.getP1().y);
			ret.add(p);
			polyPoints.add(p);
			shouldReturn = true;
			if (line2.getConnectedLines().size() > 0)
			{
				ret.addAll(addRecursivePoints(new Point((int) line2.getP1().x, (int) line2.getP1().y), line2));
			}
			p = new Point((int) line2.getP2().x, (int) line2.getP2().y);
			ret.add(p);
			polyPoints.add(p);

		}
		if (shouldReturn)
		{
			ret.add(returnPoint);
		}
		polyLine.add(polyPoints);
		return ret;
	}

	private List<TempLine> CamScan1(List<TempLine> lineList)
	{
		List<TempLine> ret = new ArrayList<TempLine>();

		// Find the leftmost MCRWPoint

		TempLine l = null;
		for (Iterator<TempLine> it = lineList.iterator(); it.hasNext();)
		{

			TempLine tl = it.next();
			if (l == null || tl.getP1().x < l.getP1().x)
				l = tl;
		}

		for (Iterator<TempLine> it = lineList.iterator(); it.hasNext();)
		{
			TempLine tl = it.next();
			if (tl.getP2().x < l.getP2().x)
				l = tl;
		}

		ret.add(l);
		lineList.remove(l);
		while (lineList.size() > 0)
		{
			// MCRWPoint targetp = new MCRWPoint((int) lastLine.x1, (int) lastLine.y1);
			// MCRWPointWLines.get(targetp);

			TempLine thisChunkLine = null;
			for (Iterator<TempLine> it = lineList.iterator(); it.hasNext();)
			{
				TempLine line = it.next();
				if (l.getP2().x == line.getP1().x && l.getP2().y == line.getP1().y)
				{

					thisChunkLine = line;
				}

			}
			if (thisChunkLine != null)
			{
				ret.add(thisChunkLine);
				lineList.remove(thisChunkLine);
				l = thisChunkLine;
			}
			else
			{
				// break;
				ret.get(ret.size() - 1).addAdditionLines(CamScan1(lineList));
			}

		}
		return ret;
	}

	// -------------------------------------------- //
	// UTIL & SHARED
	// -------------------------------------------- //

	public void updatePolys(Map<String, TempPolyLineMarker> polys)
	{
		// Map Current
		Map<String, PolyLineMarker> markers = new HashMap<>();
		for (PolyLineMarker marker : this.markerset.getPolyLineMarkers())
		{
			markers.put(marker.getMarkerID(), marker);
		}

		// Loop New
		for (Entry<String, TempPolyLineMarker> entry : polys.entrySet())
		{
			String markerId = entry.getKey();
			TempPolyLineMarker temp = entry.getValue();

			// Get Creative
			// NOTE: I remove from the map created just in the beginning of this method.
			// NOTE: That way what is left at the end will be outdated markers to remove.
			PolyLineMarker marker = markers.remove(markerId);
			if (marker == null)
			{
				marker = temp.create(this.markerset, markerId);
				if (marker == null)
				{
					severe("Could not get/create the area marker " + markerId);
				}
			}
			else
			{
				temp.update(marker);
			}
		}

		// Only old/outdated should now be left. Delete them.
		for (PolyLineMarker marker : markers.values())
		{
			marker.deleteMarker();
		}
	}

	// Thread Safe: NO
	public void updateAreas(Map<String, TempAreaMarker> areas)
	{
		// Map Current
		Map<String, AreaMarker> markers = new HashMap<>();
		for (AreaMarker marker : this.markerset.getAreaMarkers())
		{
			markers.put(marker.getMarkerID(), marker);
		}

		// Loop New
		for (Entry<String, TempAreaMarker> entry : areas.entrySet())
		{
			String markerId = entry.getKey();
			TempAreaMarker temp = entry.getValue();

			// Get Creative
			// NOTE: I remove from the map created just in the beginning of this method.
			// NOTE: That way what is left at the end will be outdated markers to remove.
			AreaMarker marker = markers.remove(markerId);
			if (marker == null)
			{
				marker = temp.create(this.markerset, markerId);
				if (marker == null)
				{
					severe("Could not get/create the area marker " + markerId);
				}
			}
			else
			{
				temp.update(marker);
			}
		}

		// Only old/outdated should now be left. Delete them.
		for (AreaMarker marker : markers.values())
		{
			marker.deleteMarker();
		}
	}

	// Thread Safe / Asynchronous: Yes
	public String createPlayersetId(Faction faction)
	{
		if (faction == null)
		{
			return null;
		}
		if (faction.isWilderness())
		{
			return null;
		}
		String factionId = faction.getId();
		if (factionId == null)
		{
			return null;
		}
		return FACTIONS_PLAYERSET_ + factionId;
	}

	// Thread Safe / Asynchronous: Yes
	public Set<String> createPlayerset(Faction faction)
	{
		if (faction == null)
		{
			return null;
		}
		if (faction.isWilderness())
		{
			return null;
		}

		Set<String> ret = new HashSet<>();

		for (FPlayer fplayer : faction.getFPlayers())
		{
			// NOTE: We add both UUID and name. This might be a good idea for future proofing.
			ret.add(fplayer.getId());
			ret.add(fplayer.getName());
		}

		return ret;
	}

	// Thread Safe / Asynchronous: Yes
	public Map<String, Set<String>> createPlayersets()
	{
		if (!Conf.dynmapVisibilityByFaction)
		{
			return null;
		}

		Map<String, Set<String>> ret = new HashMap<>();

		for (Faction faction : Factions.getInstance().getAllFactions())
		{
			String playersetId = createPlayersetId(faction);
			if (playersetId == null)
			{
				continue;
			}
			Set<String> playerIds = createPlayerset(faction);
			if (playerIds == null)
			{
				continue;
			}
			ret.put(playersetId, playerIds);
		}

		return ret;
	}

	// Thread Safe / Asynchronous: No
	public void updatePlayersets(Map<String, Set<String>> playersets)
	{
		if (playersets == null)
		{
			return;
		}

		// Remove
		for (PlayerSet set : this.markerApi.getPlayerSets())
		{
			if (!set.getSetID().startsWith(FACTIONS_PLAYERSET_))
			{
				continue;
			}

			// (Null means remove all)
			if (playersets.containsKey(set.getSetID()))
			{
				continue;
			}

			set.deleteSet();
		}

		// Add / Update
		for (Entry<String, Set<String>> entry : playersets.entrySet())
		{
			// Extract from Entry
			String setId = entry.getKey();
			Set<String> playerIds = entry.getValue();

			// Get Creatively
			PlayerSet set = this.markerApi.getPlayerSet(setId);
			if (set == null)
			{
				set = this.markerApi.createPlayerSet(setId, // id
						true, // symmetric
						playerIds, // players
						false // persistent
				);
			}
			if (set == null)
			{
				severe("Could not get/create the player set " + setId);
				continue;
			}

			// Set Content
			set.setPlayers(playerIds);
		}
	}

	// Thread Safe / Asynchronous: Yes
	private String getDescription(Faction faction)
	{
		String ret = "<div class=\"regioninfo\">" + Conf.dynmapDescription + "</div>";

		// Name
		String name = faction.getTag();
		name = escapeHtml(ChatColor.stripColor(name));
		ret = ret.replace("%name%", name);

		// Description
		String description = faction.getDescription();
		description = escapeHtml(ChatColor.stripColor(description));
		ret = ret.replace("%description%", description);

		// Money

		String money = "unavailable";
		if (Conf.bankEnabled && Conf.dynmapDescriptionMoney)
			money = String.format("%.2f", Econ.getBalance(faction.getAccountId()));
		ret = ret.replace("%money%", money);

		// Players
		Set<FPlayer> playersList = faction.getFPlayers();
		String playersCount = String.valueOf(playersList.size());
		String players = getHtmlPlayerString(playersList);

		FPlayer playersLeaderObject = faction.getFPlayerAdmin();
		String playersLeader = getHtmlPlayerName(playersLeaderObject);

		ArrayList<FPlayer> playersCoAdminsList = faction.getFPlayersWhereRole(Role.COLEADER);
		String playersCoAdminsCount = String.valueOf(playersCoAdminsList.size());
		String playersCoAdmins = getHtmlPlayerString(playersCoAdminsList);

		ArrayList<FPlayer> playersModeratorsList = faction.getFPlayersWhereRole(Role.MODERATOR);
		String playersModeratorsCount = String.valueOf(playersModeratorsList.size());
		String playersModerators = getHtmlPlayerString(playersModeratorsList);

		ArrayList<FPlayer> playersNormalsList = faction.getFPlayersWhereRole(Role.NORMAL);
		String playersNormalsCount = String.valueOf(playersNormalsList.size());
		String playersNormals = getHtmlPlayerString(playersNormalsList);

		ret = ret.replace("%players%", players);
		ret = ret.replace("%players.count%", playersCount);
		ret = ret.replace("%players.leader%", playersLeader);
		ret = ret.replace("%players.admins%", playersCoAdmins);
		ret = ret.replace("%players.admins.count%", playersCoAdminsCount);
		ret = ret.replace("%players.moderators%", playersModerators);
		ret = ret.replace("%players.moderators.count%", playersModeratorsCount);
		ret = ret.replace("%players.normals%", playersNormals);
		ret = ret.replace("%players.normals.count%", playersNormalsCount);

		return ret;
	}

	// Thread Safe / Asynchronous: Yes
	private boolean isVisible(Faction faction, String world)
	{
		if (faction == null)
		{
			return false;
		}
		final String factionId = faction.getId();
		if (factionId == null)
		{
			return false;
		}
		final String factionName = faction.getTag();
		if (factionName == null)
		{
			return false;
		}

		Set<String> visible = Conf.dynmapVisibleFactions;
		Set<String> hidden = Conf.dynmapHiddenFactions;

		if (!visible.isEmpty() && !visible.contains(factionId) && !visible.contains(factionName) && !visible.contains("world:" + world))
		{
			return false;
		}

		return !hidden.contains(factionId) && !hidden.contains(factionName) && !hidden.contains("world:" + world);
	}

	// Thread Safe / Asynchronous: Yes
	public DynmapStyle getStyle(Faction faction)
	{
		DynmapStyle ret;

		ret = Conf.dynmapFactionStyles.get(faction.getId());
		if (ret != null)
		{
			return ret;
		}

		ret = Conf.dynmapFactionStyles.get(faction.getTag());
		if (ret != null)
		{
			return ret;
		}

		return Conf.dynmapDefaultStyle;
	}

	// Find all contiguous blocks, set in target and clear in source
	private int floodFillTarget(TileFlags source, TileFlags destination, int x, int y)
	{
		int cnt = 0;
		ArrayDeque<int[]> stack = new ArrayDeque<>();
		stack.push(new int[] { x, y });

		while (!stack.isEmpty())
		{
			int[] nxt = stack.pop();
			x = nxt[0];
			y = nxt[1];
			if (source.getFlag(x, y))
			{ // Set in src
				source.setFlag(x, y, false); // Clear source
				destination.setFlag(x, y, true); // Set in destination
				cnt++;
				if (source.getFlag(x + 1, y))
				{
					stack.push(new int[] { x + 1, y });
				}
				if (source.getFlag(x - 1, y))
				{
					stack.push(new int[] { x - 1, y });
				}
				if (source.getFlag(x, y + 1))
				{
					stack.push(new int[] { x, y + 1 });
				}
				if (source.getFlag(x, y - 1))
				{
					stack.push(new int[] { x, y - 1 });
				}
			}
		}
		return cnt;
	}

	enum Direction
	{
		XPLUS, ZPLUS, XMINUS, ZMINUS
	}
}