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

namespace Svrnty.CQRS.Tests;

public class ServiceRegistrationTests
{
    [Fact]
    public void AddCommand_WithResult_RegistersHandlerInDI()
    {
        var services = new ServiceCollection();
        services.AddCommand<CreatePersonCommand, CreatePersonResult, CreatePersonCommandHandler>();

        var provider = services.BuildServiceProvider();
        var handler = provider.GetService<ICommandHandler<CreatePersonCommand, CreatePersonResult>>();

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

    [Fact]
    public void AddCommand_WithResult_RegistersCommandMeta()
    {
        var services = new ServiceCollection();
        services.AddCommand<CreatePersonCommand, CreatePersonResult, CreatePersonCommandHandler>();

        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 AddCommand_WithoutResult_RegistersHandlerInDI()
    {
        var services = new ServiceCollection();
        services.AddCommand<DeletePersonCommand, DeletePersonCommandHandler>();

        var provider = services.BuildServiceProvider();
        var handler = provider.GetService<ICommandHandler<DeletePersonCommand>>();

        Assert.NotNull(handler);
        Assert.IsType<DeletePersonCommandHandler>(handler);
    }

    [Fact]
    public void AddCommand_WithoutResult_RegistersCommandMeta()
    {
        var services = new ServiceCollection();
        services.AddCommand<DeletePersonCommand, DeletePersonCommandHandler>();

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

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

    [Fact]
    public void AddQuery_RegistersHandlerInDI()
    {
        var services = new ServiceCollection();
        services.AddQuery<PersonQuery, IEnumerable<string>, PersonQueryHandler>();

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

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

    [Fact]
    public void AddQuery_RegistersQueryMeta()
    {
        var services = new ServiceCollection();
        services.AddQuery<PersonQuery, IEnumerable<string>, PersonQueryHandler>();

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

        Assert.Single(metas);
        Assert.Equal(typeof(PersonQuery), metas[0].QueryType);
        Assert.Equal(typeof(IEnumerable<string>), metas[0].QueryResultType);
    }

    [Fact]
    public void AddDefaultCommandDiscovery_RegistersCommandDiscovery()
    {
        var services = new ServiceCollection();
        services.AddDefaultCommandDiscovery();

        var provider = services.BuildServiceProvider();
        var discovery = provider.GetService<ICommandDiscovery>();

        Assert.NotNull(discovery);
        Assert.IsType<CommandDiscovery>(discovery);
    }

    [Fact]
    public void AddDefaultQueryDiscovery_RegistersQueryDiscovery()
    {
        var services = new ServiceCollection();
        services.AddDefaultQueryDiscovery();

        var provider = services.BuildServiceProvider();
        var discovery = provider.GetService<IQueryDiscovery>();

        Assert.NotNull(discovery);
        Assert.IsType<QueryDiscovery>(discovery);
    }

    [Fact]
    public void FullPipeline_DiscoveryFindsRegisteredCommands()
    {
        var services = new ServiceCollection();
        services.AddCommand<CreatePersonCommand, CreatePersonResult, CreatePersonCommandHandler>();
        services.AddCommand<DeletePersonCommand, DeletePersonCommandHandler>();
        services.AddDefaultCommandDiscovery();

        var provider = services.BuildServiceProvider();
        var discovery = provider.GetRequiredService<ICommandDiscovery>();

        Assert.Equal(2, discovery.GetCommands().Count());
        Assert.True(discovery.CommandExists("CreatePerson"));
        Assert.True(discovery.CommandExists("DeletePerson"));
    }

    [Fact]
    public void FullPipeline_DiscoveryFindsRegisteredQueries()
    {
        var services = new ServiceCollection();
        services.AddQuery<PersonQuery, IEnumerable<string>, PersonQueryHandler>();
        services.AddQuery<PersonLookupQuery, string, PersonLookupQueryHandler>();
        services.AddDefaultQueryDiscovery();

        var provider = services.BuildServiceProvider();
        var discovery = provider.GetRequiredService<IQueryDiscovery>();

        Assert.Equal(2, discovery.GetQueries().Count());
        Assert.True(discovery.QueryExists("Person"));
        Assert.True(discovery.QueryExists("customPersonLookup"));
    }

    [Fact]
    public void AddSvrntyCqrs_RegistersDiscoveryServices()
    {
        var services = new ServiceCollection();
        services.AddSvrntyCqrs();

        var provider = services.BuildServiceProvider();

        Assert.NotNull(provider.GetService<ICommandDiscovery>());
        Assert.NotNull(provider.GetService<IQueryDiscovery>());
    }

    [Fact]
    public void AddSvrntyCqrs_WithFluentBuilder_RegistersCommandsAndQueries()
    {
        var services = new ServiceCollection();
        services.AddSvrntyCqrs(builder =>
        {
            builder
                .AddCommand<CreatePersonCommand, CreatePersonResult, CreatePersonCommandHandler>()
                .AddCommand<DeletePersonCommand, DeletePersonCommandHandler>()
                .AddQuery<PersonQuery, IEnumerable<string>, PersonQueryHandler>();
        });

        var provider = services.BuildServiceProvider();
        var cmdDiscovery = provider.GetRequiredService<ICommandDiscovery>();
        var qryDiscovery = provider.GetRequiredService<IQueryDiscovery>();

        Assert.Equal(2, cmdDiscovery.GetCommands().Count());
        Assert.Single(qryDiscovery.GetQueries());
    }
}