builder.Services.AddResponseCaching(options =>
{
    // Максимальний розмір тіла відповіді що кешується (64 МБ за замовчуванням)
    options.MaximumBodySize = 64 * 1024 * 1024; // 64 MB

    // Як трактувати URL при пошуку в кеші
    options.UseCaseSensitivePaths = false; // /Products == /products

    // Загальний розмір кешу (100 МБ за замовчуванням)
    options.SizeLimit = 100 * 1024 * 1024;
});

var app = builder.Build();

// ВАЖЛИВО: UseResponseCaching ПЕРЕД маппінгом ендпоінтів
app.UseResponseCaching();

// Варіант 1: Через WithMetadata (низькорівнево)
app.MapGet("/products", async (ProductService svc) =>
    Results.Ok(await svc.GetAllAsync()))
    .WithMetadata(new ResponseCacheAttribute
    {
        Duration = 60,           // Кешувати 60 секунд
        Location = ResponseCacheLocation.Any, // public (браузер + CDN)
        VaryByQueryKeys = ["page", "pageSize"] // Різний кеш для різних параметрів
    });

// Варіант 2: Додати заголовки вручну (більш гнучко)
app.MapGet("/products/featured", async (HttpContext ctx, ProductService svc) =>
{
    // Встановлюємо Cache-Control заголовок вручну
    ctx.Response.GetTypedHeaders().CacheControl = new CacheControlHeaderValue
    {
        Public = true,
        MaxAge = TimeSpan.FromHours(1),
        SharedMaxAge = TimeSpan.FromHours(24) // s-maxage для CDN
    };

    var products = await svc.GetFeaturedAsync();
    return Results.Ok(products);
});

using Microsoft.AspNetCore.Mvc;
using Microsoft.Net.Http.Headers;

public static class ResponseCacheExtensions
{
    // Публічний кеш — для CDN і браузера
    public static RouteHandlerBuilder CachePublic(
        this RouteHandlerBuilder builder,
        int browserSeconds = 300,
        int cdnSeconds = 3600)
    {
        return builder.WithMetadata(new ResponseCacheAttribute
        {
            Duration = cdnSeconds,
            Location = ResponseCacheLocation.Any,
            VaryByHeader = "Accept-Encoding"
        });
    }

    // Приватний кеш — тільки браузер
    public static RouteHandlerBuilder CachePrivate(
        this RouteHandlerBuilder builder,
        int seconds = 60)
    {
        return builder.WithMetadata(new ResponseCacheAttribute
        {
            Duration = seconds,
            Location = ResponseCacheLocation.Client
        });
    }

    // Без кешу — для мутуючих ендпоінтів
    public static RouteHandlerBuilder NoCache(
        this RouteHandlerBuilder builder)
    {
        return builder.WithMetadata(new ResponseCacheAttribute
        {
            NoStore = true
        });
    }
}

app.MapGet("/products", GetAll).CachePublic(browserSeconds: 60, cdnSeconds: 3600);
app.MapGet("/profile", GetProfile).CachePrivate(seconds: 60);
app.MapPost("/products", Create).NoCache();
app.MapPut("/products/{id}", Update).NoCache();

app.MapGet("/products/{id:int}", async (int id, HttpContext ctx, ProductService svc) =>
{
    var product = await svc.GetByIdAsync(id);
    if (product is null) return Results.NotFound();

    // ETag на основі останньої зміни (або хешу)
    var etag = $"\"{product.UpdatedAt.Ticks}\"";
    var lastModified = product.UpdatedAt;

    // Перевіряємо умовні заголовки ПЕРЕД формуванням відповіді
    if (ctx.Request.Headers.TryGetValue("If-None-Match", out var ifNoneMatch)
        && ifNoneMatch.ToString() == etag)
    {
        // Клієнт має актуальну версію — повертаємо 304 без тіла
        return Results.StatusCode(StatusCodes.Status304NotModified);
    }

    if (ctx.Request.Headers.TryGetValue("If-Modified-Since", out var ifModifiedSince)
        && DateTimeOffset.TryParse(ifModifiedSince, out var ifModifiedDate)
        && lastModified <= ifModifiedDate)
    {
        return Results.StatusCode(StatusCodes.Status304NotModified);
    }

    // Встановлюємо Cache-Control заголовки
    ctx.Response.Headers[HeaderNames.CacheControl] =
        "public, max-age=300, s-maxage=3600, must-revalidate";
    ctx.Response.Headers[HeaderNames.ETag] = etag;
    ctx.Response.Headers[HeaderNames.LastModified] =
        lastModified.ToString("R"); // RFC 1123 format

    return Results.Ok(product);
});

public class ETagMiddleware
{
    private readonly RequestDelegate _next;

    public ETagMiddleware(RequestDelegate next) => _next = next;

    public async Task InvokeAsync(HttpContext ctx)
    {
        // Тільки для GET/HEAD запитів
        if (ctx.Request.Method is not (HttpMethods.Get or HttpMethods.Head))
        {
            await _next(ctx);
            return;
        }

        // Буферуємо відповідь для обчислення ETag
        var originalBody = ctx.Response.Body;
        using var buffer = new MemoryStream();
        ctx.Response.Body = buffer;

        await _next(ctx);

        // Обчислюємо ETag з тіла відповіді
        buffer.Seek(0, SeekOrigin.Begin);
        var content = await new StreamReader(buffer).ReadToEndAsync();
        buffer.Seek(0, SeekOrigin.Begin);

        if (ctx.Response.StatusCode == 200)
        {
            // MD5 або SHA1 хеш вмісту
            var hash = Convert.ToHexString(
                System.Security.Cryptography.MD5.HashData(
                    System.Text.Encoding.UTF8.GetBytes(content)));

            var etag = $"\"{hash}\"";
            ctx.Response.Headers[HeaderNames.ETag] = etag;

            // Перевіряємо If-None-Match
            if (ctx.Request.Headers.TryGetValue(HeaderNames.IfNoneMatch, out var ifNoneMatch)
                && ifNoneMatch.ToString() == etag)
            {
                ctx.Response.StatusCode = 304;
                ctx.Response.Headers.ContentLength = 0;
                ctx.Response.Body = originalBody;
                return; // Не пишемо тіло
            }
        }

        // Копіюємо тіло у оригінальний stream
        await buffer.CopyToAsync(originalBody);
        ctx.Response.Body = originalBody;
    }
}

// Vary по мові — для локалізованих API
ctx.Response.Headers[HeaderNames.Vary] = "Accept-Language";

// Vary по стисненню — обов'язково якщо є gzip/br
ctx.Response.Headers[HeaderNames.Vary] = "Accept-Encoding";

// Vary по кількох заголовках
ctx.Response.Headers[HeaderNames.Vary] = "Accept-Language, Accept-Encoding";

// Vary: * — унікально для КОЖНОГО запиту (фактично вимикає CDN-кешування)
ctx.Response.Headers[HeaderNames.Vary] = "*"; // Не робіть так без причини!

app.UseStaticFiles(new StaticFileOptions
{
    OnPrepareResponse = ctx =>
    {
        // Для файлів з хешем у назві (main.a3f9bc.js) — aggressively кешуємо
        if (ctx.File.Name.Contains('.', StringSplitOptions.RemoveEmptyEntries))
        {
            ctx.Context.Response.Headers[HeaderNames.CacheControl] =
                "public, max-age=31536000, immutable";
        }
    }
});

public class CloudflareCachePurge
{
    private readonly HttpClient _http;
    private readonly string _zoneId;
    private readonly string _apiToken;

    public CloudflareCachePurge(HttpClient http, IConfiguration config)
    {
        _http = http;
        _zoneId = config["Cloudflare:ZoneId"]!;
        _apiToken = config["Cloudflare:ApiToken"]!;
    }

    // Видаляємо конкретні URL з CDN кешу після оновлення даних
    public async Task PurgeUrlsAsync(IEnumerable<string> urls)
    {
        var response = await _http.PostAsJsonAsync(
            $"https://api.cloudflare.com/client/v4/zones/{_zoneId}/purge_cache",
            new { files = urls.ToArray() },
            headers: request => request.Headers.Add("Authorization", $"Bearer {_apiToken}"));

        response.EnsureSuccessStatusCode();
    }

    // Очистити весь кеш зони (обережно!)
    public async Task PurgeEverythingAsync()
    {
        await _http.PostAsJsonAsync(
            $"https://api.cloudflare.com/client/v4/zones/{_zoneId}/purge_cache",
            new { purge_everything = true });
    }
}

public async Task UpdateAsync(int id, UpdateProductRequest req)
{
    // 1. Оновлюємо БД
    var product = await _db.Products.FindAsync(id);
    product!.Name = req.Name;
    await _db.SaveChangesAsync();

    // 2. Інвалідуємо CDN кеш для змінених URL
    await _cfCache.PurgeUrlsAsync([
        $"https://api.myshop.com/products",
        $"https://api.myshop.com/products/{id}"
    ]);
}