extends GutTest
## The escape button is the player's safety valve, and it is also the one input
## with a real consequence attached, so its timing is server-owned end to end.

var world: SimWorld
const PEER := 3


func before_each() -> void:
	world = SimWorld.new(1)
	world.add_player(PEER, "tester")
	world.players[PEER].iframes = 0


func _hold_escape(ticks: int) -> void:
	for _i in ticks:
		var frames: Array[InputFrame] = [
			InputFrame.make(world.tick + 1, Vector2.ZERO, 0.0, InputFrame.BTN_ESCAPE)]
		world.queue_input(PEER, frames)
		world.step()


func _events_of(type: int) -> Array:
	return world.events.filter(func(e: Dictionary) -> bool: return int(e["t"]) == type)


func test_escape_takes_the_full_channel_time() -> void:
	_hold_escape(SimConfig.ESCAPE_CHANNEL_TICKS - 1)
	assert_eq(_events_of(SimEvent.Type.ESCAPE_COMPLETED).size(), 0,
		"the escape must not complete early")
	_hold_escape(1)
	assert_eq(_events_of(SimEvent.Type.ESCAPE_COMPLETED).size(), 1)


func test_releasing_the_button_cancels_the_channel() -> void:
	# Deliberately short of ESCAPE_CHANNEL_TICKS: hold the full duration and the
	# channel completes instead, which is a different test.
	_hold_escape(SimConfig.ESCAPE_CHANNEL_TICKS / 2)
	assert_gt(world.players[PEER].escape_ticks, 0)
	var frames: Array[InputFrame] = [InputFrame.make(world.tick + 1, Vector2.ZERO, 0.0, 0)]
	world.queue_input(PEER, frames)
	world.step()
	assert_eq(world.players[PEER].escape_ticks, 0)
	assert_eq(_events_of(SimEvent.Type.ESCAPE_CANCELLED).size(), 1)


## The inverse of what this asserted originally. Interrupting on damage makes
## quitting the process strictly better than using the button, which turns the
## escape hatch into the exploit -- see SimConfig.ESCAPE_CHANNEL_TICKS.
func test_taking_damage_does_not_cancel_the_channel() -> void:
	_hold_escape(20)
	var before: int = world.players[PEER].escape_ticks
	world.pool.spawn(world.players[PEER].pos, Vector2.ZERO, 6.0, 60, 10,
		SimConfig.TEAM_ENEMY, SimConfig.KIND_ORB)
	_hold_escape(1)
	assert_lt(world.players[PEER].hp, SimConfig.PLAYER_MAX_HP, "setup: should have been hit")
	assert_eq(world.players[PEER].escape_ticks, before + 1,
		"the channel must keep running while under fire")
	assert_eq(_events_of(SimEvent.Type.ESCAPE_CANCELLED).size(), 0)


## Dying is still an interruption -- it is the one thing the escape cannot beat,
## which is what keeps the one-second channel a real risk.
func test_dying_ends_the_channel() -> void:
	_hold_escape(20)
	var p: SimPlayer = world.players[PEER]
	p.hp = 1
	p.iframes = 0
	world.pool.spawn(p.pos, Vector2.ZERO, 6.0, 60, 999,
		SimConfig.TEAM_ENEMY, SimConfig.KIND_ORB)
	world.step()
	assert_false(p.alive)
	assert_eq(p.escape_ticks, 0)
	assert_eq(_events_of(SimEvent.Type.ESCAPE_COMPLETED).size(), 0)


## A dropped connection channels out on exactly the same timer, so pulling the
## plug is never cheaper than pressing the button.
func test_a_linkdead_player_channels_out_without_input() -> void:
	var p: SimPlayer = world.players[PEER]
	p.linkdead = true
	for _i in SimConfig.ESCAPE_CHANNEL_TICKS - 1:
		world.step()
	assert_eq(_events_of(SimEvent.Type.ESCAPE_COMPLETED).size(), 0,
		"a disconnect must not be an instant exit")
	world.step()
	assert_eq(_events_of(SimEvent.Type.ESCAPE_COMPLETED).size(), 1)


func test_a_linkdead_player_is_still_killable_while_channelling() -> void:
	var p: SimPlayer = world.players[PEER]
	p.linkdead = true
	p.hp = 1
	p.iframes = 0
	world.step()
	world.pool.spawn(p.pos, Vector2.ZERO, 6.0, 60, 999,
		SimConfig.TEAM_ENEMY, SimConfig.KIND_ORB)
	world.step()
	assert_false(p.alive, "the whole point: disconnecting does not grant immunity")


func test_a_cancelled_channel_restarts_from_zero() -> void:
	_hold_escape(SimConfig.ESCAPE_CHANNEL_TICKS / 2)
	var frames: Array[InputFrame] = [InputFrame.make(world.tick + 1, Vector2.ZERO, 0.0, 0)]
	world.queue_input(PEER, frames)
	world.step()
	_hold_escape(SimConfig.ESCAPE_CHANNEL_TICKS - 1)
	assert_eq(_events_of(SimEvent.Type.ESCAPE_COMPLETED).size(), 0,
		"progress must not carry over from an interrupted channel")


func test_escape_completion_never_reaches_the_client_directly() -> void:
	_hold_escape(SimConfig.ESCAPE_CHANNEL_TICKS)
	var packet := NetCodec.decode_events(NetCodec.encode_events(world.tick, world.events))
	for ev: Dictionary in packet["events"]:
		assert_ne(int(ev["t"]), SimEvent.Type.ESCAPE_COMPLETED,
			"the transfer is the server's decision; clients only see the outcome")