using FluentValidation;
using Microsoft.Extensions.DependencyInjection;
using Svrnty.CQRS.Abstractions;
using Svrnty.CQRS.Abstractions.Discovery;

namespace Svrnty.CQRS.Tests;

// Validator for CreatePersonCommand
public class CreatePersonCommandValidator : AbstractValidator<CreatePersonCommand>
{
    public CreatePersonCommandValidator()
    {
        RuleFor(x => x.FirstName).NotEmpty().WithMessage("FirstName is required");
        RuleFor(x => x.LastName).NotEmpty().WithMessage("LastName is required");
    }
}

// Validator for PersonQuery
public class PersonQueryValidator : AbstractValidator<PersonQuery>
{
    public PersonQueryValidator()
    {
        RuleFor(x => x.NameFilter).MaximumLength(100).WithMessage("NameFilter too long");
    }
}

public class FluentValidationTests
{
    [Fact]
    public void AddCommand_WithValidator_RegistersHandlerAndValidator()
    {
        var services = new ServiceCollection();
        Svrnty.CQRS.FluentValidation.ServiceCollectionExtensions
            .AddCommand<CreatePersonCommand, CreatePersonCommandHandler, CreatePersonCommandValidator>(services);

        var provider = services.BuildServiceProvider();

        var handler = provider.GetService<ICommandHandler<CreatePersonCommand>>();
        var validator = provider.GetService<IValidator<CreatePersonCommand>>();

        Assert.NotNull(handler);
        Assert.NotNull(validator);
        Assert.IsType<CreatePersonCommandHandler>(handler);
        Assert.IsType<CreatePersonCommandValidator>(validator);
    }

    [Fact]
    public void AddCommand_WithResultAndValidator_RegistersHandlerAndValidator()
    {
        var services = new ServiceCollection();
        Svrnty.CQRS.FluentValidation.ServiceCollectionExtensions
            .AddCommand<CreatePersonCommand, CreatePersonResult, CreatePersonCommandHandler, CreatePersonCommandValidator>(services);

        var provider = services.BuildServiceProvider();

        var handler = provider.GetService<ICommandHandler<CreatePersonCommand, CreatePersonResult>>();
        var validator = provider.GetService<IValidator<CreatePersonCommand>>();

        Assert.NotNull(handler);
        Assert.NotNull(validator);
    }

    [Fact]
    public void AddCommand_WithResultAndValidator_RegistersCommandMeta()
    {
        var services = new ServiceCollection();
        Svrnty.CQRS.FluentValidation.ServiceCollectionExtensions
            .AddCommand<CreatePersonCommand, CreatePersonResult, CreatePersonCommandHandler, CreatePersonCommandValidator>(services);

        var provider = services.BuildServiceProvider();
        var metas = provider.GetServices<ICommandMeta>().ToList();

        Assert.Single(metas);
        Assert.Equal(typeof(CreatePersonCommand), metas[0].CommandType);
        Assert.Equal(typeof(CreatePersonResult), metas[0].CommandResultType);
    }

    [Fact]
    public void AddQuery_WithValidator_RegistersHandlerAndValidator()
    {
        var services = new ServiceCollection();
        Svrnty.CQRS.FluentValidation.ServiceCollectionExtensions
            .AddQuery<PersonQuery, IEnumerable<string>, PersonQueryHandler, PersonQueryValidator>(services);

        var provider = services.BuildServiceProvider();

        var handler = provider.GetService<IQueryHandler<PersonQuery, IEnumerable<string>>>();
        var validator = provider.GetService<IValidator<PersonQuery>>();

        Assert.NotNull(handler);
        Assert.NotNull(validator);
        Assert.IsType<PersonQueryHandler>(handler);
        Assert.IsType<PersonQueryValidator>(validator);
    }

    [Fact]
    public async Task Validator_RejectsInvalidCommand()
    {
        var validator = new CreatePersonCommandValidator();
        var command = new CreatePersonCommand { FirstName = "", LastName = "" };

        var result = await validator.ValidateAsync(command);

        Assert.False(result.IsValid);
        Assert.Equal(2, result.Errors.Count);
    }

    [Fact]
    public async Task Validator_AcceptsValidCommand()
    {
        var validator = new CreatePersonCommandValidator();
        var command = new CreatePersonCommand { FirstName = "John", LastName = "Doe" };

        var result = await validator.ValidateAsync(command);

        Assert.True(result.IsValid);
        Assert.Empty(result.Errors);
    }

    [Fact]
    public async Task Validator_ResolvedFromDI_WorksCorrectly()
    {
        var services = new ServiceCollection();
        Svrnty.CQRS.FluentValidation.ServiceCollectionExtensions
            .AddCommand<CreatePersonCommand, CreatePersonCommandHandler, CreatePersonCommandValidator>(services);

        var provider = services.BuildServiceProvider();
        var validator = provider.GetRequiredService<IValidator<CreatePersonCommand>>();

        var invalidResult = await validator.ValidateAsync(new CreatePersonCommand { FirstName = "", LastName = "" });
        Assert.False(invalidResult.IsValid);

        var validResult = await validator.ValidateAsync(new CreatePersonCommand { FirstName = "Jane", LastName = "Doe" });
        Assert.True(validResult.IsValid);
    }

    [Fact]
    public void CqrsBuilder_AddCommand_WithValidator_RegistersBoth()
    {
        var services = new ServiceCollection();
        services.AddSvrntyCqrs(builder =>
        {
            Svrnty.CQRS.FluentValidation.CqrsBuilderExtensions
                .AddCommand<CreatePersonCommand, CreatePersonCommandHandler, CreatePersonCommandValidator>(builder);
        });

        var provider = services.BuildServiceProvider();

        Assert.NotNull(provider.GetService<ICommandHandler<CreatePersonCommand>>());
        Assert.NotNull(provider.GetService<IValidator<CreatePersonCommand>>());
    }

    [Fact]
    public void CqrsBuilder_AddCommand_WithResultAndValidator_RegistersBoth()
    {
        var services = new ServiceCollection();
        services.AddSvrntyCqrs(builder =>
        {
            Svrnty.CQRS.FluentValidation.CqrsBuilderExtensions
                .AddCommand<CreatePersonCommand, CreatePersonResult, CreatePersonCommandHandler, CreatePersonCommandValidator>(builder);
        });

        var provider = services.BuildServiceProvider();

        Assert.NotNull(provider.GetService<ICommandHandler<CreatePersonCommand, CreatePersonResult>>());
        Assert.NotNull(provider.GetService<IValidator<CreatePersonCommand>>());
    }

    [Fact]
    public void CqrsBuilder_AddQuery_WithValidator_RegistersBoth()
    {
        var services = new ServiceCollection();
        services.AddSvrntyCqrs(builder =>
        {
            Svrnty.CQRS.FluentValidation.CqrsBuilderExtensions
                .AddQuery<PersonQuery, IEnumerable<string>, PersonQueryHandler, PersonQueryValidator>(builder);
        });

        var provider = services.BuildServiceProvider();

        Assert.NotNull(provider.GetService<IQueryHandler<PersonQuery, IEnumerable<string>>>());
        Assert.NotNull(provider.GetService<IValidator<PersonQuery>>());
    }
}