// Будь-який аутентифікований користувач
app.MapGet("/orders", (ClaimsPrincipal user) =>
    Results.Ok($"Orders for {user.Identity?.Name}"))
    .RequireAuthorization();

// Тільки Admin
app.MapDelete("/products/{id}", (int id) =>
    Results.NoContent())
    .RequireAuthorization(policy =>
        policy.RequireRole("Admin"));

// Admin АБО Editor (будь-яка з ролей)
app.MapPut("/articles/{id}", (int id) =>
    Results.Ok("Updated"))
    .RequireAuthorization(policy =>
        policy.RequireRole("Admin", "Editor"));

// Всі ендпоінти адмін-панелі — тільки Admin
var admin = app.MapGroup("/admin")
    .RequireAuthorization(policy =>
        policy.RequireRole("Admin"));

admin.MapGet("/users", () => "List users");
admin.MapDelete("/users/{id}", (int id) =>
    Results.NoContent());
admin.MapGet("/stats", () => "Statistics");
// Все захищено роллю Admin ✅

app.MapGet("/orders/{id}", (int id,
    ClaimsPrincipal user) =>
{
    var order = GetOrder(id);

    // Admin бачить усі деталі
    if (user.IsInRole("Admin"))
        return Results.Ok(new
        {
            order.Id, order.Items,
            order.InternalNotes  // Тільки для адміна
        });

    // Звичайний user — без internal notes
    return Results.Ok(new
    {
        order.Id, order.Items
    });
}).RequireAuthorization();

builder.Services.AddAuthorizationBuilder()
    // Політика 1: потрібна певна роль
    .AddPolicy("AdminOnly", policy =>
        policy.RequireRole("Admin"))

    // Політика 2: потрібен конкретний claim
    .AddPolicy("VerifiedEmail", policy =>
        policy.RequireClaim("email_verified", "true"))

    // Політика 3: комбінація умов
    .AddPolicy("PremiumUser", policy =>
        policy
            .RequireAuthenticatedUser()
            .RequireClaim("subscription", "premium")
            .RequireRole("User"))

    // Політика 4: мінімальний вік
    .AddPolicy("AdultOnly", policy =>
        policy.RequireAssertion(context =>
        {
            var ageClaim = context.User
                .FindFirst("age")?.Value;
            return ageClaim is not null
                && int.Parse(ageClaim) >= 18;
        }));

app.MapDelete("/products/{id}", (int id) =>
    Results.NoContent())
    .RequireAuthorization("AdminOnly");

app.MapPost("/reviews", (Review review) =>
    Results.Created($"/reviews/1", review))
    .RequireAuthorization("VerifiedEmail");

app.MapGet("/premium/content", () =>
    Results.Ok("Exclusive content"))
    .RequireAuthorization("PremiumUser");

app.MapPost("/casino/bet", (BetRequest bet) =>
    Results.Ok(bet))
    .RequireAuthorization("AdultOnly");

using Microsoft.AspNetCore.Authorization;

public class MinAgeRequirement
    : IAuthorizationRequirement
{
    public int MinAge { get; }

    public MinAgeRequirement(int minAge)
    {
        MinAge = minAge;
    }
}

using Microsoft.AspNetCore.Authorization;

public class MinAgeHandler
    : AuthorizationHandler<MinAgeRequirement>
{
    protected override Task HandleRequirementAsync(
        AuthorizationHandlerContext context,
        MinAgeRequirement requirement)
    {
        var ageClaim = context.User
            .FindFirst("date_of_birth")?.Value;

        if (ageClaim is null)
        {
            // Claim відсутній — не можемо перевірити
            // Не викликаємо Fail() — дозволяємо
            // іншим handlers спробувати
            return Task.CompletedTask;
        }

        var dateOfBirth = DateOnly.Parse(ageClaim);
        var age = CalculateAge(dateOfBirth);

        if (age >= requirement.MinAge)
        {
            context.Succeed(requirement);  // ✅
        }

        return Task.CompletedTask;
    }

    private static int CalculateAge(DateOnly dob)
    {
        var today = DateOnly.FromDateTime(
            DateTime.UtcNow);
        var age = today.Year - dob.Year;
        if (dob > today.AddYears(-age))
            age--;
        return age;
    }
}

builder.Services
    .AddSingleton<IAuthorizationHandler,
        MinAgeHandler>();

builder.Services.AddAuthorizationBuilder()
    .AddPolicy("Adult", policy =>
        policy.Requirements.Add(
            new MinAgeRequirement(18)))
    .AddPolicy("SeniorDiscount", policy =>
        policy.Requirements.Add(
            new MinAgeRequirement(60)));

public class ActiveSubscriptionRequirement
    : IAuthorizationRequirement
{
    public string RequiredPlan { get; }

    public ActiveSubscriptionRequirement(
        string requiredPlan)
    {
        RequiredPlan = requiredPlan;
    }
}

public class SubscriptionHandler
    : AuthorizationHandler<
        ActiveSubscriptionRequirement>
{
    // DI: ін'єкція сервісу підписок
    private readonly ISubscriptionService _subs;

    public SubscriptionHandler(
        ISubscriptionService subs)
    {
        _subs = subs;
    }

    protected override async Task
        HandleRequirementAsync(
            AuthorizationHandlerContext context,
            ActiveSubscriptionRequirement requirement)
    {
        var userId = context.User
            .FindFirst("sub")?.Value;

        if (userId is null)
            return;

        // Запит до БД через DI-сервіс
        var subscription = await _subs
            .GetActiveSubscription(
                int.Parse(userId));

        if (subscription?.Plan ==
                requirement.RequiredPlan
            && subscription.ExpiresAt >
                DateTime.UtcNow)
        {
            context.Succeed(requirement);
        }
    }
}

public class ResourceOwnerRequirement
    : IAuthorizationRequirement
{
}

public class PostOwnerHandler
    : AuthorizationHandler<
        ResourceOwnerRequirement, Post>
{
    protected override Task HandleRequirementAsync(
        AuthorizationHandlerContext context,
        ResourceOwnerRequirement requirement,
        Post resource)  // ← конкретний ресурс!
    {
        var userId = context.User
            .FindFirst("sub")?.Value;

        // Перевіряємо, чи автор поста = поточний user
        if (userId is not null
            && resource.AuthorId.ToString() == userId)
        {
            context.Succeed(requirement);
        }

        return Task.CompletedTask;
    }
}

app.MapPut("/posts/{id}",
    async (int id,
           UpdatePostRequest req,
           IAuthorizationService authService,
           ClaimsPrincipal user,
           PostRepository repo) =>
{
    // 1. Отримуємо ресурс
    var post = await repo.GetById(id);
    if (post is null)
        return Results.NotFound();

    // 2. Перевіряємо авторизацію НА ресурс
    var authResult = await authService
        .AuthorizeAsync(
            user,
            post,  // ← конкретний об'єкт!
            new ResourceOwnerRequirement());

    if (!authResult.Succeeded)
        return Results.Forbid();  // 403

    // 3. Оновлюємо
    post.Title = req.Title;
    post.Content = req.Content;
    await repo.Update(post);

    return Results.Ok(post);
}).RequireAuthorization();

builder.Services.AddAuthorizationBuilder()
    .SetDefaultPolicy(new AuthorizationPolicyBuilder()
        .RequireAuthenticatedUser()
        .RequireClaim("email_verified", "true")
        .Build());

builder.Services.AddAuthorizationBuilder()
    .SetFallbackPolicy(new AuthorizationPolicyBuilder()
        .RequireAuthenticatedUser()
        .Build());

// ✅ Публічний (явний виняток)
app.MapGet("/", () => "Welcome!")
    .AllowAnonymous();

// 🔒 Захищений (автоматично через Fallback)
app.MapGet("/orders", () => "Orders");

// 🔒 Теж захищений (автоматично)
app.MapGet("/profile", () => "Profile");