using Microsoft.AspNetCore.Cors;
using Microsoft.AspNetCore.SignalR;
using OASystem.Domain;
using QuartzUI.Extension.AspNetCore.Enum;
using SqlSugar;
using System;
using System.ComponentModel.DataAnnotations;
using System.IdentityModel.Tokens.Jwt;
using static OASystem.API.OAMethodLib.JWTHelper;

namespace OASystem.API.OAMethodLib.Hubs
{
    /// <summary>
    /// 站内通信 Hub
    /// </summary>
    public class ServerHub : Hub
    {

        /// <summary>
        /// 已连接的用户信息
        /// </summary>
        public static List<UserModel> OnlineUser { get; set; } = new List<UserModel>();

        private readonly ILogger<ServerHub> _logger;
        private readonly IHttpContextAccessor _accessor;

        public ServerHub( ILogger<ServerHub> logger, IHttpContextAccessor accessor)
        {
            _logger = logger;
            _accessor = accessor;
        }

        /// <summary>
        /// 当连接成功时执行
        /// </summary>
        /// <returns></returns>
        public override Task OnConnectedAsync()
        {
            string connId = Context.ConnectionId;

            _logger.LogWarning("SignalR已连接");
            //验证Token
            var token = _accessor.HttpContext.Request.Query["access_token"];
            var user = JwtHelper.SerializeJwt(token);
            _logger.LogWarning("SignalR已连接，用户名：" + user.UserName);
            //连接用户 这里可以存在Redis
            var model = new UserModel
            {
                UserId = user.Uid,
                ConnectionId = connId,
                Token = token,
                UserName = user.UserName
            };
            OnlineUser.Add(model);
            //给当前的连接分组 可以进行同一组接收消息 也可以用Token获取机构权限
            //await Groups.AddToGroupAsync(Context.ConnectionId, "测试组");

            //给当前连接返回消息 .Clients可以发多个连接ID
            Clients.Client(connId).SendAsync("ConnectResponse",
                new Result()
                {
                    Code = 200,
                    Data = model,
                    Msg = user.UserName + "连接成功"
                });

            return base.OnConnectedAsync();
        }

        /// <summary>
        /// 当连接断开时的处理
        /// </summary>
        public override Task OnDisconnectedAsync(Exception exception)
        {
            string connId = Context.ConnectionId;
            var model = OnlineUser.Find(u => u.ConnectionId == connId);
            int count = OnlineUser.RemoveAll(u => u.ConnectionId == connId);
            if (model != null)
            {
                //给当前分组发送消息 在一个分组就能接收到消息
                //Clients.Group(model.GroupName).SendAsync("GetUsersResponse", result);

                //给当前连接返回消息 .Clients可以发多个连接ID
                Clients.Client(connId).SendAsync("DisconnectResponse",
                new Result()
                {
                    Code  = 400,
                    Data = "true",
                    Msg = "断开连接"
                });
            }
            return base.OnDisconnectedAsync(exception);
        }

        public async Task Send(string name, string message)
        {
            // Call the broadcastMessage method to update clients.
            await Clients.All.SendAsync("broadcastMessage", name, message);
        }

        /// <summary>
        /// 接受用户的数进行推送
        /// </summary>
        /// <returns></returns>
        public async Task SendMessage(string user, string msg)
        {
            Result  result = new Result();
            result.Data = new UserModel
            {
                ConnectionId = Context.ConnectionId,
                Token = "",
                UserName = user
            };
            result.Code = 200;
            result.Msg = msg;

            //推送给所有连接ID的第一条数据
            await Clients.Clients(OnlineUser.Select(q => q.ConnectionId).ToList()).SendAsync("SendMessage", result);
        }
    }
}