MainWindow.xaml.cs

using System.Net;
using System.Net.NetworkInformation;
using System.Net.Sockets;
using System.Windows;
using WebSocketSharp.Server;

namespace PCRemoteControlServer
{
    public partial class MainWindow : Window
    {
        private WebSocketServer? _server;
        private NotifyIcon _notifyIcon;
        private readonly AppSettings _settings;

        public MainWindow()
        {
            InitializeComponent();
            KeyCommandExecutor.Logger = Log;
            InitializeNotifyIcon();
            StateChanged += MainWindow_StateChanged;

            _settings = AppSettings.Load();
            PortTextBox.Text = _settings.Port.ToString();
            RequireAuthCheckBox.IsChecked = _settings.RequireAuth;
            PinTextBox.Text = _settings.Secret;
            PinTextBox.IsEnabled = _settings.RequireAuth;
            RandomizePinButton.IsEnabled = _settings.RequireAuth;
        }

        private void InitializeNotifyIcon()
        {
            var iconUri = new Uri("pack://application:,,,/icon/icon.ico");
            using var stream = System.Windows.Application.GetResourceStream(iconUri).Stream;
            _notifyIcon = new NotifyIcon
            {
                Icon = new Icon(stream),
                Text = "Remote Control Server",
                Visible = false
            };
            _notifyIcon.Click += NotifyIcon_Click;
        }

        private void MainWindow_StateChanged(object? sender, EventArgs e)
        {
            if (WindowState == WindowState.Minimized)
            {
                Hide();
                _notifyIcon.Visible = true;
            }
        }

        private void NotifyIcon_Click(object? sender, EventArgs e)
        {
            Show();
            WindowState = WindowState.Normal;
            Activate();
            _notifyIcon.Visible = false;
        }

        private void StartStopButton_Click(object sender, RoutedEventArgs e)
        {
            if (_server == null)
            {
                StartServer();
            }
            else
            {
                StopServer();
            }
        }

        private void RequireAuthCheckBox_Changed(object sender, RoutedEventArgs e)
        {
            PinTextBox.IsEnabled = RequireAuthCheckBox.IsChecked == true;
            RandomizePinButton.IsEnabled = RequireAuthCheckBox.IsChecked == true;
        }

        private void StartServer()
        {
            if (!int.TryParse(PortTextBox.Text, out int port) || port < 1 || port > 65535)
            {
                Log("Invalid port number. Must be between 1 and 65535.");
                return;
            }

            bool requireAuth = RequireAuthCheckBox.IsChecked == true;
            string pin = PinTextBox.Text.Trim();

            if (requireAuth)
            {
                if (pin.Length != 6 || !int.TryParse(pin, out _))
                {
                    Log("PIN must be exactly 6 digits.");
                    return;
                }
            }

            try
            {
                var ip = TryGetLanIPv4Address() ?? IPAddress.Any;
                _server = new WebSocketServer(ip, port);
                _server.ReuseAddress = true;

                CommandBehavior.Secret = requireAuth ? pin : null;
                _server.AddWebSocketService<CommandBehavior>("/remote");
                _server.Start();

                _settings.Port = port;
                _settings.RequireAuth = requireAuth;
                _settings.Secret = pin;
                _settings.Save();

                StartStopButton.Content = "Stop";
                var host = ip.Equals(IPAddress.Any) ? "0.0.0.0" : ip.ToString();
                StatusTextBlock.Text = "Listening on ws://" + host + ":" + port + "/remote";
                Log("Server started.");
                if (requireAuth)
                    Log("PIN: " + pin);
                else
                    Log("Authentication disabled.");

                if (!ip.Equals(IPAddress.Any))
                    Log("LAN address: " + ip);
            }
            catch (Exception ex)
            {
                Log("Error starting server: " + ex.Message);
                _server = null;
            }
        }

        private static IPAddress? TryGetLanIPv4Address()
        {
            IPAddress? fallbackPrivate = null;

            foreach (var ni in NetworkInterface.GetAllNetworkInterfaces())
            {
                if (ni.OperationalStatus != OperationalStatus.Up)
                    continue;
                if (ni.NetworkInterfaceType is NetworkInterfaceType.Loopback or NetworkInterfaceType.Tunnel)
                    continue;
                if (IsLikelyVirtualAdapter(ni))
                    continue;

                var ipProps = ni.GetIPProperties();
                bool hasGateway = ipProps.GatewayAddresses.Any(g => g?.Address is not null && !g.Address.Equals(IPAddress.Any));

                foreach (var ua in ipProps.UnicastAddresses)
                {
                    if (ua.Address.AddressFamily != AddressFamily.InterNetwork)
                        continue;

                    var ip = ua.Address;
                    if (IPAddress.IsLoopback(ip) || ip.Equals(IPAddress.Any))
                        continue;
                    if (!IsPrivateIPv4(ip))
                        continue;

                    // Best guess: a non-virtual interface that has a default gateway.
                    if (hasGateway)
                        return ip;

                    // Otherwise keep the first reasonable private IP as a fallback.
                    fallbackPrivate ??= ip;
                }
            }

            return fallbackPrivate;
        }

        private static bool IsLikelyVirtualAdapter(NetworkInterface ni)
        {
            var name = (ni.Name + " " + ni.Description).ToLowerInvariant();
            return name.Contains("virtual")
                || name.Contains("vethernet")
                || name.Contains("hyper-v")
                || name.Contains("vmware")
                || name.Contains("virtualbox")
                || name.Contains("wsl")
                || name.Contains("tunnel")
                || name.Contains("tap");
        }

        private static bool IsPrivateIPv4(IPAddress ip)
        {
            var b = ip.GetAddressBytes();
            return b[0] == 10
                || (b[0] == 172 && b[1] >= 16 && b[1] <= 31)
                || (b[0] == 192 && b[1] == 168);
        }

        private void StopServer()
        {
            try
            {
                _server?.Stop();
            }
            catch (Exception ex)
            {
                Log("Error stopping server: " + ex.Message);
            }
            finally
            {
                _server = null;
                StartStopButton.Content = "Start";
                StatusTextBlock.Text = "Stopped";
                Log("Server stopped.");
            }
        }

        private void Log(string message)
        {
            Dispatcher.Invoke(() =>
            {
                LogTextBox.AppendText("[" + DateTime.Now.ToString("HH:mm:ss") + "] " + message + Environment.NewLine);
                LogTextBox.ScrollToEnd();
            });
        }

        private void RandomizePinButton_Click(object sender, RoutedEventArgs e)
        {
            PinTextBox.Text = AppSettings.GenerateSecret();
        }

        protected override void OnClosed(EventArgs e)
        {
            _notifyIcon.Visible = false;
            _notifyIcon.Dispose();
            if (_server != null)
            {
                _server.Stop();
                _server = null;
            }
            base.OnClosed(e);
        }
    } // class
} // namespace