using Microsoft.EntityFrameworkCore.Metadata.Internal;
using Microsoft.Extensions.DependencyInjection;
using MySqlConnector;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.Encodings.Web;
using System.Threading.Tasks;
using Zxd.Core.Domain.Dto;
using Zxd.Core.Domain.Dto.Dncmsbase;
using Zxd.Domain.Config;

namespace Zxd.Core.Domain
{
    internal class UserInfoDomain : IUserInfoDomain
    {
        private readonly IServiceProvider _serviceProvider;
        private readonly IRedisManager _redisManager;
        private readonly IBaseRepository<DncmsbaseDbContext> _cmsBaseRepository;

        public UserInfoDomain(
            IRedisManager redisManager,
            IServiceProvider serviceProvider,
            IBaseRepository<DncmsbaseDbContext> cmsBaseRepository)
        {
            _redisManager = redisManager;
            _serviceProvider = serviceProvider;
            _cmsBaseRepository = cmsBaseRepository;
        }

        /// <summary>
        /// 根据条件获取用户信息
        /// </summary>
        /// <param name="cid"></param>
        /// <param name="appid"></param>
        /// <param name="appuserid"></param>
        /// <param name="resid"></param>
        /// <param name="unionid"></param>
        /// <returns></returns>
        public async Task<List<UserInfoDto>> GetUserInfos(int? cid, string? appid, string? appuserid, string? resid, string? unionid)
        {
            var userInfos = new List<UserInfoDto>();
            var paramList = new Dictionary<string, object>();
            if (cid != null && cid > 0)
            {
                paramList.Add("customerid", cid);
                userInfos = await GetUserInfoByCid(cid);
                userInfos ??= await GetUserInfoBySqlCondition(paramList);
            }
            else if (!string.IsNullOrEmpty(appid) && !string.IsNullOrEmpty(appuserid))
            {
                // 从缓存中获取用户信息
                var uid = await _redisManager.ExistsAsync($"{appid}_1_{appuserid}", "UserCenter") ? await _redisManager.GetAsync<int>($"{appid}_1_{appuserid}", "UserCenter") : 0;

                //Log.Information($"在缓存key:【{appid}_1_{appuserid}】中获取 uid：{uid}");
                if (uid == 0)
                {
                    uid = await _redisManager.ExistsAsync($"{appid}_{appuserid}", "UserCenter") ? await _redisManager.GetAsync<int>($"{appid}_{appuserid}", "UserCenter") : 0;
                    //Log.Information($"在缓存key:【{appid}_{appuserid}】中获取 uid：{uid}");
                }
                if (uid > 0 && await _redisManager.ExistsAsync($"user_{uid}", "UserCenter"))
                {
                    Log.Information($"useruid:user_{uid}");
                    var userInfoDto = await _redisManager.GetHashAsync<UserInfoDto>($"user_{uid}", "UserCenter");
                    cid = !string.IsNullOrEmpty(userInfoDto.Customerid) ? int.Parse(userInfoDto.Customerid) : 0;
                    Log.Information($"cid:{userInfoDto.ToJson()} {cid}");
                }
                if (cid != null && cid > 0)
                {
                    paramList.Add("customerid", cid);
                    userInfos = await GetUserInfoByCid(cid);
                    userInfos ??= await GetUserInfoBySqlCondition(paramList);
                }
                if (userInfos == null || !userInfos.Any())
                {
                    paramList = new Dictionary<string, object>
                    {
                        { "appid", appid },
                        { "appuserid", appuserid }
                    };
                    userInfos = await GetUserInfoBySqlCondition(paramList);
                    if (userInfos.Any())
                    {
                        cid = !string.IsNullOrEmpty(userInfos.First().Customerid) ? int.Parse(userInfos.First().Customerid) : 0;
                        userInfos = await GetUserInfoByCid(cid);
                        paramList = new Dictionary<string, object>
                        {
                            { "customerid", cid }
                        };
                        userInfos ??= await GetUserInfoBySqlCondition(paramList);
                    }
                }
            }
            else if (!string.IsNullOrEmpty(resid))
            {
                // 从缓存中获取用户信息
                cid = await _redisManager.ExistsAsync(resid, "UserCenter") ? await _redisManager.GetAsync<int>(resid, "UserCenter") : 0;
                if (cid != null && cid > 0)
                {
                    paramList.Add("Resid", resid);
                    userInfos = await GetUserInfoByCid(cid);
                    userInfos ??= await GetUserInfoBySqlCondition(paramList);
                    if (userInfos.Any())
                    {
                        cid = !string.IsNullOrEmpty(userInfos.First().Customerid) ? int.Parse(userInfos.First().Customerid) : 0;
                        userInfos = await GetUserInfoByCid(cid);
                        paramList = new Dictionary<string, object>
                        {
                            { "customerid", cid }
                        };
                        userInfos ??= await GetUserInfoBySqlCondition(paramList);
                    }
                }
            }
            else if (!string.IsNullOrEmpty(unionid))
            {
                paramList.Add("Unionid", unionid);
                // 如果缓存中没有用户信息，则从数据库中获取
                userInfos ??= await GetUserInfoBySqlCondition(paramList);
                if (userInfos.Any())
                {
                    cid = !string.IsNullOrEmpty(userInfos.First().Customerid) ? int.Parse(userInfos.First().Customerid) : 0;
                    userInfos = await GetUserInfoByCid(cid);
                    paramList = new Dictionary<string, object>
                    {
                        { "customerid", cid }
                    };
                    userInfos ??= await GetUserInfoBySqlCondition(paramList);
                }
            }
            return userInfos;
        }

        /// <summary>
        /// 根据客户id获取客户信息
        /// </summary>
        /// <param name="cid"></param>
        /// <returns></returns>
        private async Task<List<UserInfoDto>?> GetUserInfoByCid(int? cid)
        {
            var userInfos = new List<UserInfoDto>();
            var userInfo = await _redisManager.GetHashAsync<UserInfoDto>($"user_{cid}", "UserCenter");
            if (userInfo != null)
            {
                var result = await _redisManager.GetDatabase("UserCenter").SetMembersAsync($"cid_{cid}");

                #region 反序列化处理

                foreach (var item in result)
                {
                    if (!item.HasValue) continue;
                    try
                    {
                        var data = JsonSerializer.Deserialize<UserInfo>(item, new JsonSerializerOptions
                        {
                            Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping
                        });
                        if (data == null) continue;
                        var uid = data.Uid;
                        userInfo = await _redisManager.GetHashAsync<UserInfoDto>($"user_{uid}", "UserCenter");
                        userInfos.Add(userInfo);
                        continue;
                    }
                    catch (Exception e)
                    {
                        Log.Error($"反序列化失败：{e.Message}");
                    }
                    try
                    {
                        var data = JsonSerializer.Deserialize<UserInfoDto>(item, new JsonSerializerOptions
                        {
                            Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping
                        });
                        if (data == null) continue;
                        var uid = data.Uid;
                        userInfo = await _redisManager.GetHashAsync<UserInfoDto>($"user_{uid}", "UserCenter");
                        userInfos.Add(userInfo);
                    }
                    catch (Exception e)
                    {
                        Log.Error($"反序列化失败：{e.Message}");
                    }
                }

                #endregion 反序列化处理

                Log.Information($"cid_cache：{userInfos.ToJson()} ");
                return userInfos;
            }
            return null;
        }

        /// <summary>
        /// 根据sql和条件获取客户信息
        /// </summary>
        /// <param name="paramList"></param>
        /// <returns></returns>
        private async Task<List<UserInfoDto>> GetUserInfoBySqlCondition(Dictionary<string, object> paramList)
        {
            Log.Information($"lookdb:{paramList.ToJson()}");
            var sql = @"SELECT Uid, Appid, Appuserid, Customerid, Resid, Unionid FROM UserInfo WHERE 1=1";
            if (!paramList.Any()) return new List<UserInfoDto>();
            using (var scope = _serviceProvider.CreateAsyncScope())
            {
                var userCenterRepository = scope.ServiceProvider.GetRequiredService<IBaseRepository<UserCenterDbContext>>();

                var paramter = new List<MySqlParameter>() { };
                var values = new List<object>();
                foreach (var param in paramList)
                {
                    sql += $" AND {param.Key} = @{param.Key}";
                    paramter.Add(new MySqlParameter() { ParameterName = param.Key, MySqlDbType = MySqlDbType.VarChar, Value = param.Value });
                    values.Add(param.Value);
                }

                //Log.Information($"sql: {sql}, param: {string.Join(',', values)}");
                var userInfos = await userCenterRepository.ExecuteSqlToListAsync<UserInfoDto>(sql, paramter.ToArray());
                return userInfos;
            }
        }

        /// <summary>
        /// 获取业务线Id
        /// </summary>
        /// <param name="userids"></param>
        /// <returns></returns>
        public async Task<List<WeWorkUser2EidDto>> GetLineIdAsync(string userids)
        {
            var ids = userids.Split(',');
            var items = await _cmsBaseRepository.GetRepository<weworkuser2eid>().Query().Where(f => ids.Contains(f.userid)).Select(o => new WeWorkUser2EidDto
            {
                userid = o.userid,
                eid = o.eid,
                deptid = o.deptid
            }).ToListAsync();
            return items;
        }
    }
}