extends Node
## Autoload "Net": the multiplayer layer (docs/MULTIPLAYER_PLAN.md).
##
## M2.1 covers the skeleton: a dedicated server, joining it, the identity
## handshake, name rules and the player list. Gameplay over the network
## follows in M2.2-M2.5; single-player still runs as before.
##
## Server: `godot --headless --path . -- --server [--port 24242]
##   [--config user://server/server.json] [--server-name "..."]
##   [--max-players 8] [--password ...]`
## Client: Net.join("host:port", password) from the title screen.
##
## Handshake (all reliable ENet over one UDP port):
##   client -> server  _c2s_hello {protocol, name, appearance, public_key, password}
##   server -> client  _s2c_challenge nonce        (32 random bytes)
##   client -> server  _c2s_proof signature        (nonce signed with the private key)
##   server -> client  _s2c_welcome {...} or _s2c_rejected reason
## Then the server tells everyone about joins and leaves.

signal state_changed(state: String)    ## offline | connecting | connected | server
signal joined                          ## the server welcomed us
signal join_failed(reason: String)
signal left(reason: String)            ## disconnected after joining
signal players_changed

const Identity = preload("res://scripts/net/identity.gd")
const ServerConfig = preload("res://scripts/net/server_config.gd")

const PROTOCOL := 1
const DEFAULT_PORT := 24242
const HANDSHAKE_TIMEOUT := 10.0
const JOIN_TIMEOUT := 12.0

var state := "offline"
var dedicated := false                 ## started with --server
var identity: RefCounted               ## identity.gd (clients)
var config: RefCounted                 ## server_config.gd (server)
var server_info: Dictionary = {}       ## the server's public settings (clients)
## Everyone on the server: peer id -> {"id", "name", "appearance", "admin"}.
var players: Dictionary = {}
var local_peer := 0

## Test hooks (tests/net_bot.gd): sign with the wrong key, or claim another
## protocol version.
var debug_forge := false
var debug_protocol := 0
var debug_skip_name_check := false     ## send a bad name anyway: the server must refuse it

var _peer: ENetMultiplayerPeer
var _pending: Dictionary = {}          ## server: peer -> {"t": secs, "hello": {}, "nonce": bytes}
var _reject_reason := ""
var _join_left := 0.0
var _args: Dictionary = {}

func _ready() -> void:
	_args = parse_args(OS.get_cmdline_user_args())
	multiplayer.peer_connected.connect(_on_peer_connected)
	multiplayer.peer_disconnected.connect(_on_peer_disconnected)
	multiplayer.connected_to_server.connect(_on_connected)
	multiplayer.connection_failed.connect(_on_connection_failed)
	multiplayer.server_disconnected.connect(_on_server_disconnected)
	if _args.has("server"):
		dedicated = true
		_start_dedicated.call_deferred()
	# `--exit-with <pid>`: quit when that process is gone (test servers and
	# bots, so a crashed test never leaves them running).
	if _args.has("exit-with"):
		var parent := int(_args["exit-with"])
		var t := Timer.new()
		t.wait_time = 1.0
		t.autostart = true
		t.timeout.connect(func():
			# (OS.is_process_running only works for our own children.)
			if OS.get_name() != "Windows" and OS.execute("kill", ["-0", str(parent)]) != 0:
				print("[net] parent process %d is gone, quitting" % parent)
				stop()
				get_tree().quit())
		add_child(t)

## "--a=b", "--a b" and bare "--flag" all work.
static func parse_args(args: PackedStringArray) -> Dictionary:
	var out := {}
	var i := 0
	while i < args.size():
		var a: String = args[i]
		if a.begins_with("--"):
			var k := a.trim_prefix("--")
			if k.contains("="):
				out[k.get_slice("=", 0)] = k.substr(k.find("=") + 1)
			elif i + 1 < args.size() and not args[i + 1].begins_with("--"):
				out[k] = args[i + 1]
				i += 1
			else:
				out[k] = true
		i += 1
	return out

## The local identity, loaded on first use (`--identity <dir>` overrides).
func get_identity() -> RefCounted:
	if identity == null:
		identity = Identity.open(String(_args.get("identity", Identity.DEFAULT_DIR)))
	return identity

func _set_state(s: String) -> void:
	state = s
	state_changed.emit(s)

func is_server() -> bool:
	return state == "server"

# --- server -------------------------------------------------------------------

func _start_dedicated() -> void:
	var err := start_server(String(_args.get("config", ServerConfig.DEFAULT_PATH)), _args)
	if not err.is_empty():
		printerr("[server] ", err)
		get_tree().quit(1)

## Opens the server. Returns "" on success, otherwise what went wrong.
func start_server(config_path: String, overrides: Dictionary = {}) -> String:
	if state != "offline":
		return "Already %s" % state
	config = ServerConfig.open(config_path)
	var map := {"port": "port", "server-name": "server_name", "max-players": "max_players",
		"password": "password", "world": "world"}
	for flag in map:
		if overrides.has(flag):
			var v: Variant = overrides[flag]
			config.overrides[map[flag]] = int(v) if map[flag] in ["port", "max_players"] else String(v)
	_peer = ENetMultiplayerPeer.new()
	var port := int(config.v("port"))
	# A few spare slots so a full server can still say "server is full".
	var err := _peer.create_server(port, int(config.v("max_players")) + 4)
	if err != OK:
		return "Couldn't open UDP port %d (error %d). Is another server already running on it?" % [port, err]
	multiplayer.multiplayer_peer = _peer
	multiplayer.server_relay = false   # clients only ever talk to the server
	players.clear()
	_pending.clear()
	_set_state("server")
	print("[server] '%s' listening on UDP %d (max %d players%s). Config: %s" % [config.v("server_name"), port,
		int(config.v("max_players")), ", password set" if not String(config.v("password")).is_empty() else "",
		ProjectSettings.globalize_path(config.path)])
	return ""

func stop() -> void:
	if _peer != null:
		_peer.close()
	_peer = null
	multiplayer.multiplayer_peer = null
	players.clear()
	_pending.clear()
	server_info.clear()
	local_peer = 0
	if state != "offline":
		_set_state("offline")

func _on_peer_connected(id: int) -> void:
	if is_server():
		_pending[id] = {"t": 0.0}

func _on_peer_disconnected(id: int) -> void:
	if not is_server():
		return
	_pending.erase(id)
	if players.has(id):
		var p: Dictionary = players[id]
		players.erase(id)
		print("[server] %s left (%d online)" % [p.name, players.size()])
		_s2c_player_left.rpc(id)
		players_changed.emit()

func _process(delta: float) -> void:
	if is_server():
		for id in _pending.keys():
			_pending[id].t += delta
			if _pending[id].t > HANDSHAKE_TIMEOUT:
				_reject(id, "Took too long to say hello")
	elif state == "connecting":
		_join_left -= delta
		if _join_left <= 0.0:
			_fail("No answer from the server")

func _reject(peer: int, reason: String) -> void:
	_pending.erase(peer)
	print("[server] rejected peer %d: %s" % [peer, reason])
	_s2c_rejected.rpc_id(peer, reason)
	# Let the message go out before hanging up.
	get_tree().create_timer(0.4).timeout.connect(func():
		if _peer != null and is_server():
			_peer.disconnect_peer(peer))

@rpc("any_peer", "call_remote", "reliable")
func _c2s_hello(d: Dictionary) -> void:
	var peer := multiplayer.get_remote_sender_id()
	if not is_server() or not _pending.has(peer) or _pending[peer].has("hello"):
		return
	if int(d.get("protocol", 0)) != PROTOCOL:
		_reject(peer, "Different game version (server %d, you %d): update the game" % [PROTOCOL, int(d.get("protocol", 0))])
		return
	var pw := String(config.v("password"))
	if not pw.is_empty() and String(d.get("password", "")) != pw:
		_reject(peer, "Wrong password")
		return
	var nonce := Crypto.new().generate_random_bytes(32)
	_pending[peer].hello = d
	_pending[peer].nonce = nonce
	_s2c_challenge.rpc_id(peer, nonce)

@rpc("any_peer", "call_remote", "reliable")
func _c2s_proof(sig: PackedByteArray) -> void:
	var peer := multiplayer.get_remote_sender_id()
	if not is_server() or not _pending.has(peer) or not _pending[peer].has("nonce"):
		return
	var hello: Dictionary = _pending[peer].hello
	var pem := String(hello.get("public_key", ""))
	if not Identity.verify(pem, _pending[peer].nonce, sig):
		_reject(peer, "Identity check failed")
		return
	var id := Identity.id_for(pem)
	var name := String(hello.get("name", ""))
	var why := _admission_problem(id, name)
	if not why.is_empty():
		_reject(peer, why)
		return
	_pending.erase(peer)
	config.reserve_name(name, id)
	if config.data.admins.is_empty():
		config.add_admin(id)   # first player on a new server (MULTIPLAYER_PLAN.md §12)
		print("[server] %s is the first player, so they're now an admin" % name)
	var p := {"id": id, "name": name, "appearance": Identity.sanitize_appearance(hello.get("appearance", {})),
		"admin": config.is_admin(id)}
	players[peer] = p
	print("[server] %s joined (id %s%s, %d/%d online)" % [name, id, ", admin" if p.admin else "",
		players.size(), int(config.v("max_players"))])
	_s2c_welcome.rpc_id(peer, {"you": peer, "server": config.public_info(), "players": players})
	for other in players:
		if other != peer:
			_s2c_player_joined.rpc_id(other, peer, p)
	players_changed.emit()

## Why player `id` calling themselves `name` can't come in ("" = they can).
func _admission_problem(id: String, name: String) -> String:
	if id in config.data.banned:
		return "You're banned from this server"
	if not config.data.allowlist.is_empty() and not id in config.data.allowlist:
		return "You're not on this server's allowlist"
	for other in players.values():
		if other.id == id:
			return "You're already connected from another game"
	var bad := Identity.name_problem(name)
	if not bad.is_empty():
		return bad
	var owner: String = config.name_owner(name)
	if not owner.is_empty() and owner != id:
		return "The name '%s' is taken on this server: pick another" % name
	if players.size() >= int(config.v("max_players")):
		return "The server is full (%d/%d)" % [players.size(), int(config.v("max_players"))]
	return ""

# --- client -------------------------------------------------------------------

## Splits "host", "host:port" or "[v6]:port". Returns [host, port].
static func parse_address(a: String) -> Array:
	a = a.strip_edges()
	if a.begins_with("["):
		var close := a.find("]")
		var host := a.substr(1, close - 1)
		var rest := a.substr(close + 1)
		return [host, int(rest.trim_prefix(":")) if rest.begins_with(":") else DEFAULT_PORT]
	if a.count(":") == 1:
		var port := a.get_slice(":", 1)
		return [a.get_slice(":", 0), int(port) if port.is_valid_int() else DEFAULT_PORT]
	return [a, DEFAULT_PORT]

## Connects to a server. The outcome arrives as `joined` or `join_failed`.
func join(address: String, password: String = "") -> void:
	if state != "offline":
		stop()
	var me := get_identity()
	var bad := Identity.name_problem(me.name)
	if not bad.is_empty() and not debug_skip_name_check:
		join_failed.emit("Set your name first (%s)" % bad.to_lower())
		return
	var hp := parse_address(address)
	if String(hp[0]).is_empty():
		join_failed.emit("Enter a server address")
		return
	_peer = ENetMultiplayerPeer.new()
	var err := _peer.create_client(hp[0], hp[1])
	if err != OK:
		_peer = null
		join_failed.emit("Couldn't start connecting (error %d)" % err)
		return
	multiplayer.multiplayer_peer = _peer
	_reject_reason = ""
	_pending_password = password
	_join_left = JOIN_TIMEOUT
	me.last_server = address.strip_edges()
	me.save_profile()
	_set_state("connecting")

var _pending_password := ""

func leave() -> void:
	var was := state
	stop()
	if was == "connected":
		left.emit("You left the server")

func _on_connected() -> void:
	var me := get_identity()
	_c2s_hello.rpc_id(1, {"protocol": debug_protocol if debug_protocol != 0 else PROTOCOL, "name": me.name,
		"appearance": me.appearance, "public_key": me.public_pem, "password": _pending_password})

@rpc("authority", "call_remote", "reliable")
func _s2c_challenge(nonce: PackedByteArray) -> void:
	var sig: PackedByteArray = get_identity().sign(nonce)
	if debug_forge:
		var other := CryptoKey.new()
		other = Crypto.new().generate_rsa(2048)
		sig = Crypto.new().sign(HashingContext.HASH_SHA256, Identity._sha256(nonce), other)
	_c2s_proof.rpc_id(1, sig)

@rpc("authority", "call_remote", "reliable")
func _s2c_welcome(d: Dictionary) -> void:
	local_peer = int(d.you)
	server_info = d.server
	players.clear()
	for k in d.players:
		players[int(k)] = d.players[k]
	_set_state("connected")
	joined.emit()
	players_changed.emit()

@rpc("authority", "call_remote", "reliable")
func _s2c_rejected(reason: String) -> void:
	_reject_reason = reason

@rpc("authority", "call_remote", "reliable")
func _s2c_player_joined(peer: int, p: Dictionary) -> void:
	players[peer] = p
	players_changed.emit()

@rpc("authority", "call_remote", "reliable")
func _s2c_player_left(peer: int) -> void:
	players.erase(peer)
	players_changed.emit()

func _fail(reason: String) -> void:
	stop()
	join_failed.emit(reason)

func _on_connection_failed() -> void:
	_fail("Couldn't reach the server")

func _on_server_disconnected() -> void:
	var was := state
	var reason := _reject_reason
	stop()
	if was == "connecting":
		join_failed.emit(reason if not reason.is_empty() else "The server hung up")
	else:
		left.emit(reason if not reason.is_empty() else "The server closed the connection")

func _notification(what: int) -> void:
	if what == NOTIFICATION_WM_CLOSE_REQUEST or what == NOTIFICATION_PREDELETE:
		if _peer != null:
			_peer.close()