package com.wimbli.WorldBorder;

import java.util.concurrent.CompletableFuture;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.bukkit.Bukkit;
import org.bukkit.Chunk;
import org.bukkit.entity.Player;
import org.bukkit.Server;
import org.bukkit.World;

import io.papermc.lib.PaperLib;

import com.wimbli.WorldBorder.Events.WorldBorderFillFinishedEvent;
import com.wimbli.WorldBorder.Events.WorldBorderFillStartEvent;


public class WorldFillTask implements Runnable
{
	// general task-related reference data
	private transient Server server = null;
	private transient World world = null;
	private transient BorderData border = null;
	private transient WorldFileData worldData = null;
	private transient boolean readyToGo = false;
	private transient boolean paused = false;
	private transient boolean pausedForMemory = false;
	private transient int taskID = -1;
	private transient Player notifyPlayer = null;
	private transient int chunksPerRun = 1;
	private transient boolean continueNotice = false;
	private transient boolean forceLoad = false;
	
	// these are only stored for saving task to config
	private transient int fillDistance = 208;
	private transient int tickFrequency = 1;
	private transient int refX = 0, lastLegX = 0;
	private transient int refZ = 0, lastLegZ = 0;
	private transient int refLength = -1;
	private transient int refTotal = 0, lastLegTotal = 0;

	// values for the spiral pattern check which fills out the map to the border
	private transient int x = 0;
	private transient int z = 0;
	private transient boolean isZLeg = false;
	private transient boolean isNeg = false;
	private transient int length = -1;
	private transient int current = 0;
	private transient boolean insideBorder = true;
	private transient CoordXZ lastChunk = new CoordXZ(0, 0);

	// for reporting progress back to user occasionally
	private transient long lastReport = Config.Now();
	private transient long lastAutosave = Config.Now();
	private transient int reportTarget = 0;
	private transient int reportTotal = 0;
	private transient int reportNum = 0;
	
	// A map that holds to-be-loaded chunks, and their coordinates
	private transient Map<CompletableFuture<Void>, CoordXZ> pendingChunks;
	
	// and a set of "Chunk a needed for Chunk b" dependencies, which
	// unfortunately can't be a Map as a chunk might be needed for
	// several others.
	private transient Set<UnloadDependency> preventUnload;
	
	private class UnloadDependency
	{
		int neededX, neededZ;
		int forX, forZ;
		
		UnloadDependency(int neededX, int neededZ, int forX, int forZ)
		{
			this.neededX=neededX;
			this.neededZ=neededZ;
			this.forX=forX;
			this.forZ=forZ;
		}
		
		@Override
		public boolean equals(Object other)
		{
			if (other == null || !(other instanceof UnloadDependency))
				return false;

			return this.neededX == ((UnloadDependency) other).neededX
			   &&  this.neededZ == ((UnloadDependency) other).neededZ
			   &&  this.forX    == ((UnloadDependency) other).forX
			   &&  this.forZ    == ((UnloadDependency) other).forZ;
		}

		@Override
		public int hashCode()
		{
			int hash = 7;
			hash = 79 * hash + this.neededX;
			hash = 79 * hash + this.neededZ;
			hash = 79 * hash + this.forX;
			hash = 79 * hash + this.forZ;
			return hash;
		}
	}

	public WorldFillTask(Server theServer, Player player, String worldName, int fillDistance, int chunksPerRun, int tickFrequency, boolean forceLoad)
	{
		this.server = theServer;
		this.notifyPlayer = player;
		this.fillDistance = fillDistance;
		this.tickFrequency = tickFrequency;
		this.chunksPerRun = chunksPerRun;
		this.forceLoad = forceLoad;

		this.world = server.getWorld(worldName);
		if (this.world == null)
		{
			if (worldName.isEmpty())
				sendMessage("You must specify a world!");
			else
				sendMessage("World \"" + worldName + "\" not found!");
			this.stop();
			return;
		}

		this.border = (Config.Border(worldName) == null) ? null : Config.Border(worldName).copy();
		if (this.border == null)
		{
			sendMessage("No border found for world \"" + worldName + "\"!");
			this.stop();
			return;
		}

		// load up a new WorldFileData for the world in question, used to scan region files for which chunks are already fully generated and such
		worldData = WorldFileData.create(world, notifyPlayer);
		if (worldData == null)
		{
			this.stop();
			return;
		}
		
		pendingChunks = new HashMap<>();
		preventUnload = new HashSet<>();

		this.border.setRadiusX(border.getRadiusX() + fillDistance);
		this.border.setRadiusZ(border.getRadiusZ() + fillDistance);
		this.x = CoordXZ.blockToChunk((int)border.getX());
		this.z = CoordXZ.blockToChunk((int)border.getZ());

		int chunkWidthX = (int) Math.ceil((double)((border.getRadiusX() + 16) * 2) / 16);
		int chunkWidthZ = (int) Math.ceil((double)((border.getRadiusZ() + 16) * 2) / 16);
		int biggerWidth = (chunkWidthX > chunkWidthZ) ? chunkWidthX : chunkWidthZ; //We need to calculate the reportTarget with the bigger width, since the spiral will only stop if it has a size of biggerWidth x biggerWidth
		this.reportTarget = (biggerWidth * biggerWidth) + biggerWidth + 1;

		//This would be another way to calculate reportTarget, it assumes that we don't need time to check if the chunk is outside and then skip it (it calculates the area of the rectangle/ellipse)
		//this.reportTarget = (this.border.getShape()) ? ((int) Math.ceil(chunkWidthX * chunkWidthZ / 4 * Math.PI + 2 * chunkWidthX)) : (chunkWidthX * chunkWidthZ);
		//                                                                       Area of the ellipse                 just to be safe      area of the rectangle
		
		this.readyToGo = true;
		Bukkit.getServer().getPluginManager().callEvent(new WorldBorderFillStartEvent(this));
	}
	
	// for backwards compatibility
	public WorldFillTask(Server theServer, Player player, String worldName, int fillDistance, int chunksPerRun, int tickFrequency)
	{
		this(theServer, player, worldName, fillDistance, chunksPerRun, tickFrequency, false);
	}

	public void setTaskID(int ID)
	{	
		if (ID == -1) this.stop();
		this.taskID = ID;
	}

	@Override
	public void run()
	{
		if (continueNotice)
		{	// notify user that task has continued automatically
			continueNotice = false;
			sendMessage("World map generation task automatically continuing.");
			sendMessage("Reminder: you can cancel at any time with \"wb fill cancel\", or pause/unpause with \"wb fill pause\".");
		}

		if (pausedForMemory)
		{	// if available memory gets too low, we automatically pause, so handle that
			if (Config.AvailableMemoryTooLow())
				return;

			pausedForMemory = false;
			readyToGo = true;
			sendMessage("Available memory is sufficient, automatically continuing.");
		}

		if (server == null || !readyToGo || paused)
			return;

		// this is set so it only does one iteration at a time, no matter how frequently the timer fires
		readyToGo = false;
		// and this is tracked to keep one iteration from dragging on too long and possibly choking the system if the user specified a really high frequency
		long loopStartTime = Config.Now();

		// Process async results from last time. We don't make a difference
		// whether they were really async, or sync.
		
		// First, Check which chunk generations have been finished.
		// Mark those chunks as existing and unloadable, and remove
		// them from the pending set.
		int chunksProcessedLastTick = 0;
		Map<CompletableFuture<Void>, CoordXZ> newPendingChunks = new HashMap<>();
		Set<CoordXZ> chunksToUnload = new HashSet<>();
		for (CompletableFuture<Void> cf : pendingChunks.keySet())
		{
			if (cf.isDone())
			{
				++chunksProcessedLastTick;
				// If cf.get() returned the chunk reliably, pendingChunks could
				// be a set and we wouldn't have to map CFs to coords ...
				CoordXZ xz = pendingChunks.get(cf);
				worldData.chunkExistsNow(xz.x, xz.z);
				chunksToUnload.add(xz);
			}
			else
				newPendingChunks.put(cf, pendingChunks.get(cf));
		}
		pendingChunks = newPendingChunks;

		// Next, check which chunks had been loaded because a to-be-generated
		// chunk needed them, and don't have to remain in memory any more.
		Set<UnloadDependency> newPreventUnload = new HashSet<>();
		for (UnloadDependency dependency : preventUnload) 
		{
			if (worldData.doesChunkExist(dependency.forX, dependency.forZ)) 
				chunksToUnload.add(new CoordXZ(dependency.neededX, dependency.neededZ));
			else
				newPreventUnload.add(dependency);
		}
		preventUnload = newPreventUnload;

		// Unload all chunks that aren't needed anymore. NB a chunk could have
		// been needed for two different others, or been generated and needed
		// for one other chunk, so it might be in the unload set wrongly.
		// The ChunkUnloadListener checks this anyway, but it doesn't hurt to
		// save a few µs by not even requesting the unload.

		for (CoordXZ unload : chunksToUnload)
		{
			if (!chunkOnUnloadPreventionList(unload.x, unload.z))
			{
				world.setChunkForceLoaded(unload.x, unload.z, false);
				world.unloadChunkRequest(unload.x, unload.z);
			}
		}

		// Put some damper on chunksPerRun. We don't want the queue to be too
		// full; only fill it to a bit more than what we can
		// process per tick. This ensures the background task can run at
		// full speed and we recover from a temporary drop in generation rate,
		// but doesn't push user-induced chunk generations behind a very
		// long queue of fill-generations.

		int chunksToProcess = chunksPerRun;
		if (chunksProcessedLastTick > 0 || pendingChunks.size() > 0)
		{
			// Note we generally queue 3 chunks, so real numbers are 1/3 of chunksProcessedLastTick and pendingchunks.size
			int chunksExpectedToGetProcessed = (chunksProcessedLastTick - pendingChunks.size()) / 3 + 3;
			if (chunksExpectedToGetProcessed < chunksToProcess)
				chunksToProcess = chunksExpectedToGetProcessed;
		}

		for (int loop = 0; loop < chunksToProcess; loop++)
		{
			// in case the task has been paused while we're repeating...
			if (paused || pausedForMemory)
				return;

			long now = Config.Now();

			// every 5 seconds or so, give basic progress report to let user know how it's going
			if (now > lastReport + 5000)
				reportProgress();

			// if this iteration has been running for 45ms (almost 1 tick) or more, stop to take a breather
			if (now > loopStartTime + 45)
			{
				readyToGo = true;
				return;
			}

			// if we've made it at least partly outside the border, skip past any such chunks
			while (!border.insideBorder(CoordXZ.chunkToBlock(x) + 8, CoordXZ.chunkToBlock(z) + 8))
			{
				if (!moveToNext())
					return;
			}
			insideBorder = true;

			if (!forceLoad)
			{
				// skip past any chunks which are confirmed as fully generated using our super-special isChunkFullyGenerated routine
				int rLoop = 0;
				while (worldData.isChunkFullyGenerated(x, z))
				{
					rLoop++;
					insideBorder = true;
					if (!moveToNext())
						return;

					if (rLoop > 255)
					{	// only skim through max 256 chunks (~8 region files) at a time here, to allow process to take a break if needed
						readyToGo = true;
						return;
					}
				}
			}

			pendingChunks.put(getPaperLibChunk(world, x, z, true), new CoordXZ(x, z));

			// There need to be enough nearby chunks loaded to make the server populate a chunk with trees, snow, etc.
			// So, we keep the last few chunks loaded, and need to also temporarily load an extra inside chunk (neighbor closest to center of map)
			int popX = !isZLeg ? x : (x + (isNeg ? -1 : 1));
			int popZ = isZLeg ? z : (z + (!isNeg ? -1 : 1));

			pendingChunks.put(getPaperLibChunk(world, popX, popZ, false), new CoordXZ(popX, popZ));
			preventUnload.add(new UnloadDependency(popX, popZ, x, z));
			
			// make sure the previous chunk in our spiral is loaded as well (might have already existed and been skipped over)
			pendingChunks.put(getPaperLibChunk(world, lastChunk.x, lastChunk.z, false), new CoordXZ(lastChunk.x, lastChunk.z)); // <-- new CoordXZ as lastChunk isn't immutable
			preventUnload.add(new UnloadDependency(lastChunk.x, lastChunk.z, x, z));

			// move on to next chunk
			if (!moveToNext())
				return;
		}
		// ready for the next iteration to run
		readyToGo = true;
	}

	// step through chunks in spiral pattern from center; returns false if we're done, otherwise returns true
	public boolean moveToNext()
	{
		if (paused || pausedForMemory)
			return false;

		reportNum++;

		// keep track of progress in case we need to save to config for restoring progress after server restart
		if (!isNeg && current == 0 && length > 3)
		{
			if (!isZLeg)
			{
				lastLegX = x;
				lastLegZ = z;
				lastLegTotal = reportTotal + reportNum;
			} else {
				refX = lastLegX;
				refZ = lastLegZ;
				refTotal = lastLegTotal;
				refLength = length - 1;
			}
		}

		// make sure of the direction we're moving (X or Z? negative or positive?)
		if (current < length)
			current++;
		else
		{	// one leg/side of the spiral down...
			current = 0;
			isZLeg ^= true;
			if (isZLeg)
			{	// every second leg (between X and Z legs, negative or positive), length increases
				isNeg ^= true;
				length++;
			}
		}

		// keep track of the last chunk we were at
		lastChunk.x = x;
		lastChunk.z = z;

		// move one chunk further in the appropriate direction
		if (isZLeg)
			z += (isNeg) ? -1 : 1;
		else
			x += (isNeg) ? -1 : 1;

		// if we've been around one full loop (4 legs)...
		if (isZLeg && isNeg && current == 0)
		{	// see if we've been outside the border for the whole loop
			if (!insideBorder)
			{	// and finish if so
				finish();
				return false;
			}	// otherwise, reset the "inside border" flag
			else
				insideBorder = false;
		}
		return true;

	/* reference diagram used, should move in this pattern:
	 *  8 [>][>][>][>][>] etc.
	 * [^][6][>][>][>][>][>][6]
	 * [^][^][4][>][>][>][4][v]
	 * [^][^][^][2][>][2][v][v]
	 * [^][^][^][^][0][v][v][v]
	 * [^][^][^][1][1][v][v][v]
	 * [^][^][3][<][<][3][v][v]
	 * [^][5][<][<][<][<][5][v]
	 * [7][<][<][<][<][<][<][7]
	 */
	}

	// for successful completion
	public void finish()
	{
		this.paused = true;
		reportProgress();
		world.save();
		Bukkit.getServer().getPluginManager().callEvent(new WorldBorderFillFinishedEvent(world, reportTotal));
		sendMessage("task successfully completed for world \"" + refWorld() + "\"!");
		this.stop();
	}

	// for cancelling prematurely
	public void cancel()
	{
		this.stop();
	}

	// we're done, whether finished or cancelled
	private void stop()
	{
		if (server == null)
			return;

		readyToGo = false;
		if (taskID != -1)
			server.getScheduler().cancelTask(taskID);
		server = null;

		// go ahead and unload any chunks we still have loaded
		// Set preventUnload to empty first so the ChunkUnloadEvent Listener
		// doesn't get in our way
		if (preventUnload != null)
		{
			Set<UnloadDependency> tempPreventUnload = preventUnload;
			preventUnload = null;
			for (UnloadDependency entry: tempPreventUnload)
			{
				world.setChunkForceLoaded(entry.neededX, entry.neededZ, false);
				world.unloadChunkRequest(entry.neededX, entry.neededZ);
			}
		}
	}

	// is this task still valid/workable?
	public boolean valid()
	{
		return this.server != null;
	}

	// handle pausing/unpausing the task
	public void pause()
	{
		if(this.pausedForMemory)
			pause(false);
		else
			pause(!this.paused);
	}
	public void pause(boolean pause)
	{
		if (this.pausedForMemory && !pause)
			this.pausedForMemory = false;
		else
			this.paused = pause;
		if (this.paused)
		{
			Config.StoreFillTask();
			reportProgress();
		}
		else
			Config.UnStoreFillTask();
	}
	public boolean isPaused()
	{
		return this.paused || this.pausedForMemory;
	}
	
	public boolean chunkOnUnloadPreventionList(int x, int z)
	{
		if (preventUnload != null)
		{
			for (UnloadDependency entry: preventUnload)
			{
				if (entry.neededX == x && entry.neededZ == z)
					return true;
			}
		}
		return false;
	}
	
	public World getWorld()
	{
		return world;
	}

	// let the user know how things are coming along
	private void reportProgress()
	{
		lastReport = Config.Now();
		double perc = getPercentageCompleted();
		if (perc > 100) perc = 100;
		sendMessage(reportNum + " more chunks processed (" + (reportTotal + reportNum) + " total, ~" + Config.coord.format(perc) + "%" + ")");
		reportTotal += reportNum;
		reportNum = 0;

		// go ahead and save world to disk every 30 seconds or so by default, just in case; can take a couple of seconds or more, so we don't want to run it too often
		if (Config.FillAutosaveFrequency() > 0 && lastAutosave + (Config.FillAutosaveFrequency() * 1000) < lastReport)
		{
			lastAutosave = lastReport;
			sendMessage("Saving the world to disk, just to be on the safe side.");
			world.save();
		}
	}

	// send a message to the server console/log and possibly to an in-game player
	private void sendMessage(String text)
	{
		// Due to chunk generation eating up memory and Java being too slow about GC, we need to track memory availability
		int availMem = Config.AvailableMemory();

		Config.log("[Fill] " + text + " (free mem: " + availMem + " MB)");
		if (notifyPlayer != null)
			notifyPlayer.sendMessage("[Fill] " + text);

		if (availMem < 200)
		{	// running low on memory, auto-pause
			pausedForMemory = true;
			Config.StoreFillTask();
			text = "Available memory is very low, task is pausing. A cleanup will be attempted now, and the task will automatically continue if/when sufficient memory is freed up.\n Alternatively, if you restart the server, this task will automatically continue once the server is back up.";
			Config.log("[Fill] " + text);
			if (notifyPlayer != null)
				notifyPlayer.sendMessage("[Fill] " + text);
			// prod Java with a request to go ahead and do GC to clean unloaded chunks from memory; this seems to work wonders almost immediately
			// yes, explicit calls to System.gc() are normally bad, but in this case it otherwise can take a long long long time for Java to recover memory
			System.gc();
		}
	}

	// stuff for saving / restoring progress
	public void continueProgress(int x, int z, int length, int totalDone)
	{
		this.x = x;
		this.z = z;
		this.length = length;
		this.reportTotal = totalDone;
		this.continueNotice = true;
	}
	public int refX()
	{
		return refX;
	}
	public int refZ()
	{
		return refZ;
	}
	public int refLength()
	{
		return refLength;
	}
	public int refTotal()
	{
		return refTotal;
	}
	public int refFillDistance()
	{
		return fillDistance;
	}
	public int refTickFrequency()
	{
		return tickFrequency;
	}
	public int refChunksPerRun()
	{
		return chunksPerRun;
	}
	public String refWorld()
	{
		return world.getName();
	}
	public boolean refForceLoad()
	{
		return forceLoad;
	}
	
	/**
	 * Get the percentage completed for the fill task.
	 * 
	 * @return Percentage
	 */
	public double getPercentageCompleted()
	{
		return ((double) (reportTotal + reportNum) / (double) reportTarget) * 100;
	}

	/**
	 * Amount of chunks completed for the fill task.
	 * 
	 * @return Number of chunks processed.
	 */
	public int getChunksCompleted()
	{
		return reportTotal;
	}

	/**
	 * Total amount of chunks that need to be generated for the fill task.
	 * 
	 * @return Number of chunks that need to be processed.
	 */
	public int getChunksTotal()
	{
		return reportTarget;
	}

	private CompletableFuture<Void> getPaperLibChunk(World world, int x, int z, boolean gen)
	{
		return PaperLib.getChunkAtAsync(world, x, z, gen).thenAccept( (Chunk chunk) ->
			{
				if (chunk != null)
				{
					// toggle "force loaded" flag on for chunk to prevent it from being unloaded while we need it
					world.setChunkForceLoaded(x, z, true);

					// alternatively for 1.14.4+
					//world.addPluginChunkTicket(x, z, pluginInstance);
				}
			});
	}
}