class_name SystemAudioAnalyzer
extends Node

## Emette il valore RMS continuo [0.0 - 1.0] esclusivo dell'audio di sistema/applicazione
signal volume_updated(rms_value: float)
## Emette il BPM rilevato in tempo reale dalla musica
signal bpm_updated(bpm: float)
## Emette la lista delle applicazioni audio attive (es. Spotify, Chrome, Discord)
signal applications_updated(apps: Array[Dictionary])
signal genre_updated(genre: String, confidence: float, probs: Dictionary)

@export var udp_port: int = 4242
@export var cmd_port: int = 4243
@export var heartbeat_timeout_ms: int = 1500
@export var lease_enabled: bool = true
@export var genre_enabled: bool = true

const LEASE_MS: int = 10000
const GENRE_LABELS = ["latin", "electronic", "hiphop", "rock", "classical"]
const GENRE_ALPHA: float = 0.25
const GENRE_MIN_CONFIDENCE: float = 0.30

@export_group("Gain & Sensitivity")
@export var system_audio_gain: float = 3.8
@export var system_noise_floor: float = 0.0003

var _udp_peer: PacketPeerUDP
var _udp_send: PacketPeerUDP
var _loopback_pid: int = -1
var _loopback_rms: float = 0.0
var _last_bpm: float = 0.0
var _watchdog_timer: float = 0.0
var _last_heartbeat_msec: int = 0
var _bridge_protocol: int = 0
var _restart_delay: float = 1.0
var _next_restart_at: int = 0
var _selected_pid: int = 0
var _restore_selection_at: int = -1
var _healthy_since: int = -1
var _last_health_packet: int = -1
var _restart_attempt: bool = false
var _bridge_enabled: bool = false
var _last_ping_msec: int = 0
var _genre_probs: Dictionary = {}
var _genre_argmax: String = ""
var _genre_last_emit_msec: int = -5000

func _ready() -> void:
	process_mode = Node.PROCESS_MODE_ALWAYS
	_init_native_wasapi_loopback()

func _init_native_wasapi_loopback() -> void:
	_udp_peer = PacketPeerUDP.new()
	var err = _udp_peer.bind(udp_port, "*")
	if err != OK:
		err = _udp_peer.bind(udp_port, "127.0.0.1")
		
	_udp_send = PacketPeerUDP.new()
	_udp_send.set_dest_address("127.0.0.1", cmd_port)

	if err == OK:
		_bridge_enabled = true
		_spawn_bridge()

func _spawn_bridge() -> void:
	var now: int = Time.get_ticks_msec()
	if now < _next_restart_at:
		return
	# Discard queued packets from the preceding session without closing the socket.
	while _udp_peer.get_available_packet_count() > 0:
		_udp_peer.get_packet()
	_bridge_protocol = 0
	_genre_probs.clear()
	_genre_argmax = ""
	_genre_last_emit_msec = -5000
	_last_heartbeat_msec = now
	_healthy_since = -1
	_last_health_packet = -1
	var exe_path = ProjectSettings.globalize_path("res://bin/LoopbackCapture.exe")
	if FileAccess.file_exists("res://bin/LoopbackCapture.exe"):
		var args: PackedStringArray = [str(udp_port), str(OS.get_process_id())]
		if lease_enabled and not OS.is_debug_build():
			args.append("--lease-ms=%d" % LEASE_MS)
		_loopback_pid = OS.create_process(exe_path, args, false)
	else:
		_loopback_pid = -1
	if _loopback_pid <= 0:
		_schedule_restart("avvio fallito")
	else:
		_restore_selection_at = now + 300
		_send_ping()

func _send_ping() -> void:
	if _udp_send and _loopback_pid > 0 and OS.is_process_running(_loopback_pid):
		_last_ping_msec = Time.get_ticks_msec()
		_udp_send.put_packet(("PING:%d" % _last_ping_msec).to_utf8_buffer())

func _schedule_restart(reason: String, exit_code: int = -1) -> void:
	if _restart_attempt:
		_restart_delay = minf(_restart_delay * 2.0, 30.0)
	if exit_code == 3:
		print("[SystemAudioAnalyzer] istanza gia attiva, attendo")
		_restart_delay = 30.0
	# Limite noto: un'istanza vecchia senza heartbeat non viene terminata.
	print("[SystemAudioAnalyzer] Riavvio: %s; attesa %.1f s" % [reason, _restart_delay])
	_next_restart_at = Time.get_ticks_msec() + int(_restart_delay * 1000.0)
	_restart_attempt = true
	_loopback_pid = -1
	_restore_selection_at = -1
	_healthy_since = -1

func _record_health_packet(now: int) -> void:
	if _loopback_pid <= 0:
		return
	if _last_health_packet < 0 or now - _last_health_packet > heartbeat_timeout_ms:
		_healthy_since = now
	_last_health_packet = now
	if now - _healthy_since >= 10000:
		_restart_delay = 1.0
		_restart_attempt = false

func _check_bridge_lifecycle() -> void:
	if not _bridge_enabled:
		return
	var now: int = Time.get_ticks_msec()
	if _loopback_pid <= 0:
		if now >= _next_restart_at:
			_spawn_bridge()
		return
	if not OS.is_process_running(_loopback_pid):
		_schedule_restart("processo terminato", OS.get_process_exit_code(_loopback_pid))
	elif _bridge_protocol > 0:
		# Finche' non arriva il primo HB l'exe puo' essere ancora in inizializzazione
		# WASAPI: concedi una finestra piu' ampia per evitare falsi timeout a freddo.
		var timeout: int = heartbeat_timeout_ms
		if _last_health_packet < 0:
			timeout = maxi(heartbeat_timeout_ms, 5000)
		if now - _last_heartbeat_msec > timeout:
			OS.kill(_loopback_pid)
			_schedule_restart("timeout heartbeat")

## Invia al bridge la richiesta di ascoltare SOLO l'applicazione con il PID specificato (0 = Tutto)
func select_application_pid(pid: int) -> void:
	_selected_pid = pid
	if _udp_send:
		var msg = "PID:%d" % pid
		_udp_send.put_packet(msg.to_utf8_buffer())
		print("[SystemAudioAnalyzer] Applicazione audio selezionata PID: ", pid)

func _process(delta: float) -> void:
	if Time.get_ticks_msec() - _last_ping_msec >= 2000:
		_send_ping()
	# Lettura esclusiva dell'Audio di Sistema o dell'Applicazione selezionata (Zero Microfono)
	if _udp_peer:
		var packet_received: bool = false
		while _udp_peer.get_available_packet_count() > 0:
			var packet: PackedByteArray = _udp_peer.get_packet()
			
			# Pacchetto con la lista delle applicazioni attive (APPS:...)
			if packet.size() > 5 and packet[0] == 65 and packet[1] == 80 and packet[2] == 80 and packet[3] == 83 and packet[4] == 58:
				var text: String = packet.get_string_from_utf8()
				_parse_applications_list(text)
				continue
			if packet.size() >= 3 and packet[0] == 72 and packet[1] == 66 and packet[2] == 58:
				_last_heartbeat_msec = Time.get_ticks_msec()
				_record_health_packet(_last_heartbeat_msec)
				continue
			if packet.size() >= 6 and packet[0] == 72 and packet[1] == 69 and packet[2] == 76 and packet[3] == 76 and packet[4] == 79 and packet[5] == 58:
				if _bridge_protocol == 0 and _loopback_pid > 0:
					_bridge_protocol = packet.get_string_from_utf8().substr(6).to_int()
					_last_heartbeat_msec = Time.get_ticks_msec()
					_healthy_since = -1
					_last_health_packet = -1
					select_application_pid(_selected_pid)
				# Retain the 300ms resend for legacy bridges without command readiness.
				continue

			if packet.size() >= 5 and packet[0] == 71 and packet[1] == 69 and packet[2] == 78 and packet[3] == 82 and packet[4] == 58:
				if genre_enabled:
					_parse_genre(packet.get_string_from_utf8())
				continue

			# Convenzione: le future estensioni testuali non devono MAI essere lunghe
			# esattamente 8 byte (messaggio completo, non solo prefisso).
			# HELLO:/HB:/APPS:/GENR: sono riconosciuti sopra; PING: e i futuri STATUS:/SILENT:
			# devono rispettare la convenzione o essere gestiti prima del ramo binario.
			# Nessuna euristica sui byte: anche 0x41 e' legittimo in un float little-endian.
			# Pacchetto audio standard: 8 byte (4 byte RMS + 4 byte BPM).
			if packet.size() == 8:
				# No HELLO means legacy mode: process liveness only, no HB timeout.
				if _bridge_protocol == 0:
					_record_health_packet(Time.get_ticks_msec())
				_loopback_rms = packet.decode_float(0)
				packet_received = true
				
				if packet.size() >= 8:
					var incoming_bpm: float = packet.decode_float(4)
					if incoming_bpm > 50.0:
						_last_bpm = incoming_bpm
						bpm_updated.emit(incoming_bpm)
				
		if not packet_received:
			_loopback_rms = move_toward(_loopback_rms, 0.0, delta * 3.0)

	# Read queued heartbeats before checking the watchdog to avoid false timeouts.
	_watchdog_timer += delta
	if _watchdog_timer >= 0.5:
		_watchdog_timer = 0.0
		_check_bridge_lifecycle()
	if _restore_selection_at >= 0 and Time.get_ticks_msec() >= _restore_selection_at:
		_restore_selection_at = -1
		if _loopback_pid > 0 and OS.is_process_running(_loopback_pid):
			select_application_pid(_selected_pid)

	# Calcolo Volume Percepito (Curva Loudness)
	var processed_rms: float = 0.0
	if _loopback_rms > system_noise_floor:
		processed_rms = clampf(sqrt(_loopback_rms) * system_audio_gain, 0.0, 1.0)

	volume_updated.emit(processed_rms)

func _parse_genre(raw_text: String) -> void:
	var fields: PackedStringArray = raw_text.substr(5).split(";")
	if fields.size() < 8:
		return
	# Version, raw label and raw confidence precede the five probabilities.
	# The displayed label/confidence are recomputed from the smoothed distribution.
	var incoming: Dictionary = {}
	var total: float = 0.0
	for i in range(3, fields.size()):
		var pair: PackedStringArray = fields[i].split("=")
		if pair.size() != 2 or not GENRE_LABELS.has(pair[0]):
			continue
		if incoming.has(pair[0]) or not pair[1].is_valid_float():
			return
		var probability: float = pair[1].to_float()
		if not is_finite(probability) or probability < 0.0 or probability > 1.0:
			return
		incoming[pair[0]] = probability
		total += probability
	if incoming.size() != GENRE_LABELS.size() or total <= 0.0:
		return
	var first: bool = _genre_probs.is_empty()
	var best: String = ""
	var confidence: float = -1.0
	for genre in GENRE_LABELS:
		var probability: float = float(incoming[genre]) / total
		if first:
			_genre_probs[genre] = probability
		else:
			_genre_probs[genre] = lerpf(float(_genre_probs[genre]), probability, GENRE_ALPHA)
		if float(_genre_probs[genre]) > confidence:
			confidence = float(_genre_probs[genre])
			best = genre
	var label: String = best if confidence >= GENRE_MIN_CONFIDENCE else "unknown"
	var now: int = Time.get_ticks_msec()
	if best != _genre_argmax or now - _genre_last_emit_msec >= 5000:
		_genre_argmax = best
		_genre_last_emit_msec = now
		print("[SystemAudioAnalyzer] Genere: %s (%.0f%%)" % [label, confidence * 100.0])
		genre_updated.emit(label, confidence, _genre_probs.duplicate())

func _parse_applications_list(raw_text: String) -> void:
	var payload = raw_text.substr(5)
	var tokens = payload.split(";")
	var apps: Array[Dictionary] = []
	for token in tokens:
		var parts = token.split(":")
		if parts.size() >= 2:
			var pid = int(parts[0])
			var curr_name = parts[1]
			apps.append({"pid": pid, "name": curr_name})
	if not apps.is_empty():
		applications_updated.emit(apps)

func _exit_tree() -> void:
	if _loopback_pid > 0:
		OS.kill(_loopback_pid)
	if _udp_peer:
		_udp_peer.close()
	if _udp_send:
		_udp_send.close()