app.MapPost("/auth/login",
    async (LoginRequest req,
           SignInManager<AppUser> signInManager,
           UserManager<AppUser> userManager,
           TokenService tokenService) =>
{
    var user = await userManager.FindByEmailAsync(req.Email);
    if (user is null)
        return Results.Json(
            new { error = "Invalid credentials" }, statusCode: 401);

    // CheckPasswordSignInAsync — перевіряє пароль БЕЗ встановлення cookie
    // lockoutOnFailure: true — рахує невдалі спроби
    var result = await signInManager.CheckPasswordSignInAsync(
        user, req.Password, lockoutOnFailure: true);

    if (result.IsLockedOut)
        return Results.Json(
            new { error = "Account locked." }, statusCode: 423);

    if (!result.Succeeded)
        return Results.Json(
            new { error = "Invalid credentials" }, statusCode: 401);

    // 2FA потрібна — повертаємо спеціальний статус
    if (result.RequiresTwoFactor)
    {
        // Зберігаємо userId у тимчасовому коді (або можемо повернути userId)
        return Results.Ok(new
        {
            requiresTwoFactor = true,
            // Безпечно повертати userId — для 2FA ще потрібен другий фактор
            userId = user.Id
        });
    }

    // 2FA не потрібна — видаємо токен
    var roles  = await userManager.GetRolesAsync(user);
    var token  = tokenService.GenerateToken(user, roles);
    return Results.Ok(new { access_token = token });
});

app.MapPost("/auth/login/2fa",
    async (TwoFaLoginRequest req,
           UserManager<AppUser> userManager,
           SignInManager<AppUser> signInManager,
           TokenService tokenService) =>
{
    var user = await userManager.FindByIdAsync(req.UserId);
    if (user is null)
        return Results.Json(
            new { error = "Invalid session" }, statusCode: 401);

    var code = req.Code.Replace(" ", "").Replace("-", "");

    // Перевіряємо TOTP-код
    var isValid = await userManager.VerifyTwoFactorTokenAsync(
        user,
        userManager.Options.Tokens.AuthenticatorTokenProvider,
        code);

    if (!isValid)
    {
        // Рахуємо невдалі спроби (захист від брутфорсу 2FA)
        await userManager.AccessFailedAsync(user);
        return Results.Json(
            new { error = "Invalid 2FA code" }, statusCode: 401);
    }

    // Скидаємо лічильник невдалих спроб
    await userManager.ResetAccessFailedCountAsync(user);

    // Видаємо токен доступу
    var roles = await userManager.GetRolesAsync(user);
    var token = tokenService.GenerateToken(user, roles);

    return Results.Ok(new
    {
        access_token = token,
        expires_in   = 900
    });
});

record TwoFaLoginRequest(string UserId, string Code);

app.MapPost("/account/2fa/disable",
    async (Disable2FaRequest req,
           HttpContext ctx,
           UserManager<AppUser> userManager) =>
{
    var user = await userManager.GetUserAsync(ctx.User);
    if (user is null) return Results.Unauthorized();

    // Перевіряємо пароль перед вимиканням 2FA (додатковий захист)
    var passwordValid = await userManager.CheckPasswordAsync(
        user, req.Password);

    if (!passwordValid)
        return Results.BadRequest(new { error = "Invalid password." });

    await userManager.SetTwoFactorEnabledAsync(user, false);

    // Скидаємо ключ аутентифікатора — при повторному увімкненні
    // буде згенеровано новий QR-код
    await userManager.ResetAuthenticatorKeyAsync(user);

    return Results.Ok(new
    {
        message = "Two-factor authentication has been disabled."
    });
}).RequireAuthorization();

record Disable2FaRequest(string Password);

builder.Services
    .AddIdentity<AppUser, IdentityRole>(options =>
    {
        // Вказуємо Email як провайдер 2FA
        options.Tokens.EmailConfirmationTokenProvider =
            TokenOptions.DefaultEmailProvider;
    })
    .AddEntityFrameworkStores<AppDbContext>()
    .AddDefaultTokenProviders(); // Реєструє EmailTokenProvider

app.MapPost("/account/2fa/email/enable",
    async (HttpContext ctx,
           UserManager<AppUser> userManager,
           IEmailSender emailSender) =>
{
    var user = await userManager.GetUserAsync(ctx.User);
    if (user is null) return Results.Unauthorized();

    if (!user.EmailConfirmed)
        return Results.BadRequest(new
        {
            error = "Please confirm your email before enabling Email 2FA."
        });

    // Генеруємо код підтвердження (числовий, 6 символів)
    // Провайдер "Email" — це EmailTokenProvider
    var code = await userManager.GenerateTwoFactorTokenAsync(
        user, "Email");

    await emailSender.SendEmailAsync(
        user.Email!,
        "Enable Two-Factor Authentication",
        $"Your verification code: <strong>{code}</strong>. " +
        $"Expires in 10 minutes.");

    return Results.Ok(new
    {
        message = "Verification code sent to your email."
    });
}).RequireAuthorization();

// Оновлення TTL для Email токенів
builder.Services
    .Configure<EmailTokenProviderOptions>(options =>
    {
        options.TokenLifespan = TimeSpan.FromMinutes(10);
    });

app.MapPost("/auth/login/2fa/email",
    async (EmailTwoFaRequest req,
           UserManager<AppUser> userManager,
           TokenService tokenService) =>
{
    var user = await userManager.FindByIdAsync(req.UserId);
    if (user is null)
        return Results.Json(
            new { error = "Invalid session" }, statusCode: 401);

    // Перевіряємо код через EmailTokenProvider
    var isValid = await userManager.VerifyTwoFactorTokenAsync(
        user,
        TokenOptions.DefaultEmailProvider,
        req.Code);

    if (!isValid)
        return Results.Json(
            new { error = "Invalid or expired code." },
            statusCode: 401);

    var roles = await userManager.GetRolesAsync(user);
    var token = tokenService.GenerateToken(user, roles);

    return Results.Ok(new { access_token = token });
});

record EmailTwoFaRequest(string UserId, string Code);

public interface ISmsSender
{
    Task SendSmsAsync(string number, string message);
}

using Twilio;
using Twilio.Rest.Api.V2010.Account;
using Twilio.Types;

public class TwilioSmsSender : ISmsSender
{
    private readonly IConfiguration _config;
    private readonly ILogger<TwilioSmsSender> _logger;

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

        // Ініціалізуємо Twilio клієнт
        TwilioClient.Init(
            _config["Twilio:AccountSid"],
            _config["Twilio:AuthToken"]);
    }

    public async Task SendSmsAsync(string number, string message)
    {
        try
        {
            var msg = await MessageResource.CreateAsync(
                body: message,
                from: new PhoneNumber(_config["Twilio:From"]),
                to:   new PhoneNumber(number));

            _logger.LogInformation(
                "SMS sent. SID: {Sid}", msg.Sid);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex,
                "Failed to send SMS to {Number}", number);
            throw;
        }
    }
}

{
  "Twilio": {
    "AccountSid": "ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
    "AuthToken": "your_auth_token",
    "From": "+15551234567"
  }
}

app.MapPost("/account/2fa/sms/setup",
    async (SmsTwoFaSetupRequest req,
           HttpContext ctx,
           UserManager<AppUser> userManager,
           ISmsSender smsSender) =>
{
    var user = await userManager.GetUserAsync(ctx.User);
    if (user is null) return Results.Unauthorized();

    // Генеруємо код для верифікації номера
    // ChangePhoneNumberTokenProvider — окремий провайдер
    var token = await userManager
        .GenerateChangePhoneNumberTokenAsync(user, req.PhoneNumber);

    await smsSender.SendSmsAsync(
        req.PhoneNumber,
        $"Your MyApp verification code: {token}");

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

record SmsTwoFaSetupRequest(string PhoneNumber);

app.MapPost("/account/2fa/sms/enable",
    async (SmsTwoFaEnableRequest req,
           HttpContext ctx,
           UserManager<AppUser> userManager) =>
{
    var user = await userManager.GetUserAsync(ctx.User);
    if (user is null) return Results.Unauthorized();

    // Підтверджуємо номер та встановлюємо як верифікований
    var result = await userManager.ChangePhoneNumberAsync(
        user, req.PhoneNumber, req.Code);

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

    // Встановлюємо провайдер 2FA на Phone
    await userManager.SetTwoFactorEnabledAsync(user, true);

    // Генеруємо резервні коди
    var recoveryCodes = await userManager
        .GenerateNewTwoFactorRecoveryCodesAsync(user, 10);

    return Results.Ok(new
    {
        message       = "SMS two-factor authentication enabled.",
        recoveryCodes = recoveryCodes  // ⚠️ Показати один раз!
    });
}).RequireAuthorization();

record SmsTwoFaEnableRequest(string PhoneNumber, string Code);

app.MapPost("/auth/login/2fa/sms",
    async (SmsTwoFaLoginRequest req,
           UserManager<AppUser> userManager,
           ISmsSender smsSender,
           TokenService tokenService) =>
{
    var user = await userManager.FindByIdAsync(req.UserId);
    if (user is null)
        return Results.Json(
            new { error = "Invalid session" }, statusCode: 401);

    // Спочатку генеруємо і надсилаємо SMS
    // (якщо це перший запит до 2FA SMS ендпоінту)
    if (req.SendCode == true)
    {
        var code = await userManager.GenerateTwoFactorTokenAsync(
            user, TokenOptions.DefaultPhoneProvider);

        await smsSender.SendSmsAsync(user.PhoneNumber!, code);

        return Results.Ok(new
        {
            message = $"Code sent to {user.PhoneNumber!.Substring(0, 4)}***"
        });
    }

    // Перевіряємо введений код
    var isValid = await userManager.VerifyTwoFactorTokenAsync(
        user, TokenOptions.DefaultPhoneProvider, req.Code!);

    if (!isValid)
        return Results.Json(
            new { error = "Invalid or expired code." }, statusCode: 401);

    var roles = await userManager.GetRolesAsync(user);
    var token = tokenService.GenerateToken(user, roles);

    return Results.Ok(new { access_token = token });
});

record SmsTwoFaLoginRequest(
    string UserId, string? Code, bool? SendCode);

app.MapPost("/account/2fa/recovery-codes/generate",
    async (HttpContext ctx,
           UserManager<AppUser> userManager) =>
{
    var user = await userManager.GetUserAsync(ctx.User);
    if (user is null) return Results.Unauthorized();

    if (!await userManager.GetTwoFactorEnabledAsync(user))
        return Results.BadRequest(new
        {
            error = "Two-factor authentication must be enabled first."
        });

    // Генеруємо 10 нових кодів
    // Старі коди при цьому АНУЛЮЮТЬСЯ — повернення до старих неможливе
    var recoveryCodes = await userManager
        .GenerateNewTwoFactorRecoveryCodesAsync(user, 10);

    // Підраховуємо скільки кодів залишилось (для попередження UI)
    var remainingCount = await userManager
        .CountRecoveryCodesAsync(user);

    return Results.Ok(new
    {
        recoveryCodes  = recoveryCodes,  // ПОКАЗАТИ ОДИН РАЗ!
        count          = recoveryCodes!.Count(),
        remainingAfter = remainingCount,
        warning        = "These codes will not be shown again. " +
                         "Store them in a secure location."
    });
}).RequireAuthorization();

app.MapGet("/account/2fa/recovery-codes/count",
    async (HttpContext ctx,
           UserManager<AppUser> userManager) =>
{
    var user = await userManager.GetUserAsync(ctx.User);
    if (user is null) return Results.Unauthorized();

    var count = await userManager.CountRecoveryCodesAsync(user);

    return Results.Ok(new
    {
        remaining = count,
        // Попередження при малій кількості кодів
        warning = count < 3
            ? "You have very few recovery codes left. Generate new ones!"
            : null
    });
}).RequireAuthorization();

app.MapPost("/auth/login/2fa/recovery-code",
    async (RecoveryCodeLoginRequest req,
           UserManager<AppUser> userManager,
           TokenService tokenService) =>
{
    var user = await userManager.FindByIdAsync(req.UserId);
    if (user is null)
        return Results.Json(
            new { error = "Invalid session" }, statusCode: 401);

    // Нормалізуємо код: прибираємо дефіси та пробіли
    var recoveryCode = req.RecoveryCode.Replace("-", "").Replace(" ", "");

    // RedeemTwoFactorRecoveryCodeAsync:
    // 1. Знаходить хеш коду у AspNetUserTokens
    // 2. При успіху — ВИДАЛЯЄ використаний код
    // 3. Код більше не дійсний після першого використання!
    var result = await userManager
        .RedeemTwoFactorRecoveryCodeAsync(user, recoveryCode);

    if (!result.Succeeded)
        return Results.Json(
            new
            {
                error = "Invalid recovery code. " +
                        "Each code can only be used once."
            },
            statusCode: 401);

    // Перевіряємо скільки кодів залишилось — попереджаємо якщо мало
    var remainingCodes = await userManager
        .CountRecoveryCodesAsync(user);

    var roles = await userManager.GetRolesAsync(user);
    var token = tokenService.GenerateToken(user, roles);

    return Results.Ok(new
    {
        access_token         = token,
        remainingRecoveryCodes = remainingCodes,
        warning              = remainingCodes < 3
            ? "You are running low on recovery codes. Please generate new ones."
            : null
    });
});

record RecoveryCodeLoginRequest(string UserId, string RecoveryCode);

app.MapPost("/auth/login/2fa",
    async (TwoFaLoginV2Request req,
           HttpContext ctx,
           UserManager<AppUser> userManager,
           SignInManager<AppUser> signInManager,
           TokenService tokenService) =>
{
    var user = await userManager.FindByIdAsync(req.UserId);
    if (user is null)
        return Results.Json(
            new { error = "Invalid session" }, statusCode: 401);

    // Перевіряємо TOTP-код
    var code    = req.Code.Replace(" ", "").Replace("-", "");
    var isValid = await userManager.VerifyTwoFactorTokenAsync(
        user,
        userManager.Options.Tokens.AuthenticatorTokenProvider,
        code);

    if (!isValid)
        return Results.Json(
            new { error = "Invalid 2FA code" }, statusCode: 401);

    // Якщо користувач обрав "Remember this device"
    if (req.RememberDevice == true)
    {
        // Зберігаємо cookie-маркер для цього пристрою
        await signInManager.RememberTwoFactorClientAsync(user);
    }

    var roles = await userManager.GetRolesAsync(user);
    var token = tokenService.GenerateToken(user, roles);

    return Results.Ok(new { access_token = token });
});

record TwoFaLoginV2Request(
    string UserId,
    string Code,
    bool? RememberDevice);

app.MapPost("/auth/login",
    async (LoginRequest req,
           HttpContext ctx,
           SignInManager<AppUser> signInManager,
           UserManager<AppUser> userManager,
           TokenService tokenService) =>
{
    var user = await userManager.FindByEmailAsync(req.Email);
    if (user is null) return Results.Unauthorized();

    var passwordResult = await signInManager
        .CheckPasswordSignInAsync(user, req.Password, true);

    if (!passwordResult.Succeeded) return Results.Unauthorized();

    // Чи потрібна 2FA?
    var twoFactorEnabled = await userManager
        .GetTwoFactorEnabledAsync(user);

    if (twoFactorEnabled)
    {
        // Перевіряємо, чи пристрій вже запам'ятований
        var isClientRemembered = await signInManager
            .IsTwoFactorClientRememberedAsync(user);

        if (!isClientRemembered)
        {
            // 2FA потрібна
            return Results.Ok(new
            {
                requiresTwoFactor = true,
                userId            = user.Id
            });
        }

        // Пристрій запам'ятований — пропускаємо 2FA
    }

    var roles = await userManager.GetRolesAsync(user);
    var token = tokenService.GenerateToken(user, roles);
    return Results.Ok(new { access_token = token });
});