VRyHungry1/Stations/table.gd

class_name Table
extends StaticBody3D

const GAME_MANAGER = preload("res://GameManager.gd")

@export var thinking_duration: float = 3.0
@export var primary_duration: float = 60.0
@export var friend_duration: float = 10.0
@export var eating_duration: float = 4.0
@export var money_sound: AudioStream 

@onready var label_3d: Label3D = $Label3D
@onready var label_3d_time: Label3D = $Label3DTime
@onready var snap_zones: Array[XRToolsSnapZone] = []
@onready var progress_bar: ProgressBar3D = $ProgressBar3D
@onready var audio_player: AudioStreamPlayer3D = $AudioStreamPlayer3D

const lbl_thinking: String = "Thinking"
const lbl_gameover: String = "Game Over!"
const lbl_eating: String = "Eating..."

### Finite State Machine ####

enum TableState {
	EMPTY, 			 # Just finished eating or havent eaten yet
	THINKING,
	WAITING_PRIMARY, # Inital wait to be served
	WAITING_FRIEND,  # Waiting for friends food to arrive
	EATING
}

## State is server-authoritative and replicated. Transitions only ever run where
## NetworkManager.owns_world() is true — the whole station's _process is gated
## off for non-owners (NetWorld._gate) — and the setters below just refresh the
## display, so the server (via _setState) and clients (via incoming sync) show
## the same thing. Use _setState(), never assign `state` directly.
##
## These are deliberately not underscore-prefixed: that prefix is what marks a
## variable as private and unreplicated (see NetReplication), and this is exactly
## the state that has to reach every peer. state_duration is replicated for the
## same reason — the progress bar divides by it, and on a client that never ran a
## transition it would otherwise still be zero.
var state: TableState = TableState.EMPTY: set = _set_state
var state_time: float = 0.0: set = _set_state_time
var state_duration: float = 0.0 # set in _setState alongside state_time
var unsatisfied_orders: Array[String] = []: set = _set_unsatisfied_orders


func _ready() -> void:
	if not label_3d:
		push_error("Table is missing reference to Label3D")
	if not label_3d_time:
		push_error("Table is missing reference to Label3DTime")
	if not progress_bar or progress_bar is not ProgressBar3D:
		push_error("Table missing reference to progressbar, or wrong type:", progress_bar)
	progress_bar.y_billboard = true
	# Render whatever state already arrived from the server before we were in
	# the tree (see the guard in _refresh_display).
	_refresh_display.call_deferred()
	if not audio_player:
		push_error("Table is missing reference to AudioStreamPlayer3D")
		
	# Get snap_zones for plates, store in array snap_zones
	for child in get_children():
		var snap_zone_node = child as XRToolsSnapZone
		if snap_zone_node:
			snap_zones.append(snap_zone_node)

	if snap_zones.is_empty():
		push_error("Table is missing XRToolsSnapZone children")
		return

	for snap_zone_node in snap_zones:
		snap_zone_node.has_picked_up.connect(_on_object_picked_up)
		snap_zone_node.has_dropped.connect(_on_object_dropped)
	set_process(true)
	_setState(TableState.EMPTY)


func _on_object_picked_up(_item) -> void:
	print("Table: object picked up: ", _item)
	if state == TableState.EATING:
		return
	_absorb_item_if_correct(_item)


func _on_object_dropped() -> void:
	print("Table: object dropped ")


func _get_plate_from_item(_item: Node) -> PlateController:
	return _item.get_children().filter(func(c): return c is PlateController).front() as PlateController


func _absorb_item_if_correct(_item: Node) -> void:
	# Get plate controller in childer of _item (hopefully a plate XRpickable)
	var plate = _get_plate_from_item(_item)
	if not plate:
		print("Table: held object is not a Plate")
		return
	print("Table: held a Plate!")

	# Absorm items from the plate we want
	for food_item in plate.container.contained_items:
		print("Table: held a plate with FoodItem: ", food_item.id)
		if food_item.id in unsatisfied_orders:
			print("Table: held FoodItem is in unsatisfied orders, removing it")
			# Reassign rather than mutate in place. This property has a setter that
			# refreshes the label, and mutating an array never fires it — so the
			# peer that actually served the food would be the one peer whose table
			# still showed the order outstanding. duplicate() also preserves the
			# Array[String] typing the property requires.
			var remaining := unsatisfied_orders.duplicate()
			remaining.erase(food_item.id)
			unsatisfied_orders = remaining
			if unsatisfied_orders.size() > 0 and state != TableState.EATING:
				_setState(TableState.WAITING_FRIEND)

			# Table has everything it wants. Start eating
			elif unsatisfied_orders.is_empty() and state != TableState.EATING:
				GAME_MANAGER.money += food_item.sell_value
				audio_player.stream = money_sound
				audio_player.play()
				_setState(TableState.EATING)


func place_order() -> void:
	print("Table: place_order()")
	var new_orders = unsatisfied_orders.duplicate()
	new_orders.append(GAME_MANAGER.get_random_meal())
	new_orders.append(GAME_MANAGER.get_random_meal())
	_set_unsatisfied_orders(new_orders)


func satisfyAllOrders() -> void:
	print("Table: satisfyAllOrders()")
	# Assigned, not cleared in place, for the same reason as in
	# _absorb_item_if_correct: clear() would not fire the setter.
	unsatisfied_orders = []
	clearAllPlates()
	_setState(TableState.EMPTY)


func clearAllPlates() -> void:
	print("Table: clearAllPlates()")
	for snap_zone_node in snap_zones:
		var held_object = snap_zone_node.picked_up_object
		if not held_object:
			continue

		var plate = _get_plate_from_item(held_object)
		if plate:
			plate.container.clear()
			plate.is_dirty = true


func _set_snap_zones_enabled(value: bool) -> void:
	for zone in snap_zones:
		zone.enabled = value


## Server-only state transition: sets the new state's timer and assigns
## state (whose setter refreshes the display on every peer).
func _setState(newState: TableState) -> void:
	print("Table set state: ", TableState.keys()[newState])

	match newState:
		TableState.EMPTY:
			state_time = 5.0
			state_duration = 5.0
		TableState.THINKING:
			state_time = thinking_duration
			state_duration = thinking_duration # Can't be done in _set_state(), will set duration inside timer
		TableState.WAITING_PRIMARY:
			state_time = primary_duration
			state_duration = primary_duration
		TableState.WAITING_FRIEND:
			state_time = friend_duration
			state_duration = friend_duration
		TableState.EATING:
			state_time = eating_duration
			state_duration = eating_duration
			_set_snap_zones_enabled(false)

	state = newState


## Pure presentation, driven off the current (locally authoritative or
## synced-from-server) state. Runs on every peer.
func _refresh_display() -> void:
	# state, state_time and unsatisfied_orders are replicated with spawn=true,
	# and MultiplayerSpawner applies a spawn payload BEFORE the node enters the
	# tree — so these setters fire while the @onready children below are still
	# null. Bail out until _ready() has resolved them; _ready() calls back in
	# once it has, so nothing that arrived early is lost.
	if not progress_bar or not label_3d or not label_3d_time:
		return
	match state:
		TableState.EMPTY:
			progress_bar.set_bar_visible(false)
			label_3d.text = "empty"
		TableState.THINKING:
			progress_bar.set_bar_visible(false)
			label_3d.text = lbl_thinking
		TableState.WAITING_PRIMARY:
			label_3d.text = "%s\n%s" % [TableState.keys()[state], "\n".join(unsatisfied_orders)]
			progress_bar.set_bar_visible(true)
			progress_bar.override_fill_color(Color.RED if state_time < 10 else Color.YELLOW)
		TableState.WAITING_FRIEND:
			label_3d.text = "%s\n%s" % [TableState.keys()[state], "\n".join(unsatisfied_orders)]
			progress_bar.set_bar_visible(true)
			progress_bar.override_fill_color(Color.RED if state_time < 5 else Color.YELLOW)
		TableState.EATING:
			label_3d.text = lbl_eating
			progress_bar.set_bar_visible(false)
	
	label_3d_time.text = "%.1f" % state_time
	var progress := state_time / state_duration if state_duration > 0.0 else 0.0
	progress_bar.set_progress(clampf(progress, 0.0, 1.0))


func _set_state(value: TableState) -> void:
	state = value
	_refresh_display()


func _set_state_time(value: float) -> void:
	state_time = value
	_refresh_display()


func _set_unsatisfied_orders(value: Array[String]) -> void:
	unsatisfied_orders = value
	_refresh_display()


func _process(delta: float) -> void:
	# Wait for state to finish
	if state_time > 0.0:
		state_time = max(0.0, state_time - delta)
		return
	
	if GAME_MANAGER.game_state == GAME_MANAGER.GameState.GAME_OVER:
		return

	# When state timer is finished, do this stuff before moving to next state
	match state:
		TableState.EMPTY:
			print("Table State EMPTY finish")
			_setState(TableState.THINKING)

		TableState.THINKING:
			print("Table State THINKING finish")
			place_order()
			_setState(TableState.WAITING_PRIMARY)

		TableState.WAITING_PRIMARY:
			print("Table State WAITING_PRIMARY finish")
			label_3d.text = lbl_gameover
			GAME_MANAGER.game_over()

		TableState.WAITING_FRIEND:
			print("Table State WAITING_FRIEND finish")
			label_3d.text = lbl_gameover
			GAME_MANAGER.game_over()

		TableState.EATING:
			print("Table State EATING finish")
			clearAllPlates()
			_set_snap_zones_enabled(true)
			_setState(TableState.EMPTY)