using System.Text.Json;

namespace IpcChat.Contracts;

public enum MessageType
{
    Connect,     // клієнт повідомляє своє ім'я
    Chat,        // звичайне повідомлення
    Broadcast,   // сервер транслює іншим клієнтам
    Disconnect,  // клієнт від'єднується
    Error        // помилка
}

public record ChatMessage(MessageType Type, string Sender, string Content, DateTime Timestamp)
{
    public static ChatMessage Connect(string name) =>
        new(MessageType.Connect, name, "", DateTime.UtcNow);

    public static ChatMessage Chat(string sender, string text) =>
        new(MessageType.Chat, sender, text, DateTime.UtcNow);

    public static ChatMessage Broadcast(string sender, string text) =>
        new(MessageType.Broadcast, sender, text, DateTime.UtcNow);

    public static ChatMessage Disconnect(string name) =>
        new(MessageType.Disconnect, name, "", DateTime.UtcNow);
}

// Серіалізація/десеріалізація повідомлень
public static class Protocol
{
    private static readonly JsonSerializerOptions Options = new()
    {
        PropertyNamingPolicy = JsonNamingPolicy.CamelCase
    };

    public static async Task SendAsync(StreamWriter writer, ChatMessage msg, CancellationToken ct = default)
    {
        string json = JsonSerializer.Serialize(msg, Options);
        await writer.WriteLineAsync(json.AsMemory(), ct);
    }

    public static async Task<ChatMessage?> ReceiveAsync(StreamReader reader, CancellationToken ct = default)
    {
        string? line = await reader.ReadLineAsync(ct);
        if (line is null) return null;
        return JsonSerializer.Deserialize<ChatMessage>(line, Options);
    }
}

using System.IO.Pipes;
using IpcChat.Contracts;

namespace IpcChat.Server;

/// <summary>
/// Представляє одне підключення клієнта.
/// Кожна сесія виконується у власному Task для паралельного обслуговування.
/// </summary>
class ClientSession(NamedPipeServerStream pipe, ChatServer server) : IAsyncDisposable
{
    public string Name { get; private set; } = "Unknown";

    private readonly StreamReader _reader = new(pipe, leaveOpen: true);
    private readonly StreamWriter _writer = new(pipe, leaveOpen: true) { AutoFlush = true };

    public async Task RunAsync(CancellationToken ct)
    {
        try
        {
            // Перше повідомлення — Connect з іменем клієнта
            var connectMsg = await Protocol.ReceiveAsync(_reader, ct);
            if (connectMsg?.Type != MessageType.Connect)
            {
                Console.WriteLine($"[Server] Невалідний перший пакет — відключаємо");
                return;
            }

            Name = connectMsg.Sender;
            Console.WriteLine($"[Server] Підключився: {Name}");
            await server.BroadcastAsync(ChatMessage.Broadcast("Server", $">> {Name} приєднався"), exclude: this);

            // Основний цикл обробки повідомлень
            while (!ct.IsCancellationRequested && pipe.IsConnected)
            {
                var msg = await Protocol.ReceiveAsync(_reader, ct);

                if (msg is null || msg.Type == MessageType.Disconnect) break;

                if (msg.Type == MessageType.Chat)
                {
                    Console.WriteLine($"[Chat] {Name}: {msg.Content}");
                    await server.BroadcastAsync(ChatMessage.Broadcast(Name, msg.Content), exclude: this);
                }
            }
        }
        catch (OperationCanceledException) { }
        catch (IOException) { /* клієнт відключився некоректно */ }
        finally
        {
            Console.WriteLine($"[Server] Відключився: {Name}");
            await server.BroadcastAsync(ChatMessage.Broadcast("Server", $"<< {Name} покинув чат"), exclude: this);
            server.RemoveSession(this);
        }
    }

    public async Task SendAsync(ChatMessage msg, CancellationToken ct = default)
    {
        if (pipe.IsConnected)
            await Protocol.SendAsync(_writer, msg, ct);
    }

    public async ValueTask DisposeAsync()
    {
        await _writer.DisposeAsync();
        _reader.Dispose();
        await pipe.DisposeAsync();
    }
}

using System.Collections.Concurrent;
using System.IO.Pipes;
using IpcChat.Contracts;

namespace IpcChat.Server;

class ChatServer
{
    private const string PipeName = "ipc-chat";
    private const int MaxClients = 10;

    private readonly ConcurrentDictionary<string, ClientSession> _sessions = new();
    private readonly CancellationToken _ct;

    public ChatServer(CancellationToken ct) => _ct = ct;

    public async Task RunAsync()
    {
        Console.WriteLine($"[Server] Запущено. Pipe: \\\\.\\pipe\\{PipeName}");
        Console.WriteLine("[Server] Очікуємо підключень...\n");

        while (!_ct.IsCancellationRequested)
        {
            // Кожна ітерація: новий ServerStream для нового підключення
            var pipe = new NamedPipeServerStream(
                PipeName,
                PipeDirection.InOut,
                MaxClients,
                PipeTransmissionMode.Byte,
                PipeOptions.Asynchronous | PipeOptions.CurrentUserOnly
            );

            try
            {
                await pipe.WaitForConnectionAsync(_ct);
            }
            catch (OperationCanceledException)
            {
                await pipe.DisposeAsync();
                break;
            }

            // Не чекаємо — обслуговуємо клієнта у фоні
            _ = HandleClientAsync(pipe);
        }

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

    private async Task HandleClientAsync(NamedPipeServerStream pipe)
    {
        var session = new ClientSession(pipe, this);
        _sessions.TryAdd(Guid.NewGuid().ToString(), session);

        await session.RunAsync(_ct);
        await session.DisposeAsync();
    }

    public async Task BroadcastAsync(ChatMessage msg, ClientSession? exclude = null)
    {
        var tasks = _sessions.Values
            .Where(s => s != exclude)
            .Select(s => s.SendAsync(msg, _ct));

        await Task.WhenAll(tasks);
    }

    public void RemoveSession(ClientSession session)
    {
        var key = _sessions.FirstOrDefault(kv => kv.Value == session).Key;
        if (key != null) _sessions.TryRemove(key, out _);
    }
}

using IpcChat.Server;

Console.OutputEncoding = System.Text.Encoding.UTF8;

using var cts = new CancellationTokenSource();
Console.CancelKeyPress += (_, e) =>
{
    e.Cancel = true;
    Console.WriteLine("\n[Server] Зупиняємо...");
    cts.Cancel();
};

var server = new ChatServer(cts.Token);
await server.RunAsync();

using System.IO.Pipes;
using IpcChat.Contracts;

Console.OutputEncoding = System.Text.Encoding.UTF8;

Console.Write("Введіть ваше ім'я: ");
string name = Console.ReadLine() ?? "Anonymous";

// Підключення до сервера
await using var pipe = new NamedPipeClientStream(
    serverName: ".",
    pipeName: "ipc-chat",
    direction: PipeDirection.InOut,
    options: PipeOptions.Asynchronous | PipeOptions.CurrentUserOnly
);

Console.Write("Підключаємось до сервера...");
await pipe.ConnectAsync(timeout: 5000);
Console.WriteLine(" OK!\n");

using var reader = new StreamReader(pipe, leaveOpen: true);
using var writer = new StreamWriter(pipe, leaveOpen: true) { AutoFlush = true };

using var cts = new CancellationTokenSource();

// Надсилаємо Connect
await Protocol.SendAsync(writer, ChatMessage.Connect(name), cts.Token);

// Фоновий Task для читання повідомлень від сервера
var receiveTask = Task.Run(async () =>
{
    while (!cts.Token.IsCancellationRequested)
    {
        var msg = await Protocol.ReceiveAsync(reader, cts.Token);
        if (msg is null) break;

        string prefix = msg.Sender == "Server" ? "** " : $"[{msg.Sender}] ";
        Console.ForegroundColor = msg.Sender == "Server" ? ConsoleColor.Yellow : ConsoleColor.Cyan;
        Console.WriteLine($"\r{prefix}{msg.Content}");
        Console.ResetColor();
        Console.Write("> ");  // відновлюємо prompt
    }
});

// Головний цикл: читаємо stdin і надсилаємо
Console.WriteLine("Чат розпочато. Введіть повідомлення (або /quit для виходу):\n");

while (true)
{
    Console.Write("> ");
    string? input = Console.ReadLine();
    if (input is null || input.Trim() == "/quit") break;
    if (string.IsNullOrWhiteSpace(input)) continue;

    await Protocol.SendAsync(writer, ChatMessage.Chat(name, input), cts.Token);
}

await Protocol.SendAsync(writer, ChatMessage.Disconnect(name), cts.Token);
cts.Cancel();
await receiveTask.ConfigureAwait(ConfigureAwaitOptions.SuppressThrowing);

Console.WriteLine("До побачення!");