{
  "OpenIdConnect": {
    "Authority": "http://localhost:8080/realms/myrealm",
    "ClientId": "myapp",
    "ClientSecret": "your-client-secret-here"
  }
}

builder.Services
    .AddAuthentication(options =>
    {
        // За замовчуванням — cookie аутентифікація
        options.DefaultScheme          = CookieAuthenticationDefaults.AuthenticationScheme;
        // Для аутентифікації — OIDC
        options.DefaultChallengeScheme = OpenIdConnectDefaults.AuthenticationScheme;
    })
    .AddCookie(options =>
    {
        options.LoginPath  = "/Account/Login";   // Сторінка при відсутній аутентифікації
        options.LogoutPath = "/Account/Logout";

        // Час тривалості cookie-сесії
        options.ExpireTimeSpan    = TimeSpan.FromHours(8);
        options.SlidingExpiration = true; // Продовжується при активності

        // Захист cookie від клієнтського JS та передачі по HTTP
        options.Cookie.HttpOnly  = true;
        options.Cookie.SecurePolicy = CookieSecurePolicy.Always;
        options.Cookie.SameSite = SameSiteMode.Lax; // Lax дозволяє POST-redirect
    })
    .AddOpenIdConnect(options =>
    {
        var oidcConfig = builder.Configuration.GetSection("OpenIdConnect");

        // Authority — Keycloak Authority URL
        // Middleware відкриє /.well-known/openid-configuration і знайде всі ендпоінти
        options.Authority = oidcConfig["Authority"];
        options.ClientId  = oidcConfig["ClientId"];

        // ClientSecret — зберігайте в SECRET MANAGER або env variables!
        // Ніколи не хардкодьте у коді чи публічних налаштуваннях
        options.ClientSecret = oidcConfig["ClientSecret"];

        // response_type=code — Authorization Code Flow
        options.ResponseType = OpenIdConnectResponseType.Code;

        // Scopes: openid (обов'язково для OIDC), profile, email
        options.Scope.Add("openid");
        options.Scope.Add("profile");
        options.Scope.Add("email");
        options.Scope.Add("roles"); // Кастомний scope для ролей у Keycloak

        // Зберігати токени у cookie (access_token, refresh_token, id_token)
        // Потрібно для подальших API-запитів від імені користувача
        options.SaveTokens = true;

        // При логауті — відправити запит на Keycloak для завершення SSO-сесії
        options.SignedOutCallbackPath = "/signout-callback-oidc";

        // Отримати claims профілю через UserInfo endpoint (при потребі)
        options.GetClaimsFromUserInfoEndpoint = true;

        // Маппінг claims: Keycloak може використовувати нестандартні назви
        options.ClaimActions.MapJsonKey(ClaimTypes.Role, "role");
        options.ClaimActions.MapJsonKey("groups", "groups");

        options.Events = new OpenIdConnectEvents
        {
            // Спрацьовує після отримання токенів — якнайкраще місце для логування
            OnTokenValidated = ctx =>
            {
                var userId = ctx.Principal?.FindFirst(ClaimTypes.NameIdentifier)?.Value;
                var email  = ctx.Principal?.FindFirst(ClaimTypes.Email)?.Value;

                // Можна тут збагатити claims, завантажити додаткові дані з БД
                ctx.HttpContext.RequestServices
                    .GetRequiredService<ILogger<Program>>()
                    .LogInformation(
                        "User authenticated via Keycloak: {UserId} ({Email})",
                        userId, email);

                return Task.CompletedTask;
            },

            // Обробка помилок аутентифікації
            OnAuthenticationFailed = ctx =>
            {
                ctx.Response.Redirect("/error?message=" +
                    Uri.EscapeDataString(ctx.Exception.Message));
                ctx.HandleResponse();
                return Task.CompletedTask;
            },

            // Додаємо PKCE автоматично — але можна перевірити, що параметр є
            OnRedirectToIdentityProvider = ctx =>
            {
                // Можна модифікувати redirect URL, наприклад, примусити конкретний IDP:
                // ctx.ProtocolMessage.SetParameter("kc_idp_hint", "google");
                return Task.CompletedTask;
            }
        };
    });

app.UseAuthentication();
app.UseAuthorization();

// Метод 1: захист конкретного ендпоінту
app.MapGet("/dashboard",
    [Authorize] (HttpContext ctx) =>
    {
        // User.Identity.IsAuthenticated завжди true тут
        var name = ctx.User.FindFirst("name")?.Value;
        return Results.Ok(new { Message = $"Привіт, {name}!" });
    });

// Метод 2: вимагати конкретну роль Keycloak
app.MapGet("/admin",
    [Authorize(Roles = "admin")] () => Results.Ok("Адмін-панель"))
    .WithOpenApi();

// Метод 3: вимагати авторизацію для всього додатку
// (виключити лише публічні сторінки)
app.MapRazorPages().RequireAuthorization();
app.MapGet("/public", () => Results.Ok()).AllowAnonymous();

app.MapGet("/call-api",
    async (HttpContext ctx) =>
{
    // Отримуємо збережений access_token
    var accessToken = await ctx.GetTokenAsync("access_token");

    // Використовуємо для API-запитів
    var httpClient = ctx.RequestServices
        .GetRequiredService<IHttpClientFactory>()
        .CreateClient();

    httpClient.DefaultRequestHeaders.Authorization =
        new AuthenticationHeaderValue("Bearer", accessToken);

    var response = await httpClient.GetAsync("https://api.example.com/data");
    // ...
}).RequireAuthorization();

builder.Services
    .AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        // Authority — Keycloak URL. Middleware завантажить публічні ключі
        // з {Authority}/.well-known/openid-configuration → jwks_uri
        options.Authority = "http://localhost:8080/realms/myrealm";

        // Audience — назва клієнта або resource у Keycloak
        // JWT повинен мати "aud": "myapi" або містити у списку
        options.Audience = "myapi";

        // Для dev з HTTP Keycloak (без HTTPS)
        options.RequireHttpsMetadata = false; // true для production!

        options.TokenValidationParameters = new TokenValidationParameters
        {
            // Яку authority вважаємо довіреною — тільки наш Keycloak
            ValidIssuer      = "http://localhost:8080/realms/myrealm",
            ValidateIssuer   = true,

            // Аудиторія — токен призначений для нашого API
            ValidAudience    = "myapi",
            ValidateAudience = true,

            // Перевіряємо термін дії токена
            ValidateLifetime = true,

            // Мінімальний час між exp та now (компенсація clock skew між серверами)
            ClockSkew = TimeSpan.FromSeconds(30),

            // Відображення claim names зі стандартних на Microsoft-стиль
            // Наприклад: "sub" → ClaimTypes.NameIdentifier
            NameClaimType = "preferred_username",
            RoleClaimType = "realm_access.roles" // Keycloak-специфічно
        };

        options.Events = new JwtBearerEvents
        {
            // Детальне логування помилок валідації (тільки для dev!)
            OnAuthenticationFailed = ctx =>
            {
                var logger = ctx.HttpContext.RequestServices
                    .GetRequiredService<ILogger<Program>>();

                logger.LogWarning(
                    "JWT validation failed: {Error}",
                    ctx.Exception.Message);

                return Task.CompletedTask;
            },

            // Спрацьовує після успішної валідації
            OnTokenValidated = ctx =>
            {
                // Можна збагатити claims з БД
                return Task.CompletedTask;
            }
        };
    });

using Microsoft.AspNetCore.Authentication;
using System.Security.Claims;
using System.Text.Json;

public class KeycloakRolesClaimsTransformer : IClaimsTransformation
{
    private readonly string _clientId;

    public KeycloakRolesClaimsTransformer(IConfiguration config)
        => _clientId = config["OpenIdConnect:ClientId"] ?? "myapi";

    public Task<ClaimsPrincipal> TransformAsync(ClaimsPrincipal principal)
    {
        // Якщо claims вже трансформовані — пропускаємо
        if (principal.HasClaim(c => c.Type == ClaimTypes.Role))
            return Task.FromResult(principal);

        var identity = (ClaimsIdentity)principal.Identity!;

        // 1. Realm-level ролі (глобальні для всього realm)
        var realmAccessClaim = principal.FindFirst("realm_access");
        if (realmAccessClaim is not null)
        {
            using var doc = JsonDocument.Parse(realmAccessClaim.Value);
            if (doc.RootElement.TryGetProperty("roles", out var roles))
            {
                foreach (var role in roles.EnumerateArray())
                {
                    identity.AddClaim(new Claim(
                        ClaimTypes.Role, role.GetString()!));
                }
            }
        }

        // 2. Client-level ролі (специфічні для вашого клієнта)
        var resourceAccessClaim = principal.FindFirst("resource_access");
        if (resourceAccessClaim is not null)
        {
            using var doc = JsonDocument.Parse(resourceAccessClaim.Value);
            if (doc.RootElement.TryGetProperty(_clientId, out var clientRoles) &&
                clientRoles.TryGetProperty("roles", out var roles))
            {
                foreach (var role in roles.EnumerateArray())
                {
                    identity.AddClaim(new Claim(
                        "client_role", role.GetString()!));
                }
            }
        }

        return Task.FromResult(principal);
    }
}

builder.Services.AddSingleton<
    IClaimsTransformation, KeycloakRolesClaimsTransformer>();

app.MapGet("/logout",
    async (HttpContext ctx, SignInManager<AppUser>? signInManager) =>
{
    // 1. Завершуємо локальну cookie-сесію
    await ctx.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);

    // 2. Redirect на Keycloak End Session Endpoint
    // Keycloak завершить SSO-сесію та redirect назад на наш застосунок
    return Results.SignOut(
        new AuthenticationProperties
        {
            RedirectUri = "/"  // Куди redirect після виходу
        },
        [OpenIdConnectDefaults.AuthenticationScheme]);
});

public class KeycloakTokenService
{
    private readonly HttpClient    _httpClient;
    private readonly IConfiguration _config;
    private readonly ILogger<KeycloakTokenService> _logger;

    // Кешований токен та час його закінчення
    private string?  _cachedToken;
    private DateTime _tokenExpiry = DateTime.MinValue;
    private readonly SemaphoreSlim _lock = new(1, 1);

    public KeycloakTokenService(
        HttpClient httpClient,
        IConfiguration config,
        ILogger<KeycloakTokenService> logger)
    {
        _httpClient = httpClient;
        _config     = config;
        _logger     = logger;
    }

    /// <summary>
    /// Повертає актуальний access token, поновлюючи його при потребі.
    /// Thread-safe завдяки SemaphoreSlim.
    /// </summary>
    public async Task<string> GetAccessTokenAsync(
        CancellationToken ct = default)
    {
        // Перевіряємо кеш (з запасом 30 секунд)
        if (_cachedToken is not null &&
            DateTime.UtcNow < _tokenExpiry - TimeSpan.FromSeconds(30))
        {
            return _cachedToken;
        }

        // Блокуємо одночасні запити (тільки один може оновлювати токен)
        await _lock.WaitAsync(ct);
        try
        {
            // Double-check після отримання lock
            if (_cachedToken is not null &&
                DateTime.UtcNow < _tokenExpiry - TimeSpan.FromSeconds(30))
                return _cachedToken;

            _logger.LogDebug("Refreshing M2M access token from Keycloak...");
            await RefreshTokenAsync(ct);
            return _cachedToken!;
        }
        finally
        {
            _lock.Release();
        }
    }

    private async Task RefreshTokenAsync(CancellationToken ct)
    {
        var authority    = _config["OpenIdConnect:Authority"];
        var clientId     = _config["OpenIdConnect:ClientId"];
        var clientSecret = _config["OpenIdConnect:ClientSecret"];

        var formData = new Dictionary<string, string>
        {
            ["grant_type"]    = "client_credentials",
            ["client_id"]     = clientId!,
            ["client_secret"] = clientSecret!,
            ["scope"]         = "openid payment-api" // Запитуємо потрібні scopes
        };

        var response = await _httpClient.PostAsync(
            $"{authority}/protocol/openid-connect/token",
            new FormUrlEncodedContent(formData),
            ct);

        response.EnsureSuccessStatusCode();

        var content = await response.Content.ReadFromJsonAsync<TokenResponse>(ct);

        _cachedToken = content!.AccessToken;
        // Зберігаємо термін дії з невеликим запасом
        _tokenExpiry = DateTime.UtcNow.AddSeconds(content.ExpiresIn - 10);

        _logger.LogDebug(
            "M2M token refreshed, expires in {Seconds}s",
            content.ExpiresIn);
    }

    private record TokenResponse(
        [property: JsonPropertyName("access_token")] string AccessToken,
        [property: JsonPropertyName("expires_in")]   int    ExpiresIn);
}

public class OrderService
{
    private readonly HttpClient            _httpClient;
    private readonly KeycloakTokenService  _tokenService;

    public OrderService(
        HttpClient httpClient,
        KeycloakTokenService tokenService)
    {
        _httpClient   = httpClient;
        _tokenService = tokenService;
    }

    public async Task<PaymentResult> ProcessPaymentAsync(
        PaymentRequest request,
        CancellationToken ct = default)
    {
        // Автоматично отримуємо актуальний токен (з кешу або оновлення)
        var token = await _tokenService.GetAccessTokenAsync(ct);

        using var requestMessage = new HttpRequestMessage(
            HttpMethod.Post, "https://payment-service/api/payments");

        requestMessage.Headers.Authorization =
            new AuthenticationHeaderValue("Bearer", token);

        requestMessage.Content = JsonContent.Create(request);

        var response = await _httpClient.SendAsync(requestMessage, ct);
        return await response.Content.ReadFromJsonAsync<PaymentResult>(ct)
               ?? throw new InvalidOperationException("Empty response");
    }
}

.AddOpenIdConnect(options =>
{
    // ... базова конфігурація ...

    // Увімкнути backchannel logout
    options.BackchannelTimeout           = TimeSpan.FromSeconds(30);
    options.MaxAge                       = TimeSpan.FromDays(1);

    options.Events = new OpenIdConnectEvents
    {
        // Обробка logout-токену від Keycloak
        OnSignedOutCallbackRedirect = ctx =>
        {
            // Тут можна виконати cleanup (видалити дані сесії з Redis тощо)
            ctx.Response.Redirect("/logged-out");
            ctx.HandleResponse();
            return Task.CompletedTask;
        }
    };
});

options.TokenValidationParameters = new TokenValidationParameters
{
    ValidateAudience = true,      // Завжди true!
    ValidAudience    = "myapi",   // Точна назва вашого клієнта/ресурсу
    // АБО список допустимих:
    // ValidAudiences = new[] { "myapi", "myapi-v2" }
};