using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Threading;

using System.Web.UI;

using Vintagestory.API.Common;
using Vintagestory.API.MathTools;



namespace Automap
{
	public partial class AutomapMod
	{
		private Thread cartographer_thread;

		private const string _mapPath = @"Maps";
		private const string _chunkPath = @"Chunks";
		private const string _domain = @"automap";

		private ConcurrentDictionary<Vec2i, uint> columnCounter = new ConcurrentDictionary<Vec2i, uint>(3, 103 );//ChunkMeta struct?
		private HashSet<Vec2i> knownChunkTops = new HashSet<Vec2i>( );

		private PointsOfInterest POIs;
		private Dictionary<int, Designator> BlockID_Designators;

		private int North_mostChunk;
		private int East_mostChunk;
		private int West_mostChunk;
		private int South_mostChunk;
		private Vec2i startChunkColumn;
		private uint lastUpdate;

		private string path;
		private IAsset stylesFile;

		#region Internals
		private void StartAutomap( )
		{
		path = ClientAPI.GetOrCreateDataPath(_mapPath);
		path = ClientAPI.GetOrCreateDataPath(Path.Combine(path, "World_" + ClientAPI.World.Seed));//Add name of World too!

		stylesFile = ClientAPI.World.AssetManager.Get(new AssetLocation(_domain, "config/automap_format.css"));
		Logger.VerboseDebug("CSS loaded: {0} size: {1}",stylesFile.IsLoaded() ,stylesFile.ToText( ).Length);


		Prefill_POI_Designators( );
		startChunkColumn = new Vec2i((ClientAPI.World.Player.Entity.LocalPos.AsBlockPos.X / ClientAPI.World.BlockAccessor.ChunkSize), (ClientAPI.World.Player.Entity.LocalPos.AsBlockPos.Z / ClientAPI.World.BlockAccessor.ChunkSize));
		North_mostChunk = startChunkColumn.Y;
		South_mostChunk = startChunkColumn.Y;
		East_mostChunk = startChunkColumn.X;
		West_mostChunk = startChunkColumn.X;

		Logger.Notification("AUTOMAP Start {0}", startChunkColumn);

		ClientAPI.Event.ChunkDirty += ChunkAChanging;

		cartographer_thread = new Thread(Cartographer);
		cartographer_thread.Name = "Cartographer";
		cartographer_thread.Priority = ThreadPriority.Lowest;
		cartographer_thread.IsBackground = true;

		ClientAPI.Event.RegisterGameTickListener(AwakenCartographer, 6000);
		}

		private void ChunkAChanging(Vec3i chunkCoord, IWorldChunk chunk, EnumChunkDirtyReason reason)
		{			
		Vec2i topPosition = new Vec2i(chunkCoord.X, chunkCoord.Z);

		columnCounter.AddOrUpdate(topPosition, 1, (key, colAct) => colAct + 1);		
		}

		private void AwakenCartographer(float delayed)
		{

		if (ClientAPI.IsGamePaused != false || ClientAPI.IsShuttingDown != true) {
		#if DEBUG
		Logger.VerboseDebug("Cartographer re-trigger from [{0}]", cartographer_thread.ThreadState);
		#endif

		if (cartographer_thread.ThreadState.HasFlag(ThreadState.Unstarted)) {
		cartographer_thread.Start( );
		}
		else if (cartographer_thread.ThreadState.HasFlag(ThreadState.WaitSleepJoin)) {
		//Time to (re)write chunk shards
		cartographer_thread.Interrupt( );
		}
		ClientAPI.TriggerChatMessage($"Automap {lastUpdate} changes - MAX (N:{North_mostChunk},S:{South_mostChunk},E:{East_mostChunk}, W:{West_mostChunk} - TOTAL: {knownChunkTops.Count})");
		}

		}


		private void Cartographer( )
		{
	wake:
		Logger.VerboseDebug("Cartographer thread awoken");

		try {
		uint ejectedItem = 0;
		uint updatedChunks = 0;

		//-- Should dodge enumerator changing underfoot....at a cost.
		if (!columnCounter.IsEmpty) {
		var tempSet = columnCounter.ToArray( ).OrderByDescending(kvp => kvp.Value);
		foreach (var mostActiveCol in tempSet) {

		var mapChunk = ClientAPI.World.BlockAccessor.GetMapChunk(mostActiveCol.Key);

		if (mapChunk == null) {
		Logger.Warning("SKIP CHUNK: ({0}) - Map Chunk NULL!", mostActiveCol.Key);

		columnCounter.TryRemove(mostActiveCol.Key, out ejectedItem);
		continue;
		}

		string filename = $"{mostActiveCol.Key.X}_{mostActiveCol.Key.Y}.png";
		filename = Path.Combine(path, filename);

		uint pixels = 0;
		var chkImg = GenerateChunkImage(mostActiveCol.Key, mapChunk, out pixels);

		if (pixels > 0) {
		chkImg.Save(filename, ImageFormat.Png);
		#if DEBUG
		Logger.VerboseDebug("Wrote chunk shard: ({0}) - Edits#:{1}, Pixels#:{2}", mostActiveCol.Key, mostActiveCol.Value, pixels);
		#endif
		updatedChunks++;
		knownChunkTops.Add(mostActiveCol.Key);
		columnCounter.TryRemove(mostActiveCol.Key, out ejectedItem);
		}
		else {
		columnCounter.TryRemove(mostActiveCol.Key, out ejectedItem);
		Logger.VerboseDebug("Un-painted chunk: ({0}) ", mostActiveCol.Key);
		}

		}
		}

		if (updatedChunks > 0) {
		lastUpdate = updatedChunks;
		GenerateMapHTML( );
		updatedChunks = 0;
		}

		//Then sleep until interupted again, and repeat

		Logger.VerboseDebug("Thread '{0}' about to sleep indefinitely.", Thread.CurrentThread.Name);

		Thread.Sleep(Timeout.Infinite);

		} catch (ThreadInterruptedException) {

		Logger.VerboseDebug("Thread '{0}' interupted [awoken]", Thread.CurrentThread.Name);
		goto wake;

		} catch (ThreadAbortException) {
		Logger.VerboseDebug("Thread '{0}' aborted.", Thread.CurrentThread.Name);

		} finally {
		Logger.VerboseDebug("Thread '{0}' executing finally block.", Thread.CurrentThread.Name);
		}
		}
		#endregion


		private void Prefill_POI_Designators( )
		{
		this.POIs = new PointsOfInterest( );
		this.BlockID_Designators = new Dictionary<int, Designator>( );

		//Add special marker types for BlockID's of "Interest", overwrite colour, and method

		var theDesignators = new List<Designator>{
				DefaultDesignators.Roads,
                DefaultDesignators.GroundSigns,
                DefaultDesignators.WallSigns,
                DefaultDesignators.PostSigns,
				};

		Install_POI_Designators(theDesignators);
		}

		private void Install_POI_Designators(ICollection<Designator> designators)
		{
		Logger.VerboseDebug("Connecting {0} configured Designators", designators.Count);
		foreach (var designator in designators) {				
			var blockIDs = Helpers.ArbitrarytBlockIdHunter(ClientAPI, designator.Pattern, designator.Material);
				if (blockIDs.Count > 0) { Logger.VerboseDebug("Designator {0} has {1} associated blockIDs", designator.ToString( ), blockIDs.Count); }
			foreach (var entry in blockIDs) {
			BlockID_Designators.Add(entry.Key, designator);
			}
		}

		}



		#region COPYPASTA
		//TODO: rewrite - with alternate algo.
		//A slightly re-written; ChunkMapLayer :: public int[] GenerateChunkImage(Vec2i chunkPos, IMapChunk mc)
		internal Bitmap GenerateChunkImage(Vec2i chunkPos, IMapChunk mc, out uint pixelCount)
		{
		pixelCount = 0;
		BlockPos tmpPos = new BlockPos( );
		Vec2i localpos = new Vec2i( );
		int chunkSize = ClientAPI.World.BlockAccessor.ChunkSize;
		var chunksColumn = new IWorldChunk[ClientAPI.World.BlockAccessor.MapSizeY / chunkSize];
		Bitmap chunkImage = new Bitmap(chunkSize, chunkSize, PixelFormat.Format24bppRgb);
		int topChunkY = mc.YMax / chunkSize;//Heywaitaminute -- this isn't a highest FEATURE, if Rainmap isn't accurate!
											//Metadata of DateTime chunk was edited, chunk coords.,world-seed? Y-Max feature height
											//Grab a chunk COLUMN... Topmost Y down...
		for (int chunkY = 0; chunkY <= topChunkY; chunkY++) {
		chunksColumn[chunkY] = ClientAPI.World.BlockAccessor.GetChunk(chunkPos.X, chunkY, chunkPos.Y);
		//What to do if chunk is a void? invalid?
		}

		// Prefetch map chunks, in pattern
		IMapChunk[ ] mapChunks = new IMapChunk[ ]
		{
			ClientAPI.World.BlockAccessor.GetMapChunk(chunkPos.X - 1, chunkPos.Y - 1),
			ClientAPI.World.BlockAccessor.GetMapChunk(chunkPos.X - 1, chunkPos.Y),
			ClientAPI.World.BlockAccessor.GetMapChunk(chunkPos.X, chunkPos.Y - 1)
		};


		for (int posIndex = 0; posIndex < (chunkSize * chunkSize); posIndex++) {
		int mapY = mc.RainHeightMap[posIndex];
		int localChunkY = mapY / chunkSize;
		if (localChunkY >= (chunksColumn.Length)) continue;//Out of range!

		MapUtil.PosInt2d(posIndex, chunkSize, localpos);
		int localX = localpos.X;
		int localZ = localpos.Y;

		float b = 1;
		int leftTop, rightTop, leftBot;

		IMapChunk leftTopMapChunk = mc;
		IMapChunk rightTopMapChunk = mc;
		IMapChunk leftBotMapChunk = mc;

		int topX = localX - 1;
		int botX = localX;
		int leftZ = localZ - 1;
		int rightZ = localZ;

		if (topX < 0 && leftZ < 0) {
		leftTopMapChunk = mapChunks[0];
		rightTopMapChunk = mapChunks[1];
		leftBotMapChunk = mapChunks[2];
		}
		else {
		if (topX < 0) {
		leftTopMapChunk = mapChunks[1];
		rightTopMapChunk = mapChunks[1];
		}
		if (leftZ < 0) {
		leftTopMapChunk = mapChunks[2];
		leftBotMapChunk = mapChunks[2];
		}
		}

		topX = GameMath.Mod(topX, chunkSize);
		leftZ = GameMath.Mod(leftZ, chunkSize);

		leftTop = leftTopMapChunk == null ? 0 : Math.Sign(mapY - leftTopMapChunk.RainHeightMap[leftZ * chunkSize + topX]);
		rightTop = rightTopMapChunk == null ? 0 : Math.Sign(mapY - rightTopMapChunk.RainHeightMap[rightZ * chunkSize + topX]);
		leftBot = leftBotMapChunk == null ? 0 : Math.Sign(mapY - leftBotMapChunk.RainHeightMap[leftZ * chunkSize + botX]);

		float slopeness = (leftTop + rightTop + leftBot);

		if (slopeness > 0) b = 1.2f;
		if (slopeness < 0) b = 0.8f;

		b -= 0.15f; //Slope boost value 

		if (chunksColumn[localChunkY] == null) {

		continue;
		}

		chunksColumn[localChunkY].Unpack( );
		int blockId = chunksColumn[localChunkY].Blocks[MapUtil.Index3d(localpos.X, mapY % chunkSize, localpos.Y, chunkSize, chunkSize)];

		Block block = ClientAPI.World.Blocks[blockId];

		tmpPos.Set(chunkSize * chunkPos.X + localpos.X, mapY, chunkSize * chunkPos.Y + localpos.Y);

		int avgCol = block.GetColor(ClientAPI, tmpPos);
		int rndCol = block.GetRandomColor(ClientAPI, tmpPos, BlockFacing.UP);
		//This is still, an abnormal color - the tint is too blue
		int col = ColorUtil.ColorOverlay(avgCol, rndCol, 0.125f);
		var packedFormat = ColorUtil.ColorMultiply3Clamped(col, b);

		Color pixelColor = Color.FromArgb(ColorUtil.ColorB(packedFormat), ColorUtil.ColorG(packedFormat), ColorUtil.ColorR(packedFormat));

		//============ POI Population =================
		if (BlockID_Designators.ContainsKey(blockId)) {
		var desig = BlockID_Designators[blockId];
		pixelColor = desig.OverwriteColor;

		if (desig.SpecialAction != null) {		
		desig.SpecialAction(ClientAPI, this.POIs, tmpPos, block);
		}
		}

		chunkImage.SetPixel(localX, localZ, pixelColor);
		pixelCount++;
		}


		return chunkImage;
		}
		#endregion


		private void GenerateMapHTML( )
		{
		string mapFilename = Path.Combine(path, "Automap.html");

		North_mostChunk = knownChunkTops.Min(tc => tc.Y);
		South_mostChunk = knownChunkTops.Max(tc => tc.Y);
		East_mostChunk = knownChunkTops.Max(tc => tc.X);
		West_mostChunk = knownChunkTops.Min(tc => tc.X);


		using (StreamWriter outputText = new StreamWriter(File.Open(mapFilename, FileMode.Create, FileAccess.Write, FileShare.ReadWrite))) {
		using (HtmlTextWriter tableWriter = new HtmlTextWriter(outputText)) {
		tableWriter.BeginRender( );
		tableWriter.RenderBeginTag(HtmlTextWriterTag.Html);

		tableWriter.RenderBeginTag(HtmlTextWriterTag.Head);
		tableWriter.RenderBeginTag(HtmlTextWriterTag.Title);
		tableWriter.WriteEncodedText("Generated Automap");
		tableWriter.RenderEndTag( );
		//CSS  style  here
		tableWriter.RenderBeginTag(HtmlTextWriterTag.Style);
		tableWriter.Write(stylesFile.ToText( ));
		tableWriter.RenderEndTag( );//</style>

		tableWriter.RenderEndTag( );

		tableWriter.RenderBeginTag(HtmlTextWriterTag.Body);
		tableWriter.RenderBeginTag(HtmlTextWriterTag.P);
		tableWriter.WriteEncodedText($"Created {DateTimeOffset.UtcNow.ToString("u")}");
		tableWriter.RenderEndTag( );
		tableWriter.RenderBeginTag(HtmlTextWriterTag.P);
		tableWriter.WriteEncodedText($"W:{West_mostChunk}, E: {East_mostChunk}, N:{North_mostChunk}, S:{South_mostChunk} ");
		tableWriter.RenderEndTag( );
		tableWriter.WriteLine( );
		tableWriter.RenderBeginTag(HtmlTextWriterTag.Table);
		tableWriter.RenderBeginTag(HtmlTextWriterTag.Caption);
		tableWriter.WriteEncodedText($"Start: {startChunkColumn}, Seed: {ClientAPI.World.Seed}\n");		
		tableWriter.RenderEndTag( );

		//################ X-Axis <thead> #######################
		tableWriter.RenderBeginTag(HtmlTextWriterTag.Thead);
		tableWriter.RenderBeginTag(HtmlTextWriterTag.Tr);

		tableWriter.RenderBeginTag(HtmlTextWriterTag.Th);
		tableWriter.Write("N, W");
		tableWriter.RenderEndTag( );

		for (int xAxisT = West_mostChunk; xAxisT <= East_mostChunk; xAxisT++) {
		tableWriter.RenderBeginTag(HtmlTextWriterTag.Th);
		tableWriter.Write(xAxisT);
		tableWriter.RenderEndTag( );
		}

		tableWriter.RenderBeginTag(HtmlTextWriterTag.Th);
		tableWriter.Write("N, E");
		tableWriter.RenderEndTag( );
		
		tableWriter.RenderEndTag( );
		tableWriter.RenderEndTag( );
		//###### </thead> ################################

		//###### <tbody> - Chunk rows & Y-axis cols
		tableWriter.RenderBeginTag(HtmlTextWriterTag.Tbody);
		//######## <tr> for every vertical row
		for (int yAxis = North_mostChunk; yAxis <= South_mostChunk; yAxis++) {
		tableWriter.RenderBeginTag(HtmlTextWriterTag.Tr);
		tableWriter.RenderBeginTag(HtmlTextWriterTag.Td);
		tableWriter.Write(yAxis);//legend: Y-axis
		tableWriter.RenderEndTag( );

		for (int xAxis = West_mostChunk; xAxis <= East_mostChunk; xAxis++) {
		//###### <td>  #### for chunk shard 
		tableWriter.RenderBeginTag(HtmlTextWriterTag.Td);
		if (knownChunkTops.Contains( new Vec2i(xAxis, yAxis))){
		tableWriter.AddAttribute(HtmlTextWriterAttribute.Src, $"{xAxis}_{yAxis}.png");
		tableWriter.AddAttribute(HtmlTextWriterAttribute.Alt, $"X{xAxis}, Y{yAxis}");
		tableWriter.RenderBeginTag(HtmlTextWriterTag.Img);
		tableWriter.RenderEndTag( );
		}
		else {
		tableWriter.Write("?");
		}		
		tableWriter.RenderEndTag( );
		}//############ </td> ###########

		tableWriter.RenderBeginTag(HtmlTextWriterTag.Td);
		tableWriter.Write(yAxis);//legend: Y-axis
		tableWriter.RenderEndTag( );

		tableWriter.RenderEndTag( );
		tableWriter.EndRender( );
		tableWriter.Flush( );
		}
		tableWriter.RenderEndTag( );

		//################ X-Axis <tfoot> #######################
		tableWriter.RenderBeginTag(HtmlTextWriterTag.Tfoot);
		tableWriter.RenderBeginTag(HtmlTextWriterTag.Tr);

		tableWriter.RenderBeginTag(HtmlTextWriterTag.Td);
		tableWriter.Write("S, W");
		tableWriter.RenderEndTag( );

		for (int xAxisB = West_mostChunk; xAxisB <= East_mostChunk; xAxisB++) {
		tableWriter.RenderBeginTag(HtmlTextWriterTag.Td);
		tableWriter.Write(xAxisB);
		tableWriter.RenderEndTag( );
		}

		tableWriter.RenderBeginTag(HtmlTextWriterTag.Td);
		tableWriter.Write("S, E");
		tableWriter.RenderEndTag( );

		tableWriter.RenderEndTag( );
		tableWriter.RenderEndTag( );
		//###### </tfoot> ################################


		tableWriter.RenderEndTag( );//</table>
		
		//############## POI list #####################
		tableWriter.RenderBeginTag(HtmlTextWriterTag.Ul);
		foreach (var poi in this.POIs) {
		tableWriter.RenderBeginTag(HtmlTextWriterTag.Li);
		tableWriter.WriteEncodedText(poi.Timestamp.ToString("u"));
		tableWriter.WriteEncodedText(poi.Notes);
		tableWriter.WriteEncodedText(poi.Location.PrettyCoords(this.ClientAPI));
		tableWriter.RenderEndTag( );
		}

		tableWriter.RenderEndTag( );
		tableWriter.RenderEndTag( );
		tableWriter.RenderEndTag( );

		tableWriter.EndRender( );
		tableWriter.Flush( );
		}
		outputText.Flush( );		
		}

		Logger.VerboseDebug("Generated HTML map");
		}



	}

}