using Dpz.Core.Web.Library.Middleware;
using Microsoft.AspNetCore.Mvc.Filters;
using OpenIddict.Client.AspNetCore;

namespace Dpz.Core.Web.Library.Filter;

public class ExceptionHandleAttribute(ILogger<ExceptionHandleAttribute> logger)
    : ExceptionFilterAttribute
{
    public override async Task OnExceptionAsync(ExceptionContext context)
    {
        await HandleException(context, () => base.OnExceptionAsync(context));
    }

    private Task HandleException(ExceptionContext context, Func<Task> _)
    {
        if (
            context is
            {
                Exception: OperationCanceledException,
                HttpContext.RequestAborted.IsCancellationRequested: true
            }
        )
        {
            context.ExceptionHandled = true;
            return Task.CompletedTask;
        }

        if (context.Exception is SyntheticTimeoutException syntheticTimeoutException)
        {
            logger.LogInformation(syntheticTimeoutException, "timeout");
            context.ExceptionHandled = true;
            context.HttpContext.Response.Clear();
            context.HttpContext.Response.StatusCode = StatusCodes.Status408RequestTimeout;
            return Task.CompletedTask;
        }

        if (context.Exception is CurrentUserRequiredException currentUserRequiredException)
        {
            return HandleCurrentUserRequiredExceptionAsync(context, currentUserRequiredException);
        }

        if (context.Exception is BusinessException businessException)
        {
            logger.LogError(context.Exception, "business error");
            context.Result = new JsonResult(new ResultInfo(businessException.Message));
            context.HttpContext.Response.Clear();
            context.HttpContext.Response.StatusCode = 200;
            return Task.CompletedTask;
        }

        logger.LogError(context.Exception, "Uncaught exception");

        var httpContext = context.HttpContext;
        if (httpContext.Request.ExpectsJsonResponse())
        {
            context.ExceptionHandled = true;
            context.Result = new JsonResult(new ResultInfo(context.Exception.Message));
            context.HttpContext.Response.Clear();
            context.HttpContext.Response.StatusCode = 200;
            return Task.CompletedTask;
        }

        httpContext.Items[HtmlErrorPageMiddleware.ExceptionLoggedItemKey] = true;
        return Task.CompletedTask;
    }

    private async Task HandleCurrentUserRequiredExceptionAsync(
        ExceptionContext context,
        CurrentUserRequiredException exception
    )
    {
        logger.LogInformation(exception, "Current user is required");

        var httpContext = context.HttpContext;
        context.ExceptionHandled = true;
        httpContext.Response.Clear();

        if (httpContext.Request.ExpectsJsonResponse())
        {
            context.Result = new JsonResult(ResultInfo.ToFail(exception.Message))
            {
                StatusCode = StatusCodes.Status401Unauthorized,
            };
            httpContext.Response.StatusCode = StatusCodes.Status401Unauthorized;
            return;
        }

        await httpContext.SignOutAsync(Program.AuthorizeCookieName);

        var returnUrl =
            httpContext.Request.PathBase
            + httpContext.Request.Path
            + httpContext.Request.QueryString;
        context.Result = new ChallengeResult(
            OpenIddictClientAspNetCoreDefaults.AuthenticationScheme,
            new AuthenticationProperties { RedirectUri = returnUrl }
        );
    }
}