using Microsoft.Extensions.DependencyInjection;

var services = new ServiceCollection();
services.AddSpace(opt =>
{
    opt.NotificationDispatchType = NotificationDispatchType.Parallel; // or Sequential
});

services.AddSpaceInMemoryCache(); // if caching module needed

var provider = services.BuildServiceProvider();
var space = provider.GetRequiredService<ISpace>();

public sealed record UserLoginRequest(string UserName);
/*
The response type can be defined using IRequest<T>.
*/
public sealed record UserLoginRequest(string UserName) : IRequest<UserLoginResponse>
public sealed record UserLoginResponse(bool Success);

public class UserHandlers
{
    [Handle]
    public ValueTask<UserLoginResponse> Login(HandlerContext<UserLoginRequest> ctx)
        => ValueTask.FromResult(new UserLoginResponse(true));
}

 /*
 The same functionality can be implemented using the IHandler<UserLoginRequest,  UserLoginResponse> interface.
 The primary difference from the attribute-based approach is that the method name will be explicitly defined in the interface implementation.
*/

public class UserHandlers : IHandler<UserLoginRequest, UserLoginResponse>
{
    public ValueTask<UserLoginResponse> Handle  (UserLoginRequest request, CancellationToken  cancellationToken)
        => ValueTask.FromResult(new UserLoginResponse   (true));
}

var response = await space.Send<UserLoginResponse>(new UserLoginRequest("demo"));
/*
A more efficient solution can be achieved in the Send method by utilizing both the request and response types.
*/
var response = await space.Send<UserLoginRequest, UserLoginResponse>(new UserLoginRequest("demo"))

public class PricingHandlers
{
    [Handle(Name = "Default")] public ValueTask<PriceResult> GetDefault(HandlerContext<PriceQuery> ctx) => ...;
    [Handle(Name = "Discounted")] public ValueTask<PriceResult> GetDiscounted(HandlerContext<PriceQuery> ctx) => ...;
}
var discounted = await space.Send<PriceResult>(new PriceQuery(...), handlerName: "Discounted");

public class LoggingPipeline
{
    [Pipeline(Order = 100)]
    public async ValueTask<TResponse> Log<TRequest, TResponse>(PipelineContext<TRequest> ctx)
    {
        // pre-execution 
        var result = await ctx.Next(ctx);
        // post-execution
        return result;
    }
}

public sealed record UserLoggedIn(string UserName);
public class LoginNotifications
{
    [Notification]
    public ValueTask Log(NotificationContext<UserLoggedIn> ctx) => ValueTask.CompletedTask;
}
await space.Publish(new UserLoggedIn("demo"));

public class UserQueries
{
    [Handle]
    [CacheModule(DurationSeconds = 60)]
    public ValueTask<UserProfile?> GetUser(HandlerContext<UserId> ctx) => ...;
}