magician/components/web_client_tcp.gd

class_name WebClientTCP
extends Node

## Sender tag for system messages displayed in the chat
const SENDER_SYSTEM: String = "SYSTEM"

#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

var _is_first_play: bool = false

var _connected_client_ids: Array[String] = []
var _connected_client_names: Array[String] = []

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

signal connected_to_lobby(lobby_id: String)
signal disconnected_from_lobby()
signal received_client_id(client_id: String)

signal client_joined_lobby(client_name: String, connected_client_names: Array[String])
signal client_left_lobby(client_name: String, connected_client_names: Array[String])

signal received_connection_message(message: String)
signal received_chat_message(client_name: String, message: String)

signal connection_status_changed(new_status: ConnectionStatus)

# This signal is messy as fuck
signal client_order_received(client_ids: Array[String], client_ids_playing_order: Array[String], client_names: Array[String])

signal client_played_card(client_id: String, card_id: int)
signal received_expected_bet(client_id: String, expected_bet: int)
signal new_round_started()
signal cards_received(cards: Dictionary)
signal trump_received(trump_id: int)
signal received_bet_request(disallowed_bet: int, current_round: int)
signal received_win()
signal received_winning_client(client_id: String)
signal notify_play_card_request()
signal reset_first_card()
signal received_first_card(card_id: int)
signal received_played_card(client_id: String, card_id: int)
signal received_play_winner_request()
signal received_end_game_request()
signal request_next_play()
signal request_next_round()

# new signals
## Emitted when a message that needs to be displayed to the player has been received.
signal user_message_received(sender: String, message: String)

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
	
	if _processed_status == WebSocketPeer.STATE_OPEN:
		while _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 _listen_for_data() -> void:
	while true:
		if _socket.get_available_packet_count():
			cached_response = _socket.get_packet().get_string_from_utf8()
			print(cached_response)
			if cached_response.ends_with("}"):
				_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"]
				received_client_id.emit.call_deferred(_client_id)
				connected_to_lobby.emit.call_deferred(_lobby_id)
				connection_status_changed.emit.call_deferred(ConnectionStatus.JOINED)
		"join_lobby_response":
			_handle_join(data)
		"client_joined_lobby":
			print(data["connected_client_ids"])
			_connected_client_ids.assign(data["connected_client_ids"])
			_connected_client_names.assign(data["connected_client_names"])
			client_joined_lobby.emit.call_deferred(data["new_client_name"], _connected_client_names)
		"leave_lobby_request":
			leave_lobby()
		"leave_lobby":
			if data["status"] == "ok":
				client_left_lobby.emit.call_deferred(data["client_name"])
		"client_left_lobby":
			_connected_client_ids.assign(data["connected_client_ids"])
			_connected_client_names.assign(data["connected_client_names"])
			client_left_lobby.emit.call_deferred(data["client_name"], _connected_client_names)
		
		## A chat message has been received
		"receive_chat_message":
			# Relay message to be displayed in the chat panel
			user_message_received.emit.call_deferred(data["client_name"], data["message"])
		
		"new_round_started":
			if data["current_round"] == 1:
				var playing_order: Array[String] = []
				playing_order.assign(data["playing_order"])
				client_order_received.emit.call_deferred(playing_order, _connected_client_ids, _connected_client_names)
			
			var received_cards = data["cards"]
			new_round_started.emit.call_deferred()
			cards_received.emit.call_deferred(received_cards)
			trump_received.emit.call_deferred(data["trump"])
		"client_submitted_bet":
			received_expected_bet.emit.call_deferred(
				data["client_id"],
				data["bet"],
			)
		"request_bet":
			received_bet_request.emit.call_deferred(data["disallowed_bet"], data["round"])
		"begin_playing_cards":
			# all players know it's time to play
			print(data)
			_is_first_play = true
			reset_first_card.emit.call_deferred()
		"request_card":
			# individual player asked to play card
			notify_play_card_request.emit.call_deferred()
		"begin_next_play":
			print("beginning next play!")
			_is_first_play = true
			reset_first_card.emit.call_deferred()
		"play_card":
			print(data)
			#client_played_card.emit.call_deferred(data["client_id"], data["played_card"])
		"determine_play_winner_request": # single card go-around
			received_play_winner_request.emit.call_deferred()
		"end_game_request":
			received_end_game_request.emit.call_deferred()
		"client_played_card":
			print("RECEIVED FOLLOWING CARD ID: " + str(data["played_card"]))
			if _is_first_play:
				print("set first card")
				received_first_card.emit.call_deferred(data["played_card"])
				if not CardManager.get_card_color(data["played_card"]) == Card.CardColor.WHITE:
					_is_first_play = false
			received_played_card.emit.call_deferred(data["client_id"], data["played_card"])
		"client_won_play":
			if data["client_id"] == _client_id:
				received_win.emit.call_deferred()
			received_winning_client.emit.call_deferred(data["client_id"])

func _handle_join(data) -> void:
	match data["status"]:
		"lobby_not_found":
			received_connection_message.emit.call_deferred("Could not join; lobby does not exist")
			connection_status_changed.emit.call_deferred(ConnectionStatus.LOBBYLESS)
		"lobby_full":
			received_connection_message.emit.call_deferred("Could not join; lobby is full")
			connection_status_changed.emit.call_deferred(ConnectionStatus.LOBBYLESS)
		"ok":
			_client_id = data["client_id"]
			connected_to_lobby.emit.call_deferred(_lobby_id)
			received_client_id.emit.call_deferred(_client_id)
			connection_status_changed.emit.call_deferred(ConnectionStatus.JOINED)

func  _exit_tree() -> void:
	disconnect_from_server()

func connect_to_server(text: String) -> void:
	var err = _socket.connect_to_url(text)
	if err != OK:
		print("didn't work!")

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

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))
	connection_status_changed.emit.call_deferred(ConnectionStatus.ATTEMPTING_JOIN)

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 start_game() -> void:
	_send_message(JSON.stringify({
		"response": "start_game",
		"lobby_id": _lobby_id,
		"cards": CardManager.get_shuffled_cards(_connected_client_ids, 1),
	}))

func start_next_play() -> void:
	_send_message(JSON.stringify({
		"response": "start_next_play",
		"lobby_id": _lobby_id,
	}))

func start_next_round(round_count: int) -> void:
	_send_message(JSON.stringify({
		"response": "start_next_round",
		"lobby_id": _lobby_id,
		"round": round_count,
		"cards": CardManager.get_shuffled_cards(_connected_client_ids, round_count),
	}))

func end_game() -> void:
	_send_message(JSON.stringify({
		"response": "end_game",
		"lobby_id": _lobby_id,
	}))

func play_card(card_id: int) -> void:
	_send_message(JSON.stringify({
		"response": "play_card",
		"lobby_id": _lobby_id,
		"client_id": _client_id,
		"played_card": card_id,
	}))

func submit_bet(bet: int, current_round: int) -> void:
	_send_message(JSON.stringify({
		"response": "submit_bet",
		"lobby_id": _lobby_id,
		"client_id": _client_id,
		"round": current_round,
		"bet": bet,
	}))

func submit_play_winner(winning_client_id: String) -> void:
	_send_message(JSON.stringify({
		"response": "submit_play_winner",
		"lobby_id": _lobby_id,
		"client_id": winning_client_id,
	}))
	request_next_play.emit.call_deferred()
	#request_next_round.emit.call_deferred()

func _send_message(message: String) -> void:
	_socket.send_text(message)