using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using Bunny.Common.Exception;
using Bunny.Dao.Entity.Constant;
using Newtonsoft.Json;

namespace Bunny.Common.Utils.Jwt;

public static partial class JwtUtil
{
    /// <summary>
    ///     返回所有的 jwt
    /// </summary>
    /// <param name="token">token解析</param>
    public static JwtSecurityToken JwtParse(string token)
    {
        if (token == null) return null;
        var tokenHandler = new JwtSecurityTokenHandler();
        return tokenHandler.ReadJwtToken(token);
    }

    /// <summary>
    ///     返回发行者
    /// </summary>
    /// <param name="jwt">token解析</param>
    public static string JwtParseIssuer(string jwt)
    {
        return JwtParse(jwt).Issuer;
    }

    /// <summary>
    ///     返回授权者
    /// </summary>
    /// <param name="jwt">token解析</param>
    public static IEnumerable<string> JwtParseAudiences(string jwt)
    {
        return JwtParse(jwt).Audiences;
    }

    /// <summary>
    ///     返回负载中内容
    /// </summary>
    /// <param name="jwt">jwt 解析</param>
    public static IEnumerable<Claim> JwtParseClaim(string jwt)
    {
        return JwtParse(jwt).Claims;
    }

    /// <summary>
    ///     将生成的JWT值转成字典格式
    /// </summary>
    /// <param name="jwt"></param>
    /// <returns>Dictionary</returns>
    public static Dictionary<string, object> ParseJwtToDictionary(string jwt)
    {
        var tokenHandler = new JwtSecurityTokenHandler();
        var jwtSecurityToken = tokenHandler.ReadJwtToken(jwt);

        // 初始化字典
        var dictionary = new Dictionary<string, object>();
        var jClaims = jwtSecurityToken.Claims;

        // 将得到的每一个值都放入字典中
        foreach (var claim in jClaims) dictionary[claim.Type] = claim.Value;

        // 返回字典
        return dictionary;
    }

    /// <summary>
    ///     将生成的 JwtSecurityToken 值转成字典格式
    /// </summary>
    /// <param name="jwtToken"></param>
    /// <returns>Dictionary</returns>
    public static Dictionary<string, object> ParseJwtToDictionary(JwtSecurityToken jwtToken)
    {
        // 初始化字典
        var dictionary = new Dictionary<string, object>();

        // 将得到的每一个值都放入字典中
        foreach (var claim in jwtToken.Claims) dictionary[claim.Type] = claim.Value;

        // 返回字典
        return dictionary;
    }

    /// <summary>
    ///     将 jwt 转成 实体类
    /// </summary>
    /// <param name="jwt">jwt</param>
    /// <returns>实体类</returns>
    public static T? ParseJwtToObject<T>(string jwt)
    {
        if (jwt == null) throw new BunnyException(ExceptionConstant.TokenIsEmpty);
        var dictionary = new Dictionary<string, object>();
        // 将 jwt 转成 Claim
        var claims = JwtParseClaim(jwt);

        // 找到对应的字典 Dictionary
        foreach (var claim in claims) dictionary[claim.Type] = claim.Value;

        // 返回实体类
        var json = JsonConvert.SerializeObject(dictionary);
        // 将JSON转为对象
        return JsonConvert.DeserializeObject<T>(json);
    }


    /// <summary>
    ///     将 JSON 转成 Dictionary
    /// </summary>
    /// <param name="jsonString"></param>
    /// <returns>Dictionary</returns>
    public static Dictionary<string, object> ParseJsonToDictionary(string jsonString)
    {
        // 初始化字典
        var dictionary = new Dictionary<string, object>();

        // 将JSON转成字典格式
        var claims = ParseJsonToClaimEnumerable(jsonString);

        // 将得到的每一个值都放入字典中
        foreach (var claim in claims) dictionary[claim.Type] = claim.Value;

        // 返回 Dictionary
        return dictionary;
    }

    /// <summary>
    ///     将 JSON 转成 Claim
    /// </summary>
    /// <param name="jsonString"></param>
    /// <returns>Claim</returns>
    public static IEnumerable<Claim> ParseJsonToClaimEnumerable(string jsonString)
    {
        // 将JSON转成字典格式
        var deserializeWithDictionary = JsonConvert.DeserializeObject<IDictionary<string, object>>(jsonString);

        // 返回Claim
        return deserializeWithDictionary!.Select(item =>
            {
                if (item.Value == null)
                    return new Claim(item.Key, string.Empty);
                return new Claim(item.Key, item.Value.ToString()!);
            })
            .ToList();
    }

    /// <summary>
    ///     将 JSON 转成 实体类
    /// </summary>
    /// <param name="jsonString">JSON字符串</param>
    /// <returns>实体类</returns>
    public static T? ParseJsonToObject<T>(string jsonString)
    {
        // 将JSON转成字典格式
        var claims = ParseJsonToClaimEnumerable(jsonString);

        // 初始化字典
        var dictionary = new Dictionary<string, object>();

        // 将得到的每一个值都放入字典中
        foreach (var claim in claims) dictionary[claim.Type] = claim.Value;

        // 返回实体类
        var json = JsonConvert.SerializeObject(dictionary);
        // 将JSON转为对象
        return JsonConvert.DeserializeObject<T>(json);
    }


    /// <summary>
    ///     将 Claim 抓成 Dictionary
    /// </summary>
    /// <param name="claims"></param>
    /// <returns>Dictionary</returns>
    public static Dictionary<string, object> ParseClaimToDictionary(IEnumerable<Claim> claims)
    {
        // 初始化字典
        var dictionary = new Dictionary<string, object>();

        // 将得到的每一个值都放入字典中
        foreach (var claim in claims) dictionary[claim.Type] = claim.Value;

        // 返回字典格式
        return dictionary;
    }
}