using ATS.NonCustodial.Shared.Common.Enums;
using ATS.NonCustodial.Shared.Extensions;
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Http;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;

namespace ATS.NonCustodial.Shared.Common.Auth
{
    /// <summary>
    /// 用户信息
    /// </summary>
    /// Author:mxg
    /// CreatedTimed:2022-05-15 10:08 PM
    public class User : IUser
    {
        #region Identity

        private readonly IHttpContextAccessor _accessor;

        public User(IHttpContextAccessor accessor)
        {
            _accessor = accessor;
        }

        #endregion Identity

        /// <summary>
        /// 用户Id
        /// </summary>
        public virtual long Id
        {
            get
            {
                var id = _accessor?.HttpContext?.User?.FindFirst(ClaimAttributes.userId);
                if (id != null && id.Value.NotNull())
                {
                    return id.Value.ToLong().Value;
                }
                return 0;
            }
        }

        /// <summary>
        /// 用户名
        /// </summary>
        public string Name
        {
            get
            {
                var name = _accessor?.HttpContext?.User?.FindFirst(ClaimAttributes.userName);

                if (name != null && name.Value.NotNull())
                {
                    return name.Value;
                }

                return "";
            }
        }

        /// <summary>
        /// 单位id
        /// </summary>
        public long UnitId
        {
            get
            {
                var userUnitId = _accessor?.HttpContext?.User?.FindFirst(ClaimAttributes.userUnitId);

                if (userUnitId != null && userUnitId.Value.NotNull())
                {
                    return (long)userUnitId.Value.ToLong();
                }

                return 0;
            }
        }

        /// <summary>
        /// 部门id
        /// </summary>
        public long DeptcodeId
        {
            get
            {
                var userDeptcodeId = _accessor?.HttpContext?.User?.FindFirst(ClaimAttributes.userDeptcodeId);

                if (userDeptcodeId != null && userDeptcodeId.Value.NotNull())
                {
                    return (long)userDeptcodeId.Value.ToLong();
                }

                return 0;
            }
        }
        /// <summary>
        /// 头像
        /// </summary>
        public string Avatar
        {
            get
            {
                var avatar = _accessor?.HttpContext?.User?.FindFirst(ClaimAttributes.avatar);

                return avatar != null && avatar.Value.NotNull() ? avatar.Value : "";
            }
        }

        /// <summary>
        /// 手机号
        /// </summary>
        public string Phone
        {
            get
            {
                var phone = _accessor?.HttpContext?.User?.FindFirst(ClaimAttributes.phone);

                return phone != null && phone.Value.NotNull() ? phone.Value : "";
            }
        }

        /// <summary>
        /// 当前用户的只为类型转换为枚举
        /// </summary>
        public ChatPersonTypeEnum ChatPersonType
        {
            get
            {
                var personType = _accessor?.HttpContext?.User?.FindFirst(ClaimAttributes.personType);

                //return personType != null && personType.Value.NotNull() ? ChatPersonTypeEnum.TryParse(ChatPersonTypeEnum.Admin);
                var chatPersonType = ChatPersonTypeEnum.Admin;

                if (personType != null && personType.Value.NotNull() && Enum.TryParse(personType.Value, out chatPersonType))
                {
                }

                return chatPersonType;
            }
        }

        /// <summary>
        /// 昵称
        /// </summary>
        public string NickName
        {
            get
            {
                var name = _accessor?.HttpContext?.User?.FindFirst(ClaimAttributes.userNickName);

                if (name != null && name.Value.NotNull())
                {
                    return name.Value;
                }

                return "";
            }
        }

        /// <summary>
        /// 租户Id
        /// </summary>
        public virtual long? TenantId
        {
            get
            {
                var tenantId = _accessor?.HttpContext?.User?.FindFirst(ClaimAttributes.tenantId);
                if (tenantId != null && tenantId.Value.NotNull())
                {
                    return tenantId.Value.ToLong();
                }
                return null;
            }
        }

        /// <summary>
        /// 角色列表
        /// </summary>
        public List<long> RoleList
        {
            get
            {
                var roles = _accessor?.HttpContext?.User?.FindFirst(ClaimAttributes.roles);
                if (roles != null && roles.Value.NotNull())
                {
                    return roles.Value.ToList().Select(w => w.ToLong()).ToList();
                }
                return new List<long>();
            }
        }

        /// <summary>
        /// 组织机构
        /// </summary>
        public List<long> OrgList
        {
            get
            {
                var orgs = _accessor?.HttpContext?.User?.FindFirst(ClaimAttributes.orgs);
                if (orgs != null && orgs.Value.NotNull())
                {
                    return orgs.Value.ToList().Select(w => w.ToLong()).ToList();
                }
                return new List<long>();
            }
        }

        /// <summary>
        /// 租户类型
        /// </summary>
        public virtual TenantTypeEnum? TenantType
        {
            get
            {
                var tenantType = _accessor?.HttpContext?.User?.FindFirst(ClaimAttributes.tenantType);
                if (tenantType != null && tenantType.Value.NotNull())
                {
                    return (TenantTypeEnum)Enum.Parse(typeof(TenantTypeEnum), tenantType.Value, true);
                }
                return null;
            }
        }

        /// <summary>
        /// 数据隔离
        /// </summary>
        public virtual DataIsolationTypeEnum? DataIsolationType
        {
            get
            {
                var dataIsolationType = _accessor?.HttpContext?.User?.FindFirst(ClaimAttributes.dataIsolationType);
                if (dataIsolationType != null && dataIsolationType.Value.NotNull())
                {
                    return (DataIsolationTypeEnum)Enum.Parse(typeof(DataIsolationTypeEnum), dataIsolationType.Value, true);
                }
                return null;
            }
        }

        /// <summary>
        /// 请求Ip地址
        /// </summary>
        public string? RemoteIpAddress => _accessor?.HttpContext.Connection.RemoteIpAddress.MapToIPv4().ToString();

        /// <summary>
        ///
        /// </summary>
        /// <returns></returns>
        public bool IsAuthenticated() => _accessor.HttpContext.User.Identity!.IsAuthenticated;

        /// <summary>
        ///
        /// </summary>
        /// <returns></returns>
        public string? GetToken()
        {
            var token = string.Empty;

            if (GetTokenByKeyword("access_token").NotNull())
            {
                token = GetTokenByKeyword("access_token");
            }
            else if (GetTokenByKeyword("token").NotNull())
            {
                token = GetTokenByKeyword("token");
            }
            else if (GetTokenByKeyword("Authorization").NotNull())
            {
                token = GetTokenByKeyword("Authorization")?.Trim().Replace("Bearer ", "")!;
            }

            return token;
        }

        /// <summary>
        ///
        /// </summary>
        /// <returns></returns>
        public IEnumerable<Claim> GetClaimsIdentity()
        {
            var claims = _accessor.HttpContext.User.Claims.ToList();
            var headers = _accessor.HttpContext.Request.Headers;
            claims.AddRange(headers.Select(header => new Claim(header.Key, header.Value)));

            return claims;
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="claimType"></param>
        /// <returns></returns>
        public List<string> GetClaimValueByType(string claimType)
        {
            return (from item in GetClaimsIdentity()
                    where item.Type == claimType
                    select item.Value).ToList();
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="claimType"></param>
        /// <returns></returns>
        public List<string> GetUserInfoFromToken(string claimType)
        {
            var jwtHandler = new JwtSecurityTokenHandler();
            var token = "";

            token = GetToken();
            // token校验
            if (!token.IsNotNullOrEmpty() || !jwtHandler.CanReadToken(token)) return new List<string>() { };
            var jwtToken = jwtHandler.ReadJwtToken(token);

            return (from item in jwtToken.Claims
                    where item.Type == claimType
                    select item.Value).ToList();
        }

        /// <summary>
        /// 注销
        /// </summary>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task LoginOutAsync() => await _accessor.HttpContext.SignOutAsync();

        #region private

        /// <summary>
        /// 获取token
        /// </summary>
        /// <param name="tokenKey"></param>
        /// <returns></returns>
        private string? GetTokenByKeyword(string tokenKey) => _accessor.HttpContext?.Request.Query[tokenKey].ToString();

        #endregion private
    }
}