builder.Services
    .AddIdentity<AppUser, IdentityRole>(options =>
    {
        // 🔑 Ключова опція: вхід лише з підтвердженим email
        options.SignIn.RequireConfirmedEmail = true;

        // За бажанням — вимагати підтвердженого телефону
        options.SignIn.RequireConfirmedPhoneNumber = false;

        // Токени: термін дії токена підтвердження
        options.Tokens.EmailConfirmationTokenProvider =
            TokenOptions.DefaultEmailProvider; // або "DataProtector"
    })
    .AddEntityFrameworkStores<AppDbContext>()
    .AddDefaultTokenProviders();

builder.Services
    .Configure<DataProtectionTokenProviderOptions>(options =>
    {
        // Токен підтвердження email живе 3 дні
        options.TokenLifespan = TimeSpan.FromDays(3);
    });

app.MapPost("/auth/register",
    async (RegisterRequest req,
           UserManager<AppUser> userManager,
           IEmailSender<AppUser> emailSender,
           LinkGenerator linkGenerator,
           HttpContext ctx) =>
{
    // 1. Створюємо користувача (без підтвердженого email)
    var user = new AppUser
    {
        UserName = req.Email,
        Email    = req.Email,
        FullName = req.FullName
    };

    var result = await userManager.CreateAsync(user, req.Password);

    if (!result.Succeeded)
    {
        return Results.ValidationProblem(
            result.Errors.ToDictionary(
                e => e.Code,
                e => new[] { e.Description }));
    }

    // 2. Генеруємо токен підтвердження
    //    Токен — цe зашифрований blob із userId + email + timestamp
    var token = await userManager
        .GenerateEmailConfirmationTokenAsync(user);

    // 3. Кодуємо токен для URL (він може містити +, /, = тощо)
    var encodedToken = WebEncoders.Base64UrlEncode(
        Encoding.UTF8.GetBytes(token));

    // 4. Будуємо посилання для підтвердження
    var confirmUrl = linkGenerator.GetUriByName(
        ctx, "ConfirmEmail",
        new { userId = user.Id, token = encodedToken })!;

    // 5. Надсилаємо лист
    await emailSender.SendConfirmationLinkAsync(
        user, user.Email!, confirmUrl);

    return Results.Ok(new
    {
        message = "Registration successful! Check your email to confirm.",
        userId  = user.Id
    });
});

app.MapGet("/auth/confirm-email",
    async (string userId, string token,
           UserManager<AppUser> userManager) =>
{
    // 1. Знаходимо користувача
    var user = await userManager.FindByIdAsync(userId);

    if (user is null)
        return Results.NotFound(
            new { error = "User not found." });

    // 2. Декодуємо токен з URL-safe Base64
    string decodedToken;
    try
    {
        decodedToken = Encoding.UTF8.GetString(
            WebEncoders.Base64UrlDecode(token));
    }
    catch
    {
        return Results.BadRequest(
            new { error = "Invalid token format." });
    }

    // 3. Підтверджуємо email
    //    ConfirmEmailAsync перевіряє: токен валідний? не прострочений?
    //    SecurityStamp не змінився? Якщо так — встановлює EmailConfirmed=true
    var result = await userManager
        .ConfirmEmailAsync(user, decodedToken);

    if (!result.Succeeded)
    {
        var errors = result.Errors
            .Select(e => e.Description);
        return Results.BadRequest(new { errors });
    }

    return Results.Ok(new
    {
        message = "Email confirmed successfully! You can now log in."
    });
}).WithName("ConfirmEmail");

using Microsoft.AspNetCore.Identity.UI.Services;

public class SmtpEmailSender : IEmailSender
{
    private readonly IConfiguration _config;
    private readonly ILogger<SmtpEmailSender> _logger;

    public SmtpEmailSender(
        IConfiguration config,
        ILogger<SmtpEmailSender> logger)
    {
        _config = config;
        _logger = logger;
    }

    public async Task SendEmailAsync(
        string email, string subject, string htmlMessage)
    {
        var smtpHost = _config["Email:SmtpHost"]!;
        var smtpPort = int.Parse(_config["Email:SmtpPort"]!);
        var from     = _config["Email:From"]!;
        var password = _config["Email:Password"]!;

        using var client = new SmtpClient(smtpHost, smtpPort)
        {
            Credentials = new NetworkCredential(from, password),
            EnableSsl   = true
        };

        var message = new MailMessage(from, email, subject, htmlMessage)
        {
            IsBodyHtml = true
        };

        try
        {
            await client.SendMailAsync(message);
            _logger.LogInformation(
                "Email sent to {Email}", email);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex,
                "Failed to send email to {Email}", email);
            throw;
        }
    }
}

// Реєструємо власний EmailSender
builder.Services.AddTransient<IEmailSender, SmtpEmailSender>();

app.MapPost("/auth/resend-confirmation",
    async (ResendEmailRequest req,
           UserManager<AppUser> userManager,
           IEmailSender<AppUser> emailSender,
           LinkGenerator linkGenerator,
           HttpContext ctx) =>
{
    // ⚠️ Завжди повертаємо 200, навіть якщо email не знайдено
    // Це запобігає enumeration attack (визначення існуючих акаунтів)
    var user = await userManager.FindByEmailAsync(req.Email);

    if (user is null || user.EmailConfirmed)
    {
        // Не розкриваємо, чи існує акаунт або чи вже підтверджений
        return Results.Ok(new
        {
            message = "If this email exists and is not confirmed, " +
                      "a new link will be sent."
        });
    }

    // Генеруємо НОВИЙ токен
    // Старий токен (якщо він ще дійсний) при цьому перезаписується в БД
    // (або стає недійсним у разі DataProtection — бо timestamp різний)
    var token = await userManager
        .GenerateEmailConfirmationTokenAsync(user);

    var encodedToken = WebEncoders.Base64UrlEncode(
        Encoding.UTF8.GetBytes(token));

    var confirmUrl = linkGenerator.GetUriByName(
        ctx, "ConfirmEmail",
        new { userId = user.Id, token = encodedToken })!;

    await emailSender.SendConfirmationLinkAsync(
        user, user.Email!, confirmUrl);

    return Results.Ok(new
    {
        message = "If this email exists and is not confirmed, " +
                  "a new link will be sent."
    });
});

builder.Services.AddRateLimiter(options =>
{
    options.AddFixedWindowLimiter(
        "email-policy",
        limiter =>
        {
            // Не більше 3 запитів за 15 хвилин з однієї IP
            limiter.PermitLimit   = 3;
            limiter.Window        = TimeSpan.FromMinutes(15);
            limiter.QueueLimit    = 0; // Не чекаємо — одразу 429
        });
});

// Застосовуємо до ендпоінту
app.MapPost("/auth/resend-confirmation", ...)
    .RequireRateLimiting("email-policy");

app.MapPost("/auth/forgot-password",
    async (ForgotPasswordRequest req,
           UserManager<AppUser> userManager,
           IEmailSender<AppUser> emailSender,
           LinkGenerator linkGenerator,
           HttpContext ctx) =>
{
    // ЗАВЖДИ повертаємо однакову відповідь!
    const string responseMsg =
        "If an account with this email exists and is confirmed, " +
        "a password reset link will be sent.";

    var user = await userManager.FindByEmailAsync(req.Email);

    // Перевіряємо дві умови:
    // 1. Чи існує користувач
    // 2. Чи підтверджений email (лише для підтверджених адрес)
    if (user is null || !await userManager.IsEmailConfirmedAsync(user))
        return Results.Ok(new { message = responseMsg });

    // Генеруємо токен скидання пароля
    // Він дійсний протягом TokenLifeSpan (за замовчуванням 1 день)
    var token = await userManager
        .GeneratePasswordResetTokenAsync(user);

    var encodedToken = WebEncoders.Base64UrlEncode(
        Encoding.UTF8.GetBytes(token));

    // Посилання для скидання — зазвичай веде на сторінку фронтенду
    // де користувач вводить новий пароль
    var resetUrl = linkGenerator.GetUriByName(
        ctx, "ResetPasswordPage",
        new { userId = user.Id, token = encodedToken })!;

    await emailSender.SendPasswordResetLinkAsync(
        user, user.Email!, new Uri(resetUrl));

    return Results.Ok(new { message = responseMsg });
});

app.MapPost("/auth/reset-password",
    async (ResetPasswordRequest req,
           UserManager<AppUser> userManager) =>
{
    var user = await userManager.FindByIdAsync(req.UserId);

    if (user is null)
    {
        // Знову — не розкриваємо існування акаунту
        return Results.BadRequest(new
        {
            error = "Invalid reset link. Please request a new one."
        });
    }

    // Декодуємо токен
    string decodedToken;
    try
    {
        decodedToken = Encoding.UTF8.GetString(
            WebEncoders.Base64UrlDecode(req.Token));
    }
    catch
    {
        return Results.BadRequest(new
        {
            error = "Invalid token format."
        });
    }

    // ResetPasswordAsync робить три речі:
    // 1. Перевіряє токен (дійсність та термін)
    // 2. Хешує та зберігає новий пароль
    // 3. ОНОВЛЮЄ SecurityStamp → всі поточні сесії анульовані!
    var result = await userManager.ResetPasswordAsync(
        user, decodedToken, req.NewPassword);

    if (!result.Succeeded)
    {
        return Results.BadRequest(new
        {
            errors = result.Errors.Select(e => e.Description)
        });
    }

    return Results.Ok(new
    {
        message = "Password has been reset successfully. " +
                  "You have been logged out of all devices."
    });
});

// Request DTOs
record ForgotPasswordRequest(string Email);
record ResetPasswordRequest(
    string UserId,
    string Token,
    string NewPassword);

app.MapPost("/account/change-email",
    async (ChangeEmailRequest req,
           HttpContext ctx,
           UserManager<AppUser> userManager,
           IEmailSender<AppUser> emailSender,
           LinkGenerator linkGenerator) =>
{
    var user = await userManager.GetUserAsync(ctx.User);

    if (user is null)
        return Results.Unauthorized();

    // Перевіряємо, чи нова адреса вже не зайнята
    var existing = await userManager.FindByEmailAsync(req.NewEmail);

    if (existing is not null && existing.Id != user.Id)
        return Results.Conflict(new
        {
            error = "This email is already in use."
        });

    // Генеруємо токен зміни email
    // На відміну від підтвердження, цей токен прив'язаний
    // до НОВОЇ адреси — він містить її у зашифрованому вигляді
    var token = await userManager
        .GenerateChangeEmailTokenAsync(user, req.NewEmail);

    var encodedToken = WebEncoders.Base64UrlEncode(
        Encoding.UTF8.GetBytes(token));

    var confirmUrl = linkGenerator.GetUriByName(
        ctx, "ConfirmEmailChange",
        new
        {
            userId   = user.Id,
            newEmail = req.NewEmail,
            token    = encodedToken
        })!;

    // Надсилаємо підтвердження на НОВУ адресу
    await emailSender.SendConfirmationLinkAsync(
        user, req.NewEmail, confirmUrl);

    return Results.Ok(new
    {
        message = $"Confirmation sent to {req.NewEmail}. " +
                  "Your email will be changed after confirmation."
    });
}).RequireAuthorization();

app.MapGet("/account/confirm-email-change",
    async (string userId, string newEmail, string token,
           UserManager<AppUser> userManager,
           SignInManager<AppUser> signInManager) =>
{
    var user = await userManager.FindByIdAsync(userId);

    if (user is null)
        return Results.NotFound();

    var decodedToken = Encoding.UTF8.GetString(
        WebEncoders.Base64UrlDecode(token));

    // ChangeEmailAsync:
    // 1. Перевіряє токен (прив'язаний до newEmail)
    // 2. Оновлює Email та NormalizedEmail
    // 3. Оновлює UserName (якщо він збігався зі старим email)
    // 4. Оновлює SecurityStamp
    var result = await userManager
        .ChangeEmailAsync(user, newEmail, decodedToken);

    if (!result.Succeeded)
    {
        return Results.BadRequest(new
        {
            errors = result.Errors.Select(e => e.Description)
        });
    }

    // Security Stamp змінився → потрібно оновити cookie
    await signInManager.RefreshSignInAsync(user);

    return Results.Ok(new
    {
        message  = "Email changed successfully.",
        newEmail = newEmail
    });
}).WithName("ConfirmEmailChange");

// Крок 1: генеруємо код верифікації (6 цифр)
app.MapPost("/account/change-phone",
    async (ChangePhoneRequest req,
           HttpContext ctx,
           UserManager<AppUser> userManager,
           ISmsSender smsSender) =>
{
    var user = await userManager.GetUserAsync(ctx.User);
    if (user is null) return Results.Unauthorized();

    // Генеруємо числовий код (зазвичай 6 цифр)
    var token = await userManager
        .GenerateChangePhoneNumberTokenAsync(user, req.NewPhone);

    // Надсилаємо SMS
    await smsSender.SendSmsAsync(
        req.NewPhone, $"Your verification code: {token}");

    return Results.Ok(new
    {
        message = $"Verification code sent to {req.NewPhone}."
    });
}).RequireAuthorization();

// Крок 2: підтверджуємо код
app.MapPost("/account/confirm-phone",
    async (ConfirmPhoneRequest req,
           HttpContext ctx,
           UserManager<AppUser> userManager) =>
{
    var user = await userManager.GetUserAsync(ctx.User);
    if (user is null) return Results.Unauthorized();

    // ChangePhoneNumberAsync перевіряє код та оновлює телефон
    var result = await userManager.ChangePhoneNumberAsync(
        user, req.NewPhone, req.Code);

    if (!result.Succeeded)
        return Results.BadRequest(new
        {
            errors = result.Errors.Select(e => e.Description)
        });

    return Results.Ok(new { message = "Phone number updated." });
}).RequireAuthorization();

record ChangePhoneRequest(string NewPhone);
record ConfirmPhoneRequest(string NewPhone, string Code);