using System.Net;
using System.Text;

// ── Налаштування сервера ────────────────────────────────────────────────────
string wwwroot = Path.GetFullPath("./wwwroot");  // Директорія зі статичними файлами
string prefix  = "http://localhost:8080/";

if (!Directory.Exists(wwwroot))
    Directory.CreateDirectory(wwwroot);

// Таблиця MIME-типів для розширень файлів
var mimeTypes = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
{
    [".html"] = "text/html; charset=utf-8",
    [".htm"]  = "text/html; charset=utf-8",
    [".css"]  = "text/css; charset=utf-8",
    [".js"]   = "application/javascript; charset=utf-8",
    [".json"] = "application/json; charset=utf-8",
    [".png"]  = "image/png",
    [".jpg"]  = "image/jpeg",
    [".jpeg"] = "image/jpeg",
    [".gif"]  = "image/gif",
    [".svg"]  = "image/svg+xml",
    [".ico"]  = "image/x-icon",
    [".txt"]  = "text/plain; charset=utf-8",
    [".xml"]  = "application/xml; charset=utf-8",
    [".pdf"]  = "application/pdf",
    [".woff2"]= "font/woff2",
};

// ── Ініціалізація та запуск HttpListener ────────────────────────────────────
using var listener = new HttpListener();
listener.Prefixes.Add(prefix);

// CancellationTokenSource для коректного завершення по Ctrl+C
using var cts = new CancellationTokenSource();

Console.CancelKeyPress += (_, e) =>
{
    e.Cancel = true;   // Запобігаємо негайному завершенню процесу
    cts.Cancel();      // Сигналізуємо про необхідність зупинки
};

listener.Start();
Console.WriteLine($"📁 Файловий сервер запущено: {prefix}");
Console.WriteLine($"   Директорія: {wwwroot}");
Console.WriteLine($"   Натисніть Ctrl+C для зупинки.");

// ── Основний цикл обробки запитів ───────────────────────────────────────────
// Декілька паралельних обробників — сервер не чекає завершення одного
// запиту перед прийняттям наступного (Task.Run для кожного контексту)
try
{
    while (!cts.Token.IsCancellationRequested)
    {
        HttpListenerContext context;
        try
        {
            // GetContextAsync не приймає CancellationToken безпосередньо —
            // використовуємо Task.WhenAny для скасування
            Task<HttpListenerContext> getContextTask = listener.GetContextAsync();
            Task cancelTask = Task.Delay(Timeout.Infinite, cts.Token);

            Task completed = await Task.WhenAny(getContextTask, cancelTask);

            if (completed == cancelTask)
                break; // Отримали сигнал зупинки

            context = await getContextTask;
        }
        catch (HttpListenerException) when (cts.Token.IsCancellationRequested)
        {
            break; // Listener зупинено через Stop()
        }

        // Обробляємо запит у окремому завданні — не блокуємо прийом наступного
        _ = Task.Run(() => HandleRequestAsync(context, wwwroot, mimeTypes));
    }
}
finally
{
    listener.Stop();
    Console.WriteLine("\n🛑 Сервер зупинено.");
}

// ── Обробник одного запиту ──────────────────────────────────────────────────
static async Task HandleRequestAsync(
    HttpListenerContext context,
    string wwwroot,
    Dictionary<string, string> mimeTypes)
{
    HttpListenerRequest  req = context.Request;
    HttpListenerResponse res = context.Response;

    Console.WriteLine($"[{DateTime.Now:HH:mm:ss}] {req.HttpMethod} {req.RawUrl} " +
                      $"← {req.RemoteEndPoint}");

    try
    {
        // HEAD — ідентичний GET, але без тіла відповіді
        if (req.HttpMethod != "GET" && req.HttpMethod != "HEAD")
        {
            await SendErrorAsync(res, 405, "Method Not Allowed");
            res.Headers.Add("Allow", "GET, HEAD");
            return;
        }

        // Визначаємо локальний шлях до файлу
        // RawUrl: "/index.html" або "/" або "/css/style.css"
        string urlPath = req.Url!.AbsolutePath;

        // Захист від path traversal: ".." у шляху може вийти за межі wwwroot
        string localPath = Path.GetFullPath(
            Path.Combine(wwwroot, urlPath.TrimStart('/')));

        if (!localPath.StartsWith(wwwroot, StringComparison.OrdinalIgnoreCase))
        {
            await SendErrorAsync(res, 403, "Forbidden");
            return;
        }

        // Якщо шлях вказує на директорію — шукаємо index.html
        if (Directory.Exists(localPath))
            localPath = Path.Combine(localPath, "index.html");

        if (!File.Exists(localPath))
        {
            await SendErrorAsync(res, 404,
                $"File not found: {urlPath}");
            return;
        }

        // Визначаємо MIME-тип за розширенням
        string ext = Path.GetExtension(localPath);
        string contentType = mimeTypes.TryGetValue(ext, out string? mime)
            ? mime
            : "application/octet-stream";

        // Відкриваємо файл та налаштовуємо відповідь
        await using FileStream fileStream = File.OpenRead(localPath);

        res.StatusCode  = 200;
        res.ContentType = contentType;
        res.ContentLength64 = fileStream.Length;

        // Заголовки кешування: дозволяємо кешувати на 1 годину
        res.Headers[HttpResponseHeader.CacheControl] = "public, max-age=3600";
        res.Headers["Last-Modified"] =
            File.GetLastWriteTimeUtc(localPath).ToString("R");

        // HEAD-запит: заголовки без тіла
        if (req.HttpMethod == "HEAD")
        {
            res.Close();
            return;
        }

        // Потокова передача файлу — не завантажуємо повністю у пам'ять
        await fileStream.CopyToAsync(res.OutputStream);
    }
    catch (Exception ex)
    {
        Console.Error.WriteLine($"Помилка обробки {req.RawUrl}: {ex.Message}");
        try { await SendErrorAsync(res, 500, "Internal Server Error"); }
        catch { /* Відповідь вже могла бути частково надіслана */ }
    }
    finally
    {
        // ОБОВ'ЯЗКОВО — завжди закривати відповідь!
        try { res.OutputStream.Close(); } catch { }
    }
}

// ── Допоміжний метод для надсилання помилок ────────────────────────────────
static async Task SendErrorAsync(
    HttpListenerResponse res, int statusCode, string message)
{
    byte[] body = Encoding.UTF8.GetBytes($"""
        <!DOCTYPE html>
        <html lang="uk"><head><meta charset="UTF-8">
        <title>{statusCode}</title></head>
        <body>
        <h1>{statusCode}</h1>
        <p>{System.Net.WebUtility.HtmlEncode(message)}</p>
        </body></html>
        """);

    res.StatusCode   = statusCode;
    res.ContentType  = "text/html; charset=utf-8";
    res.ContentLength64 = body.Length;

    await res.OutputStream.WriteAsync(body);
    res.OutputStream.Close();
}

using System.Collections.Concurrent;
using System.Net;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Text.RegularExpressions;

// ── Модель даних ─────────────────────────────────────────────────────────────
record TodoItem(
    int Id,
    string Title,
    bool IsCompleted,
    DateTimeOffset CreatedAt
);

// ── Сховище в пам'яті ────────────────────────────────────────────────────────
// ConcurrentDictionary забезпечує thread-safe доступ без явних lock-ів
var store = new ConcurrentDictionary<int, TodoItem>();
int nextId = 1; // Лічильник ID — інкрементується через Interlocked

// Заповнюємо початковими даними
for (int i = 1; i <= 3; i++)
    store[i] = new TodoItem(i, $"Завдання #{i}", i == 1, DateTimeOffset.UtcNow);
nextId = 4;

// ── Налаштування серіалізації ────────────────────────────────────────────────
var jsonOptions = new JsonSerializerOptions
{
    PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
    WriteIndented = true,
    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
};

// ── Маршрути: регулярні вирази для REST URL ──────────────────────────────────
// REST API маршрути:
//   GET    /todos        → список усіх задач
//   POST   /todos        → створення нової задачі
//   GET    /todos/{id}   → отримання конкретної задачі
//   PUT    /todos/{id}   → повне оновлення задачі
//   PATCH  /todos/{id}   → часткове оновлення (лише IsCompleted)
//   DELETE /todos/{id}   → видалення задачі
static readonly Regex RouteCollection = new(@"^/todos/?$",
    RegexOptions.Compiled | RegexOptions.IgnoreCase);
static readonly Regex RouteItem = new(@"^/todos/(?<id>\d+)/?$",
    RegexOptions.Compiled | RegexOptions.IgnoreCase);

// ── Ініціалізація HttpListener ───────────────────────────────────────────────
using var listener = new HttpListener();
listener.Prefixes.Add("http://localhost:8081/");

// Basic Auth: логін admin, пароль secret (для прикладу)
listener.AuthenticationSchemes = AuthenticationSchemes.Basic;
listener.Realm = "TodoAPI";

using var cts = new CancellationTokenSource();
Console.CancelKeyPress += (_, e) => { e.Cancel = true; cts.Cancel(); };

listener.Start();
Console.WriteLine("📋 Todo REST API запущено: http://localhost:8081/");
Console.WriteLine("   Аутентифікація: admin / secret");
Console.WriteLine("   Натисніть Ctrl+C для зупинки.\n");

// ── Основний цикл ────────────────────────────────────────────────────────────
try
{
    while (!cts.Token.IsCancellationRequested)
    {
        Task<HttpListenerContext> getCtx = listener.GetContextAsync();
        Task cancel = Task.Delay(Timeout.Infinite, cts.Token);

        if (await Task.WhenAny(getCtx, cancel) == cancel) break;

        HttpListenerContext ctx = await getCtx;
        _ = Task.Run(() => ProcessRequestAsync(ctx));
    }
}
finally
{
    listener.Stop();
    Console.WriteLine("\n🛑 API сервер зупинено.");
}

// ── Диспетчер запитів ────────────────────────────────────────────────────────
async Task ProcessRequestAsync(HttpListenerContext ctx)
{
    HttpListenerRequest  req = ctx.Request;
    HttpListenerResponse res = ctx.Response;

    // ─ Логування ──────────────────────────────────────────────────────────
    Console.WriteLine($"  [{DateTime.Now:HH:mm:ss}] {req.HttpMethod} {req.RawUrl}");

    try
    {
        // ─ Аутентифікація ─────────────────────────────────────────────────
        // HttpListener перевіряє Basic Auth заголовок автоматично
        // і заповнює ctx.User при успіху
        if (!ctx.User.Identity.IsAuthenticated)
        {
            await WriteJsonAsync(res, 401,
                new { error = "Unauthorized", message = "Потрібна Basic аутентифікація" });
            return;
        }

        // Перевіряємо облікові дані (у реальності — із БД або Identity)
        var identity = (HttpListenerBasicIdentity)ctx.User.Identity;
        if (identity.Password != "secret")
        {
            await WriteJsonAsync(res, 403,
                new { error = "Forbidden", message = "Невірний пароль" });
            return;
        }

        // ─ CORS Headers ───────────────────────────────────────────────────
        res.Headers.Add("Access-Control-Allow-Origin", "*");
        res.Headers.Add("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE");
        res.Headers.Add("Access-Control-Allow-Headers", "Content-Type, Authorization");

        // OPTIONS preflight (браузерний CORS)
        if (req.HttpMethod == "OPTIONS")
        {
            res.StatusCode = 204;
            res.Close();
            return;
        }

        // ─ Маршрутизація ──────────────────────────────────────────────────
        string path = req.Url!.AbsolutePath;

        if (RouteCollection.IsMatch(path))
        {
            await HandleCollectionAsync(req, res);
        }
        else if (RouteItem.Match(path) is { Success: true } match)
        {
            int id = int.Parse(match.Groups["id"].Value);
            await HandleItemAsync(req, res, id);
        }
        else
        {
            await WriteJsonAsync(res, 404,
                new { error = "Not Found", path });
        }
    }
    catch (Exception ex)
    {
        Console.Error.WriteLine($"  ❌ Помилка: {ex.Message}");
        try
        {
            await WriteJsonAsync(res, 500,
                new { error = "Internal Server Error", message = ex.Message });
        }
        catch { }
    }
    finally
    {
        try { res.OutputStream.Close(); } catch { }
    }
}

// ── GET /todos, POST /todos ───────────────────────────────────────────────────
async Task HandleCollectionAsync(HttpListenerRequest req, HttpListenerResponse res)
{
    switch (req.HttpMethod)
    {
        case "GET":
        {
            // Фільтрація: ?completed=true|false
            string? completedFilter = req.QueryString["completed"];
            IEnumerable<TodoItem> items = store.Values.OrderBy(t => t.Id);

            if (completedFilter is not null &&
                bool.TryParse(completedFilter, out bool filterValue))
                items = items.Where(t => t.IsCompleted == filterValue);

            await WriteJsonAsync(res, 200, items.ToArray());
            break;
        }

        case "POST":
        {
            if (!req.HasEntityBody)
            {
                await WriteJsonAsync(res, 400,
                    new { error = "Bad Request", message = "Тіло запиту обов'язкове" });
                return;
            }

            // Читаємо та десеріалізуємо JSON-тіло
            using var reader = new StreamReader(req.InputStream,
                req.ContentEncoding ?? Encoding.UTF8);
            string body = await reader.ReadToEndAsync();

            using var doc = JsonDocument.Parse(body);
            string? title = doc.RootElement
                .GetProperty("title").GetString();

            if (string.IsNullOrWhiteSpace(title))
            {
                await WriteJsonAsync(res, 422,
                    new { error = "Unprocessable Entity",
                          message = "Поле 'title' обов'язкове та не може бути порожнім" });
                return;
            }

            // Атомарна операція збільшення лічильника ID
            int id = Interlocked.Increment(ref nextId);
            var item = new TodoItem(id, title.Trim(), false, DateTimeOffset.UtcNow);
            store[id] = item;

            // 201 Created + заголовок Location з URL нового ресурсу
            res.Headers.Add("Location", $"/todos/{id}");
            await WriteJsonAsync(res, 201, item);
            break;
        }

        default:
            res.Headers.Add("Allow", "GET, POST");
            await WriteJsonAsync(res, 405,
                new { error = "Method Not Allowed" });
            break;
    }
}

// ── GET/PUT/PATCH/DELETE /todos/{id} ─────────────────────────────────────────
async Task HandleItemAsync(
    HttpListenerRequest req, HttpListenerResponse res, int id)
{
    // Перевіряємо існування ресурсу
    if (!store.TryGetValue(id, out TodoItem? existing))
    {
        await WriteJsonAsync(res, 404,
            new { error = "Not Found", id });
        return;
    }

    switch (req.HttpMethod)
    {
        case "GET":
            await WriteJsonAsync(res, 200, existing);
            break;

        case "PUT":
        {
            // Повне оновлення — вимагає всі поля
            using var reader = new StreamReader(req.InputStream,
                req.ContentEncoding ?? Encoding.UTF8);
            string body = await reader.ReadToEndAsync();
            using var doc = JsonDocument.Parse(body);

            string? title = doc.RootElement.GetProperty("title").GetString();
            bool isCompleted = doc.RootElement
                .GetProperty("isCompleted").GetBoolean();

            if (string.IsNullOrWhiteSpace(title))
            {
                await WriteJsonAsync(res, 422,
                    new { error = "Unprocessable Entity", field = "title" });
                return;
            }

            var updated = existing with
            {
                Title = title.Trim(),
                IsCompleted = isCompleted
            };
            store[id] = updated;
            await WriteJsonAsync(res, 200, updated);
            break;
        }

        case "PATCH":
        {
            // Часткове оновлення — тільки isCompleted
            using var reader = new StreamReader(req.InputStream,
                req.ContentEncoding ?? Encoding.UTF8);
            string body = await reader.ReadToEndAsync();
            using var doc = JsonDocument.Parse(body);

            bool? isCompleted = null;
            if (doc.RootElement.TryGetProperty("isCompleted", out var val))
                isCompleted = val.GetBoolean();

            if (isCompleted is null)
            {
                await WriteJsonAsync(res, 400,
                    new { error = "Bad Request",
                          message = "Хоча б одне поле має бути вказано" });
                return;
            }

            var patched = existing with { IsCompleted = isCompleted.Value };
            store[id] = patched;
            await WriteJsonAsync(res, 200, patched);
            break;
        }

        case "DELETE":
        {
            store.TryRemove(id, out _);
            res.StatusCode = 204;  // No Content — успішно видалено, тіло відсутнє
            res.Close();
            break;
        }

        default:
            res.Headers.Add("Allow", "GET, PUT, PATCH, DELETE");
            await WriteJsonAsync(res, 405,
                new { error = "Method Not Allowed" });
            break;
    }
}

// ── Допоміжний метод: серіалізація та відправлення JSON ──────────────────────
async Task WriteJsonAsync<T>(HttpListenerResponse res, int statusCode, T data)
{
    byte[] body = JsonSerializer.SerializeToUtf8Bytes(data, jsonOptions);

    res.StatusCode   = statusCode;
    res.ContentType  = "application/json; charset=utf-8";
    res.ContentLength64 = body.Length;

    // Стандартні заголовки безпеки та відсутності кешу для API
    res.Headers[HttpResponseHeader.CacheControl] = "no-store";
    res.Headers.Add("X-Content-Type-Options", "nosniff");

    await res.OutputStream.WriteAsync(body);
}