using Microsoft.AspNetCore.DataProtection.KeyManagement;
using Microsoft.AspNetCore.Http;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Reflection;
using System.Text;

namespace Utility
{
    /// <summary>
    /// 抛异常静态类
    /// </summary>
    public static class Oops
    {

        /// <summary>
        /// 错误代码类型
        /// </summary>
        private static readonly IEnumerable<Type> ErrorCodeTypes;

        /// <summary>
        /// 构造函数
        /// </summary>
        static Oops()
        {
            ErrorCodeTypes = GetErrorCodeTypes();

        }

        /// <summary>
        /// 抛出业务异常信息
        /// </summary>
        /// <param name="errorMessage">异常消息</param>
        /// <param name="args">String.Format 参数</param>
        /// <returns>异常实例</returns>
        public static AppFriendlyException Bah(string errorMessage, params object[] args)
        {
            var friendlyException = Oh(errorMessage, typeof(ValidationException), args);
            friendlyException.StatusCode = StatusCodes.Status400BadRequest;
            friendlyException.ValidationException = true;
            return friendlyException;
        }

        /// <summary>
        /// 抛出业务异常信息
        /// </summary>
        /// <param name="errorCode">错误码</param>
        /// <param name="args">String.Format 参数</param>
        /// <returns>异常实例</returns>
        public static AppFriendlyException Bah(object errorCode, params object[] args)
        {
            var friendlyException = Oh(errorCode, typeof(ValidationException), args);
            friendlyException.StatusCode = StatusCodes.Status400BadRequest;
            friendlyException.ValidationException = true;
            return friendlyException;
        }

        /// <summary>
        /// 抛出字符串异常
        /// </summary>
        /// <param name="errorMessage">异常消息</param>
        /// <param name="args">String.Format 参数</param>
        /// <returns>异常实例</returns>
        public static AppFriendlyException Oh(string errorMessage, params object[] args)
        {
            var friendlyException = new AppFriendlyException(errorMessage, default);

            friendlyException.StatusCode = StatusCodes.Status400BadRequest;
            friendlyException.ValidationException = true;
            return friendlyException;
        }

        /// <summary>
        /// 抛出字符串异常
        /// </summary>
        /// <param name="errorMessage">异常消息</param>
        /// <param name="exceptionType">具体异常类型</param>
        /// <param name="args">String.Format 参数</param>
        /// <returns>异常实例</returns>
        public static AppFriendlyException Oh(string errorMessage, Type exceptionType, params object[] args)
        {
            var exceptionMessage = string.Format(errorMessage, args);
            return new AppFriendlyException(exceptionMessage, default,
                Activator.CreateInstance(exceptionType, new object[] { exceptionMessage }) as Exception);
        }

        /// <summary>
        /// 抛出字符串异常
        /// </summary>
        /// <typeparam name="TException">具体异常类型</typeparam>
        /// <param name="errorMessage">异常消息</param>
        /// <param name="args">String.Format 参数</param>
        /// <returns>异常实例</returns>
        public static AppFriendlyException Oh<TException>(string errorMessage, params object[] args)
            where TException : class
        {
            return Oh(errorMessage, typeof(TException), args);
        }

        /// <summary>
        /// 抛出错误码异常
        /// </summary>
        /// <param name="errorCode">错误码</param>
        /// <param name="args">String.Format 参数</param>
        /// <returns>异常实例</returns>
        public static AppFriendlyException Oh(object errorCode, params object[] args)
        {
            var (ErrorCode, Message) = GetErrorCodeMessage(errorCode, args);
            var friendlyException = new AppFriendlyException(Message, errorCode) { ErrorCode = ErrorCode };

            friendlyException.StatusCode = StatusCodes.Status400BadRequest;
            friendlyException.ValidationException = true;
            return friendlyException;
        }

        /// <summary>
        /// 抛出错误码异常
        /// </summary>
        /// <param name="errorCode">错误码</param>
        /// <param name="exceptionType">具体异常类型</param>
        /// <param name="args">String.Format 参数</param>
        /// <returns>异常实例</returns>
        public static AppFriendlyException Oh(object errorCode, Type exceptionType, params object[] args)
        {
            var (ErrorCode, Message) = GetErrorCodeMessage(errorCode, args);
            return new AppFriendlyException(Message, errorCode,
                Activator.CreateInstance(exceptionType, new object[] { Message }) as Exception)
            { ErrorCode = ErrorCode };
        }

        /// <summary>
        /// 抛出错误码异常
        /// </summary>
        /// <typeparam name="TException">具体异常类型</typeparam>
        /// <param name="errorCode">错误码</param>
        /// <param name="args">String.Format 参数</param>
        /// <returns>异常实例</returns>
        public static AppFriendlyException Oh<TException>(object errorCode, params object[] args)
            where TException : class
        {
            return Oh(errorCode, typeof(TException), args);
        }
        /// <summary>
        /// 获取错误码消息
        /// </summary>
        /// <param name="errorCode"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        private static (object ErrorCode, string Message) GetErrorCodeMessage(object errorCode, params object[] args)
        {
            string errorMessage = "";
            (errorCode, errorMessage) = HandleEnumErrorCode(errorCode);
            return (errorCode, errorMessage);
        }
        /// <summary>
        /// 处理枚举类型错误码
        /// </summary>
        /// <param name="errorCode">错误码</param>
        /// <returns></returns>
        private static (object ErrorCode, string Message) HandleEnumErrorCode(object errorCode)
        {
            string errorMessage = "";
            // 获取类型
            var errorType = errorCode.GetType();

            // 判断是否是内置枚举类型，如果是解析特性
            if (ErrorCodeTypes.Any(u => u == errorType))
            {
                var fieldinfo = errorType.GetField(Enum.GetName(errorType, errorCode));
                if (fieldinfo.IsDefined(typeof(ErrorCodeItemMetadataAttribute), true))
                {
                    var info = GetErrorCodeItemInformation(fieldinfo);
                    errorCode = info.Key;
                    errorMessage = info.Value;
                }
            }

            return (errorCode, errorMessage);
        }
        /// <summary>
        /// 获取错误代码信息
        /// </summary>
        /// <param name="fieldInfo">字段对象</param>
        /// <returns>(object key, object value)</returns>
        private static (object Key, string Value) GetErrorCodeItemInformation(FieldInfo fieldInfo)
        {
            var errorCodeItemMetadata = fieldInfo.GetCustomAttribute<ErrorCodeItemMetadataAttribute>();
            return (errorCodeItemMetadata.ErrorCode ?? fieldInfo.Name, string.Format(errorCodeItemMetadata.ErrorMessage, errorCodeItemMetadata.Args));
        }
        /// <summary>
        /// 获取错误代码类型
        /// </summary>
        /// <returns></returns>
        private static IEnumerable<Type> GetErrorCodeTypes()
        {
            var typesWithErrorCodeTypeAttribute = AppDomain.CurrentDomain
            .GetAssemblies()
            .SelectMany(assembly => assembly.GetTypes())
            .Where(type => type.IsEnum && type.GetCustomAttribute<ErrorCodeTypeAttribute>() != null)
            .ToList();
            return typesWithErrorCodeTypeAttribute;

        }

    }
}