// DiscoveryProtocol.cs
namespace NetworkDiscovery;

public static class DiscoveryProtocol
{
    // ── Порти ────────────────────────────────────────────────────────────────

    /// <summary>Порт для broadcast-запитів DISCOVER?</summary>
    public const int BroadcastPort = 9876;

    /// <summary>Порт для multicast-анонсів ANNOUNCE</summary>
    public const int MulticastPort = 9877;

    // ── Адреси ───────────────────────────────────────────────────────────────

    /// <summary>
    /// Multicast-група для анонсів сервісу.
    /// Вибрано з діапазону Site-Local (239.x.x.x),
    /// щоб пакети не виходили за межі організації.
    /// </summary>
    public const string MulticastGroupAddress = "239.255.99.1";

    // ── Команди ──────────────────────────────────────────────────────────────

    public const string CmdDiscover = "DISCOVER?";
    public const string CmdAnnounce = "ANNOUNCE";

    /// <summary>Сервер анонсує себе в multicast кожні 5 секунд.</summary>
    public const int AnnounceIntervalMs = 5_000;

    // ── Формування та парсинг ─────────────────────────────────────────────

    /// <summary>Формує рядок анонсу: ANNOUNCE:name:ip:port</summary>
    public static string FormatAnnounce(string name, string ip, int port) =>
        $"{CmdAnnounce}:{name}:{ip}:{port}";

    /// <summary>
    /// Розбирає ANNOUNCE-рядок.
    /// Повертає null, якщо формат некоректний.
    /// </summary>
    public static ServiceInfo? ParseAnnounce(string raw)
    {
        // Очікуємо рівно: ANNOUNCE:name:ip:port
        var parts = raw.Split(':');
        if (parts.Length != 4) return null;
        if (parts[0] != CmdAnnounce) return null;
        if (!int.TryParse(parts[3], out int port)) return null;

        return new ServiceInfo(parts[1], parts[2], port);
    }
}

/// <summary>Інформація про знайдений сервіс.</summary>
public record ServiceInfo(string Name, string Ip, int Port)
{
    public override string ToString() => $"{Name} @ {Ip}:{Port}";
}

// DiscoveryServer.cs
namespace NetworkDiscovery;

using System.Net;
using System.Net.NetworkInformation;
using System.Net.Sockets;
using System.Text;

/// <summary>
/// Сервер виявлення. Виконує дві функції паралельно:
/// 1. Слухає broadcast-порт (9876) і відповідає unicast на DISCOVER? запити.
/// 2. Кожні 5 секунд надсилає ANNOUNCE в multicast-групу (239.255.99.1:9877).
/// </summary>
public sealed class DiscoveryServer : IAsyncDisposable
{
    private readonly string _serviceName;
    private readonly int _servicePort;
    private readonly CancellationTokenSource _cts = new();

    // Сокет для прослуховування broadcast-запитів
    private readonly UdpClient _broadcastListener;

    // Сокет для надсилання multicast-анонсів
    private readonly UdpClient _multicastSender;

    private readonly IPEndPoint _multicastEndPoint = new(
        IPAddress.Parse(DiscoveryProtocol.MulticastGroupAddress),
        DiscoveryProtocol.MulticastPort);

    public DiscoveryServer(string serviceName, int servicePort)
    {
        _serviceName = serviceName;
        _servicePort = servicePort;

        // ── Broadcast listener ──────────────────────────────────────────
        _broadcastListener = new UdpClient();
        // ReuseAddress дозволяє кільком процесам слухати той самий порт
        _broadcastListener.Client.SetSocketOption(
            SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
        _broadcastListener.Client.Bind(
            new IPEndPoint(IPAddress.Any, DiscoveryProtocol.BroadcastPort));
        _broadcastListener.EnableBroadcast = true;

        // ── Multicast sender ────────────────────────────────────────────
        _multicastSender = new UdpClient();
        // TTL=32: пакет може пройти через до 32 маршрутизаторів
        _multicastSender.Client.SetSocketOption(
            SocketOptionLevel.IP, SocketOptionName.MulticastTimeToLive, 32);
    }

    public async Task RunAsync()
    {
        string localIp = GetLocalIpAddress();
        Console.WriteLine($"[Server] Сервіс '{_serviceName}' на {localIp}:{_servicePort}");
        Console.WriteLine($"[Server] Broadcast listener: :{DiscoveryProtocol.BroadcastPort}");
        Console.WriteLine($"[Server] Multicast announcer: {DiscoveryProtocol.MulticastGroupAddress}:{DiscoveryProtocol.MulticastPort}");
        Console.WriteLine("[Server] Ctrl+C для зупинки.");

        Console.CancelKeyPress += (_, e) => { e.Cancel = true; _cts.Cancel(); };

        await Task.WhenAll(
            BroadcastListenerLoopAsync(localIp, _cts.Token),
            MulticastAnnouncerLoopAsync(localIp, _cts.Token)
        );

        Console.WriteLine("[Server] Зупинено.");
    }

    // ── Відповідь на broadcast-запити ─────────────────────────────────────────

    private async Task BroadcastListenerLoopAsync(string localIp, CancellationToken ct)
    {
        while (!ct.IsCancellationRequested)
        {
            UdpReceiveResult result;
            try { result = await _broadcastListener.ReceiveAsync(ct); }
            catch (OperationCanceledException) { break; }
            catch (SocketException ex)
            {
                Console.WriteLine($"[Server] Broadcast помилка: {ex.SocketErrorCode}");
                continue;
            }

            string message = Encoding.UTF8.GetString(result.Buffer).Trim();
            Console.WriteLine($"[Server] Broadcast від {result.RemoteEndPoint}: '{message}'");

            if (message == DiscoveryProtocol.CmdDiscover)
            {
                // Відповідаємо unicast безпосередньо відправнику
                string announce = DiscoveryProtocol.FormatAnnounce(
                    _serviceName, localIp, _servicePort);
                byte[] response = Encoding.UTF8.GetBytes(announce);

                try
                {
                    await _broadcastListener.SendAsync(response, result.RemoteEndPoint, ct);
                    Console.WriteLine($"[Server] → Unicast відповідь: '{announce}'");
                }
                catch (SocketException ex)
                {
                    Console.WriteLine($"[Server] Помилка відповіді: {ex.SocketErrorCode}");
                }
            }
        }
    }

    // ── Регулярний multicast-анонс ─────────────────────────────────────────────

    private async Task MulticastAnnouncerLoopAsync(string localIp, CancellationToken ct)
    {
        string announce = DiscoveryProtocol.FormatAnnounce(
            _serviceName, localIp, _servicePort);
        byte[] data = Encoding.UTF8.GetBytes(announce);

        while (!ct.IsCancellationRequested)
        {
            try
            {
                await _multicastSender.SendAsync(data, _multicastEndPoint, ct);
                Console.WriteLine($"[Server] Multicast → '{announce}'");
                await Task.Delay(DiscoveryProtocol.AnnounceIntervalMs, ct);
            }
            catch (OperationCanceledException) { break; }
            catch (SocketException ex)
            {
                Console.WriteLine($"[Server] Multicast помилка: {ex.SocketErrorCode}");
                await Task.Delay(1000, ct);
            }
        }
    }

    // ── Визначення локальної IP-адреси ────────────────────────────────────────

    private static string GetLocalIpAddress()
    {
        foreach (var ni in NetworkInterface.GetAllNetworkInterfaces())
        {
            if (ni.OperationalStatus != OperationalStatus.Up) continue;
            if (ni.NetworkInterfaceType == NetworkInterfaceType.Loopback) continue;

            foreach (var addr in ni.GetIPProperties().UnicastAddresses)
            {
                if (addr.Address.AddressFamily == AddressFamily.InterNetwork)
                    return addr.Address.ToString();
            }
        }
        return "127.0.0.1";
    }

    public async ValueTask DisposeAsync()
    {
        await _cts.CancelAsync();
        _broadcastListener.Dispose();
        _multicastSender.Dispose();
        _cts.Dispose();
    }
}

// DiscoveryClient.cs
namespace NetworkDiscovery;

using System.Net;
using System.Net.Sockets;
using System.Text;

/// <summary>
/// Клієнт виявлення. Виконує два типи пошуку:
/// 1. Активний — надсилає broadcast DISCOVER? і збирає unicast-відповіді.
/// 2. Пасивний — підписується на multicast-групу та слухає анонси.
/// </summary>
public sealed class DiscoveryClient : IAsyncDisposable
{
    private readonly CancellationTokenSource _cts = new();

    // Сокет для надсилання broadcast і отримання unicast-відповідей
    private readonly UdpClient _broadcastSender;

    // Сокет для отримання multicast-анонсів
    private readonly UdpClient _multicastListener;

    private readonly IPEndPoint _broadcastEndPoint = new(
        IPAddress.Broadcast, DiscoveryProtocol.BroadcastPort);

    private readonly IPAddress _multicastGroup =
        IPAddress.Parse(DiscoveryProtocol.MulticastGroupAddress);

    public DiscoveryClient()
    {
        // ── Broadcast sender (також отримує unicast-відповіді) ──────────
        _broadcastSender = new UdpClient();
        _broadcastSender.EnableBroadcast = true;
        // Прив'язуємо до довільного порту — ОС призначить ефемерний
        _broadcastSender.Client.Bind(new IPEndPoint(IPAddress.Any, 0));

        // ── Multicast listener ──────────────────────────────────────────
        _multicastListener = new UdpClient();
        _multicastListener.Client.SetSocketOption(
            SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
        _multicastListener.Client.Bind(
            new IPEndPoint(IPAddress.Any, DiscoveryProtocol.MulticastPort));

        // Підписуємось на multicast-групу через IGMP
        _multicastListener.JoinMulticastGroup(_multicastGroup);
    }

    // ── Активний пошук через Broadcast ───────────────────────────────────────

    /// <summary>
    /// Надсилає DISCOVER? broadcast та збирає відповіді протягом <paramref name="timeoutSeconds"/> секунд.
    /// </summary>
    public async Task<List<ServiceInfo>> DiscoverViaBroadcastAsync(int timeoutSeconds = 3)
    {
        var found = new List<ServiceInfo>();

        byte[] request = Encoding.UTF8.GetBytes(DiscoveryProtocol.CmdDiscover);
        await _broadcastSender.SendAsync(request, _broadcastEndPoint);
        Console.WriteLine($"[Client] Broadcast DISCOVER? надіслано → {_broadcastEndPoint}");

        using var timeoutCts = new CancellationTokenSource(
            TimeSpan.FromSeconds(timeoutSeconds));

        Console.WriteLine($"[Client] Збираємо відповіді протягом {timeoutSeconds}с...");

        while (!timeoutCts.Token.IsCancellationRequested)
        {
            try
            {
                UdpReceiveResult result =
                    await _broadcastSender.ReceiveAsync(timeoutCts.Token);

                string raw = Encoding.UTF8.GetString(result.Buffer).Trim();
                ServiceInfo? info = DiscoveryProtocol.ParseAnnounce(raw);

                if (info is not null && !found.Any(s => s.Ip == info.Ip && s.Port == info.Port))
                {
                    found.Add(info);
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.WriteLine($"[Client] ✅ Знайдено (broadcast): {info}");
                    Console.ResetColor();
                }
            }
            catch (OperationCanceledException) { break; }
            catch (SocketException ex)
            {
                Console.WriteLine($"[Client] Помилка прийому: {ex.SocketErrorCode}");
                break;
            }
        }

        return found;
    }

    // ── Пасивний пошук через Multicast ───────────────────────────────────────

    /// <summary>
    /// Слухає multicast-групу та виводить кожен новий анонс.
    /// Зупиняється при натисканні Ctrl+C або виклику DisposeAsync().
    /// </summary>
    public async Task ListenMulticastAsync()
    {
        Console.WriteLine($"[Client] Слухаємо multicast {DiscoveryProtocol.MulticastGroupAddress}:{DiscoveryProtocol.MulticastPort}...");
        Console.WriteLine("[Client] Ctrl+C для зупинки.");

        Console.CancelKeyPress += (_, e) => { e.Cancel = true; _cts.Cancel(); };

        var seen = new HashSet<string>(); // щоб не дублювати у виводі

        while (!_cts.Token.IsCancellationRequested)
        {
            UdpReceiveResult result;
            try { result = await _multicastListener.ReceiveAsync(_cts.Token); }
            catch (OperationCanceledException) { break; }
            catch (SocketException ex)
            {
                Console.WriteLine($"[Client] Multicast помилка: {ex.SocketErrorCode}");
                break;
            }

            string raw = Encoding.UTF8.GetString(result.Buffer).Trim();
            ServiceInfo? info = DiscoveryProtocol.ParseAnnounce(raw);

            if (info is not null)
            {
                string key = $"{info.Ip}:{info.Port}";
                bool isNew = seen.Add(key);

                Console.ForegroundColor = isNew ? ConsoleColor.Green : ConsoleColor.Gray;
                string prefix = isNew ? "✅ Новий сервіс" : "🔄 Анонс";
                Console.WriteLine($"[Client] {prefix}: {info}");
                Console.ResetColor();
            }
        }

        // Відписуємось від multicast-групи при завершенні
        _multicastListener.DropMulticastGroup(_multicastGroup);
        Console.WriteLine("[Client] Зупинено.");
    }

    public async ValueTask DisposeAsync()
    {
        await _cts.CancelAsync();
        _broadcastSender.Dispose();
        _multicastListener.Dispose();
        _cts.Dispose();
    }
}

// Program.cs
using NetworkDiscovery;

string mode = args.Length > 0 ? args[0].ToLower() : string.Empty;

switch (mode)
{
    case "server":
        // dotnet run -- server MyService 8080
        string name = args.Length > 1 ? args[1] : $"Service-{Environment.MachineName}";
        int port    = args.Length > 2 && int.TryParse(args[2], out int p) ? p : 8080;

        await using var server = new DiscoveryServer(name, port);
        await server.RunAsync();
        break;

    case "broadcast":
        // Активний пошук: надсилає broadcast і чекає на відповіді
        await using (var client = new DiscoveryClient())
        {
            var services = await client.DiscoverViaBroadcastAsync(timeoutSeconds: 3);

            Console.WriteLine();
            Console.WriteLine($"=== Знайдено сервісів: {services.Count} ===");
            foreach (var svc in services)
                Console.WriteLine($"  • {svc}");
        }
        break;

    case "multicast":
        // Пасивне прослуховування multicast-анонсів
        await using (var client = new DiscoveryClient())
        {
            await client.ListenMulticastAsync();
        }
        break;

    default:
        Console.WriteLine("Використання:");
        Console.WriteLine("  dotnet run -- server [name] [port]   — запустити сервер");
        Console.WriteLine("  dotnet run -- broadcast              — знайти сервери (broadcast)");
        Console.WriteLine("  dotnet run -- multicast              — слухати multicast-анонси");
        break;
}