using System;
using System.Collections.Generic;
using Godot;

public partial class RPCNode : Node
{
	public static RPCNode Instance { get; private set; }

	public override void _EnterTree()
	{
		Instance = this;
	}

	public override void _ExitTree()
	{
		Instance = null;
	}

	[Rpc(MultiplayerApi.RpcMode.Authority)]
	public void RpcDespawnGameObject(string uuidData)
	{
		GD.Print("DESPAWNING: " + uuidData);

		if (!GameManager.Instance.playerReady)
		{
			return;
		}

		Guid uuid = Guid.Parse(uuidData);

		List<Sector> sectors = GameManager.Instance.GetCurrentSector().GetNeighbouringSectors();
		foreach (Sector sector in sectors)
		{
			bool removed = sector.RemoveObjectById(uuid);
			if (removed)
			{
				break;
			}
		}

		GameManager.Instance.Despawn(uuid);
	}

	[Rpc(MultiplayerApi.RpcMode.Authority)]
	public void RpcSyncGameObject(Godot.Collections.Dictionary gameObjectData)
	{
		GD.Print("READING: " + gameObjectData);

		if (!GameManager.Instance.playerReady)
		{
			return;
		}

		if (!gameObjectData.TryGetValue("uuid", out var uuidData))
			return;

		Guid uuid = Guid.Parse((string)uuidData);

		List<Sector> sectors = GameManager.Instance.GetCurrentSector().GetNeighbouringSectors();
		foreach (Sector sector in sectors)
		{
			GameObject gameObject = sector.GetObjectById(uuid);
			if (gameObject != null)
			{
				gameObject.NetworkRead(gameObjectData);
				return;
			}
		}
	}


	[Rpc(MultiplayerApi.RpcMode.Authority)]
	public void RpcSpawnGameObject(Godot.Collections.Dictionary gameObjectData)
	{
		GD.Print("SPAWNING: " + gameObjectData);

		if (!gameObjectData.TryGetValue("type", out var typeData))
			return;
		if (!gameObjectData.TryGetValue("sectorCoordinates", out var sectorCoordinatesData))
			return;
		if (!gameObjectData.TryGetValue("localCoordinates", out var localCoordinatesData))
			return;
		if (!gameObjectData.TryGetValue("uuid", out var uuidData))
			return;

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

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

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

			default:
				return;
		}

		gameObject.UUID = uuid;
		gameObject.NetworkRead(gameObjectData);

		sector.AssignObject(gameObject);

		GameManager.Instance.Spawn(gameObject);
	}

	[Rpc(MultiplayerApi.RpcMode.AnyPeer)]
	public void RpcSyncPlayer(long id, Vector3 position, Vector3I sectorCoordinates)
	{
		if (!GameManager.Instance.playerReady)
		{
			return;
		}

		GameManager.Instance.Players.TryGetValue(id, out Player player);
		if (player == null || !player.IsInsideTree())
		{
			return;
		}
		Character playerData = player.PlayerData;

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

		playerData.SetCoordinates(position);

		if (playerData.CurrentSector.Coordinates != sectorCoordinates)
		{
			sector.AssignObject(playerData);
		}

		player.GlobalPosition = position + playerData.SectorOffset;
	}

	[Rpc(MultiplayerApi.RpcMode.AnyPeer)]
	public void RpcSyncPlayerPhysics(long id, Vector3 _movementVelocity, Vector3 _gravityVelocity, Vector3 rotation)
	{
		if (!GameManager.Instance.playerReady)
		{
			return;
		}

		GameManager.Instance.Players.TryGetValue(id, out Player player);
		if (player == null || !player.IsInsideTree())
		{
			return;
		}

		player.MovementVelocity = _movementVelocity;
		player.GravityVelocity = _gravityVelocity;

		player.GlobalRotation = rotation;
	}
}