DigitalData.Core/DigitalData.Core.Exceptions.Middleware/GlobalExceptionHandlerMiddleware.cs

namespace DigitalData.Core.Exceptions.Middleware;

using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using System.Net;
using System.Text.Json;

/// <summary>
/// Middleware for handling exceptions globally in the application.
/// Captures exceptions thrown during the request pipeline execution,
/// logs them, and returns an appropriate HTTP response with a JSON error message.
/// </summary>
public class GlobalExceptionHandlerMiddleware
{
    private readonly RequestDelegate _next;

    private readonly ILogger<GlobalExceptionHandlerMiddleware>? _logger;

    private readonly GlobalExceptionHandlerOptions? _options;

    /// <summary>
    /// Initializes a new instance of the <see cref="GlobalExceptionHandlerMiddleware"/> class.
    /// </summary>
    /// <param name="next">The next middleware in the request pipeline.</param>
    /// <param name="logger">The logger instance for logging exceptions.</param>
    public GlobalExceptionHandlerMiddleware(RequestDelegate next, ILogger<GlobalExceptionHandlerMiddleware>? logger = null, IOptions<GlobalExceptionHandlerOptions>? options = null)
    {
        _next = next;
        _logger = logger;
        _options = options?.Value;
    }

    /// <summary>
    /// Invokes the middleware to handle the HTTP request.
    /// </summary>
    /// <param name="context">The HTTP context of the current request.</param>
    /// <returns>A task that represents the asynchronous operation.</returns>
    public async Task InvokeAsync(HttpContext context)
    {
        try
        {
            await _next(context); // Continue down the pipeline
        }
        catch (Exception ex)
        {
            await HandleExceptionAsync(context, ex, _logger);
        }
    }

    /// <summary>
    /// Handles exceptions by logging them and writing an appropriate JSON response.
    /// </summary>
    /// <param name="context">The HTTP context of the current request.</param>
    /// <param name="exception">The exception that occurred.</param>
    /// <param name="logger">The logger instance for logging the exception.</param>
    /// <returns>A task that represents the asynchronous operation.</returns>
    private static async Task HandleExceptionAsync(HttpContext context, Exception exception, ILogger? logger = null)
    {
        context.Response.ContentType = "application/json";

        string message;

        switch (exception)
        {
            case BadRequestException badRequestEx:
                context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
                message = badRequestEx.Message;
                break;

            case NotFoundException notFoundEx:
                context.Response.StatusCode = (int)HttpStatusCode.NotFound;
                message = notFoundEx.Message;
                break;

            default:
                logger?.LogError(exception, "Unhandled exception occurred.");
                context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
                message = "An unexpected error occurred.";
                break;
        }

        await context.Response.WriteAsync(JsonSerializer.Serialize(new
        {
            message
        }));
    }
}