public class RegisterRequest
{
    [Required]
    [StringLength(50, MinimumLength = 3)]
    public string Username { get; set; } = string.Empty;

    [Required]
    [EmailAddress]
    public string Email { get; set; } = string.Empty;

    [Required]
    [MinLength(8)]
    public string Password { get; set; } = string.Empty;
}

public class CreateOrderValidator : AbstractValidator<CreateOrderRequest>
{
    public CreateOrderValidator()
    {
        // Правило 1: CustomerName — обов'язкове, 2-100 символів
        RuleFor(x => x.CustomerName)
            .NotEmpty()
                .WithMessage("Ім'я покупця є обов'язковим.")
            .Length(2, 100)
                .WithMessage("Ім'я має бути від {MinLength} до {MaxLength} символів.");

        // Правило 2: Email — обов'язковий, валідний формат
        RuleFor(x => x.Email)
            .NotEmpty()
                .WithMessage("Email є обов'язковим.")
            .EmailAddress()
                .WithMessage("'{PropertyValue}' не є валідним email.");

        // Правило 3: Кількість товарів — від 1 до 100
        RuleFor(x => x.Quantity)
            .InclusiveBetween(1, 100)
                .WithMessage("Кількість має бути між {From} та {To}.");

        // Правило 4: Ціна — більше нуля, з двома знаками після коми
        RuleFor(x => x.Price)
            .GreaterThan(0)
                .WithMessage("Ціна має бути більшою за нуль.")
            .PrecisionScale(10, 2, false)
                .WithMessage("Ціна має мати не більше 2 знаків після коми.");

        // Правило 5: DeliveryDate — у майбутньому
        RuleFor(x => x.DeliveryDate)
            .GreaterThan(DateTime.UtcNow)
                .WithMessage("Дата доставки має бути в майбутньому.");
    }
}

public class ChangePasswordValidator : AbstractValidator<ChangePasswordRequest>
{
    public ChangePasswordValidator()
    {
        RuleFor(x => x.NewPassword)
            .NotEmpty()
            .MinimumLength(8)
            // Перевірка наявності великої літери
            .Must(password => password.Any(char.IsUpper))
                .WithMessage("Пароль має містити хоча б одну велику літеру.")
            // Перевірка наявності цифри
            .Must(password => password.Any(char.IsDigit))
                .WithMessage("Пароль має містити хоча б одну цифру.")
            // Перевірка наявності спецсимволу
            .Must(password => password.Any(c => !char.IsLetterOrDigit(c)))
                .WithMessage("Пароль має містити хоча б один спеціальний символ.");

        // Перевірка, що новий пароль відрізняється від старого
        // Must() може приймати весь об'єкт як другий аргумент
        RuleFor(x => x.NewPassword)
            .Must((request, newPassword) => newPassword != request.OldPassword)
                .WithMessage("Новий пароль не може збігатися зі старим.");
    }
}

public class RegisterRequestValidator : AbstractValidator<RegisterRequest>
{
    private readonly AppDbContext _db;

    // Валідатор наслідує залежності через конструктор
    public RegisterRequestValidator(AppDbContext db)
    {
        _db = db;

        RuleFor(x => x.Username)
            .NotEmpty()
            .Length(3, 50)
            // Перевірка унікальності username в БД
            .MustAsync(BeUniqueUsernameAsync)
                .WithMessage("Ім'я користувача '{PropertyValue}' вже зайнято.");

        RuleFor(x => x.Email)
            .NotEmpty()
            .EmailAddress()
            // Перевірка унікальності email в БД
            .MustAsync(async (email, cancellationToken) =>
                !await _db.Users.AnyAsync(u => u.Email == email, cancellationToken))
                .WithMessage("Ця електронна адреса вже зареєстрована.");
    }

    // Виносимо логіку в окремий приватний метод для читабельності
    private async Task<bool> BeUniqueUsernameAsync(
        string username,
        CancellationToken cancellationToken)
    {
        return !await _db.Users
            .AnyAsync(u => u.Username == username, cancellationToken);
    }
}

public class CreateOrderValidator : AbstractValidator<CreateOrderRequest>
{
    public CreateOrderValidator()
    {
        // PromoCode валідується лише якщо UsePromo == true
        RuleFor(x => x.PromoCode)
            .NotEmpty()
                .WithMessage("Промокод є обов'язковим при використанні акції.")
            .Length(6, 20)
                .WithMessage("Промокод має бути від 6 до 20 символів.")
            .When(x => x.UsePromo);  // Умова!

        // ShippingAddress є обов'язковим лише для доставки, не для самовивозу
        RuleFor(x => x.ShippingAddress)
            .NotEmpty()
                .WithMessage("Адреса доставки є обов'язковою для кур'єрської доставки.")
            .Unless(x => x.DeliveryMethod == DeliveryMethod.Pickup);

        // CompanyName є обов'язковим лише для юридичних осіб
        RuleFor(x => x.CompanyName)
            .NotEmpty()
                .WithMessage("Назва компанії є обов'язковою для корпоративних замовлень.")
            .When(x => x.CustomerType == CustomerType.Business);
    }
}

public class ProductValidator : AbstractValidator<Product>
{
    public ProductValidator()
    {
        // Загальне правило — завжди активне
        RuleFor(x => x.Name)
            .NotEmpty()
            .MaximumLength(200);

        // Правила лише для Create
        RuleSet("Create", () =>
        {
            RuleFor(x => x.Sku)
                .NotEmpty()
                    .WithMessage("SKU є обов'язковим при створенні товару.");
        });

        // Правила лише для Update
        RuleSet("Update", () =>
        {
            RuleFor(x => x.Id)
                .GreaterThan(0)
                    .WithMessage("Невалідний ID для оновлення.");
        });
    }
}

// Валідація з конкретним RuleSet
var validationResult = await _validator.ValidateAsync(
    product,
    options => options.IncludeRuleSets("Create"),
    cancellationToken);

public class CreateOrderRequest
{
    public string CustomerName { get; set; } = string.Empty;
    public string Email        { get; set; } = string.Empty;
    public List<OrderItemDto> Items { get; set; } = [];
    public AddressDto? ShippingAddress { get; set; }
}

public class AddressDto
{
    public string Street { get; set; } = string.Empty;
    public string City   { get; set; } = string.Empty;
    public string Zip    { get; set; } = string.Empty;
}

public class OrderItemDto
{
    public int    ProductId { get; set; }
    public int    Quantity  { get; set; }
}

public class AddressDtoValidator : AbstractValidator<AddressDto>
{
    public AddressDtoValidator()
    {
        RuleFor(x => x.Street).NotEmpty().MaximumLength(200);
        RuleFor(x => x.City).NotEmpty().MaximumLength(100);
        RuleFor(x => x.Zip)
            .NotEmpty()
            .Matches(@"^\d{5}(-\d{4})?$")
                .WithMessage("Zip code має відповідати формату 12345 або 12345-6789.");
    }
}

public class OrderItemDtoValidator : AbstractValidator<OrderItemDto>
{
    public OrderItemDtoValidator()
    {
        RuleFor(x => x.ProductId).GreaterThan(0);
        RuleFor(x => x.Quantity).InclusiveBetween(1, 999);
    }
}

public class CreateOrderValidator : AbstractValidator<CreateOrderRequest>
{
    public CreateOrderValidator()
    {
        RuleFor(x => x.CustomerName).NotEmpty().Length(2, 100);
        RuleFor(x => x.Email).NotEmpty().EmailAddress();

        // Валідація вкладеного об'єкта через SetValidator
        RuleFor(x => x.ShippingAddress)
            .NotNull()
                .WithMessage("Адреса доставки є обов'язковою.")
            .SetValidator(new AddressDtoValidator());

        // Валідація кожного елемента колекції через ForEach або RuleForEach
        RuleForEach(x => x.Items)
            .SetValidator(new OrderItemDtoValidator());

        // Додаткове правило для всієї колекції
        RuleFor(x => x.Items)
            .NotEmpty()
                .WithMessage("Замовлення має містити хоча б один товар.")
            .Must(items => items.Count <= 50)
                .WithMessage("В одному замовленні не може бути більше 50 позицій.");
    }
}

public static class PhoneValidationExtensions
{
    // Розширення для IRuleBuilder — дозволяє додавати до ланцюжка
    public static IRuleBuilderOptions<T, string> ValidPhoneNumber<T>(
        this IRuleBuilder<T, string> ruleBuilder)
    {
        return ruleBuilder
            .Matches(@"^\+?[1-9]\d{1,14}$")
                .WithMessage("'{PropertyValue}' не є валідним номером телефону у форматі E.164.")
            .MaximumLength(20);
    }

    public static IRuleBuilderOptions<T, string> ValidUkrainianPhone<T>(
        this IRuleBuilder<T, string> ruleBuilder)
    {
        return ruleBuilder
            .Matches(@"^\+380\d{9}$")
                .WithMessage("Номер телефону має бути у форматі +380XXXXXXXXX.");
    }
}

public class UserValidator : AbstractValidator<UserDto>
{
    public UserValidator()
    {
        RuleFor(x => x.Phone)
            .NotEmpty()
            .ValidUkrainianPhone();  // Наше розширення!
    }
}

public class LuhnCreditCardValidator<T> : PropertyValidator<T, string>
{
    public override string Name => "LuhnCreditCardValidator";

    protected override string GetDefaultMessageTemplate(string errorCode)
        => "'{PropertyName}' не є валідним номером кредитної картки.";

    public override bool IsValid(ValidationContext<T> context, string value)
    {
        if (string.IsNullOrWhiteSpace(value)) return false;

        // Алгоритм Луна для перевірки номера картки
        var digits = value.Replace(" ", "").Replace("-", "");
        if (!digits.All(char.IsDigit)) return false;

        int sum = 0;
        bool alternate = false;

        for (int i = digits.Length - 1; i >= 0; i--)
        {
            int digit = digits[i] - '0';
            if (alternate)
            {
                digit *= 2;
                if (digit > 9) digit -= 9;
            }
            sum += digit;
            alternate = !alternate;
        }

        return sum % 10 == 0;
    }
}

// Extension method для зручного використання
public static class CreditCardValidationExtensions
{
    public static IRuleBuilderOptions<T, string> ValidCreditCardNumber<T>(
        this IRuleBuilder<T, string> ruleBuilder)
        => ruleBuilder.SetValidator(new LuhnCreditCardValidator<T>());
}

[ApiController]
[Route("api/[controller]")]
public class UsersController : ControllerBase
{
    private readonly IValidator<RegisterRequest> _validator;

    public UsersController(IValidator<RegisterRequest> validator)
    {
        _validator = validator;
    }

    [HttpPost("register")]
    public async Task<IActionResult> Register(
        [FromBody] RegisterRequest request,
        CancellationToken cancellationToken)
    {
        // Явний виклик
        var validationResult = await _validator
            .ValidateAsync(request, cancellationToken);

        if (!validationResult.IsValid)
        {
            // Повертаємо помилки у вигляді словника для фронтенду
            return BadRequest(validationResult.ToDictionary());
        }

        // ... логіка реєстрації
        return Ok();
    }
}

builder.Services.AddControllers();

// Реєструємо валідатори
builder.Services.AddValidatorsFromAssemblyContaining<Program>();

// Підключаємо автоматичну валідацію (замінює ModelState)
// УВАГА: FluentValidation.AspNetCore підтримує цей підхід,
// але команда FluentValidation рекомендує ручну валідацію
// або валідацію через Filters для кращого контролю.

using FluentValidation;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Filters;

public class ValidationFilter<T> : IAsyncActionFilter
{
    private readonly IValidator<T> _validator;

    public ValidationFilter(IValidator<T> validator)
    {
        _validator = validator;
    }

    public async Task OnActionExecutionAsync(
        ActionExecutingContext context,
        ActionExecutionDelegate next)
    {
        // Знаходимо аргумент типу T серед параметрів дії
        var argument = context.ActionArguments.Values
            .OfType<T>()
            .FirstOrDefault();

        if (argument is null)
        {
            await next();
            return;
        }

        var validationResult = await _validator.ValidateAsync(argument);

        if (!validationResult.IsValid)
        {
            // Формат Problem Details з вкладеними помилками
            var problemDetails = new ValidationProblemDetails(
                validationResult.ToDictionary())
            {
                Status = StatusCodes.Status400BadRequest,
                Title  = "Помилки валідації",
                Detail = "Одне або більше полів містять недійсні значення."
            };

            context.Result = new BadRequestObjectResult(problemDetails);
        }
        else
        {
            await next();
        }
    }
}

using FluentValidation;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddValidatorsFromAssemblyContaining<Program>();

var app = builder.Build();

app.MapPost("/api/users", async (
    RegisterRequest request,
    IValidator<RegisterRequest> validator,
    CancellationToken ct) =>
{
    var result = await validator.ValidateAsync(request, ct);

    if (!result.IsValid)
    {
        // Формуємо словник помилок: { "Email": ["Not valid email"] }
        var errors = result.ToDictionary();
        return Results.ValidationProblem(errors);
    }

    // ... логіка створення користувача
    return Results.Created($"/api/users/1", new { message = "Користувача створено." });
});

app.Run();

using FluentValidation.TestHelper;

public class RegisterRequestValidatorTests
{
    private readonly RegisterRequestValidator _validator;

    public RegisterRequestValidatorTests()
    {
        // Для валідаторів без залежностей — просте створення
        _validator = new RegisterRequestValidator();
    }

    [Fact]
    public void Should_have_error_when_email_is_empty()
    {
        var request = new RegisterRequest { Email = "" };
        var result = _validator.TestValidate(request);
        result.ShouldHaveValidationErrorFor(x => x.Email);
    }

    [Fact]
    public void Should_have_error_when_email_is_invalid()
    {
        var request = new RegisterRequest { Email = "not-an-email" };
        var result = _validator.TestValidate(request);
        result.ShouldHaveValidationErrorFor(x => x.Email);
    }

    [Fact]
    public void Should_not_have_error_when_email_is_valid()
    {
        var request = new RegisterRequest { Email = "user@example.com" };
        var result = _validator.TestValidate(request);
        result.ShouldNotHaveValidationErrorFor(x => x.Email);
    }

    [Theory]
    [InlineData("ab")]       // Задовгий (мінімум 3)
    [InlineData("")]         // Порожній
    [InlineData("this_is_way_too_long_username_for_our_system")]  // Занадто довгий
    public void Should_have_error_for_invalid_username(string username)
    {
        var request = new RegisterRequest { Username = username };
        var result = _validator.TestValidate(request);
        result.ShouldHaveValidationErrorFor(x => x.Username);
    }

    [Fact]
    public void Should_pass_for_valid_request()
    {
        var request = new RegisterRequest
        {
            Username = "valid_user",
            Email    = "user@example.com",
            Password = "SecureP@ss1"
        };
        var result = _validator.TestValidate(request);
        result.ShouldNotHaveAnyValidationErrors();
    }
}

using NSubstitute;
using Microsoft.EntityFrameworkCore;

public class RegisterRequestValidatorAsyncTests
{
    [Fact]
    public async Task Should_have_error_when_email_already_exists()
    {
        // Arrange: мокуємо DbContext
        var db = CreateMockDbContext(emailExists: true);
        var validator = new RegisterRequestValidator(db);

        var request = new RegisterRequest
        {
            Username = "newuser",
            Email    = "existing@example.com",
            Password = "SecureP@ss1"
        };

        // Act
        var result = await validator.ValidateAsync(request);

        // Assert
        Assert.False(result.IsValid);
        Assert.Contains(result.Errors,
            e => e.PropertyName == "Email" &&
                 e.ErrorMessage.Contains("вже зареєстрована"));
    }

    private static AppDbContext CreateMockDbContext(bool emailExists)
    {
        // Використання InMemory БД для тестів
        var options = new DbContextOptionsBuilder<AppDbContext>()
            .UseInMemoryDatabase(Guid.NewGuid().ToString())
            .Options;

        var db = new AppDbContext(options);

        if (emailExists)
        {
            db.Users.Add(new AppUser { Email = "existing@example.com" });
            db.SaveChanges();
        }

        return db;
    }
}

using FluentValidation.Resources;

public class UkrainianLanguageManager : LanguageManager
{
    public UkrainianLanguageManager()
    {
        // Перевизначаємо вбудовані повідомлення
        AddTranslation("uk", "NotEmptyValidator",
            "'{PropertyName}' не повинно бути порожнім.");
        AddTranslation("uk", "EmailValidator",
            "'{PropertyName}' не є коректною електронною адресою.");
        AddTranslation("uk", "MinimumLengthValidator",
            "'{PropertyName}' повинно бути не менше {MinLength} символів." +
            " Ви ввели {TotalLength}.");
        AddTranslation("uk", "MaximumLengthValidator",
            "'{PropertyName}' не може перевищувати {MaxLength} символів." +
            " Ви ввели {TotalLength}.");
        AddTranslation("uk", "InclusiveBetweenValidator",
            "'{PropertyName}' повинно бути між {From} та {To}." +
            " Ви ввели {PropertyValue}.");
        AddTranslation("uk", "GreaterThanValidator",
            "'{PropertyName}' повинно бути більше '{ComparisonValue}'.");
    }
}

ValidatorOptions.Global.LanguageManager = new UkrainianLanguageManager();
ValidatorOptions.Global.LanguageManager.Culture = new CultureInfo("uk");

public class StrictOrderValidator : AbstractValidator<CreateOrderRequest>
{
    public StrictOrderValidator()
    {
        // CASCADE: зупиняємо перевірку цього поля після першої помилки
        RuleFor(x => x.Email)
            .Cascade(CascadeMode.Stop)
            .NotEmpty()
            .EmailAddress()
            .MustAsync(BeUniqueEmailAsync);  // Не дійде, якщо вище є помилки

        // Для всього валідатора:
        // ValidatorOptions.Global.DefaultClassLevelCascadeMode = CascadeMode.Stop;
    }
}