Master-Arbeit-Tom-Hempel/Unity-Master/Assets/Scripts/Multiplayer/UDPPeerDiscovery.cs

using System;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
using Convai.Scripts.Runtime.LoggerSystem;
using UnityEngine;

namespace Convai.Scripts.Runtime.Multiplayer
{
    /// <summary>
    /// UDP Peer Discovery - Finds other Quest Pro on the same hotspot network
    /// Solves AP isolation problem by discovering peer IP and switching to direct unicast
    /// </summary>
    public class UDPPeerDiscovery : MonoBehaviour
    {
        [Header("Player Configuration")]
        [SerializeField] private byte localPlayerID = 1; // 1 or 2 - must be unique per Quest Pro
        [SerializeField] private bool enableDebugLogging = true;
        
        [Header("Discovery Settings")]
        [SerializeField] private float discoveryBroadcastInterval = 2.0f; // Broadcast every 2 seconds
        [SerializeField] private float heartbeatInterval = 5.0f; // Heartbeat every 5 seconds
        [SerializeField] private float peerTimeoutSeconds = 15.0f; // Consider peer lost after 15s
        
        // Events
        public event Action<string> OnPeerDiscovered; // Fires when peer IP is found
        public event Action OnPeerLost; // Fires when peer connection is lost
        public event Action<ConnectionState> OnConnectionStateChanged;
        
        // Network components
        private bool _isRunning = false;
        private int _listenPort;
        private CancellationTokenSource _cancellationTokenSource;
        
        // Peer state
        private string _peerIP = "";
        private byte _peerPlayerID = 0;
        private DateTime _lastPeerPacketTime;
        private ConnectionState _connectionState = ConnectionState.Disconnected;
        private bool _hasEverConnected = false; // Track if we've connected this session
        
        // Discovery protocol constants
        private const uint DISCOVERY_MAGIC = 0x44495343; // "DISC" in hex
        private const byte PACKET_TYPE_REQUEST = 0x01;
        private const byte PACKET_TYPE_RESPONSE = 0x02;
        private const byte PACKET_TYPE_HEARTBEAT = 0x03;
        
        // Singleton for easy access
        private static UDPPeerDiscovery _instance;
        public static UDPPeerDiscovery Instance => _instance;
        
        public enum ConnectionState
        {
            Disconnected,
            Discovering,
            Connected,
            Lost
        }
        
        // Event log for debugging
        private System.Collections.Generic.List<string> _eventLog = new System.Collections.Generic.List<string>();
        private const int MAX_LOG_ENTRIES = 20;
        
        // Public properties
        public string PeerIP => _peerIP;
        public byte LocalPlayerID => localPlayerID;
        public byte PeerPlayerID => _peerPlayerID;
        public ConnectionState CurrentState => _connectionState;
        public bool IsConnected => _connectionState == ConnectionState.Connected;
        public float TimeSinceLastPeerPacket => _connectionState == ConnectionState.Connected ? 
            (float)(DateTime.UtcNow - _lastPeerPacketTime).TotalSeconds : -1f;
        public System.Collections.Generic.List<string> EventLog => _eventLog;
        
        private void Awake()
        {
            // Singleton pattern
            if (_instance != null && _instance != this)
            {
                Destroy(gameObject);
                return;
            }
            _instance = this;
        }
        
        private void Start()
        {
            // Get network config
            var cfg = NetworkConfig.Instance;
            if (cfg != null)
            {
                _listenPort = cfg.port;
            }
            else
            {
                ConvaiLogger.Error("NetworkConfig not found! Using default port 1221", ConvaiLogger.LogCategory.Character);
                _listenPort = 1221;
            }
            
            _cancellationTokenSource = new CancellationTokenSource();
            
            // Always start with discovery on game launch (IP addresses may have changed)
            LogEvent($"🔍 Discovery started (Player {localPlayerID})");
            StartDiscovery();
        }
        
        private void OnDestroy()
        {
            StopDiscovery();
            _cancellationTokenSource?.Cancel();
            _cancellationTokenSource?.Dispose();
            
            if (_instance == this)
                _instance = null;
        }
        
        private void Update()
        {
            // No timeout checks - once connected, stay connected until restart
            // Removed: peer timeout monitoring
        }
        
        private void StartDiscovery()
        {
            if (_isRunning) return;
            
            try
            {
                // Wait for shared listener to be ready
                if (SharedUDPListener.Instance == null)
                {
                    ConvaiLogger.Error("SharedUDPListener not found! Make sure it's in the scene.", ConvaiLogger.LogCategory.Character);
                    return;
                }
                
                // Subscribe to shared listener
                SharedUDPListener.Instance.OnPacketReceived += HandlePacketReceived;
                
                _isRunning = true;
                SetConnectionState(ConnectionState.Discovering);
                
                ConvaiLogger.Info($"✅ Peer Discovery subscribed to shared listener - Player {localPlayerID}, listening for magic 0x{DISCOVERY_MAGIC:X}", ConvaiLogger.LogCategory.Character);
                
                // Start broadcasting discovery requests
                _ = BroadcastDiscoveryRequests(_cancellationTokenSource.Token);
                
                // NO HEARTBEATS - once connected, stay connected
            }
            catch (Exception ex)
            {
                ConvaiLogger.Error($"Failed to start peer discovery: {ex.Message}", ConvaiLogger.LogCategory.Character);
            }
        }
        
        private void StopDiscovery()
        {
            if (!_isRunning) return;
            
            _isRunning = false;
            
            // Unsubscribe from shared listener
            if (SharedUDPListener.Instance != null)
            {
                SharedUDPListener.Instance.OnPacketReceived -= HandlePacketReceived;
            }
            
            SetConnectionState(ConnectionState.Disconnected);
            ConvaiLogger.Info("Peer Discovery stopped", ConvaiLogger.LogCategory.Character);
        }
        
        private void HandlePacketReceived(byte[] data, IPEndPoint senderEndPoint)
        {
            // Check if this is a discovery packet (by magic number)
            if (data.Length < 14) return;
            
            uint magic = BitConverter.ToUInt32(data, 0);
            if (magic != DISCOVERY_MAGIC) return;
            
            // Process discovery packet
            _ = ProcessDiscoveryPacket(data, senderEndPoint);
        }
        
        private async Task BroadcastDiscoveryRequests(CancellationToken cancellationToken)
        {
            while (_isRunning && !cancellationToken.IsCancellationRequested)
            {
                try
                {
                    // Only broadcast if we're discovering AND haven't connected yet this session
                    // Once connected, we remember the peer IP for this session
                    if (_connectionState == ConnectionState.Discovering && !_hasEverConnected)
                    {
                        await SendDiscoveryRequest();
                    }
                    
                    await Task.Delay((int)(discoveryBroadcastInterval * 1000), cancellationToken);
                }
                catch (OperationCanceledException)
                {
                    break;
                }
                catch (Exception ex)
                {
                    ConvaiLogger.Error($"Error broadcasting discovery: {ex.Message}", ConvaiLogger.LogCategory.Character);
                }
            }
        }
        
        private async Task SendHeartbeats(CancellationToken cancellationToken)
        {
            while (_isRunning && !cancellationToken.IsCancellationRequested)
            {
                try
                {
                    await Task.Delay((int)(heartbeatInterval * 1000), cancellationToken);
                    
                    // Send heartbeat if we have a peer IP (Connected or Lost state)
                    // This allows automatic reconnection when peer comes back online
                    if (!string.IsNullOrEmpty(_peerIP) && 
                        (_connectionState == ConnectionState.Connected || _connectionState == ConnectionState.Lost || _connectionState == ConnectionState.Discovering))
                    {
                        await SendHeartbeat();
                    }
                }
                catch (OperationCanceledException)
                {
                    break;
                }
                catch (Exception ex)
                {
                    ConvaiLogger.Error($"Error sending heartbeat: {ex.Message}", ConvaiLogger.LogCategory.Character);
                }
            }
        }
        
        private async Task SendDiscoveryRequest()
        {
            try
            {
                byte[] packet = CreateDiscoveryPacket(PACKET_TYPE_REQUEST);
                
                // Broadcast to subnet using shared listener
                await SharedUDPListener.Instance.SendBroadcastAsync(packet, _listenPort);
                
                if (enableDebugLogging && UnityEngine.Random.value < 0.1f) // Log 10% of broadcasts to reduce spam
                {
                    ConvaiLogger.DebugLog($"🔍 Broadcasting discovery request (Player {localPlayerID})", ConvaiLogger.LogCategory.Character);
                }
            }
            catch (Exception ex)
            {
                ConvaiLogger.Error($"Failed to send discovery request: {ex.Message}", ConvaiLogger.LogCategory.Character);
            }
        }
        
        private async Task SendDiscoveryResponse(IPEndPoint targetEndPoint)
        {
            try
            {
                byte[] packet = CreateDiscoveryPacket(PACKET_TYPE_RESPONSE);
                await SharedUDPListener.Instance.SendAsync(packet, targetEndPoint);
                
                if (enableDebugLogging)
                {
                    ConvaiLogger.DebugLog($"📤 Sent discovery response to {targetEndPoint.Address}", ConvaiLogger.LogCategory.Character);
                }
            }
            catch (Exception ex)
            {
                ConvaiLogger.Error($"Failed to send discovery response: {ex.Message}", ConvaiLogger.LogCategory.Character);
            }
        }
        
        private async Task SendHeartbeat()
        {
            try
            {
                if (string.IsNullOrEmpty(_peerIP)) return;
                
                byte[] packet = CreateDiscoveryPacket(PACKET_TYPE_HEARTBEAT);
                var peerEndPoint = new IPEndPoint(IPAddress.Parse(_peerIP), _listenPort);
                await SharedUDPListener.Instance.SendAsync(packet, peerEndPoint);
            }
            catch (Exception ex)
            {
                ConvaiLogger.Warn($"Failed to send heartbeat: {ex.Message}", ConvaiLogger.LogCategory.Character);
            }
        }
        
        private byte[] CreateDiscoveryPacket(byte packetType)
        {
            byte[] packet = new byte[14];
            int offset = 0;
            
            // Magic number
            BitConverter.GetBytes(DISCOVERY_MAGIC).CopyTo(packet, offset);
            offset += 4;
            
            // Packet type
            packet[offset] = packetType;
            offset += 1;
            
            // Player ID
            packet[offset] = localPlayerID;
            offset += 1;
            
            // Timestamp
            long timestamp = DateTime.UtcNow.Ticks;
            BitConverter.GetBytes(timestamp).CopyTo(packet, offset);
            
            return packet;
        }
        
        private async Task ProcessDiscoveryPacket(byte[] data, IPEndPoint senderEndPoint)
        {
            try
            {
                // Check if this is a discovery packet
                if (data.Length < 14) return;
                
                // Verify magic number
                uint magic = BitConverter.ToUInt32(data, 0);
                if (magic != DISCOVERY_MAGIC) return;
                
                // Parse packet
                byte packetType = data[4];
                byte senderPlayerID = data[5];
                long timestamp = BitConverter.ToInt64(data, 6);
                
                // Ignore packets from ourselves
                if (senderPlayerID == localPlayerID) return;
                
                string senderIP = senderEndPoint.Address.ToString();
                
                if (enableDebugLogging)
                {
                    string typeStr = packetType switch
                    {
                        PACKET_TYPE_REQUEST => "REQUEST",
                        PACKET_TYPE_RESPONSE => "RESPONSE",
                        PACKET_TYPE_HEARTBEAT => "HEARTBEAT",
                        _ => "UNKNOWN"
                    };
                    ConvaiLogger.DebugLog($"📥 Received {typeStr} from Player {senderPlayerID} at {senderIP}", ConvaiLogger.LogCategory.Character);
                }
                
                // Update peer info
                _lastPeerPacketTime = DateTime.UtcNow;
                
                switch (packetType)
                {
                    case PACKET_TYPE_REQUEST:
                        // Respond to discovery request
                        await SendDiscoveryResponse(senderEndPoint);
                        
                        // If we weren't connected before, this is a new peer
                        if (_connectionState != ConnectionState.Connected)
                        {
                            HandlePeerDiscovered(senderIP, senderPlayerID);
                        }
                        break;
                        
                    case PACKET_TYPE_RESPONSE:
                        // Discovery response received - we found our peer!
                        if (_connectionState != ConnectionState.Connected)
                        {
                            HandlePeerDiscovered(senderIP, senderPlayerID);
                        }
                        break;
                        
                    case PACKET_TYPE_HEARTBEAT:
                        // Ignore heartbeats - no reconnection logic
                        // Once connected, stay connected until restart
                        break;
                }
            }
            catch (Exception ex)
            {
                ConvaiLogger.Error($"Error processing discovery packet: {ex.Message}", ConvaiLogger.LogCategory.Character);
            }
        }
        
        private void HandlePeerDiscovered(string peerIP, byte peerPlayerID)
        {
            _peerIP = peerIP;
            _peerPlayerID = peerPlayerID;
            _lastPeerPacketTime = DateTime.UtcNow;
            _hasEverConnected = true; // Mark that we've connected this session
            
            SetConnectionState(ConnectionState.Connected);
            
            ConvaiLogger.Info($"✅ Peer discovered! Player {peerPlayerID} at {peerIP} (will remember for this session)", ConvaiLogger.LogCategory.Character);
            LogEvent($"✅ Peer discovered! Player {peerPlayerID} at {peerIP}");
            
            // Notify listeners
            OnPeerDiscovered?.Invoke(peerIP);
        }
        
        private void HandlePeerLost()
        {
            ConvaiLogger.Warn($"⚠️ Peer connection lost (Player {_peerPlayerID} at {_peerIP}) - but ignoring, keeping connection alive", ConvaiLogger.LogCategory.Character);
            LogEvent($"⚠️ Peer connection lost (Player {_peerPlayerID}) - IGNORING (stay connected until restart)");
            
            // DO NOTHING - keep the connection state as Connected
            // Once connected at the start of the session, stay connected forever
            // Senders will continue to send to the stored IP
        }
        
        private void SetConnectionState(ConnectionState newState)
        {
            if (_connectionState != newState)
            {
                _connectionState = newState;
                OnConnectionStateChanged?.Invoke(newState);
                
                if (enableDebugLogging)
                {
                    ConvaiLogger.Info($"🔄 Connection state changed to: {newState}", ConvaiLogger.LogCategory.Character);
                }
            }
        }
        
        // Public methods for manual control
        public void RestartDiscovery()
        {
            ConvaiLogger.Info("Manually restarting peer discovery", ConvaiLogger.LogCategory.Character);
            LogEvent("🔄 Manually restarting discovery");
            
            // Reset state
            _peerIP = "";
            _peerPlayerID = 0;
            _hasEverConnected = false;
            SetConnectionState(ConnectionState.Discovering);
        }
        
        public void ShowStatus()
        {
            ConvaiLogger.Info($"=== Peer Discovery Status ===", ConvaiLogger.LogCategory.Character);
            ConvaiLogger.Info($"Local Player ID: {localPlayerID}", ConvaiLogger.LogCategory.Character);
            ConvaiLogger.Info($"Connection State: {_connectionState}", ConvaiLogger.LogCategory.Character);
            ConvaiLogger.Info($"Peer IP: {(_peerIP ?? "None")}", ConvaiLogger.LogCategory.Character);
            ConvaiLogger.Info($"Peer Player ID: {_peerPlayerID}", ConvaiLogger.LogCategory.Character);
            ConvaiLogger.Info($"Listen Port: {_listenPort}", ConvaiLogger.LogCategory.Character);
            ConvaiLogger.Info($"Has Ever Connected This Session: {_hasEverConnected}", ConvaiLogger.LogCategory.Character);
        }
        
        private void LogEvent(string message)
        {
            string timestamp = DateTime.Now.ToString("HH:mm:ss");
            string logEntry = $"[{timestamp}] {message}";
            _eventLog.Add(logEntry);
            
            // Keep only last N entries
            if (_eventLog.Count > MAX_LOG_ENTRIES)
            {
                _eventLog.RemoveAt(0);
            }
        }
    }
}