package com.ydtech.modules.admin.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ydtech.constants.InsuranceImageEnum;
import com.ydtech.constants.SysConstants;
import com.ydtech.core.page.HttpResult;
import com.ydtech.core.page.PageResult;
import com.ydtech.exception.SystemException;
import com.ydtech.modules.admin.constants.QuMarks;
import com.ydtech.modules.admin.constants.RoleConstants;
import com.ydtech.modules.admin.constants.SystemType;
import com.ydtech.modules.admin.constants.UserWorkStatus;
import com.ydtech.modules.admin.dao.SysUserMapper;
import com.ydtech.modules.admin.model.*;
import com.ydtech.modules.admin.model.dto.QuTeamNumDto;
import com.ydtech.modules.admin.model.dto.QuUserNumDto;
import com.ydtech.modules.admin.model.dto.SysUserDto;
import com.ydtech.modules.admin.model.po.SysUserIsDial;
import com.ydtech.modules.admin.model.po.SysUserTreeShowLevel;
import com.ydtech.modules.admin.model.vo.*;
import com.ydtech.modules.admin.service.*;
import com.ydtech.modules.base.controller.BaseController;
import com.ydtech.modules.base.model.dto.PageDto;
import com.ydtech.modules.base.model.vo.PageVo;
import com.ydtech.modules.esm.model.EsmUserImage;
import com.ydtech.modules.esm.model.EsmUserReferrer;
import com.ydtech.modules.esm.model.vo.EsmUserImageVo;
import com.ydtech.modules.esm.service.EsmUserImageService;
import com.ydtech.modules.esm.service.EsmUserReferrerService;
import com.ydtech.security.utils.PasswordUtils;
import com.ydtech.utils.StringUtils;
import com.ydtech.utils.idgen.IdGenerate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;


@Service
public class SysUserServiceImpl extends ServiceImpl<SysUserMapper, SysUser> implements SysUserService {

    @Autowired
    private SysMenuService sysMenuService;

    @Autowired
    private SysRoleMenuService sysRoleMenuService;

    @Autowired
    private SysDeptService sysDeptService;

    @Autowired
    private SysUserMapper sysUserMapper;

    @Autowired
    private SysUserRoleService sysUserRoleService;

    @Autowired
    private EsmUserReferrerService esmUserReferrerService;

    @Autowired
    private SysUserInfoService sysUserInfoService;

    @Autowired
    private EsmUserImageService esmUserImageService;

    @Autowired
    private SysAreaService sysAreaService;

    @Autowired
    private SysUserTreeShowLevelService sysUserTreeShowLevelService;

    @Autowired
    private SysUserIsDialService sysUserIsDialService;

    @Autowired
    private SysUserTrackService sysUserTrackService;

    @Autowired
    private SysPcAddressService sysPcAddressService;

    @Override
    public IPage<SysUserBaseVO> findUserList(PageDto<SysUserDto> pageDto) {
        PageVo<SysUserBaseVO> pageVo = new PageVo();
        Page page = new Page(pageDto.getPageNum(), pageDto.getPageSize());
        pageVo.setPageNum(pageDto.getPageNum());
        pageVo.setPageSize(pageDto.getPageSize());

        SysUserDto sysUserVO = JSONObject.parseObject(JSONObject.toJSONString(pageDto.getDto()), SysUserDto.class);
        if (sysUserVO.getAgentFlag() == null) {
            throw new SystemException("必传标识未传递");
        }
        IPage<SysUserBaseVO> userList = sysUserMapper.findUserList(page, sysUserVO);
        return userList;
    }

    @Override
    public IPage<SysUserBaseVO> findAllUserList(PageDto<SysUserDto> pageDto) {
        PageVo<SysUserBaseVO> pageVo = new PageVo();
        Page page = new Page(pageDto.getPageNum(), pageDto.getPageSize());
        pageVo.setPageNum(pageDto.getPageNum());
        pageVo.setPageSize(pageDto.getPageSize());

        SysUserDto sysUserVO = JSONObject.parseObject(JSONObject.toJSONString(pageDto.getDto()), SysUserDto.class);

        IPage<SysUserBaseVO> userList = sysUserMapper.findAllUserList(page, sysUserVO);
        return userList;
    }

    @Override
    public IPage<SysUserBaseVO> findBackUserList(SysUserDto sysUserDto) {
        PageVo<SysUserBaseVO> pageVo = new PageVo<>();
        Page<SysUserBaseVO> page = new Page<>(sysUserDto.getPageNum(), sysUserDto.getPageSize());

        pageVo.setPageNum(sysUserDto.getPageNum());
        pageVo.setPageSize(sysUserDto.getPageSize());
        if (sysUserDto.getAgentFlag() == null) {
            throw new SystemException("必传标识未传递");
        }

        return sysUserMapper.findBackUserList(page, sysUserDto);
    }

    @Override
    public List<SysUserBaseVO> findBackUserList1(SysUserDto sysUserDto) {
        if (sysUserDto.getAgentFlag() == null) {
            throw new SystemException("必传标识未传递");
        }
        return sysUserMapper.findBackUserList1(sysUserDto);
    }


    @Override
    public IPage<QuTeamNum> quTeamNum(QuTeamNumDto quTeamNumDto) {

        if (StringUtils.isNotEmpty(quTeamNumDto.getCreateTimeStart()) && StringUtils.isNotEmpty(quTeamNumDto.getCreateTimeEnd())) {
            quTeamNumDto.setCreateTimeStart(quTeamNumDto.getCreateTimeStart() + " 00:00:00");
            quTeamNumDto.setCreateTimeEnd(quTeamNumDto.getCreateTimeEnd() + " 23:59:59");
        }

        //判断必传标识是否为空
        if (quTeamNumDto.getTeamOrUserFlag() == null) {
            throw new SystemException("必传参数未传");
        }
        //判断是要查询用户还是团队
        if ("1".equals(quTeamNumDto.getTeamOrUserFlag())) {
            List<QuTeamNum> dept = sysUserMapper.getDept(quTeamNumDto);

            return getQuTeamNumIPage(quTeamNumDto, dept);

        } else if ("2".equals(quTeamNumDto.getTeamOrUserFlag())) {
            List<QuTeamNum> dept = sysUserMapper.getUser(quTeamNumDto);


            return getQuTeamNumIPage(quTeamNumDto, dept);
        }
        throw new SystemException("参数错误");
    }

    @Override
    public IPage<QuTeamNum> getQuTeamByCompany(QuTeamNumDto quTeamNumDto) {
        List<QuTeamNum> deptByCompany = sysUserMapper.getDeptByCompany(quTeamNumDto);
        IPage<QuTeamNum> page = new Page<>(quTeamNumDto.getPageNo(), quTeamNumDto.getPageSize());
        page.setRecords(deptByCompany);
        page.setTotal(deptByCompany.size());
        return page;
    }


    private IPage<QuTeamNum> getQuTeamNumIPage(QuTeamNumDto quTeamNumDto, List<QuTeamNum> dept) {
        Map<String, List<QuTeamNum>> collect = new HashMap<>();
        int flag;
        if (quTeamNumDto.getTeamOrUserFlag().equals("1")) {
            collect = dept.stream()
                    .collect(Collectors.groupingBy(QuTeamNum::getDeptId));
            flag = 1;
        } else if ("2".equals(quTeamNumDto.getTeamOrUserFlag())) {
            collect = dept.stream()
                    .collect(Collectors.groupingBy(QuTeamNum::getUserId));
            flag = 2;
        } else {
            flag = 0;
        }

        List<QuTeamNum> quTeamNums = new ArrayList<>();
        collect.forEach((k, v) -> {
            QuTeamNum teamNum = new QuTeamNum();
            teamNum.setHasInsuredNum("0");
            teamNum.setSubmitNum("0");
            teamNum.setSyPremiumSum("0");
            teamNum.setJqPremiumSum("0");
            teamNum.setTaxaMountSum("0");
            teamNum.setTotalSumpremium("0");
            teamNum.setQuoteNum("0");

            if (!v.isEmpty()) {
                v.forEach(quTeamNum -> {
                    if (quTeamNum.getOrderStatus() != null) {
                        if (quTeamNum.getOrderStatus().equals("3")) {
                            if (quTeamNum.getJqPremiumSum() == null) {
                                quTeamNum.setJqPremiumSum("0");
                            }
                            if (quTeamNum.getSyPremiumSum() == null) {
                                quTeamNum.setSyPremiumSum("0");
                            }
                            //添加总额
                            teamNum.setTotalSumpremium(String.valueOf(new BigDecimal(teamNum.getTotalSumpremium())
                                    .add(new BigDecimal(quTeamNum.getSyPremiumSum())).add(new BigDecimal(quTeamNum.getJqPremiumSum()))));
                            teamNum.setSyPremiumSum(String.valueOf(new BigDecimal(teamNum.getSyPremiumSum()).add(new BigDecimal(quTeamNum.getSyPremiumSum()))));
                            teamNum.setJqPremiumSum(String.valueOf(new BigDecimal(teamNum.getJqPremiumSum()).add(new BigDecimal(quTeamNum.getJqPremiumSum()))));
                            teamNum.setQuoteNum(String.valueOf(new BigDecimal(teamNum.getQuoteNum()).add(new BigDecimal(quTeamNum.getCount()))));
                            teamNum.setHasInsuredNum(String.valueOf(new BigDecimal(teamNum.getHasInsuredNum()).add(new BigDecimal(quTeamNum.getCount()))));
                            teamNum.setTaxaMountSum(String.valueOf(new BigDecimal(quTeamNum.getTaxaMountSum())));
                        }
                        if (quTeamNum.getOrderStatus().equals("2")) {
                            teamNum.setSubmitNum(String.valueOf(new BigDecimal(teamNum.getSubmitNum()).add(new BigDecimal(quTeamNum.getCount()))));
                            teamNum.setQuoteNum(String.valueOf(new BigDecimal(teamNum.getQuoteNum()).add(new BigDecimal(quTeamNum.getCount()))));
                        }
                        if (quTeamNum.getOrderStatus().equals("1")) {
                            teamNum.setQuoteNum(String.valueOf(new BigDecimal(teamNum.getQuoteNum()).add(new BigDecimal(quTeamNum.getCount()))));
                            teamNum.setSubmitNum(String.valueOf(new BigDecimal(teamNum.getSubmitNum()).add(new BigDecimal(quTeamNum.getCount()))));
                        }
                    }
                });
            }

            if (flag == 1) {
                teamNum.setDeptId(v.get(0).getDeptId());
                teamNum.setDeptName(v.get(0).getDeptName());
            } else if (flag == 2) {
                teamNum.setUserId(v.get(0).getUserId());
                teamNum.setUserName(v.get(0).getUserName());
            }

            quTeamNums.add(teamNum);
        });

        List<QuTeamNum> collect1 =
                quTeamNums.stream().skip((quTeamNumDto.getPageNo() - 1) * quTeamNumDto.getPageSize()).limit(quTeamNumDto.getPageSize()).
                        collect(Collectors.toList());
        IPage<QuTeamNum> page = new Page<>(quTeamNumDto.getPageNo(), quTeamNumDto.getPageSize());
        page.setRecords(collect1);
        page.setTotal(quTeamNums.size());
        return page;
    }


    @Override
    public SysUser findByUsername(String username) {
        SysUser sysUser = null;
        if (StringUtils.isNotEmpty(username)) {

            sysUser = getById(username);
        }

        return sysUser;
    }

    @Override
    public SysUser findByPhone(String phone) {
        SysUser sysUser = null;

        LambdaQueryWrapper<SysUser> lqw = new LambdaQueryWrapper<>();
        lqw.eq(StringUtils.isNotEmpty(phone), SysUser::getMobile, phone);
        List<SysUser> lst = list(lqw);
        if (lst.size() > 0) {
            sysUser = lst.get(0);
        }

        return sysUser;
    }

    @Override
    public Set<String> findPermissions(SysUser sysUser) {
        Set<String> perms = new HashSet<>();
        String sql = "";
        List<String> lsPerms = null;

        if (sysUser.getId().equalsIgnoreCase("admin")) {

            LambdaQueryWrapper<SysMenu> lqw = new LambdaQueryWrapper<>();
            lqw.isNotNull(SysMenu::getPerms);
            lqw.select(SysMenu::getPerms);
            lsPerms = sysMenuService.listObjs(lqw, id -> id.toString());

        } else {

            List<SysMenu> sysMenuList = sysRoleMenuService.gainMenuIds(sysUser.getId());

            lsPerms =
                    sysMenuList.stream().filter(a -> StringUtils.isNotEmpty(a.getPerms())).map(SysMenu::getPerms).collect(Collectors.toList());

        }

        if (lsPerms != null && lsPerms.size() > 0) {
            for (String perm : lsPerms) {
                if (!StringUtils.isNullOrEmpty(perm)) {
                    perms.add(perm);
                }
            }
        }

        return perms;
    }
//    @Override
//    public Set<String> findPermissions(SysUser sysUser) {
//        Set<String> perms = new HashSet<>();
//        String sql = "";
//        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
//        List<String> lsPerms = null;
//
//        if (sysUser.getId().equalsIgnoreCase("admin")) {
//            sql = "SELECT perms FROM sys_menu WHERE perms IS NOT NULL AND perms <> ''";
//
//            lsPerms = jdbcTemplate.queryForList(sql, String.class);
//        } else {
//            sql = "SELECT perms FROM sys_menu sm WHERE sm.id IN ( " +
//                    "SELECT menu_id FROM sys_role_menu srm, sys_user_role sur ,sys_user su " +
//                    "WHERE srm.role_id=sur.role_id " +
//                    "AND sur.user_id=su.id AND su.id=?) " +
//                    "AND perms IS NOT NULL AND perms <> ''"
//            ;
//
//            lsPerms = jdbcTemplate.queryForList(sql, String.class, sysUser.getId());
//        }
//
//        if (lsPerms != null && lsPerms.size() > 0) {
//            for (String perm : lsPerms) {
//                if (!StringUtils.isNullOrEmpty(perm)) {
//                    perms.add(perm);
//                }
//            }
//        }
//
//        return perms;
//    }

    @Override
    public List<SysUserRole> findUserRoles(Long userId) {
        return null;
    }

    @Override
    public PageResult selectPagingCustom(int pageNumber, int pageSize, String name, String deptCode) {
        return null;
    }

    /**
     * 获取用户列表
     *
     * @param page            分页信息
     * @param sysUser         查询条件
     * @param containsSubDept 是否汉堡下级机构
     * @return
     */
    @Override
    public IPage<SysUser> selectUserPage(Page page, SysUser sysUser, String containsSubDept) {
        IPage<SysUser> sysUserIPage = baseMapper.selectUserPage(page, sysUser, containsSubDept);
        List<SysUser> records = sysUserIPage.getRecords();
        if (records != null && records.size() > 0) {
            List<String> ids = records.stream().map(SysUser::getId).collect(Collectors.toList());
            LambdaQueryWrapper<SysUserTreeShowLevel> wrapper = new LambdaQueryWrapper<>();
            wrapper.in(SysUserTreeShowLevel::getUserId, ids);
            List<SysUserTreeShowLevel> list = sysUserTreeShowLevelService.list(wrapper);
            for (SysUser record : records) {
                for (SysUserTreeShowLevel showLevel : list) {
                    if (record.getId().equals(showLevel.getUserId())) {
                        record.setShowLevel(showLevel.getShowLevel());
                    }
                }
            }
            LambdaQueryWrapper<SysUserIsDial> isWrapper = new LambdaQueryWrapper<>();
            isWrapper.in(SysUserIsDial::getUserId, ids);
            List<SysUserIsDial> isDialList = sysUserIsDialService.list(isWrapper);
            for (SysUser record : records) {
                for (SysUserIsDial isDial : isDialList) {
                    if (record.getId().equals(isDial.getUserId())) {
                        record.setIsDial(isDial.getIsDial());
                        record.setDialUserName(isDial.getDialUserName());
                        record.setDialPassWord(isDial.getDialPassWord());
                    }
                }
            }
        }
        return sysUserIPage;
    }

    @Override
    public void findSysUseresmUserInternalVORoles(PageResult pageResult) {

    }

    @Override
    public Integer deleteFlag(List<SysUser> lsSysUser) {

        List<String> ids = lsSysUser.stream().map(SysUser::getId).collect(Collectors.toList());

        LambdaUpdateWrapper<SysUser> lqw = new LambdaUpdateWrapper<>();
        lqw.set(SysUser::getStatus, "0");
        lqw.in(SysUser::getId, ids);
        return update(lqw) == true ? ids.size() : 0;


    }

    @Override
    public SysUser findById(String id) {
        if (!StringUtils.isNullOrEmpty(id)) {
            return getById(id);
        }
        return null;
    }

    @Override
    public SysUser findByUserId(String userId) {
        SysUser sysUser = null;
        if (!StringUtils.isNullOrEmpty(userId)) {
            sysUser = getById(userId);
        }

        return sysUser;
    }

    @Override
    public SysUserVO gainUserInternal(String userId) {
        return super.baseMapper.gainInternalUser(userId);
    }

    @Override
    public SysUserVO gainUserInternalByDeptId(String deptId) {
        return super.baseMapper.gainInternalUserByDeptId(deptId);
    }

    @Override
    public List<SysUserVO> findByReferrerId(String deptId) {
        return super.baseMapper.findByReferrerId(deptId);
    }

    @Override
    public List<SysUserVO> findListByDeptId(SysUser sysUser) {
        return super.baseMapper.findListByDeptId(sysUser);
    }
  @Override
    public List<SysUserVO> findListByDeptIdNew(SysUser sysUser) {
        return super.baseMapper.findListByDeptIdNew(sysUser);
    }

    @Override
    public PageVo<SysUserBaseVO> gainUserPage(PageDto<SysUserDto> pageDto) {

        PageVo<SysUserBaseVO> pageVo = new PageVo<>();
        Page<SysUserBaseVO> page = new Page<>(pageDto.getPageNum(), pageDto.getPageSize());
        pageVo.setPageNum(pageDto.getPageNum());
        pageVo.setPageSize(pageDto.getPageSize());

        SysUserDto sysUserVO = JSONObject.parseObject(JSONObject.toJSONString(pageDto.getDto()), SysUserDto.class);
        Page<SysUserBaseVO> sysUserBaseVOIPage = super.baseMapper.gainUserBaseInfo(page, sysUserVO);
        pageVo.setContent(sysUserBaseVOIPage.getRecords());
        pageVo.setTotalPages((int) sysUserBaseVOIPage.getPages());
        pageVo.setTotalSize((int) sysUserBaseVOIPage.getTotal());
        return pageVo;
    }

    @Override
    public String gainNextUserId(String deptId) {
        int noCount = 3;//顺序号是几位的
        String nextPK;
        QueryWrapper<SysUser> lq = new QueryWrapper<>();
        lq.select(" MAX(id) as id ");
        lq.eq("dept_id", deptId);
//        lq.likeRight("id", deptId);

        SysUser userMaxId = getOne(lq);


        String maxId = "";
        if (null != userMaxId) maxId = userMaxId.getId();

        if (StringUtils.isNullOrEmpty(maxId)) {
            nextPK = deptId + "001";
        } else {
            nextPK = IdGenerate.nextCode(maxId, noCount);
        }


        return nextPK;
    }

    @Override
    public SysUserInternalVO gainUserSynthesisInfo(String userId) {
        SysUserInternalVO vo = new SysUserInternalVO();

        SysUser sysUser = getById(userId);
//        EsmUserInternal sysUserInternal = esmUserInternalService.selectByPk(userId);

        String pDeptId = sysUser.getDeptId();
        if (pDeptId.indexOf("D") > 1) {
            pDeptId = sysUser.getDeptId().substring(0, pDeptId.indexOf("D"));
        }
        SysDept sysDept = sysDeptService.getById(pDeptId);

        vo.setSysUser(sysUser);
        vo.setSysDept(sysDept);
//        vo.setSysUserInternal(sysUserInternal);

        return vo;
    }


    @Override
    public String findMaxId(String deptId) {
        QueryWrapper<SysUser> qw = new QueryWrapper<>();
        qw.select("IFNULL(MAX(id),0) maxId");
        qw.eq("dept_id", deptId);
        Map<String, Object> m = getMap(qw);
        String maxId = m.get("maxId").toString();
        return maxId;

    }

    @Override
    public boolean check(String userId, Integer approvalStatus, String approvalOpinion) {

        SysUser user = getById(userId);
//        user.setApprovalStatus(approvalStatus);
        user.setApprovalOpinion(approvalOpinion);

        return updateById(user);


    }

    @Override
    public SysUserBaseVO selectUserById(String userId) {
        return sysUserMapper.selectUserById(userId);
    }

    @Override
    @Transactional
    public boolean saveUser(SysUser sysUser) {
        // 判断用户id是否存在
        if (StringUtils.isNullOrEmpty(sysUser.getId())) {
            sysUser.setId(gainNextUserId(sysUser.getDeptId()));
            sysUser.setMobile(sysUser.getMobile());
        }

        // 角色信息
        SysUserRole sur = new SysUserRole();
        sur.setUserId(sysUser.getId());
        sur.setRoleId(StringUtils.toLong(sysUser.getRoleId()));

        // 删除角色
        sysUserRoleService.deleteByUserId(sysUser.getId());
        // 删除推荐人
        esmUserReferrerService.deldeleteByReferrerId(sysUser.getId());

        // 构建推荐人信息
        EsmUserReferrer eur = new EsmUserReferrer();
        eur.setId(sysUser.getId());
        eur.setReferrerId(sysUser.getReferrerId());//推荐人
        eur.setReferrerName(sysUser.getReferrerName());

        // 新增或跟新用户表
        save(sysUser);
        // 保存推荐人
        esmUserReferrerService.save(eur);
        // 保存角色
        sysUserRoleService.save(sur);
        return true;
    }

    @Override
    @Transactional
    public HttpResult saveUserInfo(SysUser2Vo sysUserVo) {
        SysUser sysUser = sysUserVo.getSysUser();
        // 手机号
        List<SysUser> mobileList = lambdaQuery().eq(SysUser::getMobile, sysUser.getMobile()).list();
        if (!mobileList.isEmpty()) {
            throw new SystemException("手机号已经注册请更换手机号。");
        }
        // 身份证号
        List<SysUser> identityList = lambdaQuery().eq(SysUser::getIdentity, sysUser.getIdentity()).list();
        if (!identityList.isEmpty()) {
            throw new SystemException("身份证号已经注册请更换身份证号。");
        }

        //处理密码
        if (StringUtils.isNotEmpty(sysUser.getPassword())) {
            String salt = PasswordUtils.getSalt();
            String pwd = PasswordUtils.encode(sysUser.getPassword(), salt);
            sysUser.setPassword(pwd);
            sysUser.setSalt(salt);
        } else {
            return HttpResult.error("密码不能为空");
        }
        String userId="";
        if ("19".equals(sysUser.getRoleId())) {//19 出单员 校验机构和业务员机构是否一致
            // add by  hxl  2024-08-20
            // return checkChuDanUser(sysUser);
            if (StringUtils.isEmpty(sysUser.getReferrerId())) {
                return HttpResult.error("业务员工号不能为空");
            }
            //归属业务员和出单员部门必须一致
            SysUser user = getById(sysUser.getReferrerId());
            if (user == null || !user.getDeptId().equals(sysUser.getDeptId())) {
                return HttpResult.error("出单员机构必须和归属业务员机构一致");
            }
            sysUser.setOperatorCode(sysUser.getReferrerId());
            if (StringUtils.isEmpty(sysUser.getId())) {
                userId = gainNextUserId(sysUser.getDeptId());
                sysUser.setId(userId);
                save(sysUser);
                //角色配置
                SysUserRole userRole = new SysUserRole();
                userRole.setUserId(sysUser.getId());
                userRole.setRoleId(StringUtils.toLong(sysUser.getRoleId()));
                sysUserRoleService.save(userRole);
            } else {
                userId = sysUser.getId();
                updateById(sysUser);
            }
        }else{
            userId = gainNextUserId(sysUser.getDeptId());

            if (RoleConstants.R22.getCode().equals(sysUser.getRoleId())) {//22	后线人员
                if (!SysConstants.isAdministration(userId)) {
                    throw new SystemException("后线人员只能公司部门中");
                }
            }

            sysUser.setId(userId);
            save(sysUser);

            //角色配置
            SysUserRole userRole = new SysUserRole();
            userRole.setUserId(sysUser.getId());
            userRole.setRoleId(StringUtils.toLong(sysUser.getRoleId()));
            sysUserRoleService.save(userRole);
            if (StringUtils.isNotEmpty(sysUser.getReferrerId())) {
                //推荐人
                esmUserReferrerService.addReferrer(sysUser.getReferrerId(), userId);
            } else if ("20".equals(sysUser.getRoleId()) || "21".equals(sysUser.getRoleId())) {
                //如果是 团队长或代码人 并且没有推荐人 则默认推荐人为自己
                esmUserReferrerService.addReferrer(sysUser.getId(), userId);
            }
            SysUserInfo userInfo = sysUserVo.getSysUserInfo();
            if (userInfo != null) {
                userInfo.setId(sysUser.getId());
            }
//        userInfo.setId(sysUser.getId());
            sysUserInfoService.save(userInfo);
        }
        List<EsmUserImageVo> esmUserImageVo = sysUserVo.getEsmUserImageVo();
        String finalUserId = userId;
        List<EsmUserImage> esmUserImages = esmUserImageVo.stream().map(x -> new EsmUserImage(x, finalUserId)).collect(Collectors.toList());
        esmUserImageService.saveBatch(esmUserImages);

        return HttpResult.ok("新增成功");
    }

    /**
     * 新增修改出单员
     *
     * @param sysUser
     * @return
     */
    HttpResult checkChuDanUser(SysUser sysUser) {
        if (StringUtils.isEmpty(sysUser.getReferrerId())) {
            return HttpResult.error("业务员工号不能为空");
        }
        //归属业务员和出单员部门必须一致
        SysUser user = getById(sysUser.getReferrerId());
        if (user == null || !user.getDeptId().equals(sysUser.getDeptId())) {
            return HttpResult.error("出单员机构必须和归属业务员机构一致");
        }
        sysUser.setOperatorCode(sysUser.getReferrerId());
        if (StringUtils.isEmpty(sysUser.getId())) {
            String userId = gainNextUserId(sysUser.getDeptId());
            sysUser.setId(userId);
            save(sysUser);
            //角色配置
            SysUserRole userRole = new SysUserRole();
            userRole.setUserId(sysUser.getId());
            userRole.setRoleId(StringUtils.toLong(sysUser.getRoleId()));
            sysUserRoleService.save(userRole);
        } else {
            updateById(sysUser);
        }

        return HttpResult.ok("操作成功");
    }

    @Override
    @Transactional
    public HttpResult updateUserInfo(String userId, SysUser2Vo sysUserVo) {
        SysUser sysUser = sysUserVo.getSysUser();
        int beStatus = sysUser.getStatus();
        //如果审核驳回则 重新修改为 审核状态
        if (sysUserVo.getSysUser().getStatus().equals(UserWorkStatus.UWS_3.getCode())) {
            sysUserVo.getSysUser().setStatus(UserWorkStatus.UWS_2.getCode());
        }

        if (Objects.equals(sysUserVo.getSysUser().getStatus(), UserWorkStatus.UWS_5.getCode())) {
            sysUserVo.getSysUser().setStatus(UserWorkStatus.UWS_4.getCode());
        }

        if (Objects.equals(sysUserVo.getSysUser().getStatus(), UserWorkStatus.UWS_7.getCode())
                || Objects.equals(sysUserVo.getSysUser().getStatus(), UserWorkStatus.UWS_1.getCode())) {
            sysUserVo.getSysUser().setStatus(UserWorkStatus.UWS_6.getCode());
        }

        //修改用户不能修改密码
        if (StringUtils.isEmpty(sysUser.getPassword())) {
            return HttpResult.error("密码不能为空");
        }

        //删除状态必须有离司时间
        if (StringUtils.isNotEmpty(sysUser.getStatus().toString())) {
            if (sysUser.getStatus() == 0 && sysUser.getLogoutTime() == null && !sysUser.getRoleId().equals("19")) {
                return HttpResult.error("删除状态，离职时间必填");
            }
        } else {
            return HttpResult.error("状态不能为空");
        }
        SysUser sysUser_org = findByUserId(sysUser.getId());

        // 修改密码数据库相同不做修改
        if (!sysUser_org.getPassword().equals(sysUser.getPassword())) {
            String salt = PasswordUtils.getSalt();
            String pwd = PasswordUtils.encode(sysUser.getPassword(), salt);
            sysUser.setPassword(pwd);
            sysUser.setSalt(salt);
        } else {
            sysUser.setPassword(sysUser_org.getPassword());
            sysUser.setSalt(sysUser_org.getSalt());
        }
        if ("19".equals(sysUser.getRoleId())) {//19 出单员 校验机构和业务员机构是否一致
            // add by  hxl  2024-08-20
            // return checkChuDanUser(sysUser);
            if (StringUtils.isEmpty(sysUser.getReferrerId())) {
                return HttpResult.error("业务员工号不能为空");
            }
            //归属业务员和出单员部门必须一致
            SysUser user = getById(sysUser.getReferrerId());
            if (user == null || !user.getDeptId().equals(sysUser.getDeptId())) {
                return HttpResult.error("出单员机构必须和归属业务员机构一致");
            }
            sysUser.setOperatorCode(sysUser.getReferrerId());
            if (StringUtils.isEmpty(sysUser.getId())) {
                userId = gainNextUserId(sysUser.getDeptId());
                sysUser.setId(userId);
                save(sysUser);
                //角色配置
                SysUserRole userRole = new SysUserRole();
                userRole.setUserId(sysUser.getId());
                userRole.setRoleId(StringUtils.toLong(sysUser.getRoleId()));
                sysUserRoleService.save(userRole);
            } else {
                userId = sysUser.getId();
                updateById(sysUser);
            }
        }else{
            sysUser.setStatus(sysUserVo.getSysUser().getStatus());
            updateById(sysUser);

            //角色配置
            SysUserRole sysUserRole = sysUserRoleService.selectByUserId(userId);
            sysUserRole.setRoleId(StringUtils.toLong(sysUser.getRoleId()));
            sysUserRole.setLastUpdateBy(sysUser.getCreateBy());
            sysUserRole.setLastUpdateTime(new Date());
            sysUserRoleService.updateById(sysUserRole);

            if (StringUtils.isNotEmpty(sysUser.getReferrerId())) {
                //推荐人
                esmUserReferrerService.addReferrer(sysUser.getReferrerId(), userId);
            }

            //用户详情信息
            SysUserInfo sysUserInfo = sysUserVo.getSysUserInfo();
            sysUserInfo.setId(userId);
            if (null == sysUserInfo.getRemark()) {
                sysUserInfo.setRemark("");
            }
            sysUserInfoService.saveOrUpdate(sysUserInfo);
        }
        // 影像资料
        LambdaQueryWrapper<EsmUserImage> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EsmUserImage::getUserId, userId);
        esmUserImageService.remove(wrapper);

        List<EsmUserImageVo> esmUserImageVo = sysUserVo.getEsmUserImageVo();
        String finalUserId = userId;
        List<EsmUserImage> esmUserImages = esmUserImageVo.stream().map(x -> new EsmUserImage(x, finalUserId)).collect(Collectors.toList());
        esmUserImageService.saveBatch(esmUserImages);

        if (UserWorkStatus.UWS_5.getCode() == beStatus ||
                UserWorkStatus.UWS_3.getCode() == beStatus ||
                UserWorkStatus.UWS_7.getCode() == beStatus) {
            //添加轨迹
            SysUserTrack sysUserTrack = new SysUserTrack();
            sysUserTrack.setUserId(sysUser.getId());
            SysUser user = BaseController.getUser();
            sysUserTrack.setApproveBy(user.getName());
            sysUserTrack.setApproveById(user.getId());
            sysUserTrack.setStatus(sysUserVo.getSysUser().getStatus());
            sysUserTrack.setApproveTime(new Date());
            sysUserTrackService.save(sysUserTrack);
        }

        return HttpResult.ok("修改成功");
    }

    @Override
    public List<SysUser> findAllAgentRoleUser(String userId, String roleId) {
        return super.baseMapper.findAllAgentRoleUser(userId, roleId);
    }

    @Override
    public int getDeptLevel(SysUser2Vo sysUser2Vo) {
        //获取机构层级
        SysUser sysUser = sysUser2Vo.getSysUser();
        String deptId = sysUser.getDeptId();
        int level = 0;
        //1 2 3 4 5级 M 6级 D
        if (deptId.length() > 8) {
            String substring = deptId.substring(8);
            return substring.length() / 3 + 4;
        } else {
            level = deptId.length() / 2;
        }
        return level;
    }

    /**
     * 根据机构代码，查询所有人员
     *
     * @param deptId
     * @return
     */
    @Override
    public List<SysUser> findUserList(String deptId) {
        LambdaQueryWrapper<SysUser> lqw = new LambdaQueryWrapper<>();
        lqw.eq(SysUser::getStatus, "1");
        lqw.eq(SysUser::getDeptId, deptId);
        return list(lqw);
    }


    /**
     * 查找组织结构树，返回所有层级的用户列表，其中每个用户包含其直接下级用户。
     * 该方法首先根据当前用户获取其在组织结构展示中的级别，然后根据这个级别查询或构建相应的组织结构树。
     *
     * @return 返回组织结构树形式的用户列表，每个用户对象可能包含一个子用户列表。
     */
    @Override
    public List<SysUser> findTree() {
        // 获取当前登录用户
        SysUser user = BaseController.getUser();
        String userId = user.getId();

        // 根据当前用户ID查询其在组织结构展示中的级别
        LambdaQueryWrapper<SysUserTreeShowLevel> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(SysUserTreeShowLevel::getUserId, userId);
        SysUserTreeShowLevel treeShowLevel = sysUserTreeShowLevelService.getOne(lambdaQueryWrapper);

        //如果当前用户未配置树展示等级，则默认为查询本级及以下
        if (Objects.isNull(treeShowLevel)) {
            treeShowLevel = new SysUserTreeShowLevel();
            treeShowLevel.setShowLevel("subordinate");
        }
        //获取领导字段不为空的人的ID
        List<SysUser> users = lambdaQuery().isNotNull(SysUser::getLeaderId).list();

        if (users == null || users.size() == 0) {
            return new ArrayList<>();
        }
        List<SysUser> topUsers = new ArrayList<>(); //存放1级用户,即没有直接上级的用户

        // 获取可能作为顶层节点的用户ID列表
        List<String> topUserId = users.stream().map(SysUser::getLeaderId).collect(Collectors.toList());

        List<SysUser> list2 = lambdaQuery().in(SysUser::getId, topUserId).list();

        List<String> strings = list2.stream().map(SysUser::getId).collect(Collectors.toList());
        // 根据组织结构展示级别，筛选顶层节点并构建组织结构树
        switch (treeShowLevel.getShowLevel()) {
            case "all": // 展示所有级别的用户
                // 从查询结果中筛选出没有上级的人员，作为组织结构树的顶层节点
                for (SysUser sysUser : list2) {
                    if (Objects.isNull(sysUser.getLeaderId())) {
                        topUsers.add(sysUser);
                    }
                }
                // 递归构建用户树结构
                buildUserTree(topUsers, users);
                break;
            case "same": // 只展示当前用户
//                for (String ids : strings) {
//                    if (ids.equals(userId)) {
                topUsers.add(user);
//                    }
//                }
                break;
            case "subordinate": // 只展示当前用户及下属
//                for (String ids : strings) {
//                    if (ids.equals(userId)) {
                topUsers.add(user);
//                    }
//                }
                // 递归构建用户树结构
                buildUserTree(topUsers, users);
                break;
        }
        return topUsers;
    }


    /**
     * 根据部门ID查询后台用户列表。
     *
     * @param deptId 部门ID，用于筛选指定部门的用户。
     * @return 返回一个SysUser类型的列表，包含指定部门的所有后台用户。
     */
    @Override
    public List<SysUser> findBackListByDeptId(String deptId) {
        return baseMapper.findBackListByDeptId(deptId);
    }


    /**
     * 查询用户订单数量进行区域统计信息
     *
     * @param quUserNumDto 包含查询条件和分页信息的数据传输对象
     * @return IPage<QuUserNum> 返回用户数量统计信息的分页对象
     */
    @Override
    public IPage<QuUserNum> quUserNum(QuUserNumDto quUserNumDto) {

        if (StringUtils.isNotEmpty(quUserNumDto.getCreateTimeStart()) && StringUtils.isNotEmpty(quUserNumDto.getCreateTimeEnd())) {
            quUserNumDto.setCreateTimeStart(quUserNumDto.getCreateTimeStart() + " 00:00:00");
            quUserNumDto.setCreateTimeEnd(quUserNumDto.getCreateTimeEnd() + " 23:59:59");
        }

        //获取所有用户
        List<SysUser> users = list();

        // 根据用户ID查询一级下屬
        LambdaQueryWrapper<SysUser> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(SysUser::getId, quUserNumDto.getUserId());
        List<SysUser> usersLevel1 = list(queryWrapper);

        //递归获取1级下属下所有的下属ID
        List<String> strIds = new ArrayList<>();
        findChildren(usersLevel1, users, strIds);

        // 根据区域编码和级别查询符合条件的区域
        LambdaQueryWrapper<SysArea> wrapper = new LambdaQueryWrapper<>();
        if (quUserNumDto.getAreaCode() != null && !"".equals(quUserNumDto.getAreaCode())) {
            String area = quUserNumDto.getAreaCode();
            switch (quUserNumDto.getLevel()) {
                case "1": { // 省级查询逻辑
                    quUserNumDto.setGrouping(4);
                    String prefix = area.substring(0, 2);
                    strIds.removeIf(id -> !id.contains("99" + prefix));
                    quUserNumDto.setLevel("2");
                    wrapper.eq(SysArea::getLevel, "2");
                    wrapper.likeRight(SysArea::getAreaCode, prefix);
                    break;
                }
                case "2": {  // 市级查询逻辑
                    quUserNumDto.setGrouping(6);
                    String prefix = area.substring(0, 4);
                    strIds.removeIf(id -> !id.contains("99" + prefix));
                    quUserNumDto.setLevel("3");
                    wrapper.eq(SysArea::getLevel, "3");
                    wrapper.likeRight(SysArea::getAreaCode, prefix);
                    break;
                }
                case "3": {  // 区县级查询逻辑
                    quUserNumDto.setGrouping(6);
                    String prefix = area.substring(0, 6);
                    strIds.removeIf(id -> !id.contains("99" + prefix));
                    quUserNumDto.setLevel("3");
                    wrapper.eq(SysArea::getLevel, "3");
                    wrapper.likeRight(SysArea::getAreaCode, prefix);
                    break;
                }
            }
        } else { // 默认查询省级区域
            quUserNumDto.setGrouping(2);
            quUserNumDto.setLevel("1");
            wrapper.eq(SysArea::getLevel, "1");
        }
        //遍历匹配区域名称
        List<SysArea> areaList = sysAreaService.list(wrapper);

        List<QuUserNum> quUserNums = new ArrayList<>();

        // 如果没有查询到用户ID，则直接返回空的分页对象
        if (strIds.size() != 0) {
            // 根据查询条件获取用户数量统计信息
            quUserNumDto.setUserIds(strIds);
            List<QuUserNum> userNums = sysUserMapper.getUserNum(quUserNumDto);
            // 获取地区主订单待核保订单数量
            List<QuUserNum> mainWaitAuditSums = sysUserMapper.getMainWaitAuditSum(quUserNumDto);
            // 获取地区主订单已核保待缴费订单数量
            List<QuUserNum> mainWaitPaySums = sysUserMapper.getMainWaitPaySum(quUserNumDto);
            // 获取地区主订单已承包订单数量
            List<QuUserNum> mainAcceptInsuranceSums = sysUserMapper.getMainAcceptInsuranceSum(quUserNumDto);
            // 根据区域名称匹配用户数量统计信息，并构造最终返回的结果列表
            for (QuUserNum quUserNum : userNums) {
                for (SysArea sysArea : areaList) {
                    if (!Objects.isNull(sysArea.getAreaCode())) {
                        // 匹配区域名称
                        String substring = sysArea.getAreaCode().substring(0, quUserNumDto.getGrouping());
                        if (quUserNum.getAreaCode().equals(substring)) {
                            quUserNum.setAreaName(sysArea.getAreaCname());
                        }
                    }
                }

                for (QuUserNum mainWaitAuditSum : mainWaitAuditSums) {
                    if (quUserNum.getAreaCode().equals(mainWaitAuditSum.getAreaCode())) {
                        quUserNum.setMainWaitAuditSum(mainWaitAuditSum.getMainWaitAuditSum());
                    }
                }
                for (QuUserNum mainWaitPaySum : mainWaitPaySums) {
                    if (quUserNum.getAreaCode().equals(mainWaitPaySum.getAreaCode())) {
                        quUserNum.setMainWaitPaySum(mainWaitPaySum.getMainWaitPaySum());
                    }
                }
                for (QuUserNum mainAcceptInsuranceSum : mainAcceptInsuranceSums) {
                    if (quUserNum.getAreaCode().equals(mainAcceptInsuranceSum.getAreaCode())) {
                        quUserNum.setMainAcceptInsuranceSum(mainAcceptInsuranceSum.getMainAcceptInsuranceSum());
                    }
                }
                if (quUserNum.getAreaName() != null) {
                    quUserNums.add(quUserNum);
                }
//                quUserNums.add(quUserNum);
            }
        }

        // 为每个区域生成未匹配到的统计信息
        for (SysArea sysArea : areaList) {
            if (exists(quUserNums, sysArea)) {
                QuUserNum userNum = new QuUserNum();
                // 设置未匹配到的区域的默认统计信
                userNum.setAreaName(sysArea.getAreaCname());
                quUserNums.add(userNum);
            }
        }
        List<QuUserNum> paginate = paginate(quUserNums, quUserNumDto.getPageNum(), quUserNumDto.getPageSize());

        // 构造返回的分页对象
        IPage<QuUserNum> recordsPage = new Page<>(quUserNumDto.getPageNum(), quUserNumDto.getPageSize());
        recordsPage.setRecords(paginate);
        recordsPage.setTotal(quUserNums.size());
        return recordsPage;
    }


    /**
     * 查询用户订单数量进行区域统计详细信息
     *
     * @param quUserNumDto 包含查询条件和分页信息的数据传输对象
     * @return IPage<QuUserNum> 返回用户数量统计信息的分页对象
     */
    @Override
    public IPage<QuUserNum> getQuUserByCompany(QuUserNumDto quUserNumDto) {
        if (StringUtils.isNotEmpty(quUserNumDto.getCreateTimeStart()) && StringUtils.isNotEmpty(quUserNumDto.getCreateTimeEnd())) {
            quUserNumDto.setCreateTimeStart(quUserNumDto.getCreateTimeStart() + " 00:00:00");
            quUserNumDto.setCreateTimeEnd(quUserNumDto.getCreateTimeEnd() + " 23:59:59");
        }

        //查询单个用户的详情时不需要区域code
        if (!quUserNumDto.getQuMarks().equals(QuMarks.USER_COMPANY_MARK.getCode())) {
            // 获取系统中的所有用户
            List<SysUser> users = list();

            // 创建查询包装器，用于查询指定用户ID的用
            LambdaQueryWrapper<SysUser> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(SysUser::getId, quUserNumDto.getUserId());
            // 查询指定用户ID的用户，即第一级下属
            List<SysUser> usersLevel1 = list(queryWrapper);

            // 用于存储所有下属的ID
            List<String> strIds = new ArrayList<>();
            // 递归获取第一级下属及其所有下属的ID
            findChildren(usersLevel1, users, strIds);
            // 如果未指定区域码，返回空分页对
            if (Objects.isNull(quUserNumDto.getAreaCode())) {
                return new Page<>();
            }
            // 根据区域码筛选有效的下属ID
            strIds.removeIf(id -> !id.contains("99" + quUserNumDto.getAreaCode()));
            // 如果筛选后没有有效的下属ID，返回空分页对象
            if (strIds.size() == 0) {
                return new Page<>();
            }
            // 设置查询条件中的用户ID列表
            quUserNumDto.setUserIds(strIds);
        } else {
            // 设置查询条件中的用户ID列表
            quUserNumDto.setUserIds(Collections.singletonList(quUserNumDto.getUserId()));
        }

        List<QuUserNum> deptByCompany = agentOrChannelByMark(quUserNumDto);

        List<QuUserNum> paginate = paginate(deptByCompany, quUserNumDto.getPageNum(), quUserNumDto.getPageSize());

        // 创建并设置分页信息
        IPage<QuUserNum> page = new Page<>(quUserNumDto.getPageNum(), quUserNumDto.getPageSize());
        page.setRecords(paginate);
        page.setTotal(deptByCompany.size());
        return page;
    }


    /**
     * 手动对 QuUserNum 列表进行分页
     *
     * @param quUserNums 原始 QuUserNum 数据列表
     * @param pageNum    期望获取的页码（从 1 开始）
     * @param pageSize   每页包含的 QuUserNum 数量
     * @return 对应页码的 QuUserNum 子列表，若输入参数无效则返回空列表
     */
    public List<QuUserNum> paginate(List<QuUserNum> quUserNums, int pageNum, int pageSize) {
        if (quUserNums == null || quUserNums.isEmpty() || pageNum < 1 || pageSize < 1) {
            return Collections.emptyList();
        }

        int startIndex = (pageNum - 1) * pageSize;
        int endIndex = Math.min(startIndex + pageSize, quUserNums.size());

        return quUserNums.subList(startIndex, endIndex);
    }


    private void findChildren(List<SysUser> SysUsers, List<SysUser> users, List<String> strIds) {
        for (SysUser sysUser : SysUsers) {
            List<SysUser> children = new ArrayList<>();
            for (SysUser user : users) {
                if (sysUser.getId() != null && sysUser.getId().equals(user.getLeaderId())) {
                    if (!exists(children, user)) {
                        children.add(user);
                        strIds.add(user.getId());
                    }
                }
            }
            sysUser.setChildren(children);
//            children.sort((o1, o2) -> o1.getOrderNum().compareTo(o2.getOrderNum()));
            findChildren(children, users, strIds);
        }
    }


    private boolean exists(List<QuUserNum> quUserNums, SysArea sysArea) {
        boolean exist = true;
        for (QuUserNum quUserNum1 : quUserNums) {
            if (sysArea.getAreaCname().equals(quUserNum1.getAreaName())) {
                exist = false;
                break;
            }
        }
        return exist;
    }

    private boolean exists(List<SysUser> sysUsers, SysUser sysUser) {
        boolean exist = false;
        for (SysUser user : sysUsers) {
            if (user.getId().equals(sysUser.getId())) {
                exist = true;
            }
        }
        return exist;
    }

    private void buildUserTree(List<SysUser> topUsers, List<SysUser> users) {
        for (SysUser user : topUsers) {
            List<SysUser> children = new ArrayList<>();
            for (SysUser childUser : users) {
                if (user.getId().equals(childUser.getLeaderId()) && !childUser.getId().contains("M")) {
                    children.add(childUser);
                    // 递归查找下一级
                    buildUserTree(children, users);
                }
            }
            user.setChildren(children);
        }
    }


    /**
     * @version
     * @author: hxl
     * @Date: 2024/4/16 15:51
     * @Description: 获取待客录入的可选业务员
     * 查询
     */
    @Override
    public List<SysUserBaseVO> getAllUsersByHospitality(SysUserVOExt sysUserVOExt) {
        if (StringUtils.isNotEmpty(sysUserVOExt.getUserId()) || StringUtils.isNotEmpty(sysUserVOExt.getIdentity()) ||
                StringUtils.isNotEmpty(sysUserVOExt.getMobile()) || StringUtils.isNotEmpty(sysUserVOExt.getName())) {
            return super.baseMapper.getAllUsersByHospitality(sysUserVOExt);
        }
        return new ArrayList<SysUserBaseVO>();
    }

    /**
     * @version
     * @author: hxl
     * @Date: 2024/4/18 16:14
     * @Description: 获取客服人员列表数据
     */
    @Override
    public List<SysUserBaseVO> getCustomerUsers() {
        return super.baseMapper.getCustomerUsers(new SysUserVOExt());
    }

    @Override
    public IPage<QuUserNum> quAgentAreaAdmin(QuUserNumDto quUserNumDto) {

        if (StringUtils.isNotEmpty(quUserNumDto.getCreateTimeStart()) && StringUtils.isNotEmpty(quUserNumDto.getCreateTimeEnd())) {
            quUserNumDto.setCreateTimeStart(quUserNumDto.getCreateTimeStart() + " 00:00:00");
            quUserNumDto.setCreateTimeEnd(quUserNumDto.getCreateTimeEnd() + " 23:59:59");
        }


        //获取所有代理人用户
        List<SysUserBaseVO> agentUsers = baseMapper.getAgentUserIdsByAreaIds();

        List<String> strIds = agentUsers.stream().map(SysUserBaseVO::getUserId).collect(Collectors.toList());

        // 根据区域编码和级别查询符合条件的区域
        LambdaQueryWrapper<SysArea> wrapper = new LambdaQueryWrapper<>();
        if (strIds.size() != 0) {
            if (quUserNumDto.getAreaCode() != null && !"".equals(quUserNumDto.getAreaCode())) {
                String area = quUserNumDto.getAreaCode();
                switch (quUserNumDto.getLevel()) {
                    case "1": { // 省级查询逻辑
                        quUserNumDto.setGrouping(4);
                        String prefix = area.substring(0, 2);
                        strIds.removeIf(id -> !id.contains("99" + prefix));
                        quUserNumDto.setLevel("2");
                        wrapper.eq(SysArea::getLevel, "2");
                        wrapper.likeRight(SysArea::getAreaCode, prefix);
                        break;
                    }
                    case "2": {  // 市级查询逻辑
                        quUserNumDto.setGrouping(6);
                        String prefix = area.substring(0, 4);
                        strIds.removeIf(id -> !id.contains("99" + prefix));
                        quUserNumDto.setLevel("3");
                        wrapper.eq(SysArea::getLevel, "3");
                        wrapper.likeRight(SysArea::getAreaCode, prefix);
                        break;
                    }
                    case "3": {  // 区县级查询逻辑
                        quUserNumDto.setGrouping(6);
                        String prefix = area.substring(0, 6);
                        strIds.removeIf(id -> !id.contains("99" + prefix));
                        quUserNumDto.setLevel("3");
                        wrapper.eq(SysArea::getLevel, "3");
                        wrapper.likeRight(SysArea::getAreaCode, prefix);
                        break;
                    }
                }
            } else { // 默认查询省级区域
                quUserNumDto.setGrouping(2);
                quUserNumDto.setLevel("1");
                wrapper.eq(SysArea::getLevel, "1");
            }
        }

        //遍历匹配区域名称
        List<SysArea> areaList = sysAreaService.list(wrapper);

        List<QuUserNum> quUserNums = new ArrayList<>();
        // 如果没有查询到用户ID，则直接返回空的分页对象
        if (strIds.size() != 0) {
            // 根据查询条件获取用户数量统计信息
            quUserNumDto.setUserIds(strIds);
            List<QuUserNum> userNums = sysUserMapper.getUserNum(quUserNumDto);

            // 获取地区主订单待核保订单数量
            List<QuUserNum> mainWaitAuditSums = sysUserMapper.getMainWaitAuditSum(quUserNumDto);
            // 获取地区主订单已核保待缴费订单数量
            List<QuUserNum> mainWaitPaySums = sysUserMapper.getMainWaitPaySum(quUserNumDto);
            // 获取地区主订单已承包订单数量
            List<QuUserNum> mainAcceptInsuranceSums = sysUserMapper.getMainAcceptInsuranceSum(quUserNumDto);
            // 根据区域名称匹配用户数量统计信息，并构造最终返回的结果列表
            for (QuUserNum quUserNum : userNums) {
                for (SysArea sysArea : areaList) {
                    if (!Objects.isNull(sysArea.getAreaCode())) {
                        // 匹配区域名称
                        String substring = sysArea.getAreaCode().substring(0, quUserNumDto.getGrouping());
                        if (quUserNum.getAreaCode().equals(substring)) {
                            quUserNum.setAreaName(sysArea.getAreaCname());
                        }
                    }
                }
                for (QuUserNum mainWaitAuditSum : mainWaitAuditSums) {
                    if (quUserNum.getAreaCode().equals(mainWaitAuditSum.getAreaCode())) {
                        quUserNum.setMainWaitAuditSum(mainWaitAuditSum.getMainWaitAuditSum());
                    }
                }
                for (QuUserNum mainWaitPaySum : mainWaitPaySums) {
                    if (quUserNum.getAreaCode().equals(mainWaitPaySum.getAreaCode())) {
                        quUserNum.setMainWaitPaySum(mainWaitPaySum.getMainWaitPaySum());
                    }
                }
                for (QuUserNum mainAcceptInsuranceSum : mainAcceptInsuranceSums) {
                    if (quUserNum.getAreaCode().equals(mainAcceptInsuranceSum.getAreaCode())) {
                        quUserNum.setMainAcceptInsuranceSum(mainAcceptInsuranceSum.getMainAcceptInsuranceSum());
                    }
                }
                quUserNums.add(quUserNum);
            }
        }
        // 为每个区域生成未匹配到的统计信息
        for (SysArea sysArea : areaList) {
            if (exists(quUserNums, sysArea)) {
                QuUserNum userNum = new QuUserNum();
                // 设置未匹配到的区域的默认统计信
                userNum.setAreaName(sysArea.getAreaCname());
                quUserNums.add(userNum);
            }
        }
        List<QuUserNum> paginate = paginate(quUserNums, quUserNumDto.getPageNum(), quUserNumDto.getPageSize());

        // 构造返回的分页对象
        IPage<QuUserNum> recordsPage = new Page<>(quUserNumDto.getPageNum(), quUserNumDto.getPageSize());
        recordsPage.setRecords(paginate);
        recordsPage.setTotal(quUserNums.size());
        return recordsPage;

    }

    @Override
    public IPage<QuUserNum> quAgentAreaAdminDetail(QuUserNumDto quUserNumDto) {

        if (StringUtils.isNotEmpty(quUserNumDto.getCreateTimeStart()) && StringUtils.isNotEmpty(quUserNumDto.getCreateTimeEnd())) {
            quUserNumDto.setCreateTimeStart(quUserNumDto.getCreateTimeStart() + " 00:00:00");
            quUserNumDto.setCreateTimeEnd(quUserNumDto.getCreateTimeEnd() + " 23:59:59");
        }

        //查询单个用户的详情时不需要区域code
        if (!quUserNumDto.getQuMarks().equals(QuMarks.USER_COMPANY_MARK.getCode())) {
            //获取所有代理人用户
            List<SysUserBaseVO> agentUsers = baseMapper.getAgentUserIdsByAreaIds();

            List<String> strIds = agentUsers.stream().map(SysUserBaseVO::getUserId).collect(Collectors.toList());

            // 如果未指定区域码，返回空分页对
            if (Objects.isNull(quUserNumDto.getAreaCode())) {
                return new Page<>();
            }

            // 根据区域码筛选有效的下属ID
            strIds.removeIf(id -> !id.contains("99" + quUserNumDto.getAreaCode()));

            // 如果筛选后没有有效的下属ID，返回空分页对象
            if (strIds.isEmpty()) {
                return new Page<>();
            }
            // 设置查询条件中的用户ID列表
            quUserNumDto.setUserIds(strIds);
        } else {
            // 设置查询条件中的用户ID列表
            quUserNumDto.setUserIds(Collections.singletonList(quUserNumDto.getUserId()));
        }

        List<QuUserNum> deptByCompany = agentOrChannelByMark(quUserNumDto);

        List<QuUserNum> paginate = paginate(deptByCompany, quUserNumDto.getPageNum(), quUserNumDto.getPageSize());

        // 创建并设置分页信息
        IPage<QuUserNum> page = new Page<>(quUserNumDto.getPageNum(), quUserNumDto.getPageSize());
        page.setRecords(paginate);
        page.setTotal(deptByCompany.size());
        return page;
    }


    public List<QuUserNum> agentOrChannelByMark(QuUserNumDto quUserNumDto) {

        List<QuUserNum> deptByCompany = new ArrayList<>();
        if (quUserNumDto.getQuMarks().equals(QuMarks.COMPANY_MARK.getCode())) {
            // 根据公司和用户ID列表查询用户数量统计信息
            deptByCompany = sysUserMapper.getUserByCompany(quUserNumDto);
            // 获取公司主订单待核保订单数量
            List<QuUserNum> mainWaitAuditSums = sysUserMapper.getComMainWaitAuditSum(quUserNumDto);
            // 获取公司主订单已核保待缴费订单数量
            List<QuUserNum> mainWaitPaySums = sysUserMapper.getComMainWaitPaySum(quUserNumDto);
            // 获取公司主订单已承包订单数量
            List<QuUserNum> mainAcceptInsuranceSums = sysUserMapper.getComMainAcceptInsuranceSum(quUserNumDto);

            for (QuUserNum quUserNum : deptByCompany) {
                for (QuUserNum mainWaitAuditSum : mainWaitAuditSums) {
                    if (quUserNum.getCompanyId().equals(mainWaitAuditSum.getCompanyId())) {
                        quUserNum.setMainWaitAuditSum(mainWaitAuditSum.getMainWaitAuditSum());
                    }
                }
                for (QuUserNum mainWaitPaySum : mainWaitPaySums) {
                    if (quUserNum.getCompanyId().equals(mainWaitPaySum.getCompanyId())) {
                        quUserNum.setMainWaitPaySum(mainWaitPaySum.getMainWaitPaySum());
                    }
                }
                for (QuUserNum mainAcceptInsuranceSum : mainAcceptInsuranceSums) {
                    if (quUserNum.getCompanyId().equals(mainAcceptInsuranceSum.getCompanyId())) {
                        quUserNum.setMainAcceptInsuranceSum(mainAcceptInsuranceSum.getMainAcceptInsuranceSum());
                    }
                }
            }

        } else if (quUserNumDto.getQuMarks().equals(QuMarks.USER_MARK.getCode())) {
            // 根据公司和用户ID列表查询用户数量统计信息
            deptByCompany = sysUserMapper.getUserDetail(quUserNumDto);

            // 获取用户主订单待核保订单数量
            List<QuUserNum> mainWaitAuditSums = sysUserMapper.getUserMainWaitAuditSum(quUserNumDto);
            // 获取用户主订单已核保待缴费订单数量
            List<QuUserNum> mainWaitPaySums = sysUserMapper.getUserMainWaitPaySum(quUserNumDto);
            // 获取用户主订单已承包订单数量
            List<QuUserNum> mainAcceptInsuranceSums = sysUserMapper.getUserMainAcceptInsuranceSum(quUserNumDto);

            for (QuUserNum quUserNum : deptByCompany) {
                for (QuUserNum mainWaitAuditSum : mainWaitAuditSums) {
                    if (quUserNum.getUserId().equals(mainWaitAuditSum.getUserId())) {
                        quUserNum.setMainWaitAuditSum(mainWaitAuditSum.getMainWaitAuditSum());
                    }
                }
                for (QuUserNum mainWaitPaySum : mainWaitPaySums) {
                    if (quUserNum.getUserId().equals(mainWaitPaySum.getUserId())) {
                        quUserNum.setMainWaitPaySum(mainWaitPaySum.getMainWaitPaySum());
                    }
                }
                for (QuUserNum mainAcceptInsuranceSum : mainAcceptInsuranceSums) {
                    if (quUserNum.getUserId().equals(mainAcceptInsuranceSum.getUserId())) {
                        quUserNum.setMainAcceptInsuranceSum(mainAcceptInsuranceSum.getMainAcceptInsuranceSum());
                    }
                }
            }
        } else if (quUserNumDto.getQuMarks().equals(QuMarks.USER_COMPANY_MARK.getCode())) {
            // 根据公司和用户ID列表查询用户数量统计信息
            deptByCompany = sysUserMapper.getUserByCompany(quUserNumDto);
            // 获取公司主订单待核保订单数量
            List<QuUserNum> mainWaitAuditSums = sysUserMapper.getComMainWaitAuditSum(quUserNumDto);
            // 获取公司主订单已核保待缴费订单数量
            List<QuUserNum> mainWaitPaySums = sysUserMapper.getComMainWaitPaySum(quUserNumDto);
            // 获取公司主订单已承包订单数量
            List<QuUserNum> mainAcceptInsuranceSums = sysUserMapper.getComMainAcceptInsuranceSum(quUserNumDto);

            for (QuUserNum quUserNum : deptByCompany) {
                for (QuUserNum mainWaitAuditSum : mainWaitAuditSums) {
                    if (quUserNum.getCompanyId().equals(mainWaitAuditSum.getCompanyId())) {
                        quUserNum.setMainWaitAuditSum(mainWaitAuditSum.getMainWaitAuditSum());
                    }
                }
                for (QuUserNum mainWaitPaySum : mainWaitPaySums) {
                    if (quUserNum.getCompanyId().equals(mainWaitPaySum.getCompanyId())) {
                        quUserNum.setMainWaitPaySum(mainWaitPaySum.getMainWaitPaySum());
                    }
                }
                for (QuUserNum mainAcceptInsuranceSum : mainAcceptInsuranceSums) {
                    if (quUserNum.getCompanyId().equals(mainAcceptInsuranceSum.getCompanyId())) {
                        quUserNum.setMainAcceptInsuranceSum(mainAcceptInsuranceSum.getMainAcceptInsuranceSum());
                    }
                }
            }
        }
        return deptByCompany;
    }


    /**
     * @version
     * @author: hxl
     * @Date: 2024/4/29 16:01
     * @Description: 查询当前登陆人管理的渠道人 即领导人为当前登陆人的用户需要递归查询
     */
    public List<String> getUserIdsByLeaderId(String userId) {
        // 获取系统中的所有用户
        LambdaQueryWrapper<SysUser> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(SysUser::getStatus, 1);
        List<SysUser> allUsers = this.getBaseMapper().selectList(queryWrapper);
        // 查询指定用户ID管理的用户，即第一级下属
        queryWrapper.eq(SysUser::getId, userId);
        List<SysUser> leadUsers = this.getBaseMapper().selectList(queryWrapper);
        // 用于存储所有下属的ID
        List<String> strIds = new ArrayList<>();
        // 递归获取第一级下属及其所有下属的ID
        findChildren(leadUsers, allUsers, strIds);
        return strIds;
    }

    /**
     * @version
     * @author: hxl
     * @Date: 2024/5/7 10:45
     * @Description: 通过部门id和角色id查询是否存在团队长
     */
    @Override
    public int getCountByDeptAndRoleId(SysUser sysUserVo) {
        return sysUserMapper.getCountByDeptAndRoleId(sysUserVo);
    }

    /**
     * @version
     * @author: hxl
     * @Date: 2024/5/7 11:44
     * @Description: 查询该部门的团队长
     */
    @Override
    public String findTDZUserIdByDeptId(String deptId) {
        return sysUserMapper.findTDZUserIdByDeptId(deptId);
    }

    /**
     * 获取多条用户数据
     *
     * @param userIds 用户idList
     * @return
     */
    @Override
    public List<SysUser> getByIds(List<String> userIds) {
        LambdaQueryWrapper<SysUser> sysUserLambdaQueryWrapper = new LambdaQueryWrapper<>();
        sysUserLambdaQueryWrapper.in(SysUser::getId, userIds);
        return sysUserMapper.selectList(sysUserLambdaQueryWrapper);
    }

    /**
     * @version
     * @author: hxl
     * @Date: 2024/7/11 16:08
     * @Description: 查询所有的后线人员
     */
    @Override
    public List<SysUser> findHxUserList() {
        return sysUserMapper.findHxUserList();
    }

    /**
     * 离职申请
     *
     * @param sysUserVO
     * @return
     */
    @Override
    @Transactional
    public boolean departApply(SysUser2Vo sysUserVO) {
        if (Objects.isNull(sysUserVO.getSysUser().getLogoutTime())) {
            throw new SystemException("请填写离职时间");
        }
        if (Objects.isNull(sysUserVO.getEsmUserImageVo()) && sysUserVO.getEsmUserImageVo().isEmpty()) {
            throw new SystemException("请上传离职证明");
        }
        SysUser byId = this.getById(sysUserVO.getSysUser().getId());
        byId.setLogoutTime(sysUserVO.getSysUser().getLogoutTime());
        byId.setStatus(UserWorkStatus.UWS_4.getCode());
        this.updateById(byId);

        //添加离职证明
        //判斷是否存在先刪除   add by hxl
        LambdaQueryWrapper<EsmUserImage> lqw = new LambdaQueryWrapper<>();
        lqw.eq(EsmUserImage::getUserId, sysUserVO.getSysUser().getId());
        lqw.eq(EsmUserImage::getType, InsuranceImageEnum.LZ_01.getCode());
        esmUserImageService.getBaseMapper().delete(lqw);

        EsmUserImageVo esmUserImageVo = sysUserVO.getEsmUserImageVo().get(0);
        esmUserImageVo.setType(InsuranceImageEnum.LZ_01.getCode());
        EsmUserImage esmUserImage = new EsmUserImage(esmUserImageVo, sysUserVO.getSysUser().getId());
        esmUserImageService.save(esmUserImage);

        //添加轨迹
        SysUserTrack sysUserTrack = new SysUserTrack(byId);
        sysUserTrackService.save(sysUserTrack);
        return true;
    }

    @Override
    public List<String> getUserIds() {
        return baseMapper.getUserIds();
    }

    @Override
    @Transactional
    public void separationReinstatement(String userid) {
        SysUser sysUser = getByIdExist(userid, "离职用户未查询到");
        sysUser.setStatus(UserWorkStatus.UWS_2.getCode());
        this.updateById(sysUser);
    }

    @Override
    public SysUser getByUserId(String userid){
        return baseMapper.getByUserId(userid);
    }

    @Override
    public List<String> getTelemarketingPersonnelData() {
        return baseMapper.getTelemarketingPersonnelUserId();
    }

    @Override
    public void saveLoginIpAddr(String systemType,SysUser user) {
        if (SystemType.ST_1.getCode().equals(systemType)) {
            try {
                sysPcAddressService.saveSysPcAddress(user);
            }catch (Exception e){}
        }

    }

}