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

public partial class Connection : Node
{
	public const string WS_DEFAULT_ADDRESS = "wss://connect4.abunchofknowitalls.com";

	public static Connection Instance { get; private set; }

	private WebSocketPeer _webSocket = new WebSocketPeer();
	private bool _firstConnect = true;
	private Thread _gameListThread;
	private bool _gameListThreadRunning;

	public event Action OnConnected;
	public event Action OnReadyAcknowledged;
	public event Action<bool> OnGameStart;
	public event Action OnGameWin;
	public event Action OnGameLoss;
	public event Action OnGameDraw;
	public event Action OnGameTerminated;
	public event Action<int> OnOpponentMove;

	public event Action OnWatchGameAck;
	public event Action<string> OnObserveWin;
	public event Action OnObserveDraw;
	public event Action OnObserveTerminated;
	public event Action<string, int> OnObserveMove;
	public event Action<List<MatchData>> OnUpdatedMatches;
	public event Action<List<PlayerData>> OnUpdatedPlayers;
	public event Action OnStartTournamentAck;
	public event Action<List<(string, int)>> OnTournamentEnd;
	public event Action OnBecomeAdmin;
	

	// Already prints to console
	public event Action<string, string> OnError;

	public bool IsAdmin { get; private set; }
	public bool IsPlayer { get; private set; }
	public bool ActiveTournament { get; private set; }
	public List<(string, int)> PreviousMoves { get; private set; } = new List<(string, int)>();
	public double CurrentWaitTimeout { get; private set; } = 5.0;
	
	
	public MatchData CurrentObservingMatch { get; private set; }

	private bool IsSocketOpen => _webSocket.GetReadyState() == WebSocketPeer.State.Open;

	public override void _Ready()
	{
		Instance = this;
		_webSocket.SetHeartbeatInterval(5.0);
		_webSocket.HeartbeatInterval = 5.0;
	}

	public bool Connect(string address)
	{
		if (_webSocket.GetReadyState() == WebSocketPeer.State.Open)
		{
			return false;
		}

		Error error = _webSocket.ConnectToUrl(address);
		if (error != Error.Ok)
		{
			return false;
		}

		_webSocket.Poll();

		while (_webSocket.GetReadyState() == WebSocketPeer.State.Connecting)
		{
			_webSocket.Poll();
			Thread.Sleep(TimeSpan.FromMilliseconds(5));
		}

		if (_webSocket.GetReadyState() != WebSocketPeer.State.Open)
		{
			return false;
		}

		_webSocket.SetHeartbeatInterval(5.0);
		_webSocket.HeartbeatInterval = 5.0;
		_firstConnect = false;
		StartGameListRefreshLoop();
		return true;
	}

	public override void _ExitTree()
	{
		StopGameListRefreshLoop();
	}

	public override void _PhysicsProcess(double delta)
	{
		_webSocket.Poll();
		WebSocketPeer.State state = _webSocket.GetReadyState();
		if ((state == WebSocketPeer.State.Closed || state == WebSocketPeer.State.Closing) && !_firstConnect)
		{
			StopGameListRefreshLoop();
			GD.PrintErr("Connection lost.");
			//GetTree().Quit();
		}

		if (IsSocketOpen)
		{
			while (_webSocket.GetAvailablePacketCount() > 0)
			{
				string message = _webSocket.GetPacket().GetStringFromUtf8();
				HandleServerMessage(message);
			}
		}
	}

	// Player commands
	public void SendConnect(string clientId)
	{
		if (string.IsNullOrWhiteSpace(clientId))
		{
			GD.PrintErr("Client ID is required to CONNECT.");
			return;
		}

		clientId = clientId.Trim();

		if (clientId.Contains(":"))
		{
			GD.PrintErr("Client ID cannot contain ':' characters.");
			return;
		}

		SendCommand("CONNECT", clientId);
	}

	public void SendReady()
	{
		SendCommand("READY");
	}

	public void SendPlay(int column)
	{
		SendCommand("PLAY", column.ToString());
	}

	// Observer commands
	public void UpdateGameList()
	{
		SendCommand("GAME", "LIST");
	}

	private void StartGameListRefreshLoop()
	{
		if (_gameListThreadRunning)
		{
			return;
		}

		_gameListThreadRunning = true;
		_gameListThread = new Thread(() =>
		{
			while (_gameListThreadRunning)
			{
				if (IsSocketOpen)
				{
					UpdateGameList();
					UpdatePlayerList();
				}

				Thread.Sleep(TimeSpan.FromSeconds(5));
			}
		})
		{
			IsBackground = true
		};
		_gameListThread.Start();
	}

	private void StopGameListRefreshLoop()
	{
		if (!_gameListThreadRunning)
		{
			return;
		}

		_gameListThreadRunning = false;
		_gameListThread?.Join();
		_gameListThread = null;
	}

	public void UpdatePlayerList()
	{
		SendCommand("PLAYER", "LIST");
	}

	public void SendWatchGame(int matchID)
	{
		SendCommand("GAME", "WATCH:" + matchID);
	}

	public void AdminAuth(string password)
	{
		if (IsAdmin) return;
		SendCommand("ADMIN", "AUTH:" + password);
	}


	// Admin commands
	public void KickPlayer(string playerId)
	{
		if (!IsAdmin) return;
		SendCommand("ADMIN", "KICK:" + playerId);
	}

	public void StartTournament()
	{
		if (!IsAdmin) return;
		SendCommand("TOURNAMENT", "START");
	}

	public void TerminateGame(int matchID)
	{
		if (!IsAdmin) return;
		SendCommand("GAME", "TERMINATE:" + matchID);
	}

	public void SetTournamentWait(float waitTime)
	{
		if (!IsAdmin) return;
		CurrentWaitTimeout = waitTime;
		SendCommand("TOURNAMENT", "WAIT:" + waitTime);
	}

	private void SendCommand(string header, string body = "")
	{
		if (!IsSocketOpen)
		{
			GD.PrintErr($"Cannot send {header}, socket is not open.");
			return;
		}

		string payload = string.IsNullOrEmpty(body) ? header : $"{header}:{body}";
		_webSocket.SendText(payload);
	}

	private void HandleServerMessage(string message)
	{
		if (string.IsNullOrWhiteSpace(message))
		{
			return;
		}

		message = message.Trim();

		string header;
		string body;
		int separatorIndex = message.IndexOf(':');
		if (separatorIndex >= 0)
		{
			header = message.Substring(0, separatorIndex).Trim();
			body = message.Substring(separatorIndex + 1).Trim();
		}
		else
		{
			header = message.Trim();
			body = string.Empty;
		}

		header = header.ToUpperInvariant();

		switch (header)
		{
			case "CONNECT":
				if (body.Equals("ACK", StringComparison.OrdinalIgnoreCase))
				{
					IsPlayer = true;
					OnConnected?.Invoke();
				}

				break;
			case "READY":
				if (body.Equals("ACK", StringComparison.OrdinalIgnoreCase))
				{
					OnReadyAcknowledged?.Invoke();
				}

				break;
			case "GAME":
				HandleGameMessage(body);
				break;
			case "PLAYER":
				HandlePlayerList(body);
				break;
			case "OPPONENT":
				if (int.TryParse(body, out int column))
				{
					OnOpponentMove?.Invoke(column);
				}
				else
				{
					GD.PrintErr($"Invalid opponent column: {body}");
				}

				break;
			case "ADMIN":
				if (body == "AUTH:ACK")
				{
					IsAdmin = true;
					SetTournamentWait(5.0f);
					OnBecomeAdmin?.Invoke();
				}

				break;
			case "TOURNAMENT":
				HandleTournamentMessage(body);
				break;
			case "ERROR":
				HandleErrorMessage(body);
				GD.PrintErr($"Error: {body}");
				break;
			default:
				GD.Print($"Unhandled server message: {message}");
				break;
		}
	}

	private void HandleTournamentMessage(string body)
	{
		if (string.IsNullOrWhiteSpace(body))
		{
			return;
		}

		string[] segments = body.Split(':');
		string command = segments[0].Trim().ToUpperInvariant();
		string argument = segments.Length > 1 ? segments[1].Trim() : string.Empty;

		switch (command)
		{
			case "END":
			{
				ActiveTournament = false;
				List<(string, int)> playerScoreboard = new List<(string, int)>();
				string[] entries = segments[1].Split("|");
				foreach (string entry in entries)
				{
					string[] data = entry.Split(',');
					playerScoreboard.Add((data[0], int.Parse(data[1])));
				}

				OnTournamentEnd?.Invoke(playerScoreboard);
				break;
			}
			case "START":
			{
				OnStartTournamentAck?.Invoke();
				ActiveTournament = true;
				break;
			}
		}
	}

	private void HandlePlayerList(string body)
	{
		if (string.IsNullOrWhiteSpace(body))
		{
			return;
		}

		string[] segments = body.Split(':');
		string command = segments[0].Trim().ToUpperInvariant();
		string argument = segments.Length > 1 ? segments[1].Trim() : string.Empty;

		switch (command)
		{
			case "LIST":
			{
				List<PlayerData> players = new List<PlayerData>();

				if (segments.Length < 2)
				{
					OnUpdatedPlayers?.Invoke(players);
					break;
				}

				string[] entries = segments[1].Split("|");
				foreach (string entry in entries)
				{
					string[] data = entry.Split(',');
					players.Add(new PlayerData(data[0], bool.Parse(data[1]), bool.Parse(data[2])));
				}

				OnUpdatedPlayers?.Invoke(players);
				break;
			}
		}
	}

	private void HandleGameMessage(string body)
	{
		if (string.IsNullOrWhiteSpace(body))
		{
			return;
		}

		string[] segments = body.Split(':');
		string command = segments[0].Trim().ToUpperInvariant();
		string argument = segments.Length > 1 ? segments[1].Trim() : string.Empty;

		if (IsPlayer)
		{
			switch (command)
			{
				case "START":
					bool isFirst = argument == "1" || argument.Equals("TRUE", StringComparison.OrdinalIgnoreCase);
					OnGameStart?.Invoke(isFirst);
					break;
				case "WINS":
					OnGameWin?.Invoke();
					break;
				case "LOSS":
					OnGameLoss?.Invoke();
					break;
				case "DRAW":
					OnGameDraw?.Invoke();
					break;
				case "TERMINATED":
					OnGameTerminated?.Invoke();
					break;
				default:
					GD.Print($"Unhandled GAME message: {body}");
					break;
			}
		}
		else // Regular observer/admin
		{
			switch (command)
			{
				case "WIN":
					OnObserveWin?.Invoke(segments[1]);
					break;
				case "MOVE":
					OnObserveMove?.Invoke(segments[1], int.Parse(segments[2]));
					break;
				case "DRAW":
					OnObserveDraw?.Invoke();
					break;
				case "TERMINATED":
					OnObserveTerminated?.Invoke();
					break;
				case "LIST":
					List<MatchData> matches = new List<MatchData>();

					if (segments.Length < 2)
					{
						OnUpdatedMatches?.Invoke(matches);
						break;
					}

					string[] entries = segments[1].Split("|");
					foreach (string entry in entries)
					{
						string[] data = entry.Split(',');
						matches.Add(new MatchData(int.Parse(data[0]), data[1], data[2]));
					}

					OnUpdatedMatches?.Invoke(matches);
					break;
				case "WATCH":
					CurrentObservingMatch = null;
					PreviousMoves.Clear();
					string[] activeMatchData = segments[2].Split("|");
					if (activeMatchData.IsEmpty())
					{
						string[] matchData = segments[2].Split(',');
						CurrentObservingMatch = new MatchData(int.Parse(matchData[0]), matchData[1], matchData[2]);
					}
					else
					{
						string[] matchData = activeMatchData[0].Split(',');
						CurrentObservingMatch = new MatchData(int.Parse(matchData[0]), matchData[1], matchData[2]);
						for (int i = 1; i < activeMatchData.Length; i++)
						{
							string[] moveData = activeMatchData[i].Split(',');
							PreviousMoves.Add((moveData[0], int.Parse(moveData[1])));
						}
					}
					OnWatchGameAck?.Invoke();
					break;
				default:
					GD.Print($"Unhandled GAME message: {body}");
					break;
			}
		}
	}

	private void HandleErrorMessage(string body)
	{
		if (string.IsNullOrWhiteSpace(body))
		{
			OnError?.Invoke("UNKNOWN", string.Empty);
			return;
		}

		string[] segments = body.Split(':');
		string code = segments.Length > 0 ? segments[0].Trim().ToUpperInvariant() : "UNKNOWN";
		string detail = segments.Length > 1 ? string.Join(":", segments, 1, segments.Length - 1).Trim() : string.Empty;

		OnError?.Invoke(code, detail);
	}
}