using AutoMapper;
using AutoMapper.Internal;
using com.sun.xml.@internal.bind.v2.model.core;
using Elight.Entity;
using Elight.Entity.APPDto.Lawyer;
using Elight.Entity.AppMode.Lawyer;
using Elight.Logic;
using Elight.Logic.Model.Lawyer;
using Elight.Logic.SystemModel;
using Elight.Utility;
using Elight.Utility.Code;
using Elight.Utility.Extensions;
using Elight.Utility.logs;
using java.io;
using java.lang;
using java.time;
using javax.xml.crypto;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Filters;
using Newtonsoft.Json;
using NPOI.OpenXmlFormats.Spreadsheet;
using NPOI.SS.Formula.Functions;
using SqlSugar;
using SqlSugar.Extensions;
using System.Data;
using System.IO.Compression;
using System.Linq;
using System.Net.WebSockets;
using System.Text;
using static _24Hour.TwentySystemProxyClient;
using static com.sun.tools.@internal.xjc.reader.xmlschema.bindinfo.BIConversion;
using static NPOI.HSSF.Util.HSSFColor;
using Exception = System.Exception;
using User = Elight.Utility.User;

namespace _24Hour.Controllers.Common
{
    /// <summary>
    /// 律师服务
    /// </summary>
    [Authorize]
    [ApiController]
    [Route("api/Lawyer")]
    public class LawyerArchivesController : Controller
    {
        #region Identity
        private readonly SqlSugarClient _db;//数据库
        private readonly WriteSysLog _logs;//操作日志
        App_Sys_UserModel _userdata = new App_Sys_UserModel();//当前用户
        private readonly ILogger<LawyerArchivesController> logger;//日志
        Result result = new Result();
        private readonly TwentySystemProxyClient twentyClient;
        private readonly IMapper mapper;
        public LawyerArchivesController(ILogger<LawyerArchivesController> _logger, SqlSugarClient db, WriteSysLog logs, User user, IMapper _mapper, TwentySystemProxyClient _twentyClient)
        {
            this.logger = _logger;
            _db = db;
            _logs = logs;
            this.mapper = _mapper;
            this.twentyClient = _twentyClient;
            _userdata = user.Userdata();
        }
        #endregion
        #region 律师阅卷
        /// <summary>
        /// 获取当前登录人员的单位下所有的律师信息
        /// </summary>
        /// <returns></returns>
        [HttpGet("GetAllLawyerByUnitCode")]
        public async Task<Result<IEnumerable<App_Sys_UserModel>>> GetAllLawyerByUnitCode()
        {
            var res = new Result<IEnumerable<App_Sys_UserModel>>();

            var data = await _db.Queryable<App_Sys_UserModel>()
                .Where(x => x.unitCode == _userdata.unitCode && x.IsDeleted == 0 && x.isdeactivate == 0)
                .Where(x => x.identity == "律师")
                .ToListAsync();
            res.IsSucceed = true;
            res.result = data;
            return res;
        }

        /// <summary>
        /// 修改内网律师信息
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("EditLawyer")]
        public async Task<Result> EditLawyer(App_Sys_AddLawyerInput input)
        {
            try
            {
                var data = await _db.Queryable<App_Sys_UserModel>().FirstAsync(x => x.Id == input.Id);
                if (data != null)
                {
                    data = mapper.Map(input, data);
                    _db.BeginTran();
                    var num = await _db.Updateable(data).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();
                    _db.CommitTran();

                    if (num > 0)
                    {
                        result.IsSucceed = true;
                        result.result = "修改成功";

                    }
                }
                else
                {
                    result.IsSucceed = false;
                    result.result = "用户不存在";
                }
            }
            catch (Exception ex)
            {
                result.IsSucceed = false;
                logger.LogError(ex, "");
            }
            return result;
        }
        /// <summary>
        /// 导入律师库信息，先调用/api/Common/Upload_Files1将文件上传至库，然后用url调用ImportLawyerData
        /// </summary>
        /// <param name="path">excel文件相对路径</param>
        /// <returns></returns>
        [HttpGet]
        [Route("ImportLawyerData")]
        public async Task<Result> ImportLawyerData(string path)
        {
            Result res = new Result();
            int updated = 0, added = 0;
            var ext = Path.GetExtension(path).ToLower();

            if (ext == ".xlsx" || ext == ".xls")
            {
                if (System.IO.File.Exists(path))
                {
                    var reader = new ExcelReader(path);
                    var dt = reader.ExcelToDataTable();
                    if (dt != null)
                    {
                        var lawyers = new List<App_Sys_UserModel>();
                        foreach (DataRow dr in dt.Rows)
                        {
                            var cardid = dr.Field<string>("证件编号");
                            if (string.IsNullOrEmpty(cardid))
                            {
                                continue;
                            }
                            lawyers.Add(new()
                            {
                                Id = Guid.NewGuid().ToString(),
                                name = dr.Field<string>("姓名"),
                                sex = dr?.Field<string>("性别")?.Contains('男') == true ? 0 : 1,
                                phone = dr.Field<string>("手机号码"),
                                departmentName = dr.Field<string>("执业机构"),
                                identitycardId = dr.Field<string>("执业证号"),
                                cardId = dr.Field<string>("证件编号"),
                                unitCode = _userdata.unitCode,

                                createtime = DateTime.Now,
                                createuserId = _userdata.createuserId,
                                createusername = _userdata.name,
                                identity = "律师",
                                usertype = 1,
                                audit = 0,

                                isdeactivate = 0,
                                IsDeleted = 0,
                            });
                        }
                        var cardids = lawyers.Select(e => e.cardId).ToList();
                        var lawyersInDb = await _db.Queryable<App_Sys_UserModel>().In(x => x.cardId, cardids).ToListAsync();
                        if (lawyersInDb.Any())
                        {
                            var updatelist = new List<App_Sys_UserModel>();
                            foreach (var item in lawyersInDb)
                            {
                                var lawyerinfo = lawyers.FirstOrDefault(x => x.cardId == item.cardId);
                                if (lawyerinfo == null)
                                {
                                    continue;
                                }
                                if (item.name != lawyerinfo.name ||
                                    item.sex != lawyerinfo.sex ||
                                    item.phone != lawyerinfo.phone ||
                                    item.departmentName != lawyerinfo.departmentName ||
                                    item.cardId != lawyerinfo.cardId)
                                {
                                    item.name = lawyerinfo.name;
                                    item.sex = lawyerinfo.sex;
                                    item.phone = lawyerinfo.phone;
                                    item.departmentName = lawyerinfo.departmentName;
                                    item.cardId = lawyerinfo.cardId;
                                    updatelist.Add(item);
                                }
                            }
                            if (updatelist.Any())
                                updated = await _db.Updateable(updatelist)
                                    .IgnoreColumns(ignoreAllNullColumns: true)
                                    .ExecuteCommandAsync();
                        }
                        var addlawyers = lawyers.Where(x => lawyersInDb.Any(e => e.cardId == x.cardId) == false).ToList();

                        if (addlawyers.Any())
                            added = await _db.Insertable(addlawyers).ExecuteCommandAsync();

                        res.IsSucceed = true;
                        res.result = new
                        {
                            updated,
                            added
                        };
                    }
                    else
                    {
                        res.IsSucceed = false;
                        res.Message = "数据格式不正确";
                    }
                }
                else
                {
                    res.IsSucceed = false;
                    res.Message = "文件上传失败";
                }
            }
            else
            {
                res.IsSucceed = false;
                res.Message = "文件格式不支持";
            }
            if (System.IO.File.Exists(path))
                System.IO.File.Delete(path);
            return res;
        }
        /// <summary>
        /// 同步外网律师人员信息(未完成) (根据律师身份证号更新或新增用户信息)
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("AddLawyerInfo")]
        public async Task<Result> AddLawyer(App_Sys_AddLawyerInput input)
        {
            try
            {
                var data = await _db.Queryable<App_Sys_UserModel>().FirstAsync(x => x.cardId == input.cardId && x.IsDeleted == 0 && x.isdeactivate == 0);
                if (data != null)
                {
                    #region 为了避免律师先在一体机刷卡自动创建账号后无法添加律师身份的问题
                    if (data.identity != "律师")
                    {
                        data.identity = "律师";
                    }
                    try
                    {
                        _db.BeginTran();
                        var num = await _db.Updateable(data)
                            .WhereColumns(x => x.Id)
                            .IgnoreColumns(ignoreAllNullColumns: true)
                            .ExecuteCommandAsync();
                        _db.CommitTran();
                    }
                    catch (Exception ex)
                    {
                        logger.LogError(ex, "AddLawyer");
                    }
                    #endregion

                    result.IsSucceed = false;
                    result.Message = "用户已存在";
                    return result;
                }
                else
                {
                    var user = mapper.Map<App_Sys_UserModel>(input);
                    //user.name = input.name;
                    //user.phone = input.phone;
                    //user.cardId=input.cardId;
                    user.Id = Guid.NewGuid().ToString();
                    user.unitCode = _userdata.unitCode;
                    if (user.cardId.Length == 18)
                    {
                        user.sex = int.Parse(user.cardId.Substring(16, 1)) % 2;
                    }
                    user.sex = _userdata.sex;
                    user.usertype = 1;
                    user.isdeactivate = 0;
                    user.becurrent = 0;
                    user.IsDeleted = 0;
                    user.audit = 0;
                    user.createuserId = _userdata.Id;
                    user.createusername = _userdata.name;
                    user.createtime = DateTime.Now;
                    user.identity = "律师";

                    //insert
                    _db.BeginTran();
                    var num = await _db.Insertable(user).ExecuteCommandAsync();
                    _db.CommitTran();
                    if (num > 0)
                    {
                        result.IsSucceed = true;
                        result.Message = "添加成功";
                    }
                    else
                    {
                        result.IsSucceed = false;
                        result.Message = "添加失败";
                    }
                }
            }
            catch
            {
                result.IsSucceed = false;
            }
            return result;
        }
        /// <summary>
        /// 查询律师阅卷信息
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("QueryLawyerArchives")]
        public async Task<Result> QueryLawyerArchives([FromQuery] LawyerArchivesInput input)
        {
            RefAsync<int> totalNumber = 0;//总数据
            var starttime = input.StartTime ?? DateTime.Now.AddDays(-100);
            var endtime = input.EndTime ?? DateTime.Now;
            //查询律师服务
            var list = await _db.Queryable<LawyerArchives>()
                .WhereIF(string.IsNullOrEmpty(input.lawyerName) == false, x => x.lawyerName.Contains(input.lawyerName))
                .WhereIF(string.IsNullOrEmpty(input.party) == false, x => x.party.Contains(input.party))
                .WhereIF(string.IsNullOrEmpty(input.partyCardId) == false, x => x.partycardId == input.partyCardId)
                .WhereIF(string.IsNullOrEmpty(input.caseName) == false, x => x.casename.Contains(input.caseName))
                .WhereIF(string.IsNullOrEmpty(input.bmsah) == false, x => x.bmsah.Contains(input.bmsah))
                .Where(x => x.createTime.Value.Date >= starttime.Date && x.createTime.Value.Date <= endtime.Date)
                .Where(x => x.unitcode == input.unitCode)
                .WhereIF(input.Isdelete != null, x => x.IsDeleted == input.Isdelete)
                .OrderByDescending(x => x.createTime)
                .ToPageListAsync(input.PageIndex, input.PageSize, totalNumber);
            input.RowsCount = totalNumber;
            var data = new QueryResult<LawyerArchives>(input, list.OrderByDescending(q => q.createTime).ToList());
            result.IsSucceed = true;
            result.result = data;
            return result;
        }
        /// <summary>
        /// 新增阅卷信息
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("AddLawyerArchives")]
        public async Task<Result> AddLawyerArchives(LawyerArchivesDto dto)
        {
            try
            {
                var entity = mapper.Map<LawyerArchives>(dto);
                entity.Id = Guid.NewGuid().ToString();
                entity.createrId = _userdata.Id;
                entity.createTime = DateTime.Now;
                entity.status = 0;
                entity.copyStatus = 0;
                entity.IsDeleted = 0;
                _db.BeginTran();
                var num = await _db.Insertable(entity).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.Message = "添加成功";
                    result.result = mapper.Map<LawyerArchivesDto>(entity);
                }
            }
            catch
            {
                result.IsSucceed = false;
            }
            return result;
        }
        /// <summary>
        /// 删除律师阅卷信息
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("DeleteLawyerArchives")]
        public async Task<Result> DeleteLawyerArchives(CurrencyDelete Currency)
        {
            try
            {
                _db.BeginTran();
                var Deletelist = await _db.Queryable<LawyerArchives>().In(q => q.Id, Currency.id).ToListAsync();
                Deletelist.ForEach(q =>
                {
                    q.IsDeleted = 1;
                });
                var num = await _db.Updateable(Deletelist).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "删除成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
                LogService.WriteLog(ex, "删除律师阅卷预约");
            }
            _logs.WriteSysLogadd("律师阅卷服务", "删除律师阅卷预约", result, _db);
            return result;
        }
        /// <summary>
        /// 修改律师阅卷信息
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPut]
        [Route("UpdateLawyerArchives")]
        public async Task<Result> UpdateLawyerArchives(LawyerArchivesDto Lawyerdata)
        {
            try
            {
                var entity = mapper.Map<LawyerArchives>(Lawyerdata);
                _db.BeginTran();
                var num = await _db.Updateable(entity)
                    .WhereColumns(x => x.Id)
                    .IgnoreColumns(ignoreAllNullColumns: true)
                    .ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "修改成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
                LogService.WriteLog(ex, "删除律师阅卷预约");

            }
            _logs.WriteSysLogadd("律师阅卷服务", "删除律师阅卷预约", result, _db);
            return result;
        }
        /// <summary>
        /// 从2.0系统查询案件信息
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        /// <remarks>接口，还没有确定好这个接口返回的数据的具体格式</remarks>
        [HttpGet]
        [Route("QueryCaseFromtwenty")]
        public async Task<Result<QueryResult<CaseInfo>>> QueryCaseFromtwenty(string? bmsah, string? dwbm, string? casename, DateTime? starttime, DateTime? endtime, int page, int size)
        {
            return await twentyClient.GetCaseList(casename, bmsah, dwbm, starttime, endtime, page, size);
        }
        /// <summary>
        /// 从2.0系统查询卷宗信息
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        /// <remarks>数据的返回格式已确定，内容时真实数据经过修改的</remarks>
        [HttpGet]
        [Route("QueryFileFromtwenty")]
        public async Task<Result> QueryFileFromtwenty(string bmsah, string dwbm)
        {
            var reponse = await twentyClient.GetArchivesInfo(bmsah, dwbm);
            if (reponse.IsSucceed == true)
            {
                var a = reponse.result;
                if (a?.jzml?.Any() == true)
                {
                    var datd = new
                    {
                        id = a.Id,
                        lable = a.jzmc,
                        children = a.jzml.Where(x => x.fmlbh == null).OrderBy(x => x.mlsxh).Select(x => new
                        {
                            id = x.Id,
                            lable = x.mlxsmc,
                            children = a.jzml.Where(q => q.fmlbh == x.mlbh).OrderBy(q => q.mlsxh).Select(q => new
                            {
                                id = q.Id,
                                lable = q.mlxsmc,
                                children = q.jzwj.OrderBy(e => e.wjsxh).Select(e => new
                                {
                                    id = e.wjxh,
                                    lable = e.wjxsmc,
                                    filepath = e.jpgwjlj
                                })
                            })
                        })
                    };

                    result.IsSucceed = true;
                    result.result = datd;
                }
                else
                {
                    result.IsSucceed = false;
                    result.Message = "未找到对应的卷宗信息";

                }
            }
            else
            {
                result.IsSucceed = false;
                result.Message = reponse.Message;
            }
            return result;
        }
        /// <summary>
        /// PC端根据卷宗id获取卷宗信息
        /// </summary>
        /// <param name="jzid"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("QueryArchiveByIdPC")]
        public async Task<Result> QueryArchiveByIdPC(string jzid)
        {
            var list = await _db.Queryable<JZJBXX>()
                   .Includes(x => x.jzml.OrderBy(x => x.mlsxh).ToList())
                   .Includes(x => x.jzml, x => x.jzwj.OrderBy(x => x.wjsxh).ToList())
                   .FirstAsync(x => x.Id == jzid);
            if (list != null)
            {
                var a = mapper.Map<JZJBXXDto>(list);
                var datd = new
                {
                    id = a.Id,
                    lable = a.jzmc,
                    children = a.jzml.Where(x => x.fmlbh == null).OrderBy(x => x.mlsxh).Select(x => new
                    {
                        id = x.mlbh,
                        lable = x.mlxsmc,
                        children = a.jzml.Where(q => q.fmlbh == x.mlbh).OrderBy(q => q.mlsxh).Select(q => new
                        {
                            id = q.mlbh,
                            lable = q.mlxsmc,
                            children = q.jzwj.OrderBy(e => e.wjsxh).Select(e => new
                            {
                                id = e.wjxh,
                                lable = e.wjxsmc,
                                filepath = e.jpgwjlj
                            })
                        })
                    })
                };

                result.IsSucceed = true;
                result.result = datd;
            }
            else
            {
                result.IsSucceed = false;
                result.Message = "卷宗不存在";
            }
            return result;
        }
        /// <summary>
        /// 上传已选中的第三级页码的id
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <remarks>
        /// {
        ///     "IsSucceed": false,
        ///     "Message": null,
        ///     "result": "9f272d7f-2b66-4314-95a3-ca4e0de2b1ec"
        /// }
        ///返回的id 用于在调用 AddLawyerArchives 传入jzlbxxId
        /// </remarks>
        [HttpPost("AddArchivesInfoByChildId")]
        public async Task<Result> AddArchivesInfoByChildId(AddArchivesInfoInput input)
        {
            try
            {
                var reponse = await twentyClient.GetArchivesInfo(input.Bmsah, _userdata.unitCode);
                if (reponse.IsSucceed == true)
                {
                    var dto = reponse.result;
                    //先将没有被选中的第三级文件排除
                    foreach (var item in dto.jzml)
                    {
                        item.jzwj = item.jzwj.Where(x => input.Ids.Contains(x.wjxh)).ToList();
                    }
                    //再排除没有文件的目录信息
                    //这样筛选后获取的数据就可以保证不会出现空子节点的父节点
                    //dto.jzml = dto.jzml.Where(x => x.jzwj.Any() || x.fmlbh == null).ToList();
                    //var fml = dto.jzml.Where(x => x.fmlbh == null);

                    var hasfileslist = dto.jzml.Where(x => x.jzwj.Any()).ToList();
                    var fmllist = dto.jzml.Where(x => string.IsNullOrEmpty(x.fmlbh) && hasfileslist.Any(q => q != null && q.fmlbh == x.mlbh));

                    dto.jzml = hasfileslist.Concat(fmllist).Distinct().ToList();
                    var insert = await AddArchivesInfo(dto);
                    result.result = insert.result.Id;
                    result.IsSucceed = true;
                }
                else
                {
                    result.IsSucceed = false;
                    result.Message = reponse.Message;
                }

            }
            catch (Exception ex)
            {
                result.IsSucceed = false;
                result.Message = ex.Message;
                logger.LogError(ex, "AddArchivesInfoByChildId");
            }
            return result;
        }
        /// <summary>
        /// 一体机 根据卷宗id获取详细的卷宗信息
        /// </summary>
        /// <param name="jzid"></param>
        /// <returns></returns>
        [HttpGet("QueryArchiveById")]
        public async Task<Result> QueryArchiveById(string jzid)
        {
            try
            {
                var list = await _db.Queryable<JZJBXX>()
                    .Includes(x => x.jzml.OrderBy(x => x.mlsxh).ToList())
                    .Includes(x => x.jzml, x => x.jzwj.OrderBy(x => x.wjsxh).ToList())
                    .FirstAsync(x => x.Id == jzid);

                var data = mapper.Map<JZJBXXDto>(list);

                result.result = data;
                result.IsSucceed = true;
            }
            catch (Exception ex)
            {
                logger.LogError(ex, "QueryArchiveById");
            }
            return result;
        }
        /// <summary>
        /// 一体机查询当前用户已有的 被同意的 预约阅卷信息
        /// </summary>
        /// <returns></returns>
        [HttpGet("QueryReservedInfo")]
        public async Task<Result> QueryReservedInfo()
        {
            try
            {
                logger.LogInformation("12312312312");
                var list = await _db.Queryable<LawyerArchives>()
                  .Where(x => x.lawyerId == _userdata.Id)
                  .Where(x => x.status == 0 || x.status == 1)
                  .Where(x => x.permissibleStartTime <= DateTime.Now && x.permissibleEndTime >= DateTime.Now)
                  .Where(x => x.IsDeleted == 0)
                  .ToListAsync();

                var data = mapper.Map<IEnumerable<LawyerArchivesDto>>(list);
                result.result = data;
                result.IsSucceed = true;
            }
            catch (Exception ex)
            {
                logger.LogError(ex, "QueryReservedInfo");
            }
            return result;
        }
        /// <summary>
        /// 统计律师名下的预约信息
        /// </summary>
        /// <param name="lawyerId"></param>
        /// <returns></returns>
        [HttpGet("QueryLawyerReservedInfo")]
        public async Task<Result> QueryLawyerReservedInfo(string? lawyerId)
        {
            try
            {
                var list = await _db.Queryable<LawyerArchives>()
                  .Where(x => x.lawyerId == lawyerId)
                  .Where(x => x.status == 0 || x.status == 1)
                  .Where(x => x.IsDeleted == 0)
                  .ToListAsync();

                var data = mapper.Map<IEnumerable<LawyerArchivesDto>>(list);
                result.result = data;
                result.IsSucceed = true;
            }
            catch (Exception ex)
            {
                logger.LogError(ex, "QueryReservedInfo");
            }
            return result;
        }
        #endregion
        #region HiddenApi
        /// <summary>
        /// 添加卷宗信息
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HiddenApi]
        [HttpPost]
        [Route("AddArchivesInfo")]
        public async Task<Result<JZJBXXDto>> AddArchivesInfo(JZJBXXDto dto)
        {
            Result<JZJBXXDto> res = new Result<JZJBXXDto>();
            try
            {
                var data = mapper.Map<JZJBXX>(dto);
                var mls = dto.jzml.ToList();
                var vloum = mapper.Map<List<JZML>>(mls);
                var wjs = dto.jzml.SelectMany(x => x.jzwj).ToList();
                var files = mapper.Map<List<JZWJItem>>(wjs);

                _db.BeginTran();
                var num = await _db.Insertable(data).ExecuteCommandAsync();
                var add = await _db.Insertable(vloum).ExecuteCommandAsync();
                var addwj = await _db.Insertable(files).ExecuteCommandAsync();
                _db.CommitTran();
                res.result = dto;
                return res;
            }
            catch (Exception ex)
            {
                logger.LogError(ex, "AddArchivesInfo");
                result.IsSucceed = false;
                return res;
            }
        }
        /// <summary>
        /// 统计 总数 已读的 未读的 刻录
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [Route("Countinfo")]
        public async Task<Result> Countinfo()
        {
            try
            {
                var registerCount = await _db.Queryable<LawyerArchives>().Where(x => x.unitcode == _userdata.unitCode).CountAsync(x => x.IsDeleted == 0);
                var readcount = await _db.Queryable<LawyerArchives>().Where(x => x.unitcode == _userdata.unitCode).CountAsync(x => x.IsDeleted == 0 && x.status != 0);
                var unreadcount = await _db.Queryable<LawyerArchives>().Where(x => x.unitcode == _userdata.unitCode).CountAsync(x => x.IsDeleted == 0 && x.status == 0);
                var burnedcount = await _db.Queryable<LawyerArchives>().Where(x => x.unitcode == _userdata.unitCode).CountAsync(x => x.IsDeleted == 0 && (x.copyStatus == 2 || x.copyStatus == 3));

                result.result = new
                {
                    registerCount = registerCount,
                    readcount = readcount,
                    unreadcount = unreadcount,
                    burnedcount = burnedcount,
                };
                result.IsSucceed = true;
            }
            catch
            {
                result.result = new
                {
                    registerCount = 0,
                    readcount = 0,
                    unreadcount = 0,
                    burnedcount = 0,
                };
                result.IsSucceed = false;
            }
            return result;
        }
        /// <summary>
        /// 统计近7天阅卷登记情况
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [Route("CountRegistSevendays")]
        public async Task<Result> CountRegistSevendays()
        {
            try
            {
                int dayscount = 7;
                var days = Enumerable.Range(0, dayscount).Select(x => DateTime.Now.AddDays(-x).Date).ToList();
                var registerCount = await _db.Queryable<LawyerArchives>()
                    .Where(x => x.createTime.Value.Date >= days[dayscount - 1] && x.createTime.Value.Date <= days[0])
                    .Where(x => x.unitcode == _userdata.unitCode)
                    .Where(x => x.IsDeleted == 0)
                    .ToListAsync();
                var data = registerCount
                    .GroupBy(x => x.createTime.Value.Date)
                    .ToDictionary(x => x.Key, x => x.Count());
                foreach (var item in days)
                {
                    if (data.ContainsKey(item) == false)
                    {
                        data.Add(item, 0);
                    }
                }
                var res = data.OrderBy(x => x.Key).Select(x => new
                {
                    date = x.Key.ToShortDateString(),
                    count = x.Value
                }).ToList();
                result.result = res;
                result.IsSucceed = true;
            }
            catch
            {
                result.IsSucceed = false;
            };
            return result;
        }


        /// <summary>
        /// 统计阅卷信息
        /// </summary>
        /// <param name="stime">开始时间</param>
        /// <param name="etime">结束时间</param>
        /// <param name="groupby">分类类型 有效值：year，month,day</param>
        /// <returns></returns>
        [HttpGet]
        [Route("CountReadStatusByTime")]
        public async Task<Result> CountReadStatusByTime(DateTime? stime, DateTime? etime, string groupby)
        {
            #region 入参校验
            DateTime starttime = stime == null ? DateHelper.GetStartDateOfDay(DateTime.Now.AddDays(-30)) : stime.Value;
            DateTime endtime = etime == null ? DateHelper.GetEndDateOfDay(DateTime.Now) : etime.Value;
            if (string.IsNullOrEmpty(groupby) || (groupby.ToLower() != "year" && groupby.ToLower() != "month" && groupby.ToLower() != "day"))
            {
                groupby = "day";
            }
            #endregion
            try
            {
                #region 根据入参获取查询区间
                var dates = new List<DateTime>();
                DateTime start, end;
                switch (groupby)
                {
                    case "year":
                        dates = DateHelper.GetArrayByYear(starttime, endtime);
                        start = DateHelper.GetStartDateOfYear(starttime);
                        end = DateHelper.GetEndDateOfYear(endtime);
                        break;
                    case "month":
                        dates = DateHelper.GetArrayByMonth(starttime, endtime);
                        start = DateHelper.GetStartDateOfMonth(starttime);
                        end = DateHelper.GetEndDateOfMonth(endtime);
                        break;
                    default:
                        dates = DateHelper.GetArrayByDay(starttime, endtime);
                        start = DateHelper.GetStartDateOfDay(starttime);
                        end = DateHelper.GetEndDateOfDay(endtime);
                        break;
                }
                #endregion
                #region 查询已经阅卷的统计信息

                var readedlist = await Task.Run(async () =>
                {
                    var registerCount = await _db.Queryable<LawyerArchives>()
                    .Where(x => x.status != 0)
                    .Where(x => x.actualStartTime != null && x.actualStartTime >= start)
                    .Where(x => x.actualStartTime != null && x.actualStartTime <= end)
                    .Where(x => x.unitcode == _userdata.unitCode)
                    .Where(x => x.IsDeleted == 0)
                    .ToListAsync();
                    var groupedlist = groupby switch
                    {
                        "year" => registerCount.GroupBy(x => DateHelper.GetStartDateOfYear(x.actualStartTime.Value))
                                               .ToDictionary(x => x.Key, x => x.Count()),
                        "month" => registerCount.GroupBy(x => DateHelper.GetStartDateOfMonth(x.actualStartTime.Value))
                                               .ToDictionary(x => x.Key, x => x.Count()),
                        _ => registerCount.GroupBy(x => x.actualStartTime.Value.Date)
                                               .ToDictionary(x => x.Key, x => x.Count())
                    };
                    foreach (var item in dates)
                    {
                        if (groupedlist.ContainsKey(item) == false)
                        {
                            groupedlist.Add(item, 0);
                        }
                    }
                    var res = groupedlist.OrderBy(x => x.Key).Select(x => new
                    {
                        name = groupby switch
                        {
                            "year" => x.Key.ToString("yyyy"),
                            "month" => x.Key.ToString("yyyy-MM"),
                            _ => x.Key.ToString("yyyy-MM-dd")
                        },
                        value = x.Value
                    }).ToList();
                    return res;
                });
                #endregion
                #region 根据查阅状态进行分组
                var groupbystatus = await Task.Run(async () =>
                        {
                            var registerCount = await _db.Queryable<LawyerArchives>()
                               .Where(x => x.createTime != null && x.createTime >= start)
                               .Where(x => x.createTime != null && x.createTime <= end)
                               .Where(x => x.unitcode == _userdata.unitCode)
                               .Where(x => x.IsDeleted == 0)
                               .Where(x => x.status != null)
                               .ToListAsync();

                            var a = registerCount.GroupBy(x => x.status)
                                                 .ToDictionary(x => x.Key, x => x.Count());

                            var res = a.Select(x => new
                            {
                                name = x.Key switch
                                {
                                    0 => "待查阅",
                                    1 => "查阅中",
                                    2 => "已查阅",
                                    _ => "待查阅"
                                },
                                value = x.Value
                            }).ToList();
                            return res;
                        });
                #endregion
                #region 根据案件类型进行分组

                var groupbycasetype = await Task.Run(async () =>
                {
                    var registerCount = await _db.Queryable<LawyerArchives>()
                   .Where(x => x.createTime != null && x.createTime >= start)
                   .Where(x => x.createTime != null && x.createTime <= end)
                   .Where(x => x.unitcode == _userdata.unitCode)
                   .Where(x => x.IsDeleted == 0)
                   .Where(x => x.status != null)
                   .LeftJoin<JZJBXX>((x, e) => x.jzlbxxId == e.Id)
                   .GroupBy((x, e) => new { e.ajlbmc })
                   .Select((x, e) => new
                   {
                       name = e.ajlbmc,
                       value = SqlFunc.AggregateCount(e.ajlbmc)
                   })
                   .Take(10)
                   .ToListAsync();

                    if (registerCount.Count >= 10)
                    {
                        var excount = registerCount.Sum(x => x.value);
                        var allCount = await _db.Queryable<LawyerArchives>()
                                       .Where(x => x.createTime != null && x.createTime >= start)
                                       .Where(x => x.createTime != null && x.createTime <= end)
                                       .Where(x => x.unitcode == _userdata.unitCode)
                                       .Where(x => x.IsDeleted == 0)
                                       .Where(x => x.status != null)
                                       .CountAsync();
                        if (allCount > excount)
                        {
                            var list = new[]
                            {
                                new
                                {
                                    name = "其他",
                                    value = allCount-excount,
                                }
                            };
                            registerCount.AddRange(list);
                        }
                    }
                    return registerCount;
                });
                #endregion

                result.IsSucceed = true;
                result.result = new
                {
                    GroupByReadStatus = readedlist,
                    GroupByStatus = groupbystatus,
                    GroupByType = groupbycasetype
                };
            }
            catch
            {
                result.IsSucceed = false;
            };
            return result;
        }

        /// <summary>
        /// 按律师分类
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [Route("CountByLawyer")]
        public async Task<Result> CountByLawyer()
        {
            try
            {
                // var allcount = await _db.Queryable<LawyerArchives>().CountAsync();
                var registerCount = await _db.Queryable<LawyerArchives>()
                    .LeftJoin<App_Sys_UserModel>((it, user) => it.lawyerId == user.Id)
                       .GroupBy((it, user) => new { it.lawyerId }).Select((it, user) => new
                       {
                           name = user.name,
                           cardId = user.cardId,
                           departmentName = user.departmentName,
                           value = (double)SqlFunc.AggregateCount(it.lawyerId)
                           //  count = (double)SqlFunc.AggregateCount(it.lawyerId) / (double)allcount
                       }).Take(10).ToListAsync();
                result.result = registerCount;
                result.IsSucceed = true;
            }
            catch (Exception ex)
            {
                result.IsSucceed = true;
                result.Message = "查询异常";
                logger.LogError(ex, "CountByLawyer");
            }
            return result;
        }
        /// <summary>
        /// 按卷宗案件类型分类
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [Route("CountByCaseType")]
        public async Task<Result> CountByCaseType()
        {
            try
            {
                // var allcount = await _db.Queryable<JZJBXX>().CountAsync();
                var registerCount = await _db.Queryable<JZJBXX>()
                       .GroupBy(it => new { it.ajlbmc }).Select(it => new
                       {
                           name = it.ajlbmc,
                           value = SqlFunc.AggregateCount(it.ajlbmc)
                           //count = (double)SqlFunc.AggregateCount(it.ajlbmc) / (double)allcount
                       }).ToListAsync();
                result.result = registerCount;
                result.IsSucceed = true;
            }
            catch
            {

            }
            return result;
        }
        /// <summary>
        /// 同步外网预约信息（不需要调用此接口） 
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [HiddenApi]
        [Route("AddLawyerServiceInfo")]
        public async Task<Result> AddLawyerServiceInfo(App_LawyerServicesModel info)
        {
            var data = await _db.Queryable<App_LawyerServicesModel>().FirstAsync(x => x.Id == info.Id);
            if (data != null)
            {
                result.IsSucceed = true;
                result.Message = "改数据已同步";
                return result;
            }
            else
            {
                _db.BeginTran();
                var num = await _db.Insertable(info).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.Message = "添加成功";
                    result.result = mapper.Map<LawyerArchivesDto>(info);
                    return result;
                }
                else
                {
                    result.IsSucceed = false;
                    result.Message = "添加失败";
                    return result;
                }
            }
        }
        /// <summary>
        /// 加密字符串信息
        /// </summary>
        /// <param name="idcard"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("EncodeData")]
        public Task<Result<string>> EncodeData()
        {
            var str = $"{_userdata.cardId},{_userdata.name}";
            Result<string> result = new();
            result.result = Convert.ToBase64String(Encoding.UTF8.GetBytes(str));
            result.IsSucceed = true;

            return Task.FromResult(result);
        }
        [HttpGet]
        [Route("ImportLawyerArchivesInfo")]
        public async Task<Result> ImportLawyerArchivesInfo(string path)
        {
            if (System.IO.File.Exists(path)==false)
            {
                result.Message = "文件丢失";
                result.IsSucceed = false;
                return result;
            }
            var dir = Path.Combine(Environment.CurrentDirectory,"wwwroot","CaseFile","imports");
            var userdir = Path.Combine(dir, "users");
            var lawyersvcs = Path.Combine(dir, "lawyersvcs");
   
            var extratname = Path.GetFileNameWithoutExtension(path);
            var extratdirpath = Path.Combine(dir, extratname);
            ZipFile.ExtractToDirectory(path, extratdirpath,true);
            var zipusers = Path.Combine(extratdirpath, "users");
            var ziplawyersvcs = Path.Combine(extratdirpath, "lawyerservices");
            var zipjson = Path.Combine(extratdirpath, "data");
            if (System.IO.File.Exists(zipjson)==false)
            {
                result.Message = "文件丢失";
                result.IsSucceed = false;
                return result;
            }
            var json = System.IO.File.ReadAllText(zipjson);

            var jsonstr = Encoding.UTF8.GetString(Convert.FromBase64String(json));

            var importdata = jsonstr.ConvertToAnonymousType(new
            {
                lawyerservices=default(List<App_LawyerServicesModel>),
                users=default(List<App_Sys_UserModel>)
            });
            foreach (var userim in importdata.users)
            {
                var user = await _db.Queryable<App_Sys_UserModel>()
                    .Where(x => x.cardId == userim.cardId)
                    .Where(x => x.IsDeleted == 0)
                    .Where(x => x.isdeactivate == 0)
                    .Where(x => x.identity == "律师")
                    .FirstAsync();
                var identityphotopath = Path.Combine(zipusers, userim.cardId, "identityphotos");
                var files = new DirectoryInfo(identityphotopath)
                    .GetFiles()
                    .Select(x => "/CaseFile/imports/" + Path.GetRelativePath(dir, x.FullName)
                    .Replace(@"\", @"/"))
                    .ToList()
                    .ConvertToJsonStr();

                var departmentPhotos = Path.Combine(zipusers, userim.cardId, "departmentPhotos");
                var departments = new DirectoryInfo(departmentPhotos)
                    .GetFiles()
                    .Select(x => "/CaseFile/imports/" + Path.GetRelativePath(dir, x.FullName)
                    .Replace(@"\", @"/"))
                    .ToList()
                    .ConvertToJsonStr();

                var cardidphotos = Path.Combine(zipusers, userim.cardId, "cardids");
                var cardids = new DirectoryInfo(cardidphotos)
                    .GetFiles()
                    .Select(x => "/CaseFile/imports/" + Path.GetRelativePath(dir, x.FullName)
                    .Replace(@"\", @"/"))
                    .ToList()
                    .ConvertToJsonStr();

                if (user==null)
                {
                    userim.cardIdphoto = cardids;
                    userim.identityphoto = files;
                    userim.departmentPhoto = departments;

                    _db.BeginTran();
                    var num = await _db.Insertable(userim).ExecuteCommandAsync();
                    _db.CommitTran();
                }
                else
                {
                    user.cardIdphoto = cardids;
                    user.identityphoto = files;
                    user.departmentPhoto = departments;
                    _db.BeginTran();
                    var num = await _db.Updateable(user)
                        .UpdateColumns(x => new
                        {
                            x.cardIdphoto,
                            x.identityphoto,
                            x.departmentPhoto
                        })
                        .IgnoreColumns(ignoreAllNullColumns: true)
                        .ExecuteCommandAsync();
                    _db.CommitTran();
                }
            }
            foreach (var lawyersvc in importdata.lawyerservices)
            {
                var svc =await _db.Queryable<App_LawyerServicesModel>()
                    .Where(x => x.Id == lawyersvc.Id).FirstAsync();
                var annexphoto = Path.Combine(ziplawyersvcs, lawyersvc.Id, "annexs");
                var annexs = new DirectoryInfo(annexphoto)
                    .GetFiles()
                    .Select(x => "/CaseFile/imports/" + Path.GetRelativePath(dir, x.FullName)
                    .Replace(@"\", @"/"))
                    .ToList()
                    .ConvertToJsonStr();
                if (svc==null)
                {
                    lawyersvc.annex = annexs;
                    _db.BeginTran();
                    var num = await _db.Insertable(lawyersvc).ExecuteCommandAsync();
                    _db.CommitTran();
                }
                else
                {
                    svc.annex = annexs;
                    _db.BeginTran();
                    var num = await _db.Updateable(svc)
                        .UpdateColumns(x => new
                        {
                            x.annex
                        })
                        .IgnoreColumns(ignoreAllNullColumns: true)
                        .ExecuteCommandAsync();
                    _db.CommitTran();
                }
            }
            return result;
        }
        [HttpPost]
        [Route("PackegLawyerArchivesInfo")]
        public async Task<Result> ExportLawyerArchivesInfo(IEnumerable<string> ids)
        {    
            var lawyerarchives = await _db.Queryable<App_LawyerServicesModel>()
                .In(info => info.Id, ids)
                .ToListAsync();
            var userids=lawyerarchives
                .Select(x=>x.createuserId)
                .Distinct()
                .ToList();
            var users = await _db.Queryable<App_Sys_UserModel>()
                .In(x => x.Id, userids)
                .ToListAsync();
            var packegdirname = DateTime.Now.Ticks.ToString();
            var dir = Path.Combine(Environment.CurrentDirectory,"wwwroot","temp");
            var packegdir = Path.Combine(dir, packegdirname);
            var packegzipname = Path.ChangeExtension(packegdir, ".zip");
            if (Directory.Exists(packegdir) == false) Directory.CreateDirectory(packegdir);
            var jsonfilepath = Path.Combine(packegdir, "data");
            var jsonstr = new
            {
                lawyerservices = lawyerarchives,
                users = users
            }.ConvertToJsonStr().ConvertToBase64();
            System.IO.File.WriteAllText(jsonfilepath, jsonstr);
            //存储预约申请的相关附件
            foreach (var item in lawyerarchives)
            {
                var lawyerdir = Path.Combine(packegdir,"lawyerservices", item.Id);
                if (Directory.Exists(lawyerdir)==false) Directory.CreateDirectory(lawyerdir);
                var files = item.annex.ConvertToModel<List<string>>();
                var annecdir = Path.Combine(lawyerdir,"annexs");
                if (Directory.Exists(annecdir) == false) Directory.CreateDirectory(annecdir);

                foreach (var file in files)
                {
                    var filepath = Path.Combine(Environment.CurrentDirectory,"wwwroot") + file.Replace("/",@"\");
                    if (System.IO.File.Exists(filepath))
                    {
                        var targetfile = Path.Combine(annecdir, Path.GetFileName(filepath));
                        System.IO.File.Copy(filepath, targetfile);
                    }
                }
            }
            //存储用户的相关附件
            foreach (var item in users)
            {
                //["/CaseFile/card/2023-11-21/20231121200659497.jpg"]
                var userdir= Path.Combine(packegdir, "users", item.cardId);

                //保存身份证图片
                var cardids = item.cardIdphoto.ConvertToModel<List<string>>();
                var cardidDir = Path.Combine(userdir, "cardids");
                if (Directory.Exists(cardidDir) == false) Directory.CreateDirectory(cardidDir);
                foreach (var file in cardids)
                {
                    var filepath = Path.Combine(Environment.CurrentDirectory, "wwwroot") + file.Replace("/", @"\");
                    if (System.IO.File.Exists(filepath))
                    {
                        System.IO.File.Copy(filepath, Path.Combine(cardidDir, Path.GetFileName(filepath)));
                    }
                }
                //保存工作证图片  律师职业证书
                var identityphotos = item.identityphoto.ConvertToModel<List<string>>();
                var identityphotosDir = Path.Combine(userdir, "identityphotos");
                if (Directory.Exists(identityphotosDir) == false) Directory.CreateDirectory(identityphotosDir);
                foreach (var file in identityphotos)
                {
                    var filepath = Path.Combine(Environment.CurrentDirectory, "wwwroot") + file.Replace("/", @"\");
                    if (System.IO.File.Exists(filepath))
                    {
                        System.IO.File.Copy(filepath, Path.Combine(identityphotosDir, Path.GetFileName(filepath)));
                    }
                }

                var departmentPhotos = item.departmentPhoto.ConvertToModel<List<string>>();
                var departmentPhotosDir = Path.Combine(userdir, "departmentPhotos");
                if (Directory.Exists(departmentPhotosDir) == false) Directory.CreateDirectory(departmentPhotosDir);
                foreach (var file in departmentPhotos)
                {
                    var filepath = Path.Combine(Environment.CurrentDirectory, "wwwroot") + file.Replace("/", @"\");
                    if (System.IO.File.Exists(filepath))
                    {
                        System.IO.File.Copy(filepath, Path.Combine(departmentPhotosDir, Path.GetFileName(filepath)));
                    }
                }
            }

            ZipFile.CreateFromDirectory(packegdir, packegzipname);
            Directory.Delete(packegdir, true);

            result.result = $"/temp/{packegdirname}.zip";
            result.IsSucceed = true;
            return result;
        }

        [HttpPost]
        [Route("UploadSignImage")]
        /// <summary>
        /// 
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public async Task<Result> UploadSignImage(object data)
        {
            var input = data.ConvertToAnonymousType(new
            {
                id = default(string),
                image = default(string)
            });
            if (string.IsNullOrEmpty(input.image) == false)
            {
                var _path = Path.Combine("CaseFile", "card", DateTime.Now.ToString("yyyy-MM-dd"));
                var dic = Path.Combine(Environment.CurrentDirectory, "wwwroot", _path);
                var filename = DateTime.Now.Ticks.ToString() + ".png";
                var filefullpath = Path.Combine(dic, filename);
                if (Directory.Exists(dic) == false)
                {
                    Directory.CreateDirectory(dic);
                }
                await System.IO.File.WriteAllBytesAsync(filefullpath, Convert.FromBase64String(input.image));

                var item = await _db.Queryable<LawyerArchives>().Where(x => x.Id == input.id).FirstAsync();
                if (item != null)
                {
                    var __path = Path.Combine(_path, filename);
                    var repath = "/" + __path.Replace(@"\", @"/");
                    item.secertphoto = repath;
                    await _db.Updateable(item).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();
                    result.IsSucceed = true;
                }
                else
                {
                    result.IsSucceed = false;
                    result.Message = "数据不存在";
                }
            }
            else
            {
                result.IsSucceed = false;
                result.Message = "图片接收失败";
            }

            return result;
        }
        public class DecodeQRDataModel
        {
            public string QRData { get; set; }
        }
        ///// <summary>
        ///// 加密二维码信息
        ///// </summary>
        ///// <returns></returns>
        //[HttpGet]
        //[HiddenApi]
        //[Route("EncodeData")]
        //public async Task<Result> EncodeData(string id)
        //{
        //    var groupedlist = await _db.Queryable<App_LawyerServicesModel>().LeftJoin<App_Sys_UserModel>((lawyer, user) => lawyer.createuserId == user.Id)
        //    .Where(lawyer => lawyer.Id == id)
        //    .Select((lawyer, user) => new
        //    {
        //        info = lawyer,
        //        user
        //    }).FirstAsync();
        //    if (groupedlist != null)
        //    {
        //        var dto = new
        //        {
        //            info = mapper.Map<QRLawyerServiceDto>(groupedlist.info),
        //            user = mapper.Map<QRUserDto>(groupedlist.user)
        //        };
        //        var encodingdata = Convert.ToBase64String(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(dto)));
        //        result.IsSucceed = true;
        //        result.result = encodingdata;
        //    }
        //    return result;
        //}

        ///// <summary>
        ///// 解码二维码信息
        ///// </summary>
        ///// <returns></returns>
        //[HttpPost]
        //[HiddenApi]
        //[Route("DecodeQRData")]
        //public Task<Result> DecodeQRData(DecodeData groupedlist)
        //{
        //    try
        //    {
        //        var basestr = Convert.FromBase64String(groupedlist.EncodingString);
        //        var str = Encoding.UTF8.GetString(basestr);

        //        var model = str.ConvertToAnonymousType(new
        //        {
        //            info = default(QRLawyerServiceDto),
        //            user = default(QRUserDto)
        //        });
        //        result.IsSucceed = true;
        //        result.result = model;
        //    }
        //    catch (System.Exception ex)
        //    {
        //        result.IsSucceed = false;
        //    }
        //    return Task.FromResult(result);
        //}
        #endregion
    }
}