using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Godot;

public partial class GameManager : Node3D
{
	[Export] public Control GameMenu { get; private set; }
	[Export] public QueueManager QueueManager { get; private set; }
	[Export] public Node3D SpaceRoot { get; private set; }

	[Export] public double closeTickInterval = 1;
	[Export] public double farTickInterval = 10;
	[Export] public int maxFarThreads = 16;

	public static bool Loading { get; private set; } = true;
	public static GameManager Singleton { get; private set; }
	public static IGenerator Generator { get; private set; }
	public static Universe GameUniverse { get; private set; }
	public Player MainPlayer { get; private set; }
	public List<Player> Players { get; private set; } = [];

	private double closeTickTimer = 0;
	private double farTickTimer = 0;

	public bool simulating = false;
	public bool playerReady = false;

	private readonly Dictionary<GameObject, Node3D> spawnedObjects = [];
	private readonly ConcurrentQueue<GameObject> spawnQueue = [];

	public override void _Ready()
	{
		Singleton = this;

		Generator = new TestGenerator();

		if (Global.IsGameHost)
		{
			GameUniverse = Generator.GenerateUniverse();
			Loading = false;
		}
	}

	private void OnPlayerReady()
	{
		playerReady = true;
		SpawnClose();
	}

	public override void _ExitTree()
	{
		Loading = true;
		Singleton = null;
	}

	public override void _Process(double delta)
	{
		if (!playerReady || !Global.IsGameHost)
		{
			return;
		}

		closeTickTimer += delta;
		farTickTimer += delta;

		if (closeTickTimer >= closeTickInterval)
		{
			SimulateClose(closeTickTimer);
			closeTickTimer = 0;
		}

		if (simulating)
		{
			farTickTimer = 0;
		}

		if (farTickTimer >= farTickInterval)
		{
			double taskFarTickTimer = farTickTimer;
			Task.Run(() =>
			{
				SimulateFar(taskFarTickTimer);
			});

			farTickTimer = 0;
		}
	}

	public Sector GetCurrentSector()
	{
		return MainPlayer.PlayerData.CurrentSector;
	}

	private void SimulateClose(double delta)
	{
		List<Sector> neighbours = GetCurrentSector().GetNeighbouringSectors();

		neighbours.ForEach(sector =>
		{
			Task.Run(() =>
			{
				sector.Simulate(delta);
			});
		});
	}

	private void SimulateFar(double delta)
	{
		simulating = true;

		List<Task> tasks = [];

		Sector[,,] sectors = GameUniverse.Sectors;

		int sizeX = sectors.GetLength(0);
		int countX = Mathf.Clamp(sizeX / maxFarThreads, 1, int.MaxValue);

		for (int x = 0; x < sizeX; x += countX)
		{
			double taskDelta = delta;
			int taskStartX = x;
			int taskCountX = countX;

			Task clusteredTask = Task.Run(() =>
			{
				SimulateFarClustered(taskDelta, taskStartX, taskCountX);
			});

			tasks.Add(clusteredTask);
		}

		Task.WaitAll([.. tasks]);

		simulating = false;
	}

	private void SimulateFarClustered(double delta, int startX, int countX)
	{
		Vector3I currentCoordinates = GetCurrentSector().Coordinates;

		Sector[,,] sectors = GameUniverse.Sectors;

		int sizeX = sectors.GetLength(0);
		int sizeY = sectors.GetLength(1);
		int sizeZ = sectors.GetLength(2);

		int startSkipX = Mathf.Clamp(currentCoordinates.X - 1, 0, sizeX);
		int startSkipY = Mathf.Clamp(currentCoordinates.Y - 1, 0, sizeY);
		int startSkipZ = Mathf.Clamp(currentCoordinates.Z - 1, 0, sizeZ);

		int endSkipX = Mathf.Clamp(currentCoordinates.X + 1, 0, sizeX);
		int endSkipY = Mathf.Clamp(currentCoordinates.Y + 1, 0, sizeY);
		int endSkipZ = Mathf.Clamp(currentCoordinates.Z + 1, 0, sizeZ);

		int endX = Mathf.Clamp(startX + countX, 0, sizeX);

		for (int x = startX; x < endX; x++)
		{
			for (int y = 0; y < sizeY; y++)
			{
				Thread.Sleep(5);
				for (int z = 0; z < sizeZ; z++)
				{
					if (Helpers.IsBetweenInclusive(x, startSkipX, endSkipX))
					{
						if (Helpers.IsBetweenInclusive(y, startSkipY, endSkipY))
						{
							if (Helpers.IsBetweenInclusive(z, startSkipZ, endSkipZ))
							{
								continue;
							}
						}
					}

					try
					{
						sectors[x, y, z].Simulate(delta);
					}
					catch (Exception e)
					{
						QueueManager.LogQueue.Enqueue("EXCEPTION: " + e.Message);
					}
				}
			}
		}
	}

	private void SpawnClose()
	{
		List<Sector> neighbours = GetCurrentSector().GetNeighbouringSectors();

		neighbours.ForEach(sector => sector.SpawnObjects());
	}

	public Player SpawnPlayer(Character character, bool isMainPlayer = false)
	{
		Player player = character.InstantiatePlayer();
		player.GameMenu = GameMenu;

		if (isMainPlayer)
		{
			MainPlayer = player;
			OnPlayerReady();
		}

		Players.Add(player);

		character.UpdateSector();

		SpaceRoot.CallDeferred("add_child", player);
		return player;
	}

	public void DespawnPlayer(Player player)
	{
		SpaceRoot.CallDeferred("remove_child", player);
		player.CallDeferred("queue_free");
	}

	public void Spawn(GameObject gameObject)
	{
		spawnQueue.Enqueue(gameObject);
		CallDeferred(nameof(ProcessSpawnQueue));
	}

	private void ProcessSpawnQueue()
	{
		spawnQueue.TryDequeue(out GameObject gameObject);
		if (gameObject == null)
		{
			return;
		}
		if (spawnedObjects.ContainsKey(gameObject))
		{
			return;
		}

		Node3D instance = gameObject.Instantiate(GetCurrentSector());
		spawnedObjects.Add(gameObject, instance);

		SpaceRoot.CallDeferred("add_child", instance);
	}

	public void Despawn(GameObject gameObject)
	{
		if (!spawnedObjects.ContainsKey(gameObject))
		{
			return;
		}

		Node3D nodeToDespawn = spawnedObjects.GetValueOrDefault(gameObject);
		spawnedObjects.Remove(gameObject);

		SpaceRoot.CallDeferred("remove_child", nodeToDespawn);
		nodeToDespawn.CallDeferred("queue_free");
	}

	public void ApplyOrigin()
	{
		Sector current = GetCurrentSector();

		foreach (Player player in Players)
		{
			player.PlayerData.UpdateSectorOffset(current);
			player.PlayerData.UpdateNodePosition();
		}

		List<Sector> nearby = current.GetNeighbouringSectors();
		foreach (KeyValuePair<GameObject, Node3D> spawned in spawnedObjects)
		{
			GameObject gameObject = spawned.Key;
			Node3D node = spawned.Value;

			if (!nearby.Contains(gameObject.CurrentSector))
			{
				Despawn(gameObject);
			}
			else
			{
				gameObject.UpdateSectorOffset(current);
				node.GlobalPosition = gameObject.LocalCoordinates + gameObject.SectorOffset;
			}
		}

		nearby.ForEach(sector => sector.SpawnObjects());
	}

	// These should be in RPCNode and should be queued
	public void SendUniverseToClient(long id)
	{
		RpcId(id, nameof(RpcDownloadUniverse), Generator.GetUniverseSize(), Generator.GetSectorSize());
	}

	// These should be in RPCNode and should be queued
	[Rpc(MultiplayerApi.RpcMode.Authority)]
	public void RpcDownloadUniverse(Vector3I universeSize, Vector3 sectorSize)
	{
		GameUniverse = Generator.InitializeEmptyUniverse(universeSize, sectorSize);

		Loading = false;
	}

	// These should be in RPCNode and should be queued
	[Rpc(MultiplayerApi.RpcMode.AnyPeer)]
	public void RpcSendNearbySectors(Vector3I coordinates, long id = -1)
	{
		Sector sector = GameUniverse.GetSector(coordinates);
		if (sector == null)
		{
			return;
		}

		List<Sector> sectors = sector.GetNeighbouringSectors();
		sectors.ForEach(sector => SendSectorToClients(sector, id == -1 ? null : id));
	}

	// These should be in RPCNode and should be queued
	public void SendSectorToClients(Sector sector, long? id = null)
	{
		foreach (GameObject gameObject in sector.GameObjects)
		{
			if (gameObject is Character)
			{
				continue;
			}

			Godot.Collections.Dictionary gameObjectData = new() {
					{ "type", gameObject.GetType().Name },
					{ "sectorCoordinates", sector.Coordinates },
					{ "coordinates", gameObject.LocalCoordinates },
					{ "uuid", gameObject.UUID.ToString() },
				};

			if (id.HasValue)
			{
				RpcId(id.Value, nameof(RpcDownloadGameObject), gameObjectData);
			}
			else
			{
				Rpc(nameof(RpcDownloadGameObject), gameObjectData);
			}
		}
	}

	// These should be in RPCNode and should be queued
	[Rpc(MultiplayerApi.RpcMode.Authority)]
	public void RpcDownloadGameObject(Godot.Collections.Dictionary gameObjectData)
	{
		if (!gameObjectData.TryGetValue("type", out var typeData))
		{
			return;
		}
		if (!gameObjectData.TryGetValue("sectorCoordinates", out var sectorCoordinatesData))
		{
			return;
		}
		if (!gameObjectData.TryGetValue("coordinates", out var coordinatesData))
		{
			return;
		}
		if (!gameObjectData.TryGetValue("uuid", out var uuidData))
		{
			return;
		}

		string type = (string)typeData;
		Vector3I sectorCoordinates = (Vector3I)sectorCoordinatesData;
		Vector3 coordinates = (Vector3)coordinatesData;
		Guid uuid = Guid.Parse((string)uuidData);

		Sector sector = GameUniverse.GetSector(sectorCoordinates);
		if (sector == null)
		{
			return;
		}

		GameObject gameObject;
		switch (type)
		{
			case "Star":
				gameObject = new Star(sector, coordinates);
				break;

			default:
				return;
		}

		gameObject.UUID = uuid;

		Spawn(gameObject);

		sector.AssignObject(gameObject);
	}
}