extends Control

signal number_change_finished(value: int)
signal spin_finished(symbols: Array[int], payout_multiplier: float)
signal continue_requested

@export var icon_reels: Array[Control]
@export var number_reels: Array[Control]
@export_range(-40.0, 0.0, 0.5) var click_volume_db := -11.0
@export_range(0.0, 0.2, 0.005) var pitch_variation := 0.055
@export_range(-40.0, -10.0, 0.5) var reel_whir_volume_db := -30.0
@export_range(0.0, 1.5, 0.05) var extra_icon_reel_stop_delay := 0.4
@export_range(0.1, 2.0, 0.05) var number_roll_duration := 0.6
@export_category("Slot Math")
@export_range(0.0, 1.0, 0.001) var target_rtp := 0.96
@export var symbol_names := PackedStringArray([
	"Star", "Diamond", "Potion", "Shield", "Chips", "Gift"
])
@export var symbol_payout_min := PackedInt32Array([1, 50, 400, 300, 5, 0])
@export var symbol_payout_max := PackedInt32Array([1, 100, 400, 300, 10, 0])
@export var symbol_rtp_shares := PackedFloat32Array([
	0.25686958, 0.15625, 0.16666667, 0.15625, 0.20833333, 0.05563042
])
@export var loss_symbol_weights := PackedFloat32Array([1.0, 2.0, 4.0, 6.0, 10.0, 3.0])
@export_range(0.0, 1.0, 0.01) var near_miss_rate := 0.15
@export_category("Early Session Study")
@export_range(0, 20, 1) var early_boost_spin_count := 5
@export_range(0.0, 1.0, 0.01) var early_blue_stack_chance := 0.20

const CLICK_SOUNDS: Array[AudioStream] = [
	preload("res://assets/ccs_cases_2/audio/CLICK-01.wav"),
	preload("res://assets/ccs_cases_2/audio/CLICK-02.wav"),
	preload("res://assets/ccs_cases_2/audio/CLICK-03.wav"),
	preload("res://assets/ccs_cases_2/audio/CLICK-04.wav"),
]
# The recordings contain different amounts of silence before their transients.
# Starting here preserves a tiny lead-in while keeping the impact synchronized.
const CLICK_START_OFFSETS: Array[float] = [0.040, 0.039, 0.052, 0.061]
const STOP_CLICK: AudioStream = preload("res://assets/ccs_cases_2/audio/LOUDCLICK-01.wav")
# This recording has about 167 ms of silence before its impact.
const STOP_CLICK_START_OFFSET := 0.167
const STOP_FLAP: AudioStream = preload("res://assets/ccs_cases_2/audio/DEEPFLAP-01.wav")
# The deep layer has about 159 ms of silence before its transient.
const STOP_FLAP_START_OFFSET := 0.159
const SPIN_START_THUMP: AudioStream = preload("res://assets/ccs_cases_2/audio/THUMP-01.wav")
const LEVER_THWAP: AudioStream = preload("res://assets/ccs_cases_2/audio/MAGNET-THWAP-01.wav")
const LEVER_THWAP_START_OFFSET := 0.110
const REEL_WHIR: AudioStream = preload("res://assets/ccs_cases_2/audio/FAN-WHIR-01.wav")
const REEL_WHIR_START_OFFSET := 1.72
const CHIP_SOUNDS: Array[AudioStream] = [
	preload("res://assets/ccs_cases_2/audio/CHIPS-01.wav"),
	preload("res://assets/ccs_cases_2/audio/CHIPS-02.wav"),
	preload("res://assets/ccs_cases_2/audio/CHIPS-03.wav"),
	preload("res://assets/ccs_cases_2/audio/CHIPS-04.wav"),
]
const CHIP_START_OFFSETS: Array[float] = [0.224, 0.154, 0.201, 0.261]
const AUDIO_POOL_SIZE := 16
const SYMBOL_COUNT := 6
const SINGLE_COIN_SYMBOL := 0
const BLUE_COIN_STACK_SYMBOL := 4
const PRESENT_SYMBOL := 5
const LEVER_FRAME_POSITIONS: Array[Vector2] = [
	Vector2(19.0, -105.0),
	Vector2(23.0, -106.0),
	Vector2(12.0, -82.0),
	Vector2(12.0, -90.0),
	Vector2(5.0, -90.0),
]

var values: Array[int] = []
var reel_tweens: Array[Tween] = []
var number_tweens: Array[Tween] = []
var number_value := 100
var number_animation_active := false
var audio_pool: Array[AudioStreamPlayer] = []
var next_audio_player := 0
var last_click_sound := -1
var last_chip_sound := -1
var chip_count_tween: Tween
var reel_whir_player: AudioStreamPlayer
var reel_whir_tween: Tween
var win_effect_tween: Tween
var spin_in_progress := false
var stopped_icon_reels := 0
var selected_payout := 0.0
var selected_near_miss := false
var selected_early_session_boost := false
var session_spins_started := 0
var early_stack_bonus_consumed := false
var rng := RandomNumberGenerator.new()
var lever_tween: Tween
var lever_foley_tween: Tween
var lever_animating := false

@onready var spin_result_label: Label = $SpinResultLabel
@onready var lever_pivot: Node2D = $LeverPivot
@onready var lever_sprite: AnimatedSprite2D = $LeverPivot/LeverSprite
@onready var lever_button: Button = $LeverButton


func _ready() -> void:
	rng.randomize()
	reel_whir_player = AudioStreamPlayer.new()
	reel_whir_player.name = "ReelWhirPlayer"
	reel_whir_player.stream = REEL_WHIR
	add_child(reel_whir_player)
	# A small voice pool lets nearby reel clicks overlap without cutting each other off.
	for i in AUDIO_POOL_SIZE:
		var player := AudioStreamPlayer.new()
		player.name = "ReelClickVoice%d" % (i + 1)
		player.volume_db = click_volume_db
		add_child(player)
		audio_pool.append(player)
	_apply_number_immediately(number_value)


func spin() -> void:
	if spin_in_progress:
		return

	var configuration_error := _get_slot_math_error()
	if not configuration_error.is_empty():
		push_error(configuration_error)
		spin_result_label.text = "CONFIG ERROR"
		return
	if number_value <= 0:
		spin_result_label.text = "NO CREDITS"
		return

	_reset_win_effect()

	for active_tween in reel_tweens:
		if active_tween and active_tween.is_valid():
			active_tween.kill()
	reel_tweens.clear()
	var early_session_eligible := (
		not early_stack_bonus_consumed
		and session_spins_started < early_boost_spin_count
	)
	var outcome := _select_spin_outcome(early_session_eligible)
	session_spins_started += 1
	values = outcome.symbols
	if (
		values[0] == BLUE_COIN_STACK_SYMBOL
		and values[0] == values[1]
		and values[1] == values[2]
	):
		early_stack_bonus_consumed = true
	selected_payout = outcome.payout
	selected_near_miss = outcome.is_near_miss
	selected_early_session_boost = outcome.early_session_boost
	stopped_icon_reels = 0
	spin_in_progress = true
	lever_button.disabled = true
	spin_result_label.text = "Spinning..."
	add_to_number(-1)
	_play_spin_start()
	_play_short_reel_whir()

	for i in icon_reels.size():
		var spinner := icon_reels[i]
		var n_rows := int(spinner.material.get_shader_parameter("n_rows"))
		var result := values[i]

		var step := 1.0 / float(n_rows)
		var start := float(spinner.material.get_shader_parameter("y_offset"))

		# Several full downward rotations plus the predetermined final result.
		# Negative texture offset moves this vertical strip downward on screen.
		var rotations := randi_range(4, 7)
		var target := floorf(start) - rotations + result * step

		# Later reels stop later, with slight randomness.
		var duration := 1.8 + i * 0.55 + randf_range(0.1, 0.45)
		# Open up the spacing between the three prominent icon-reel stops without
		# changing reel 1 or the timing of the smaller number reels.
		if i < 3:
			duration += i * extra_icon_reel_stop_delay
		var tick_state := {
			"last_row": floori(start * n_rows),
			"start": start,
			"distance": target - start,
			"final_row": floori(target * n_rows),
		}

		var reel_tween := create_tween()
		reel_tweens.append(reel_tween)
		reel_tween.tween_method(
			func(value: float) -> void:
				spinner.material.set_shader_parameter("y_offset", value)
				var current_row := floori(value * n_rows)
				if current_row != tick_state.last_row:
					tick_state.last_row = current_row
					# The final detent is scheduled separately to compensate for
					# audio-device latency; do not also play it at the endpoint.
					if current_row != tick_state.final_row:
						var progress := clampf(
							(value - tick_state.start) / tick_state.distance,
							0.0,
							1.0
						)
						_play_reel_click(progress, i),
			start,
			target,
			duration
		).set_trans(Tween.TRANS_CUBIC).set_ease(Tween.EASE_OUT)

		reel_tween.tween_callback(func() -> void:
			spinner.material.set_shader_parameter("y_offset", fmod(target, 1.0))
			stopped_icon_reels += 1
			if stopped_icon_reels == icon_reels.size():
				_complete_spin()
		)

		if i < 3:
			# Audio reaches the speakers after the engine submits it. Start the stop
			# sound early by the latency reported for the active audio device so its
			# transient reaches the listener at the visual tween endpoint.
			var audio_latency := AudioServer.get_output_latency()
			audio_latency += AudioServer.get_time_to_next_mix()
			var stop_click_tween := create_tween()
			reel_tweens.append(stop_click_tween)
			stop_click_tween.tween_interval(maxf(duration - audio_latency, 0.0))
			stop_click_tween.tween_callback(_play_stop_click)


func _select_spin_outcome(allow_early_session_boost: bool = false) -> Dictionary:
	if allow_early_session_boost and rng.randf() < early_blue_stack_chance:
		return {
			"symbols": [
				BLUE_COIN_STACK_SYMBOL,
				BLUE_COIN_STACK_SYMBOL,
				BLUE_COIN_STACK_SYMBOL,
			] as Array[int],
			"payout": _roll_symbol_payout(BLUE_COIN_STACK_SYMBOL),
			"is_near_miss": false,
			"early_session_boost": true,
		}

	var roll := rng.randf()
	var cumulative_probability := 0.0
	var share_total := _sum_positive(symbol_rtp_shares)

	for symbol_index in SYMBOL_COUNT:
		var normalized_share := maxf(symbol_rtp_shares[symbol_index], 0.0) / share_total
		var win_probability := target_rtp * normalized_share / _get_symbol_model_value(symbol_index)
		cumulative_probability += win_probability
		if roll < cumulative_probability:
			return {
				"symbols": [symbol_index, symbol_index, symbol_index] as Array[int],
				"payout": _roll_symbol_payout(symbol_index),
				"is_near_miss": false,
				"early_session_boost": false,
			}

	if rng.randf() < near_miss_rate:
		var near_miss_symbol := _pick_near_miss_symbol()
		# With the current downward travel, the preceding symbol on the cyclic
		# strip stops one position beyond the matching symbol.
		var adjacent_symbol := posmod(near_miss_symbol - 1, SYMBOL_COUNT)
		return {
			"symbols": [near_miss_symbol, near_miss_symbol, adjacent_symbol] as Array[int],
			"payout": 0.0,
			"is_near_miss": true,
			"early_session_boost": false,
		}

	var losing_symbols: Array[int] = []
	while true:
		losing_symbols = [
			_pick_weighted_symbol(loss_symbol_weights),
			_pick_weighted_symbol(loss_symbol_weights),
			_pick_weighted_symbol(loss_symbol_weights),
		]
		# First-two matches are reserved for the explicit near-miss outcome so
		# its configured rate remains exact and measurable.
		if losing_symbols[0] != losing_symbols[1]:
			break

	return {
		"symbols": losing_symbols,
		"payout": 0.0,
		"is_near_miss": false,
		"early_session_boost": false,
	}


func reset_early_session_study() -> void:
	session_spins_started = 0
	early_stack_bonus_consumed = false


func _pick_weighted_symbol(weights: PackedFloat32Array) -> int:
	var total := _sum_positive(weights)
	var roll := rng.randf() * total
	var cumulative := 0.0
	for i in SYMBOL_COUNT:
		cumulative += maxf(weights[i], 0.0)
		if roll < cumulative:
			return i
	return SYMBOL_COUNT - 1


func _pick_near_miss_symbol() -> int:
	var total := 0.0
	for i in range(1, SYMBOL_COUNT):
		total += maxf(loss_symbol_weights[i], 0.0)
	var roll := rng.randf() * total
	var cumulative := 0.0
	for i in range(1, SYMBOL_COUNT):
		cumulative += maxf(loss_symbol_weights[i], 0.0)
		if roll < cumulative:
			return i
	return SYMBOL_COUNT - 1


func _complete_spin() -> void:
	if values[0] == PRESENT_SYMBOL and values[0] == values[1] and values[1] == values[2]:
		spin_result_label.text = "PRESENT — no award"
	elif selected_payout > 0.0:
		var symbol_name := symbol_names[values[0]]
		spin_result_label.text = "WIN %sx — %s" % [_format_multiplier(selected_payout), symbol_name.to_upper()]
		_play_win_celebration()
		return
	else:
		spin_result_label.text = "No win"
	_finish_spin()


func _play_win_celebration() -> void:
	_reset_win_effect()
	win_effect_tween = create_tween()
	win_effect_tween.tween_interval(0.10)
	win_effect_tween.tween_method(_set_win_intensity, 0.0, 1.0, 0.10).set_trans(
		Tween.TRANS_QUAD
	).set_ease(Tween.EASE_OUT)
	win_effect_tween.tween_method(_set_win_intensity, 1.0, 0.35, 0.13).set_trans(
		Tween.TRANS_QUAD
	).set_ease(Tween.EASE_IN)
	win_effect_tween.tween_method(_set_win_intensity, 0.35, 0.85, 0.14).set_trans(
		Tween.TRANS_SINE
	).set_ease(Tween.EASE_OUT)
	win_effect_tween.tween_callback(_award_selected_win)
	win_effect_tween.tween_method(_set_win_intensity, 0.85, 0.0, 0.30).set_trans(
		Tween.TRANS_SINE
	).set_ease(Tween.EASE_IN_OUT)
	win_effect_tween.tween_callback(_finish_spin)


func _award_selected_win() -> void:
	if values[0] == BLUE_COIN_STACK_SYMBOL:
		_play_chip_count(int(roundf(selected_payout)))
	_award_counter_for_symbol(values[0], selected_payout)


func _set_win_intensity(intensity: float) -> void:
	for reel in icon_reels:
		reel.material.set_shader_parameter("win_intensity", intensity)


func _reset_win_effect() -> void:
	if win_effect_tween and win_effect_tween.is_valid():
		win_effect_tween.kill()
	win_effect_tween = null
	_set_win_intensity(0.0)


func _finish_spin() -> void:
	_set_win_intensity(0.0)
	spin_in_progress = false
	if not lever_animating:
		lever_button.disabled = false
	spin_finished.emit(values.duplicate(), selected_payout)


func pull_lever() -> void:
	if lever_animating or spin_in_progress:
		return

	lever_animating = true
	lever_button.disabled = true
	if lever_tween and lever_tween.is_valid():
		lever_tween.kill()
	if lever_foley_tween and lever_foley_tween.is_valid():
		lever_foley_tween.kill()
	var audio_latency := AudioServer.get_output_latency()
	audio_latency += AudioServer.get_time_to_next_mix()
	lever_foley_tween = create_tween()
	lever_foley_tween.tween_interval(maxf(0.28 - audio_latency, 0.0))
	lever_foley_tween.tween_callback(_play_lever_thwap)
	lever_tween = create_tween()
	lever_tween.tween_method(_set_lever_pull_progress, 0.0, 1.0, 0.28).set_trans(
		Tween.TRANS_CUBIC
	).set_ease(Tween.EASE_IN)
	lever_tween.tween_callback(spin)
	lever_tween.tween_interval(0.08)
	lever_tween.tween_method(_set_lever_pull_progress, 1.0, 0.0, 0.46).set_trans(
		Tween.TRANS_BACK
	).set_ease(Tween.EASE_OUT)
	lever_tween.tween_callback(func() -> void:
		lever_animating = false
		if not spin_in_progress:
			lever_button.disabled = false
	)


func _play_lever_thwap() -> void:
	var player := audio_pool[next_audio_player]
	next_audio_player = (next_audio_player + 1) % audio_pool.size()
	player.stream = LEVER_THWAP
	player.pitch_scale = 1.0 + randf_range(-pitch_variation * 0.3, pitch_variation * 0.3)
	player.volume_db = click_volume_db + 1.5
	player.play(LEVER_THWAP_START_OFFSET)


func _play_chip_count(point_count: int) -> void:
	if chip_count_tween and chip_count_tween.is_valid():
		chip_count_tween.kill()
	chip_count_tween = create_tween()
	for point_index in point_count:
		chip_count_tween.tween_callback(
			_play_chip_point.bind(point_index, point_count)
		)
		if point_index < point_count - 1:
			var progress := float(point_index) / maxf(float(point_count - 1), 1.0)
			chip_count_tween.tween_interval(lerpf(0.105, 0.072, progress))


func _play_chip_point(point_index: int, point_count: int) -> void:
	var sound_index := rng.randi_range(0, CHIP_SOUNDS.size() - 2)
	if last_chip_sound >= 0 and sound_index >= last_chip_sound:
		sound_index += 1
	last_chip_sound = sound_index
	var player := audio_pool[next_audio_player]
	next_audio_player = (next_audio_player + 1) % audio_pool.size()
	player.stream = CHIP_SOUNDS[sound_index]
	var count_progress := float(point_index) / maxf(float(point_count - 1), 1.0)
	player.pitch_scale = lerpf(0.96, 1.08, count_progress) + randf_range(-0.012, 0.012)
	# Individual recordings have long tails, so keep each voice restrained as
	# the sequence builds into the familiar overlapping chip-count texture.
	player.volume_db = click_volume_db - 3.0 + randf_range(-0.6, 0.4)
	player.play(CHIP_START_OFFSETS[sound_index])


func _play_short_reel_whir() -> void:
	if reel_whir_tween and reel_whir_tween.is_valid():
		reel_whir_tween.kill()
	reel_whir_player.stop()
	reel_whir_player.volume_db = reel_whir_volume_db
	reel_whir_player.pitch_scale = 0.92 + randf_range(-0.01, 0.01)
	# Use only the recording's naturally decelerating tail, then fade it before
	# it can compete with the individual reel clicks.
	reel_whir_player.play(REEL_WHIR_START_OFFSET)
	reel_whir_tween = create_tween()
	reel_whir_tween.tween_interval(0.6)
	reel_whir_tween.tween_property(reel_whir_player, "volume_db", -60.0, 0.35)
	reel_whir_tween.tween_callback(reel_whir_player.stop)


func _set_lever_pull_progress(progress: float) -> void:
	# The generated poses contain real perspective changes. Per-frame offsets keep
	# their slightly different mounting sockets anchored to the cabinet pivot.
	lever_pivot.rotation = 0.0
	var frame_index := clampi(roundi(progress * 4.0), 0, 4)
	lever_sprite.frame = frame_index
	lever_sprite.position = LEVER_FRAME_POSITIONS[frame_index]


func _award_counter_for_symbol(symbol_index: int, payout: float) -> void:
	match symbol_index:
		SINGLE_COIN_SYMBOL:
			add_to_number(int(roundf(payout)))
		BLUE_COIN_STACK_SYMBOL:
			add_to_number(int(roundf(payout)))


func _roll_symbol_payout(symbol_index: int) -> float:
	if symbol_index == PRESENT_SYMBOL:
		return 0.0
	return float(rng.randi_range(symbol_payout_min[symbol_index], symbol_payout_max[symbol_index]))


func _get_symbol_model_value(symbol_index: int) -> float:
	if symbol_index == PRESENT_SYMBOL:
		var other_symbol_total := 0.0
		for i in PRESENT_SYMBOL:
			other_symbol_total += _get_symbol_expected_payout(i)
		return other_symbol_total / float(PRESENT_SYMBOL)
	return _get_symbol_expected_payout(symbol_index)


func _get_symbol_expected_payout(symbol_index: int) -> float:
	return (float(symbol_payout_min[symbol_index]) + float(symbol_payout_max[symbol_index])) * 0.5


func _format_multiplier(multiplier: float) -> String:
	if is_equal_approx(multiplier, roundf(multiplier)):
		return str(int(roundf(multiplier)))
	return "%.2f" % multiplier


func get_theoretical_rtp() -> float:
	if not _get_slot_math_error().is_empty():
		return 0.0
	var share_total := _sum_positive(symbol_rtp_shares)
	var theoretical_rtp := 0.0
	for i in SYMBOL_COUNT:
		var normalized_share := maxf(symbol_rtp_shares[i], 0.0) / share_total
		var model_value := _get_symbol_model_value(i)
		var probability := target_rtp * normalized_share / model_value
		theoretical_rtp += probability * model_value
	return theoretical_rtp


func get_theoretical_credited_rtp() -> float:
	if not _get_slot_math_error().is_empty():
		return 0.0
	var share_total := _sum_positive(symbol_rtp_shares)
	var credited_rtp := 0.0
	for i in [SINGLE_COIN_SYMBOL, BLUE_COIN_STACK_SYMBOL]:
		var normalized_share := maxf(symbol_rtp_shares[i], 0.0) / share_total
		var model_value := _get_symbol_model_value(i)
		var probability := target_rtp * normalized_share / model_value
		credited_rtp += probability * _get_symbol_expected_payout(i)
	return credited_rtp


func get_theoretical_hit_rate() -> float:
	if not _get_slot_math_error().is_empty():
		return 0.0
	var share_total := _sum_positive(symbol_rtp_shares)
	var hit_rate := 0.0
	for i in SYMBOL_COUNT:
		var normalized_share := maxf(symbol_rtp_shares[i], 0.0) / share_total
		hit_rate += target_rtp * normalized_share / _get_symbol_model_value(i)
	return hit_rate


func _get_slot_math_error() -> String:
	if icon_reels.size() != 3:
		return "Slot math requires exactly three icon reels."
	if symbol_names.size() != SYMBOL_COUNT:
		return "Symbol names must contain exactly six entries."
	if symbol_payout_min.size() != SYMBOL_COUNT or symbol_payout_max.size() != SYMBOL_COUNT:
		return "Symbol payout minimums and maximums must contain exactly six entries."
	if symbol_rtp_shares.size() != SYMBOL_COUNT or loss_symbol_weights.size() != SYMBOL_COUNT:
		return "RTP shares and loss display weights must contain exactly six entries."
	for i in SYMBOL_COUNT:
		if symbol_payout_min[i] < 0 or symbol_payout_max[i] < symbol_payout_min[i]:
			return "Symbol payout ranges must be nonnegative and minimum cannot exceed maximum."
		if i != PRESENT_SYMBOL and _get_symbol_expected_payout(i) <= 0.0:
			return "Every non-present symbol must have a positive expected payout."
	if _sum_positive(symbol_rtp_shares) <= 0.0:
		return "At least one RTP share must be positive."
	if _sum_positive(loss_symbol_weights) <= 0.0:
		return "At least one loss display weight must be positive."
	var near_miss_weight_total := 0.0
	for i in range(1, SYMBOL_COUNT):
		near_miss_weight_total += maxf(loss_symbol_weights[i], 0.0)
	if near_miss_rate > 0.0 and near_miss_weight_total <= 0.0:
		return "Near misses require a positive display weight for a non-coin symbol."
	if near_miss_rate < 0.0 or near_miss_rate > 1.0:
		return "Near-miss rate must be between zero and one."

	var share_total := _sum_positive(symbol_rtp_shares)
	var total_win_probability := 0.0
	for i in SYMBOL_COUNT:
		var normalized_share := maxf(symbol_rtp_shares[i], 0.0) / share_total
		total_win_probability += target_rtp * normalized_share / _get_symbol_model_value(i)
	if total_win_probability > 1.0:
		return "Configured payouts and RTP produce a win probability above 100%."
	return ""


func _sum_positive(numbers: PackedFloat32Array) -> float:
	var total := 0.0
	for number in numbers:
		total += maxf(number, 0.0)
	return total


func _play_reel_click(spin_progress: float, _reel_index: int) -> void:
	if audio_pool.is_empty():
		return

	# Avoid the artificial sound of choosing the same sample twice in a row.
	var sound_index := randi_range(0, CLICK_SOUNDS.size() - 2)
	if last_click_sound >= 0 and sound_index >= last_click_sound:
		sound_index += 1
	last_click_sound = sound_index

	var player := audio_pool[next_audio_player]
	next_audio_player = (next_audio_player + 1) % audio_pool.size()
	player.stream = CLICK_SOUNDS[sound_index]
	# The mechanism loses a little energy as it coasts to a stop. Small random
	# variation keeps simultaneous reels from sounding cloned.
	player.pitch_scale = lerpf(1.08, 0.91, spin_progress) + randf_range(
		-pitch_variation,
		pitch_variation
	)
	player.volume_db = click_volume_db + randf_range(-1.5, 0.8)
	player.play(CLICK_START_OFFSETS[sound_index])


func _play_stop_click() -> void:
	if audio_pool.is_empty():
		return

	var stop_pitch := 0.97 + randf_range(-pitch_variation * 0.5, pitch_variation * 0.5)
	var player := audio_pool[next_audio_player]
	next_audio_player = (next_audio_player + 1) % audio_pool.size()
	player.stream = STOP_CLICK
	player.pitch_scale = stop_pitch
	# The source is substantially louder than the four running clicks, so tame it
	# slightly while retaining a distinct, weighty reel-lock sound.
	player.volume_db = click_volume_db - 2.0 + randf_range(-0.5, 0.5)
	player.play(STOP_CLICK_START_OFFSET)

	# Layer the quieter low flap under the detent for mechanical body. Matching
	# pitch variation makes both recordings read as one physical impact.
	var flap_player := audio_pool[next_audio_player]
	next_audio_player = (next_audio_player + 1) % audio_pool.size()
	flap_player.stream = STOP_FLAP
	flap_player.pitch_scale = stop_pitch
	flap_player.volume_db = click_volume_db + 4.0 + randf_range(-0.5, 0.5)
	flap_player.play(STOP_FLAP_START_OFFSET)


func _play_spin_start() -> void:
	if audio_pool.is_empty():
		return

	var player := audio_pool[next_audio_player]
	next_audio_player = (next_audio_player + 1) % audio_pool.size()
	player.stream = SPIN_START_THUMP
	player.pitch_scale = 0.94 + randf_range(-pitch_variation * 0.35, pitch_variation * 0.35)
	player.volume_db = click_volume_db + 2.0 + randf_range(-0.4, 0.4)
	player.play()


func set_number(value: int, animate: bool = true) -> void:
	var clamped_value := clampi(value, 0, 9999)
	if not animate:
		_cancel_number_animation()
		number_value = clamped_value
		_apply_number_immediately(number_value)
		number_change_finished.emit(number_value)
		return

	if clamped_value == number_value and not number_animation_active:
		number_change_finished.emit(number_value)
		return

	var previous_target := number_value
	number_value = clamped_value
	_animate_number_to(number_value, previous_target, true)


func add_to_number(amount: int, animate: bool = true) -> void:
	var previous_target := number_value
	var new_value := clampi(number_value + amount, 0, 9999)
	if not animate:
		set_number(new_value, false)
		return

	if new_value == previous_target and not number_animation_active:
		number_change_finished.emit(number_value)
		return

	number_value = new_value
	_animate_number_to(number_value, previous_target, true)


func get_number() -> int:
	return number_value


func is_number_animating() -> bool:
	return number_animation_active


func test_counter_setting() -> void:
	set_number(randi_range(0, 9999))


func go_to_doctor_scene() -> void:
	continue_requested.emit()


func _animate_number_to(target_value: int, previous_target: int, is_addition: bool) -> void:
	_cancel_number_animation()
	if number_reels.is_empty():
		number_change_finished.emit(number_value)
		return

	number_animation_active = true
	var amount := target_value - previous_target
	var direction := signi(amount)
	var duration := number_roll_duration
	if is_addition:
		duration += minf(float(absi(amount)) / 1000.0, 1.0) * 0.35

	for i in number_reels.size():
		var reel := number_reels[i]
		var start := float(reel.material.get_shader_parameter("y_offset"))
		var target_digit := _digit_at(target_value, i)
		var current_digit_position := start * 10.0
		var current_digit_phase := fposmod(current_digit_position, 10.0)
		var digit_steps: float

		if is_addition and direction != 0:
			var place := _place_for_index(i)
			var transition_count := floori(float(target_value) / place)
			transition_count -= floori(float(previous_target) / place)
			var extra_turns := mini(floori(float(absi(transition_count)) / 10.0), 3)
			if direction > 0:
				digit_steps = fposmod(float(target_digit) - current_digit_phase, 10.0)
				digit_steps += extra_turns * 10.0
			else:
				digit_steps = -fposmod(current_digit_phase - float(target_digit), 10.0)
				digit_steps -= extra_turns * 10.0
		else:
			# This is only reached when retargeting to the same value from a
			# fractional position; settle directly without choosing a spin direction.
			digit_steps = fposmod(float(target_digit) - current_digit_phase + 5.0, 10.0) - 5.0

		var target_offset := start + digit_steps / 10.0
		var digit_tween := create_tween()
		number_tweens.append(digit_tween)
		digit_tween.tween_method(
			func(offset: float) -> void:
				reel.material.set_shader_parameter("y_offset", offset),
			start,
			target_offset,
			duration
		).set_trans(Tween.TRANS_CUBIC).set_ease(Tween.EASE_OUT)
		digit_tween.tween_callback(func() -> void:
			reel.material.set_shader_parameter("y_offset", float(target_digit) / 10.0)
		)

	var completion_tween := create_tween()
	number_tweens.append(completion_tween)
	completion_tween.tween_interval(duration)
	completion_tween.tween_callback(func() -> void:
		number_animation_active = false
		number_tweens.clear()
		number_change_finished.emit(number_value)
	)


func _cancel_number_animation() -> void:
	for active_tween in number_tweens:
		if active_tween and active_tween.is_valid():
			active_tween.kill()
	number_tweens.clear()
	number_animation_active = false


func _apply_number_immediately(value: int) -> void:
	for i in mini(number_reels.size(), 4):
		var digit := _digit_at(value, i)
		number_reels[i].material.set_shader_parameter("y_offset", float(digit) / 10.0)


func _digit_at(value: int, index: int) -> int:
	return floori(float(value) / _place_for_index(index)) % 10


func _place_for_index(index: int) -> int:
	return int(pow(10, 3 - index))