using DG.EntityFramework;
using Exceptionless.Models;
using Microsoft.AspNetCore.Mvc.RazorPages;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Internal;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using MySqlConnector;
using Serilog;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Numerics;
using System.Reflection.Emit;
using System.Security.Cryptography;
using System.Security.Cryptography.Xml;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using WX.CRM.Common.Employee;
using Zxd.Core.Shared.Dto;
using Zxd.Core.Shared.Helpers;
using Zxd.Crm.Domain.Dto;
using Zxd.Crm.Domain.Impl;
using Zxd.Domain.Config;
using Zxd.Entity.SSO;
using Zxd.Entity.Zxd;
using Zxd.EntityFramework;
using DeptmentDto = Zxd.Crm.Domain.Dto.DeptmentDto;
using Employee = Zxd.Entity.SSO.Employee;

namespace Zxd.Crm.Domain
{
    public class SSOEmployeeDomain : ISSOEmployeeDomain
    {
        private readonly IConfiguration _configuration;
        private readonly ICacheDomain _cacheDomain;
        private readonly IBaseRepository<SSODbContext> _repository;
        private readonly IBaseRepository<ZxdDbContext> _zxdRepository;
        private readonly IServiceProvider _serviceProvider;

        public SSOEmployeeDomain(IConfiguration configuration, ICacheDomain cacheDomain, IBaseRepository<SSODbContext> repository, IBaseRepository<ZxdDbContext> zxdRepository, IServiceProvider serviceProvider)
        {
            _configuration = configuration;
            _cacheDomain = cacheDomain;
            _repository = repository;
            _zxdRepository = zxdRepository;
            _serviceProvider = serviceProvider;
        }

        /// <summary>
        /// 记录员工软件用户字典
        /// </summary>
        ///
        /// <returns></returns>
        public async Task<ApiResult<bool>> SetEmployeeSoftDict(EMPLOYEE_SOFT_DICT data)
        {
            try
            {
                var existModel = await _zxdRepository.GetRepository<EMPLOYEE_SOFT_DICT>().FirstOrDefaultAsync(n => n.eid == data.eid && n.resid == data.resid && n.appusername == data.appusername);
                if (existModel == null)
                {
                    await _zxdRepository.GetRepository<Entity.Zxd.EMPLOYEE_SOFT_DICT>().InsertAsync(data);
                }
            }
            catch (Exception ex)
            {
                Log.Error($"记录员工软件用户字典失败:{ex.ToString()}");
                return new ApiResult<bool> { Code = 0, Data = false, Message = "记录员工软件用户字典失败" };
            }
            return new ApiResult<bool> { Code = 0, Data = false, Message = "记录员工软件用户字典成功" };
        }

        public async Task<PageResult<GetEmpowermentDto>> GetEmpowerment(GetEmpowermentByAppidDto dto)
        {
            var resList = new List<GetEmpowermentDto>();
            int count;
            try
            {
                var appid = dto.appid;

                var eidsByBusinessLine = new List<int>();

                if (appid == null || appid == "") return new PageResult<GetEmpowermentDto>(dto.PageIndex, dto.PageSize, 0, resList);

                // 员工数据
                var employeeList = _zxdRepository.GetRepository<Entity.Zxd.Employee>().Query().Where(e => e.is_deleted != 1 && (e.status == 1 || e.status == 3));

                //employeeList = employeeList.Where(e => e.appid == appid);
                // 筛选条件
                // 筛选员工id
                if (dto.eid != null || dto.userId != null)
                {
                    employeeList = employeeList.Where(e => (dto.eid != null && e.employee_id == dto.eid) || (dto.userId != null && e.id == dto.userId));
                };
                // 筛选事业部
                if (dto.deptId != null)
                {
                    eidsByBusinessLine = await _zxdRepository.GetRepository<EmployeeDepartmentDetail>().Query().Where(d => d.department_id == (int)dto.deptId).Select(s => (int)s.eid).ToListAsync();

                    employeeList = employeeList.Where(e => eidsByBusinessLine.Contains((int)e.employee_id));
                }
                // 筛选姓名
                if (dto.name != null && dto.name != "")
                {
                    employeeList = employeeList.Where(e => e.employee_name.Contains(dto.name));
                }
                // 员工软件用户数据
                var softEmployeeBindList = _zxdRepository.GetRepository<EMPLOYEE_PHONE_BIND>().Query().Where(w => employeeList.FirstOrDefault(f => f.employee_id == w.eid) != null);
                //var softuserList = _zxdRepository.GetRepository<SOFT_USER>().Query().Where(s => s.RESID != null && s.RESID != "" && softEmployeeBindList.FirstOrDefault(so => so.resid == s.RESID) != null);
                // 根据resid分类，并获取创建时间最新的软件账号再转成字典
                //var softTemp = softuserList.AsEnumerable().GroupBy(m => m.RESID).Select(s => s.OrderByDescending(g => g.CTIME).FirstOrDefault()).ToList();
                //var softDict = softTemp.ToDictionary(soft => soft.RESID == null ? "" : soft.RESID, soft => soft.USERNAME == null ? "" : soft.USERNAME);
                // 获取员工绑定数据

                var resQuery = from bind in softEmployeeBindList
                               join employee in employeeList on bind.eid equals employee.employee_id
                               join ef in _zxdRepository.GetRepository<EmployeeDepartmentFull>().Query() on bind.eid equals ef.eid into tmpef
                               from ef in tmpef.DefaultIfEmpty()
                               join a in _zxdRepository.GetRepository<RES_CUSTOMER>().Query() on bind.resid equals a.RESID into tmpAB
                               from a in tmpAB.DefaultIfEmpty()
                                   //join soft in softuserList on bind.resid equals soft.RESID into softRes
                                   //from res in softRes.DefaultIfEmpty()
                               where ef.appid == appid
                               orderby bind.eid
                               select
                               new GetEmpowermentDto
                               {
                                   employee_id = bind.eid,
                                   employee_name = employee.employee_name,
                                   showPhone = bind.show_phone,
                                   phone = bind.show_phone,
                                   resid = bind.resid,
                                   umid = a.UMID,
                                   is_main = bind.is_main,
                                   last_empower_time = bind.last_empower_time,
                                   appusername = bind.appusername,
                               }
                               ;

                resQuery = resQuery.If(!string.IsNullOrEmpty(dto.umid), x => x.Where(x => x.umid == dto.umid));
                count = resQuery.Count();
                var bindList = resQuery.Skip((dto.PageIndex - 1) * dto.PageSize)
                .Take(dto.PageSize);

                resList = await bindList.ToListAsync();
                //resList.ForEach(resItem =>
                //{
                //    string value;
                //    softDict.TryGetValue(resItem.resid, out value);
                //    resItem.appusername = value;
                //});
            }
            catch (Exception ex)
            {
                Log.Error(ex.ToString());
                throw new ApiException($"获取数据失败：{ex}");
            }
            return new PageResult<GetEmpowermentDto>(dto.PageIndex, dto.PageSize, count, resList);
        }

        public class softRes
        {
            public string username { get; set; }
            public DateTime createdTime { get; set; }
        }

        public List<DeptmentDto> getDeptment()
        {
            List<DeptmentDto> departmentList = new List<DeptmentDto>();
            var systemConfig = _configuration.GetSection("SystemConfig").Get<SystemConfig>();
            var url = systemConfig.GetDeptsUrl();
            var req = HttpHelper.GetData(url, "", Encoding.UTF8);
            var resModel = JsonHelper.FromJson<ApiResult<List<DeptmentDto>>>(req);
            if (resModel.Code == 0)
            {
                departmentList = resModel.Data.ToList();
                //departmentList = resModel.Data.Where(d => d.Appid == appid).ToList();
            }
            return departmentList;
        }

        public class TempMapForDeptidAppid
        {
            public int deptId { get; set; }
            public string appId { get; set; }
        }

        // 递归出坐席id
        public string? FindDepartment(int id, List<DepartmentCrmConf> departmap, List<Department> SSODeptsList)
        {
            // 当层递归的部门id
            var curDept = SSODeptsList.FirstOrDefault(d => d.id == id);
            // 当层部门id对应的坐席id
            var curMap = departmap.FirstOrDefault(de => de.department_id == id);
            // 没有更上层，不需要递归，直接返回结果
            if (curDept.parent_id == null) return curMap == null ? null : curMap.AppId;
            if (curMap == null)
            {
                // 没找到坐席id，进入递归
                return FindDepartment((int)curDept.parent_id, departmap, SSODeptsList);
            }
            else
            {
                return curMap.AppId;
            }
        }

        // 清空备份表
        public async Task<bool> ClearZxdEmpolyee()
        {
            try
            {
                var employeeList = _zxdRepository.GetRepository<Entity.Zxd.Employee>().Query().ToList();
                await _zxdRepository.GetRepository<Entity.Zxd.Employee>().BatchDeleteAsync(employeeList);
                return true;
            }
            catch (Exception ex)
            {
                Log.Error("清空备份表失败：" + ex.Message);
                return false;
            }
        }

        public async Task<bool> BindSoftUserInit()
        {
            try
            {
                // 拿绑定表的数据，调用 UpdateAppusername 接口
                //var bindList = _zxdRepository.GetRepository<Entity.Zxd.EMPLOYEE_PHONE_BIND>().Query().Select(s => new Appuser { eid = s.eid, resid = s.resid }).ToList();
                //var dto = new UpdateAppusernameDto { UpdateAppusernameList = bindList };

                await UpdateAppusername();
                Log.Information("绑定数据初始化软件用户数据结束");
                return true;
            }
            catch (Exception ex)
            {
                Log.Error("绑定数据初始化软件用户数据失败：" + ex.Message);
                return false;
            }
        }

        public async Task<bool> SSOBindDataInit()
        {
            try
            {
                //var phoneResids = await _zxdRepository.GetRepository<Entity.Zxd.Employee>().Query().Where(x => !string.IsNullOrEmpty(x.phone_resid)).Select(x => x.phone_resid).Distinct().ToListAsync();

                //var softuserList = await _zxdRepository.GetRepository<SOFT_USER>().Query().Where(s => phoneResids.Contains(s.RESID)).ToListAsync();

                var date = new DateTime(2023, 9, 5, 17, 00, 00);
                //todo 把empolyee_phone_bind表的数据拉出来循环调用 更新软件用户名数据接口
                var wx_empower_log = await _zxdRepository.GetRepository<WX_EMPOWER_LOG>().Query()
                    .Where(w => w.created_time < date)
                    .GroupBy(g => new { g.to_by_eid, g.softusername, g.appid })
                    .Select(x => new { x.Key.to_by_eid, x.Key.softusername, x.Key.appid, x.First().from_by_eid })
                    .Select(s => s).ToListAsync();

                var appDict = new Dictionary<string, string>() {
                    {"asset_h5","b+eki574sYoyNaWIsHhJj2j3I0hvqjAsMb3ts3nTxmc="},
                    {"cms_dg","2XPMELRrlzH7kOeR/QTJCA8ltRk4kmvTaB/y7WczZe4="},
                    {"crm_app_10000","gzymZTnIcdxM2TugT8p00jIvZWP5VneiimYUyIbw5Hk="},
                    {"crm_d1d2_dnzz","tXxYuzU3H9Wki0Qh5HhxVnBKg9kbqIYGyxGqgtbPljc="},
                    {"crm_d3_dnyy","3gy2vCskdrpPziFykGKNmeTkyKGCitgGPO7q5qIvmfs="},
                    {"crm_df_yypt","TYd8USnG3yKFuW/hFigwxfMpzygMEmfZYNewXdJVaU4="},
                    {"crm_hq","dgk42zepqMGn0vr5YeHxtSgpc/sAZjow3WYz0ugDHdg="},
                    {"crm_pt_ptd2","VQcggIYFw7wAsi4OTRXBn1x9N0f/95ricnCjJbHDys4="},
                    {"crm_tg_dnbb","N0e44dEIA0hQwOOATZu/bij55N0fD0CNAA9IsisCZeM="},
                    {"crm_tg_dng8","17D4xLHTFQbRrMchTr4Dd5RcUyn4WbJda+MarKTlw78="},
                    {"decision_making_system","kegsfgECmohd2Qxq1fojbQ+RkS4THNtVRWeHLXW6ADA="},
                    {"dg_tgzt","nboMi57qEqGv95+3W13lSN31YTOBlirG8m0RWlyNi6A="},
                    {"qt_compliance","AdC+vVj58wG48swyjyW2WM6aC6CxYNKt8pP0c8sdozs="},
                    {"qt_core","uoJdPl19HK2iWGLPGuOMxh38BGx8WveClY3I3PqDNYk="},
                };

                #region 单例

                //string AppId = "crm_tg_dng8";//坐席的appid
                //string Secret = "+P44LokNo+1mdWxu6V/DhpdlA7z+EvHHEinxZ3WKI24=";//坐席的appid的密钥
                //ApiDockHelper dock = new ApiDockHelper(AppId, Secret);
                //Dictionary<string, object> dic = new Dictionary<string, object>();
                //dic.Add("employeeId", 132015);
                //dic.Add("account", "dn0003774");
                //dic.Add("operator", 132015);
                //dic.Add("reason", "初始化数据");
                //var ssoUrl = "https://conf.soft.dn8188.com";
                //ssoUrl = "http://192.168.11.141:24434";

                //ApiResultTemp<string> model = dock.PostApi<string>(ssoUrl + "/v1/api/open/employee/ip/add", dic);

                #endregion 单例

                foreach (var log in wx_empower_log)
                {
                    Log.Information($"推送SSO数据：to_by_eid={log.to_by_eid};softusername={log.softusername};from_by_eid={log.from_by_eid};appid={log.appid}");
                    string appid = log.appid;//坐席的appid
                    string secret = appDict[log.appid];//坐席的appid的密钥
                    ApiDockHelper dock = new ApiDockHelper(appid, secret);
                    Dictionary<string, object> dic = new()
                    {
                        { "employeeid", log.to_by_eid },
                        { "account", log.softusername },
                        { "operator", log.from_by_eid },
                        { "reason", "初始化数据" }
                    };
                    var ssourl = "https://conf.soft.dn8188.com";
                    //ssourl = "http://192.168.11.141:24434";

                    ApiResultTemp<string> model = dock.PostApi<string>(ssourl + "/v1/api/open/employee/ip/add", dic);
                    if (model.ret != 0)
                    {
                        Log.Error("sso_推送错误:" + model.ToJson());
                    }
                }
                Log.Information("推送SSO数据结束");
                return true;
            }
            catch (Exception ex)
            {
                Log.Error("推送SSO数据失败：" + ex.Message);
                return false;
            }
        }

        /// <summary>
        /// 增加员工软件用户的绑定数据日志
        /// </summary>
        /// <param name="to_by_eid">被操作员工id</param>
        /// <param name="resid">资源id</param>
        /// <param name="type">操作类型 bind: 绑定或更新 unbind 解绑</param>
        /// <param name="from_by_eid">操作员工id</param>
        ///
        /// <returns></returns>
        public async Task<ApiResult<bool>> AddSoftEmployeeBindLog(int to_by_eid, string resid, string type, int from_by_eid)
        {
            #region 绑定日志

            try
            {
                var softEmployeeBindLog = _zxdRepository.GetRepository<EMPLOYEE_PHONE_BIND_LOG>();

                // 绑定或解绑日志
                await softEmployeeBindLog.InsertAsync(new EMPLOYEE_PHONE_BIND_LOG
                {
                    from_by_eid = from_by_eid,
                    createtime = DateTime.Now,
                    type = type,
                    resid = resid,
                    to_by_eid = to_by_eid
                });
            }
            catch (Exception ex)
            {
                Log.Error("埋点失败" + ex.ToString());
                return new ApiResult<bool> { Code = -1, Data = false, Message = "埋点失败" };
            }

            #endregion 绑定日志

            return new ApiResult<bool> { Code = 0, Data = false, Message = "埋点成功" };
        }

        /// <summary>
        /// 解绑员工软件用户的绑定数据
        /// </summary>
        /// <param name="to_by_eid">被操作员工id</param>
        /// <param name="resid">资源id</param>
        /// <param name="show_phone">脱敏后电话</param>
        /// <param name="from_by_eid">操作员工id</param>
        /// <param name="is_main">是否为主账号</param>
        ///
        /// <returns></returns>
        public async Task<ApiResult<bool>> DeleteSoftEmployeeBind(int to_by_eid, string resid, string show_phone, int from_by_eid)
        {
            try
            {
                var softEmployeeBind = _zxdRepository.GetRepository<EMPLOYEE_PHONE_BIND>();

                var Appuser = await softEmployeeBind.Query().FirstOrDefaultAsync(f => to_by_eid == f.eid && resid == f.resid);
                // 删除不存在的数据，或删除主账号，直接返回
                if (Appuser == null) return new ApiResult<bool> { Code = -1, Data = false, Message = "不存在该用户，无法解绑" };
                if (Appuser.is_main == 1) return new ApiResult<bool> { Code = -1, Data = false, Message = "无法解绑主用户" };
                await softEmployeeBind.DeleteAsync(Appuser);
            }
            catch (Exception ex)
            {
                Log.Error("解绑失败" + ex.ToString());
                return new ApiResult<bool> { Code = -1, Data = false, Message = "解绑失败" };
            }
            var logRes = await AddSoftEmployeeBindLog(to_by_eid, resid, "unbind", from_by_eid);
            if (logRes.Code != 0)
            {
                return new ApiResult<bool> { Code = 0, Data = false, Message = "解绑成功,但埋点失败" };
            }
            return new ApiResult<bool> { Code = 0, Data = false, Message = "解绑成功" };
        }

        /// <summary>
        /// 增加员工软件用户的绑定数据
        /// </summary>
        /// <param name="to_by_eid">被操作员工id</param>
        /// <param name="resid">资源id</param>
        /// <param name="show_phone">脱敏后电话</param>
        /// <param name="from_by_eid">操作员工id</param>
        /// <param name="is_main">是否为主账号</param>
        /// <returns></returns>
        public async Task<ApiResult<bool>> AddSoftEmployeeBind(int to_by_eid, string resid, string show_phone, int from_by_eid, int is_main = 0)
        {
            try
            {
                var softEmployeeBind = _zxdRepository.GetRepository<EMPLOYEE_PHONE_BIND>();
                var count = await softEmployeeBind.Query().Where(b => b.eid == to_by_eid).CountAsync();

                var limit = await _cacheDomain.GetValueParameter("EmployeePhoneBindLimit");
                limit = limit == "" || limit == null ? "3" : limit;
                // todo 从参数里拿限制个数
                if (count >= int.Parse(limit)) return new ApiResult<bool> { Code = -1, Data = false, Message = $"员工绑定电话已经达上限,不能超过{limit}个！" };
                var Appuser = await softEmployeeBind.Query().FirstOrDefaultAsync(f => to_by_eid == f.eid && resid == f.resid);
                //if (await softEmployeeBind.Query().FirstOrDefaultAsync(f => resid == f.resid) != null) return new ApiResult<bool> { Code = -1, Data = false, Message = "该电话已经被绑定，不能重复绑定" };

                #region 更新员工的软件账号（目前只有主账号会被更新）

                if (is_main == 1)
                {
                    Appuser = await softEmployeeBind.Query().FirstOrDefaultAsync(f => to_by_eid == f.eid && f.is_main == 1);
                }
                if (Appuser != null && is_main == 1)
                {
                    Appuser.resid = resid;
                    Appuser.show_phone = show_phone;
                    await softEmployeeBind.UpdateAsync(Appuser);
                }

                #endregion 更新员工的软件账号（目前只有主账号会被更新）

                else if (Appuser == null)
                {
                    #region 绑定

                    await softEmployeeBind.InsertAsync(new EMPLOYEE_PHONE_BIND
                    {
                        eid = to_by_eid,
                        resid = resid,
                        show_phone = show_phone,
                        is_main = is_main
                    });

                    #endregion 绑定
                }
                var softuser =  await _zxdRepository.GetRepository<SOFT_USER>().Query().FirstOrDefaultAsync(n=>n.RESID == resid);
                if(softuser != null)
                {
                    await SetEmployeeSoftDict(new EMPLOYEE_SOFT_DICT
                    {
                        appusername = softuser.USERNAME,
                        eid = to_by_eid,
                        resid = resid,
                    });
                }

            }
            catch (Exception ex)
            {
                Log.Error("绑定失败" + ex.ToString());
                return new ApiResult<bool> { Code = -1, Data = false, Message = "绑定失败" };
            }
            var logRes = await AddSoftEmployeeBindLog(to_by_eid, resid, "bind", from_by_eid);
            if (logRes.Code != 0)
            {
                return new ApiResult<bool> { Code = 0, Data = false, Message = "绑定成功,但埋点失败" };
            }
            return new ApiResult<bool> { Code = 0, Data = false, Message = "绑定成功" };
        }

        public async Task AsyncEmplyeeData(string eid)
        {
            var eids = eid.Split(',').Select(x => int.Parse(x)).ToList();
            var users = await _repository.GetRepository<Employee>().Query().Where(x => eids.Contains(x.employee_id.Value))
                .ToListAsync();
            foreach (var user in users)
            {
                await AddSoftEmployeeBind((int)user.employee_id, user.phone_resid, user.phone, 10000, 1);
            }
        }

        // 从SSO同步员工数据到【中心点】的员工表
        public async Task<bool> AsyncEmplyeeData()
        {
            try
            {
                // 中心点的员工数据
                var employeeList = _zxdRepository.GetRepository<Entity.Zxd.Employee>().Query().OrderByDescending(o => o.update_time).ToList();
                // 员工电话绑定表
                var softEmployeeBind = _zxdRepository.GetRepository<EMPLOYEE_PHONE_BIND>();
                var SSOUserList = new List<Employee>();
                if (employeeList.Count != 0)
                {
                    var lastFlag = employeeList.FirstOrDefault();
                    Log.Information($"同步表最新时间:{lastFlag.update_time}");
                    // SSO的员工数据
                    SSOUserList = _repository.GetRepository<Entity.SSO.Employee>().Query().Where(s => s.update_time > lastFlag.update_time).ToList();
                }
                else
                {
                    SSOUserList = _repository.GetRepository<Entity.SSO.Employee>().Query().ToList();
                }

                if (SSOUserList.Count == 0)
                {
                    return true;
                }
                // SSO的部门数据
                var SSODeptsList = _repository.GetRepository<Department>().Query().ToList();
                // 软件用户表
                var softuserList = _zxdRepository.GetRepository<SOFT_USER>().Query().ToList();
                // 坐席对应部门表
                var departmap = _repository.GetRepository<DepartmentCrmConf>().Query().ToList();
                // 员工部门关系表
                var employeeDept = _repository.GetRepository<EmployeeDepartment>().Query().Where(e => e.is_deleted != 1).ToList();
                // 部门id和坐席id对照临时表
                var tempMapForDeptidAppid = new List<TempMapForDeptidAppid>();
                // 生成对照表数据
                SSODeptsList.ForEach(D =>
                {
                    var appid = FindDepartment(D.id, departmap, SSODeptsList);
                    tempMapForDeptidAppid.Add(new TempMapForDeptidAppid { deptId = D.id, appId = appid });
                });

                #region 员工备份表同步逻辑

                // 如果在【中心点】能找到对应员工id，并且更新时间不一致，则更新
                // 如果在【中心点】没找到对应员工id，则新增
                foreach (var SSOUser in SSOUserList)
                {
                    Log.Information($"需要同步的员工:{SSOUser.employee_id}");
                    var ZXDUser = employeeList.FirstOrDefault(z => z.employee_id == SSOUser.employee_id);
                    var ophone = SSOUser != null ? SSOUser.phone : "";// 原始电话号码
                    var resid = "";
                    var phone = "";// 加密电话号码
                    var showPhone = "";// 屏蔽中间五个数字后的电话号码
                    var appusername = ""; // 软件用户名
                    var currDept = employeeDept.Where(em => em.employee_id == SSOUser.id).OrderByDescending(em2 => em2.department_id).FirstOrDefault();

                    string? appid = null;
                    if (currDept != null)
                    {
                        var tappid = tempMapForDeptidAppid.FirstOrDefault(map => map.deptId == currDept.department_id)?.appId;
                        appid = tappid;
                    };
                    if (SSOUser.phone_resid != "" && SSOUser.phone_resid != null)
                    {
                        resid = SSOUser.phone_resid;
                        appusername = softuserList.FirstOrDefault(s => s.RESID == resid) is null ? "" : softuserList.FirstOrDefault(s => s.RESID == resid).USERNAME;
                    }
                    // 把已经删除的员工账号剔除出绑定表
                    if (SSOUser.is_deleted == 1)
                    {
                        var Appuser = await softEmployeeBind.Query().Where(f => f.eid == SSOUser.employee_id).ToListAsync();
                        if (Appuser.Count != 0)
                        {
                            await softEmployeeBind.BatchDeleteAsync(Appuser);
                        }
                    }
                    else
                    {
                        // 同步该员工绑定主账号
                        await AddSoftEmployeeBind((int)SSOUser.employee_id, resid, ophone, 10000, 1);
                        await SetEmployeeSoftDict(new EMPLOYEE_SOFT_DICT
                        {
                            appusername = appusername,
                            eid = (int)SSOUser.employee_id,
                            resid = resid,
                        });
                    }

                    if ((ZXDUser != null && ZXDUser.update_time != SSOUser.update_time))
                    {
                        // 更新
                        ZXDUser.employee_id = SSOUser.employee_id;
                        ZXDUser.status = SSOUser.status;
                        ZXDUser.employee_name = SSOUser.employee_name;
                        ZXDUser.is_deleted = SSOUser.is_deleted;
                        ZXDUser.update_time = SSOUser.update_time;
                        ZXDUser.create_time = SSOUser.create_time;
                        ZXDUser.phone = ophone;
                        ZXDUser.showPhone = ophone;
                        ZXDUser.appid = appid;
                        ZXDUser.phone_resid = resid;
                        await _zxdRepository.GetRepository<Entity.Zxd.Employee>().UpdateAsync(ZXDUser);
                    }
                    else if (ZXDUser == null)
                    {
                        //  新增
                        await _zxdRepository.GetRepository<Entity.Zxd.Employee>().InsertAsync(new Entity.Zxd.Employee
                        {
                            id = SSOUser.id,
                            employee_id = SSOUser.employee_id,
                            employee_name = SSOUser.employee_name,
                            is_deleted = SSOUser.is_deleted,
                            update_time = SSOUser.update_time,
                            create_time = SSOUser.create_time,
                            status = SSOUser.status,
                            phone = ophone,
                            showPhone = ophone,
                            appid = appid,
                            phone_resid = resid
                        });
                    }

                    #endregion 员工备份表同步逻辑
                }
            }
            catch (Exception ex)
            {
                Log.Error($"同步报错：{ex.ToString()}");
                //return false;
            }
            Log.Information("同步成功");
            return true;
        }

        /// <summary>
        /// 替换手机号中间五位为*
        /// </summary>
        /// <param name="phoneNo"></param>
        /// <returns></returns>
        public string ReturnPhoneNO(string phoneNo)
        {
            Regex re = new Regex(@"(\d{3})(\d{5})(\d{3})", RegexOptions.None); //构造手机号的正则表达式 将其分为三组分别为3、4、4个数字
            phoneNo = re.Replace(phoneNo, "$1*****$3");//保留第一组和第三组 用"*****"替换第二组
            return phoneNo;
        }

        public async Task<List<DeptMentReturnModel>> GetDeptmentByEid(string? eidList)
        {
            List<DeptMentReturnModel> res = new List<DeptMentReturnModel>();
            if (string.IsNullOrWhiteSpace(eidList))
            {
                throw new Exception("参数不能为空");
            }
            var deptList = await _cacheDomain.GetDeptMapList();
            var filterEid = eidList.Split(",").Where(n => !string.IsNullOrWhiteSpace(n)).ToList();
            var hasValueList = deptList.Where(n => filterEid.Contains(n.Eid)).ToList();
            if (hasValueList.Count > 0)
            {
                res.AddRange(hasValueList);
            }
            filterEid = filterEid.Where(n => !hasValueList.Select(s => s.Eid).Contains(n)).ToList();
            if (filterEid.Count == 0)
            {
                return hasValueList;
            }
            var userList = _repository.GetRepository<Employee>().Query().Where(n => filterEid.Contains(Convert.ToString(n.employee_id)) && n.is_deleted == 0).ToList();
            var departmentsList = _repository.GetRepository<Department>().Query().Where(n => n.is_deleted == 0).ToList();
            var employeeDept = _repository.GetRepository<EmployeeDepartment>().Query().Where(p => userList.Select(n => n.id).Contains(p.employee_id.Value) && p.is_deleted == 0).ToList();
            var departments = departmentsList.Where(p => employeeDept.Select(n => n.department_id).Contains(p.id) && p.is_deleted == 0).ToList();
            var departmap = _repository.GetRepository<DepartmentCrmConf>().Query().ToList();
            var mapquery = from n in userList
                           join b in employeeDept
                           on n.id equals b.employee_id
                           join c in departments
                           on b.department_id equals c.id
                           select new DeptMentReturnModel
                           {
                               Eid = n.employee_id.ToString(),
                               DeptId = c.id,
                               DeptName = c.department_name
                           };
            var mapList = mapquery.ToList();
            var hasChange = false;
            foreach (var eid in filterEid)
            {
                var map = deptList.FirstOrDefault(n => n.Eid == eid);
                if (map == null)
                {
                    var item = mapList.FirstOrDefault(n => n.Eid == eid);
                    if (item != null)
                    {
                        var deptItem = departmentsList.FirstOrDefault(n => n.id == item.DeptId);
                        var config = BuildParentDept(deptItem, departmentsList, departmap);
                        if (config != null)
                        {
                            var mapItem = departmentsList.FirstOrDefault(n => n.id == config.department_id);
                            hasChange = true;
                            map = new DeptMentReturnModel
                            {
                                Eid = item.Eid,
                                DeptId = mapItem?.id,
                                DeptName = mapItem?.department_name,
                                AppId = config.AppId,
                                CompanyCode = config.CompanyCode,
                                SaleDeptId = config.SaleDeptId
                            };
                            res.Add(map);
                            deptList.Add(map);
                        }
                    }
                    else
                    {
                        map = new DeptMentReturnModel
                        {
                            Eid = eid,
                            DeptId = 0,
                            DeptName = ""
                        };
                        deptList.Add(map);
                        hasChange = true;
                    }
                }
            }
            //重新塞进缓存
            if (hasChange)
            {
                await _cacheDomain.AddDeptMapInfo(deptList);
            }
            return res;
        }

        public async Task<bool> RemoveEidCache(string? eidList)
        {
            if (string.IsNullOrEmpty(eidList))
            {
                await _cacheDomain.UpdateDeptMapInfo(new List<DeptMentReturnModel>());
                return true;
            }
            var deptList = await _cacheDomain.GetDeptMapList();
            var filterEid = eidList.Split(",").ToList();
            var hasValueList = deptList.Where(n => !filterEid.Contains(n.Eid)).ToList();
            await _cacheDomain.UpdateDeptMapInfo(hasValueList);
            return true;
        }

        /// <summary>
        /// 通过员工id获取软件用户名
        /// </summary>
        /// <param name="eid">员工id</param>
        ///
        /// <returns></returns>
        public async Task<ApiResult<List<string>>> GetAppuserByEid(int eid)
        {
            try
            {
                // 员工软件账号绑定表
                var softEmployeeBind = _zxdRepository.GetRepository<EMPLOYEE_PHONE_BIND>().Query().Where(e => e.eid == eid);
                var appuserQuery = await _zxdRepository.GetRepository<SOFT_USER>().Query().Where(e => softEmployeeBind.FirstOrDefault(f => f.resid == e.RESID) != null && e.USERNAME != "" && e.USERNAME != null).Select(s => s.USERNAME).ToListAsync();
                var appuserBind = await _zxdRepository.GetRepository<EMPLOYEE_SOFT_DICT>().Query().Where(e => e.eid == eid).Select(s => s.appusername).ToListAsync();
                var res = appuserQuery.Union(appuserBind).ToList();
                return new ApiResult<List<string>> { Code = 0, Data = res, Message = "获取成功" };
            }
            catch (Exception ex)
            {
                Log.Error(ex.ToString());
                Log.Error("通过员工id获取软件用户名获取失败" + ex.ToString());
                return new ApiResult<List<string>> { Code = -1, Data = new List<string>(), Message = "获取失败" };
            }
        }

        // 更新【授权日志】
        // 虽然这里可以批量添加，但是绝大数情况下，都是单个添加
        public async Task<ApiResult<bool>> SetEmpowerment(SetEmpowermentDto dto)
        {
            try
            {
                //SetEmpowermentDto
                var EmployeeList = dto.EmployeeList;
                var productIdList = dto.ProductList;
                var employeeSoftDict = _zxdRepository.GetRepository<Entity.Zxd.EMPLOYEE_SOFT_DICT>().Query();

                #region 更新最新赋权时间

                var residList = String.Join(';', EmployeeList.Select(e => e.resid).ToList());
                await UpdateLastEmpowerTime(residList);

                #endregion 更新最新赋权时间

                for (var eIndex = 0; eIndex < EmployeeList.Count; eIndex++)
                {
                    var curEmployee = EmployeeList[eIndex];

                    #region 判断是否需要增加【员工 软件用户】字典数据

                    if (employeeSoftDict.FirstOrDefault(f => f.eid == curEmployee.employee_id && f.resid == curEmployee.resid && f.appusername == curEmployee.softusername) == null)
                    {
                        await SetEmployeeSoftDict(new EMPLOYEE_SOFT_DICT
                        {
                            appusername = curEmployee.softusername,
                            eid = curEmployee.employee_id,
                            resid = curEmployee.resid,
                        });
                    }

                    #endregion 判断是否需要增加【员工 软件用户】字典数据

                    for (var pIndex = 0; pIndex < productIdList.Count; pIndex++)
                    {
                        var curPro = productIdList[pIndex];
                        var endtime = DateTime.Now.AddDays(dto.duration);

                        await _zxdRepository.GetRepository<Entity.Zxd.WX_EMPOWER_LOG>().InsertAsync(new Entity.Zxd.WX_EMPOWER_LOG
                        {
                            to_by_resid = curEmployee.resid,
                            from_by_eid = dto.fromByEid,
                            to_by_eid = curEmployee.employee_id,
                            type = 1,
                            created_time = DateTime.Now,
                            duration = dto.duration,
                            product_name = curPro.subproductname,
                            product_id = curPro.subproductid,
                            order_id = dto.orderid,
                            appid = dto.appid,
                            softusername = curEmployee.softusername,
                        });
                    }
                }
            }
            catch (Exception ex)
            {
                return new ApiResult<bool> { Code = -1, Data = false, Message = "添加失败" };
            }
            return new ApiResult<bool> { Code = 0, Data = true, Message = "添加成功" };
        }

        // 更新员工电话绑定表的软件用户数据
        public async Task<ApiResult<string>> UpdateAppusername(List<Appuser> UpdateAppusernameList = null)
        {
            using var scope = _serviceProvider.CreateAsyncScope();
            var zxdRepository = scope.ServiceProvider.GetRequiredService<IBaseRepository<ZxdDbContext>>();
            var list = new List<EMPLOYEE_PHONE_BIND>();
            if (UpdateAppusernameList == null)
            {
                list = await zxdRepository.GetRepository<EMPLOYEE_PHONE_BIND>().Query().Where(item => !string.IsNullOrEmpty(item.resid)).ToListAsync();
            }
            else
            {
                var resids = UpdateAppusernameList.Select(x => x.resid);
                var eids = UpdateAppusernameList.Select(x => x.eid);
                list = await zxdRepository.GetRepository<EMPLOYEE_PHONE_BIND>().Query().Where(x => resids.Contains(x.resid) && eids.Contains(x.eid)).Where(item => !string.IsNullOrEmpty(item.resid)).ToListAsync();
            }
            using var transaction = await zxdRepository.BeginTransactionAsync();
            try
            {
                var needUpdateList = new List<EMPLOYEE_PHONE_BIND>();
                foreach (var item in list)
                {
                    // 软件用户
                    var softuser = await zxdRepository.GetRepository<SOFT_USER>().Query()
                        .Where(s => s.RESID != null && s.RESID != "" && s.RESID == item.resid)
                        .OrderByDescending(g => g.CTIME).FirstOrDefaultAsync();

                    // 员工电话绑定
                    //var softuser = softuserList.FirstOrDefault(f => f.RESID == item.resid);
                    //var softEmployee = softEmployeeBind.FirstOrDefault(f => f.resid == item.resid && f.eid == item.eid);
                    if (softuser != null && item != null && softuser.USERNAME != item.appusername)
                    {
                        item.appusername = softuser.USERNAME;
                        needUpdateList.Add(item);
                    }
                    if (softuser != null)
                    {
                        await SetEmployeeSoftDict(new EMPLOYEE_SOFT_DICT
                        {
                            appusername = item.appusername,
                            eid = (int)item.eid,
                            resid = item.resid,
                        });
                    }
                }
                await zxdRepository.GetRepository<EMPLOYEE_PHONE_BIND>().BatchUpdateAsync(needUpdateList, x => new { x.appusername });

                await transaction.CommitAsync();
            }
            catch (Exception ex)
            {
                await transaction.DisposeAsync();
                await transaction.RollbackAsync();
                Log.Error("更新软件用户数据失败:" + ex.ToString());
                return new ApiResult<string> { Code = -1, Data = "", Message = "更新失败" };
            }
            return new ApiResult<string> { Code = 0, Data = "", Message = "更新成功" };
        }

        public class Appuser
        {
            public int id { get; set; }
            public int eid { get; set; }
            public string resid { get; set; }
        }

        public class UpdateAppusernameDto
        {
            public List<Appuser> UpdateAppusernameList { get; set; }
        }

        // 更新上次赋权时间
        public async Task<ApiResult<string>> UpdateLastEmpowerTime(string residString, long? timestamp = null)
        {
            var empower_time = DateTime.Now;
            try
            {
                if (timestamp != null)
                {
                    empower_time = Utility.ConvertStringToDateTime(timestamp.ToString());
                }
                var residList = residString.Split(";");
                var query = _zxdRepository.GetRepository<EMPLOYEE_PHONE_BIND>().Query();
                foreach (var resid in residList)
                {
                    var curBindList = await query.Where(w => w.resid == resid && w.last_empower_time != empower_time).ToListAsync();
                    foreach (var curBind in curBindList)
                    {
                        curBind.last_empower_time = empower_time;
                    }
                    await _zxdRepository.GetRepository<EMPLOYEE_PHONE_BIND>().BatchUpdateAsync(curBindList);
                }
            }
            catch (Exception ex)
            {
                Log.Error("更新上次赋权时间失败:" + ex.ToString());
                return new ApiResult<string> { Code = -1, Data = "", Message = "更新失败" };
            }
            return new ApiResult<string> { Code = 0, Data = empower_time.ToString(), Message = "更新成功" };
        }

        public DepartmentCrmConf BuildParentDept(Department dept, List<Department> deptList, List<DepartmentCrmConf> mapList)
        {
            if (dept != null)
            {
                var map = mapList.FirstOrDefault(n => n.department_id == dept.id);
                if (map != null)
                {
                    return map;
                }
                if (dept.parent_id.HasValue)
                {
                    var parDept = deptList.FirstOrDefault(n => n.id == dept.parent_id);
                    return BuildParentDept(parDept, deptList, mapList);
                }
            }
            return null;
        }
    }
}