class_name WebClientTCP
extends Node

#var _tcp := StreamPeerTCP.new()
var _socket := WebSocketPeer.new()

var _new_status: int = WebSocketPeer.STATE_CLOSED
var _processed_status: int = -1

var _lobby_id: String
var _client_id: String
var _client_name: String

var received_data: Array
var cached_response: String

var _thread: Thread
var _stop_thread: bool = false

signal connected_to_server()
signal connection_error_occurred()
signal disconnected_from_server()

signal connected_to_lobby(lobby_id: String)
signal disconnected_from_lobby()

signal client_joined_lobby(client_name: String)
signal client_left_lobby(client_name: String)

signal received_chat_message(client_name: String, message: String)

signal connection_status_changed(new_status: ConnectionStatus)

enum ConnectionStatus {
	DISCONNECTED,
	ATTEMPTING_CONNECTION,
	LOBBYLESS, # == connected
	ATTEMPTING_JOIN,
	JOINED,
}

func _process(_delta: float) -> void:
	_socket.poll()
	_new_status = _socket.get_ready_state()
	if not _processed_status == _new_status:
		match _new_status:
			WebSocketPeer.STATE_OPEN:
				print("open")
				_stop_thread = false
				_thread = Thread.new()
				_thread.start(_listen_for_data)
				connected_to_server.emit()
				connection_status_changed.emit(ConnectionStatus.LOBBYLESS)
			WebSocketPeer.STATE_CONNECTING:
				print("connecting")
				connection_status_changed.emit(ConnectionStatus.ATTEMPTING_CONNECTION)
			WebSocketPeer.STATE_CLOSING:
				print("closing")
				pass
			WebSocketPeer.STATE_CLOSED:
				print("closed")
				_clean_up_thread()
				connection_status_changed.emit(ConnectionStatus.DISCONNECTED)
			
		_processed_status = _new_status
	#_new_status = _tcp.get_status()
	## Ensure status change is only processed once
	#if not _processed_status == _new_status:
		#match _new_status:
			#StreamPeerTCP.Status.STATUS_NONE:
				#_clean_up_thread()
				#connection_status_changed.emit(ConnectionStatus.DISCONNECTED)
			#StreamPeerTCP.Status.STATUS_CONNECTING:
				#connection_status_changed.emit(ConnectionStatus.ATTEMPTING_CONNECTION)
			#StreamPeerTCP.Status.STATUS_CONNECTED:
				#_stop_thread = false
				#_thread = Thread.new()
				#_thread.start(_listen_for_data)
				#connected_to_server.emit()
				#connection_status_changed.emit(ConnectionStatus.LOBBYLESS)
			#StreamPeerTCP.Status.STATUS_ERROR:
				#connection_error_occurred.emit()
				#connection_status_changed.emit(ConnectionStatus.DISCONNECTED)
		#
		#_processed_status = _new_status

func _listen_for_data() -> void:
	while true:
		#received_data = _tcp.get_data(1)
		
		# Error (e.g. abrupt disconnect), stop listening
		#if not received_data[0] == OK:
			#disconnected_from_server.emit.call_deferred()
			#return
		if _socket.get_available_packet_count():
			cached_response = _socket.get_packet().get_string_from_utf8()
			print(cached_response)
			#cached_response += (received_data[1] as PackedByteArray).get_string_from_utf8()
			if cached_response.ends_with("}"):
				#print(cached_response)
				_handle_response(cached_response)
				cached_response = ""

func _handle_response(response: String) -> void:
	var data = JSON.parse_string(response)
	match data["response"]:
		"create_lobby":
			if data["status"] == "ok":
				_lobby_id = data["lobby_id"]
				_client_id = data["client_id"]
				connected_to_lobby.emit.call_deferred(_lobby_id)
				connection_status_changed.emit.call_deferred(ConnectionStatus.JOINED)
		"join_lobby":
			if data["status"] == "ok":
				_client_id = data["client_id"]
				connected_to_lobby.emit.call_deferred(_lobby_id)
				connection_status_changed.emit.call_deferred(ConnectionStatus.JOINED)
		"client_joined_lobby":
			client_joined_lobby.emit.call_deferred(data["new_client_name"])
		"leave_lobby_request":
			leave_lobby()
		"leave_lobby":
			if data["status"] == "ok":
				client_left_lobby.emit.call_deferred(data["client_name"])
		"client_left_lobby":
			client_left_lobby.emit.call_deferred(data["client_name"])
		"receive_chat_message":
			received_chat_message.emit.call_deferred(data["client_name"], data["message"])

func  _exit_tree() -> void:
	disconnect_from_server()

func connect_to_server() -> void:
	#_tcp.connect_to_host("168.119.97.227", 9974)
	#_tcp.set_no_delay(true)
	var err = _socket.connect_to_url("127.0.0.1:9974")
	if err != OK:
		print("didn't work!")

func disconnect_from_server() -> void:
	#_tcp.disconnect_from_host()
	_socket.close()
	_clean_up_thread()
	disconnected_from_server.emit()
	connection_status_changed.emit(ConnectionStatus.DISCONNECTED)

func _clean_up_thread() -> void:
	_stop_thread = true
	if _thread:
		_thread.wait_to_finish()
		_thread = null

func create_lobby(client_name: String) -> void:
	_client_name = client_name
	
	_send_message(TCPMessages.create_lobby(client_name))

func join_lobby(lobby_id: String, client_name: String) -> void:
	_lobby_id = lobby_id
	_client_name = client_name
	
	_send_message(TCPMessages.join_lobby(_lobby_id, client_name))

func leave_lobby() -> void:
	_send_message(TCPMessages.leave_lobby(_lobby_id, _client_id))
	
	_lobby_id = ""
	_client_id = ""
	_client_name = ""
	
	disconnected_from_lobby.emit.call_deferred()
	connection_status_changed.emit.call_deferred(ConnectionStatus.LOBBYLESS)

func send_chat_message(message: String) -> void:
	_send_message(TCPMessages.send_chat_message(_lobby_id, _client_id, message))

func _send_message(message: String) -> void:
	#_tcp.put_data(message.to_utf8_buffer())
	_socket.send_text(message)