var builder = WebApplication.CreateBuilder(args);

builder.Services.AddDbContext<AppDbContext>(opt =>
    opt.UseSqlite("Data Source=app.db"));

builder.Services
    .AddAuthentication(options =>
    {
        options.DefaultScheme = "Cookies";
        options.DefaultChallengeScheme = "Google";
    })
    .AddCookie("Cookies")
    .AddGoogle("Google", options =>
    {
        options.ClientId = builder.Configuration[
            "Google:ClientId"]!;
        options.ClientSecret = builder.Configuration[
            "Google:ClientSecret"]!;

        // Додаткові scopes (за замовчуванням:
        // openid, profile, email)
        options.Scope.Add("email");
        options.Scope.Add("profile");

        // Mapping claims
        options.ClaimActions.MapJsonKey(
            "picture", "picture");
    });

builder.Services.AddAuthorization();

// Ініціювати логін через Google
app.MapGet("/auth/google-login", () =>
    Results.Challenge(
        new AuthenticationProperties
        {
            RedirectUri = "/auth/google-callback"
        },
        ["Google"]))
    .AllowAnonymous();

// Callback — після Google redirect
app.MapGet("/auth/google-callback",
    async (HttpContext ctx) =>
{
    // Claims від Google вже заповнені
    // через Cookie middleware
    var user = ctx.User;

    var email = user.FindFirst(
        ClaimTypes.Email)?.Value;
    var name = user.FindFirst(
        ClaimTypes.Name)?.Value;
    var picture = user.FindFirst("picture")?.Value;
    var googleId = user.FindFirst(
        ClaimTypes.NameIdentifier)?.Value;

    return Results.Ok(new
    {
        message = "Logged in via Google!",
        email,
        name,
        picture,
        googleId
    });
}).RequireAuthorization();

builder.Services
    .AddAuthentication(options =>
    {
        options.DefaultScheme = "Cookies";
    })
    .AddCookie("Cookies")
    .AddGoogle("Google", options =>
    {
        // ... конфігурація Google
    })
    .AddGitHub("GitHub", options =>
    {
        options.ClientId = builder.Configuration[
            "GitHub:ClientId"]!;
        options.ClientSecret = builder.Configuration[
            "GitHub:ClientSecret"]!;
        options.Scope.Add("user:email");
    });

app.MapGet("/auth/github-login", () =>
    Results.Challenge(
        new AuthenticationProperties
        {
            RedirectUri = "/auth/callback"
        },
        ["GitHub"]))
    .AllowAnonymous();

app.MapGet("/auth/callback",
    async (HttpContext ctx,
           UserManager<AppUser> userManager,
           SignInManager<AppUser> signInManager) =>
{
    // 1. Отримуємо дані від зовнішнього провайдера
    var info = await signInManager
        .GetExternalLoginInfoAsync();

    if (info is null)
        return Results.Json(
            new { error = "External login failed" },
            statusCode: 401);

    var email = info.Principal.FindFirst(
        ClaimTypes.Email)?.Value;
    var name = info.Principal.FindFirst(
        ClaimTypes.Name)?.Value;

    // 2. Шукаємо існуючого користувача
    var user = await userManager
        .FindByEmailAsync(email!);

    if (user is null)
    {
        // 3a. Створюємо нового користувача
        user = new AppUser
        {
            UserName = email,
            Email = email,
            FullName = name ?? "Unknown",
            EmailConfirmed = true // Google вже підтвердив
        };

        var createResult = await userManager
            .CreateAsync(user);

        if (!createResult.Succeeded)
            return Results.Json(
                new { error = "User creation failed" },
                statusCode: 500);

        await userManager
            .AddToRoleAsync(user, "User");
    }

    // 4. Зв'язуємо зовнішній логін з користувачем
    //    (якщо ще не зв'язаний)
    var logins = await userManager
        .GetLoginsAsync(user);

    if (!logins.Any(l =>
            l.LoginProvider == info.LoginProvider))
    {
        await userManager
            .AddLoginAsync(user, info);
    }

    // 5. Генеруємо JWT (або cookie)
    var roles = await userManager
        .GetRolesAsync(user);

    var token = tokenService.GenerateAccessToken(
        user.Id, user.FullName,
        user.Email!, roles);

    return Results.Ok(new
    {
        access_token = token,
        is_new_user = logins.Count == 0
    });
}).AllowAnonymous();

builder.Services
    .AddTransient<IClaimsTransformation,
        AppClaimsTransformation>();

public class AppClaimsTransformation
    : IClaimsTransformation
{
    private readonly UserManager<AppUser> _userManager;

    public AppClaimsTransformation(
        UserManager<AppUser> userManager)
    {
        _userManager = userManager;
    }

    public async Task<ClaimsPrincipal> TransformAsync(
        ClaimsPrincipal principal)
    {
        var email = principal.FindFirst(
            ClaimTypes.Email)?.Value;

        if (email is null)
            return principal;

        var user = await _userManager
            .FindByEmailAsync(email);

        if (user is null)
            return principal;

        // Додаємо кастомні claims з нашої БД
        var identity = principal.Identity
            as ClaimsIdentity;

        var roles = await _userManager
            .GetRolesAsync(user);

        foreach (var role in roles)
        {
            identity?.AddClaim(
                new Claim(ClaimTypes.Role, role));
        }

        identity?.AddClaim(
            new Claim("user_id", user.Id));
        identity?.AddClaim(
            new Claim("full_name", user.FullName));

        return principal;
    }
}