var app = builder.Build();

// Инлайновый middleware: видно обе половины
app.Use(async (context, next) =>
{
    var sw = Stopwatch.GetTimestamp();          // ← код ДО: путь внутрь
    await next(context);                        //   передаём управление глубже
    var elapsed = Stopwatch.GetElapsedTime(sw); // ← код ПОСЛЕ: путь наружу
    app.Logger.LogInformation("{Method} {Path} -> {Status} за {Ms} мс",
        context.Request.Method, context.Request.Path,
        context.Response.StatusCode, elapsed.TotalMilliseconds);
});

// Терминальный middleware: next не вызывается, конвейер обрывается
app.Run(async context => await context.Response.WriteAsync("Не найдено"));

// 1. По конвенции: создаётся ОДИН раз (эффективно singleton).
//    Scoped-зависимости внедряйте в Invoke, а не в конструктор!
public sealed class CorrelationIdMiddleware(RequestDelegate next)
{
    private const string Header = "X-Correlation-Id";

    public async Task Invoke(HttpContext context, ILogger<CorrelationIdMiddleware> logger)
    {
        var id = context.Request.Headers[Header].FirstOrDefault() ?? Guid.NewGuid().ToString("n");
        context.Response.Headers[Header] = id;

        using (logger.BeginScope(new Dictionary<string, object> { ["CorrelationId"] = id }))
            await next(context);
    }
}

// 2. Через IMiddleware: создаётся фабрикой на каждый запрос, можно scoped-зависимости
public sealed class AuditMiddleware(IAuditWriter writer) : IMiddleware
{
    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
    {
        await next(context);
        await writer.RecordAsync(context.Request.Path, context.Response.StatusCode,
            context.RequestAborted);
    }
}

app.UseExceptionHandler();          // 1. Внешняя обёртка: видит ошибки всех остальных
app.UseHsts();                      // 2. Заголовок строгой транспортной безопасности
app.UseHttpsRedirection();          // 3.
app.UseStaticFiles();               // 4. Статику отдаём до маршрутизации — дешевле
app.UseRouting();                   // 5. Выбор endpoint (но НЕ его выполнение)
app.UseCors();                      // 6. После routing: политика может быть на endpoint
app.UseRateLimiter();               // 7.
app.UseAuthentication();            // 8. Кто это? Заполняет HttpContext.User
app.UseAuthorization();             // 9. Можно ли ему сюда? Читает атрибуты endpoint
app.UseOutputCache();               // 10.
app.MapControllers();               // 11. Выполнение выбранного endpoint

public sealed class DomainExceptionHandler(IProblemDetailsService problems) : IExceptionHandler
{
    public async ValueTask<bool> TryHandleAsync(HttpContext context, Exception ex,
        CancellationToken ct)
    {
        // Доменные ошибки превращаем в осмысленные статусы, остальное отдаём дальше
        var (status, title) = ex switch
        {
            OrderNotFoundException => (StatusCodes.Status404NotFound, "Заказ не найден"),
            ValidationException    => (StatusCodes.Status400BadRequest, "Некорректные данные"),
            RateLimitedException   => (StatusCodes.Status429TooManyRequests, "Слишком часто"),
            _                      => (0, string.Empty)          // не наш случай
        };

        if (status == 0) return false;   // false = мы не обработали, пусть летит выше

        context.Response.StatusCode = status;
        return await problems.TryWriteAsync(new ProblemDetailsContext
        {
            HttpContext = context,
            ProblemDetails = { Title = title, Status = status }
        });
    }
}

builder.Services.AddProblemDetails();
builder.Services.AddExceptionHandler<DomainExceptionHandler>();

// Группа маршрутов с общими настройками — идиома .NET 7+
var orders = app.MapGroup("/api/orders")
    .RequireAuthorization("orders:read")
    .WithTags("Orders")
    .AddEndpointFilter<ValidationFilter>();

orders.MapGet("/{id:int:min(1)}", async (int id, IOrderService svc, CancellationToken ct)
    => await svc.FindAsync(id, ct) is { } o ? Results.Ok(o) : Results.NotFound());

orders.MapGet("/", async ([AsParameters] OrderQuery query, IOrderService svc,
    CancellationToken ct) => Results.Ok(await svc.SearchAsync(query, ct)));

orders.MapPost("/", async (CreateOrderRequest req, IOrderService svc, CancellationToken ct) =>
{
    var id = await svc.PlaceAsync(req, ct);
    return Results.Created($"/api/orders/{id}", new { id });
}).RequireAuthorization("orders:write");

// 1. Группировка параметров запроса в один тип — вместо шести аргументов
public sealed record OrderQuery(
    [FromQuery] string? Customer,
    [FromQuery] DateOnly? From,
    [FromQuery] int Page = 1,
    [FromQuery] int Size = 20);

// 2. Свой разбор простого типа: работает и в маршруте, и в query
public readonly record struct Sku(string Value)
{
    public static bool TryParse(string? s, IFormatProvider? _, out Sku result)
    {
        result = new Sku(s ?? string.Empty);
        return !string.IsNullOrWhiteSpace(s) && s.Length <= 32;
    }
}

// 3. Полный контроль над связыванием сложного типа
public sealed record PagingHeader(int Limit)
{
    public static ValueTask<PagingHeader?> BindAsync(HttpContext ctx)
    {
        var raw = ctx.Request.Headers["X-Limit"].FirstOrDefault();
        return ValueTask.FromResult<PagingHeader?>(
            new PagingHeader(int.TryParse(raw, out var v) ? Math.Clamp(v, 1, 500) : 50));
    }
}

public sealed class ValidationFilter<T>(IValidator<T> validator) : IEndpointFilter
{
    public async ValueTask<object?> InvokeAsync(EndpointFilterInvocationContext ctx,
        EndpointFilterDelegate next)
    {
        var model = ctx.Arguments.OfType<T>().FirstOrDefault();
        if (model is not null)
        {
            var result = await validator.ValidateAsync(model, ctx.HttpContext.RequestAborted);
            if (!result.IsValid)
                return Results.ValidationProblem(result.ToDictionary());
        }
        return await next(ctx);
    }
}

builder.Services
    .AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.Authority = builder.Configuration["Auth:Authority"];   // издатель токенов
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidAudience = "orders-api",
            ValidateLifetime = true,
            ClockSkew = TimeSpan.FromSeconds(30)   // по умолчанию целых 5 минут
        };
    });

builder.Services.AddAuthorization(options =>
{
    // Политика на основе claim-ов
    options.AddPolicy("orders:write", p => p.RequireClaim("scope", "orders.write"));
    // Политика на основе требования с собственной логикой
    options.AddPolicy("same-tenant", p => p.AddRequirements(new SameTenantRequirement()));
    options.FallbackPolicy = new AuthorizationPolicyBuilder()
        .RequireAuthenticatedUser()
        .Build();   // всё закрыто по умолчанию; открываем через [AllowAnonymous]
});

// CORS: браузерная политика доступа с другого origin
builder.Services.AddCors(o => o.AddPolicy("spa", p => p
    .WithOrigins("https://app.example.com")
    .WithMethods("GET", "POST")
    .AllowCredentials()));            // AllowAnyOrigin + AllowCredentials запрещено спецификацией

// Ограничение частоты запросов (.NET 7+), встроено — без внешних пакетов
builder.Services.AddRateLimiter(o =>
{
    o.AddFixedWindowLimiter("api", opt =>
    {
        opt.PermitLimit = 100;
        opt.Window = TimeSpan.FromMinutes(1);
        opt.QueueLimit = 0;                       // лишнее сразу отбрасываем
    });
    o.RejectionStatusCode = StatusCodes.Status429TooManyRequests;
});

// Кэш ответов на стороне сервера
builder.Services.AddOutputCache(o =>
    o.AddPolicy("short", b => b.Expire(TimeSpan.FromSeconds(30)).SetVaryByQuery("page")));

builder.WebHost.ConfigureKestrel(k =>
{
    k.Limits.MaxRequestBodySize = 10 * 1024 * 1024;              // 10 МБ вместо 30 по умолчанию
    k.Limits.MaxConcurrentConnections = 10_000;
    k.Limits.KeepAliveTimeout = TimeSpan.FromSeconds(120);
    k.Limits.RequestHeadersTimeout = TimeSpan.FromSeconds(30);   // защита от медленных заголовков
    k.Limits.MinRequestBodyDataRate = new MinDataRate(240, TimeSpan.FromSeconds(5));
});

// Таймауты на уровне эндпоинтов (.NET 8)
builder.Services.AddRequestTimeouts(o =>
    o.DefaultPolicy = new RequestTimeoutPolicy { Timeout = TimeSpan.FromSeconds(15) });