using Furion;
using Furion.DataValidation;
using Furion.FriendlyException;
using Furion.UnifyResult;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Filters;
using Microsoft.CodeAnalysis;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace FlexJobApi.Core
{
    /// <summary>
    /// RESTful 风格返回值
    /// </summary>
    [UnifyModel(typeof(FriendlyResult<>))]
    public class FriendlyResultProvider : IUnifyResultProvider
    {
        /// <summary>
        /// JWT 授权异常返回值
        /// </summary>
        /// <param name="context"></param>
        /// <param name="metadata"></param>
        /// <returns></returns>
        public IActionResult OnAuthorizeException(DefaultHttpContext context, ExceptionMetadata metadata)
        {
            return new JsonResult(
                GetResult(
                    metadata.StatusCode,
                    data: metadata.Data,
                    errorCode: metadata.ErrorCode.ToString(),
                    errors: metadata.Errors),
                UnifyContext.GetSerializerSettings(context));
        }

        /// <summary>
        /// 异常返回值
        /// </summary>
        /// <param name="context"></param>
        /// <param name="metadata"></param>
        /// <returns></returns>
        public IActionResult OnException(ExceptionContext context, ExceptionMetadata metadata)
        {
            return new JsonResult(
                GetResult(
                    metadata.StatusCode,
                    data: metadata.Data,
                    errorCode: metadata.ErrorCode?.ToString() ?? "s500",
                    errors: metadata.Errors)
                , UnifyContext.GetSerializerSettings(context));
        }

        /// <summary>
        /// 成功返回值
        /// </summary>
        /// <param name="context"></param>
        /// <param name="data"></param>
        /// <returns></returns>
        public IActionResult OnSucceeded(ActionExecutedContext context, object data)
        {
            return new JsonResult(
                GetResult(
                    StatusCodes.Status200OK,
                    true,
                    data),
                UnifyContext.GetSerializerSettings(context));
        }

        /// <summary>
        /// 验证失败返回值
        /// </summary>
        /// <param name="context"></param>
        /// <param name="metadata"></param>
        /// <returns></returns>
        public IActionResult OnValidateFailed(ActionExecutingContext context, ValidationMetadata metadata)
        {
            UnifyContext.Fill(metadata.ValidationResult);
            var errors = "参数错误";
            if (metadata.ValidationResult is Dictionary<string, string[]> result && result != null && result.Count > 0)
            {
                errors = result.SelectMany(it => it.Value).FirstOrDefault() ?? "参数错误";
            }
            return new JsonResult(
                GetResult(
                    metadata.StatusCode ?? StatusCodes.Status400BadRequest,
                    data: metadata.Data,
                    errorCode: "s400",
                    errors: errors),
                UnifyContext.GetSerializerSettings(context));
        }

        /// <summary>
        /// 特定状态码返回值
        /// </summary>
        /// <param name="context"></param>
        /// <param name="statusCode"></param>
        /// <param name="unifyResultSettings"></param>
        /// <returns></returns>
        public async Task OnResponseStatusCodes(HttpContext context, int statusCode, UnifyResultSettingsOptions unifyResultSettings)
        {
            // 设置响应状态码
            UnifyContext.SetResponseStatusCodes(context, statusCode, unifyResultSettings);

            // 默认情况下，并未设置 HTTP 状态码，所以返回为 200，如需设置可通过以下代码：
            // context.Response.StatusCode = statusCode;

            switch (statusCode)
            {
                // 处理 401 状态码
                case StatusCodes.Status401Unauthorized:
                    await context.Response.WriteAsJsonAsync(
                        GetResult(
                            statusCode,
                            errorCode: "401",
                            errors: "401 Unauthorized"),
                        App.GetOptions<JsonOptions>()?.JsonSerializerOptions);
                    break;
                // 处理 403 状态码
                case StatusCodes.Status403Forbidden:
                    await context.Response.WriteAsJsonAsync(
                        GetResult(
                            statusCode,
                            errorCode: "403",
                            errors: "403 Forbidden"),
                        App.GetOptions<JsonOptions>()?.JsonSerializerOptions);
                    break;
                default: break;
            }
        }

        /// <summary>
        /// 返回 RESTful 风格结果集
        /// </summary>
        /// <param name="statusCode"></param>
        /// <param name="succeeded"></param>
        /// <param name="data"></param>
        /// <param name="errorCode"></param>
        /// <param name="errors"></param>
        /// <returns></returns>
        private static FriendlyResult<object> GetResult(int statusCode, bool succeeded = default, object data = default, string errorCode = null, object errors = default)
        {
            return new FriendlyResult<object>
            {
                TraceId = App.GetTraceId(),
                Code = statusCode,
                ErrorCode = errorCode,
                Success = succeeded,
                Data = data,
                Msg = errors,
                Extras = UnifyContext.Take(),
                Timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
            };
        }
    }
}