package com.zhgd.xmgl.async;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.zhgd.jeecg.common.execption.OpenPromptException;
import com.zhgd.jeecg.common.util.SpringContextUtils;
import com.zhgd.jeecg.common.util.pass.HttpUtils;
import com.zhgd.xmgl.call.HikvisionCall;
import com.zhgd.xmgl.constant.Cts;
import com.zhgd.xmgl.modules.basicdata.entity.Notice;
import com.zhgd.xmgl.modules.basicdata.service.INoticeService;
import com.zhgd.xmgl.modules.car.entity.CarInfo;
import com.zhgd.xmgl.modules.car.service.impl.CarInfoServiceImpl;
import com.zhgd.xmgl.modules.project.entity.Project;
import com.zhgd.xmgl.modules.project.entity.vo.ProjectInfoExtVo;
import com.zhgd.xmgl.modules.project.mapper.ProjectMapper;
import com.zhgd.xmgl.modules.project.service.IProjectUfaceConfigService;
import com.zhgd.xmgl.modules.project.service.impl.ProjectServiceImpl;
import com.zhgd.xmgl.modules.video.mapper.ProjectVideoHkVqdMapper;
import com.zhgd.xmgl.modules.video.mapper.VideoItemMapper;
import com.zhgd.xmgl.modules.worker.entity.*;
import com.zhgd.xmgl.modules.worker.mapper.EnterpriseInfoMapper;
import com.zhgd.xmgl.modules.worker.service.impl.WorkerInfoServiceImpl;
import com.zhgd.xmgl.modules.xz.entity.XzHikvisionSync;
import com.zhgd.xmgl.modules.xz.mapper.XzHikvisionCompareDataMapper;
import com.zhgd.xmgl.modules.xz.mapper.XzHikvisionSyncMapper;
import com.zhgd.xmgl.modules.xz.service.impl.XzHikvisionCompareDataServiceImpl;
import com.zhgd.xmgl.security.entity.UserInfo;
import com.zhgd.xmgl.util.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.jetbrains.annotations.NotNull;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.concurrent.Future;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * 海康
 */
@Slf4j
@Component
public class AsyncHikvision {
    public static final String XZ_HIKVISION_SYNC_TIME = "xzHikvisionSyncTime";
    @Lazy
    @Autowired
    public CarInfoServiceImpl carInfoService;
    @Autowired
    @Lazy
    public WorkerInfoServiceImpl workerInfoService;
    @Autowired
    @Lazy
    public IProjectUfaceConfigService projectUfaceConfigService;
    @Autowired
    @Lazy
    HikvisionCall hikvisionCall;
    @Lazy
    @Autowired
    ProjectMapper projectMapper;
    @Lazy
    @Autowired
    VideoItemMapper videoItemMapper;
    @Lazy
    @Autowired
    ProjectVideoHkVqdMapper projectVideoHkVqdMapper;
    @Lazy
    @Autowired
    EnterpriseInfoMapper enterpriseInfoMapper;
    @Lazy
    @Autowired
    ProjectServiceImpl projectService;
    @Lazy
    @Autowired
    private INoticeService noticeService;
    @Lazy
    @Autowired
    private AsyncHikvision asyncHikvision;
    @Lazy
    @Autowired
    private XzHikvisionSyncMapper xzHikvisionSyncMapper;
    @Lazy
    @Autowired
    private XzHikvisionCompareDataMapper xzHikvisionCompareDataMapper;
    @Lazy
    @Autowired
    private XzHikvisionCompareDataServiceImpl xzHikvisionCompareDataService;

    /**
     * @param bigType 1人员2车辆
     * @param tableId
     * @return
     */
    public static Date getSyncTimeWithInitIfAbsent(int bigType, Long tableId) {
        Date now = ThreadLocalUtil.getNotNull().getDate(XZ_HIKVISION_SYNC_TIME);
        if (now == null) {
            //首次执行，清空以前同步记录
            now = new Date();
            ThreadLocalUtil.addInKey(XZ_HIKVISION_SYNC_TIME, now);
            SpringContextUtils.getBean(XzHikvisionSyncMapper.class).delete(new LambdaQueryWrapper<XzHikvisionSync>()
                    .eq(XzHikvisionSync::getBigType, bigType)
                    .eq(XzHikvisionSync::getWhoId, tableId)
            );
        }
        return now;
    }

    public static Date getSyncTime() {
        return ThreadLocalUtil.getNotNull().getDate(XZ_HIKVISION_SYNC_TIME);
    }

    @Async("sendWorkerExecutor")
    public Future addWorkerAndAuthAsync(WorkerInfo workerInfo, boolean isSaveWorker, boolean isSaveWorkerFace) {
        addWorkerAsync(workerInfo, true, true);
        projectUfaceConfigService.addWorkerInfo(workerInfo);
        return null;
    }

    /**
     * 添加劳务人员-海康
     *
     * @param workerInfo
     * @param isSaveWorker
     * @param isSaveWorkerFace
     */
    @Async("sendWorkerExecutor")
    public void addWorkerAsync(WorkerInfo workerInfo, boolean isSaveWorker, boolean isSaveWorkerFace) {
        try {
            hikvisionCall.addWorkerForHikvision(workerInfo, isSaveWorker, isSaveWorkerFace);
        } catch (Exception e) {
            log.error("海康：", e);
            sendNoticeForWorker(workerInfo, e, "添加");
        }
    }

    public void addWorker(WorkerInfo workerInfo, boolean isSaveWorker, boolean isSaveWorkerFace) {
        this.addWorkerAsync(workerInfo, isSaveWorker, isSaveWorkerFace);
    }

    @Async("sendWorkerExecutor")
    public void editWorkerAndAuthAsync(WorkerInfo workerInfo, boolean isSaveWorker, boolean isSaveWorkerFace) {
        this.editWorkerAsync(workerInfo, true, true);
        projectUfaceConfigService.updateWorkerInfo(workerInfo, workerInfo);
    }

    @Async("sendWorkerExecutor")
    public void editWorkerAsync(WorkerInfo workerInfo, boolean isSaveWorker, boolean isSaveWorkerFace) {
        try {
            hikvisionCall.editWorker(workerInfo, isSaveWorker, isSaveWorkerFace);
        } catch (Exception e) {
            log.error("海康：", e);
            sendNoticeForWorker(workerInfo, e, "更新");
        }
    }

    public void editWorker(WorkerInfo workerInfo, boolean isSaveWorker, boolean isSaveWorkerFace) {
        this.editWorkerAsync(workerInfo, isSaveWorker, isSaveWorkerFace);
    }

    private void sendNoticeForWorker(WorkerInfo workerInfo, Exception e, String action) {
        String title = action + "人员到海康isc失败";
        String type = "23";
        String msg;
        if (HttpUtils.isTimeOut(e)) {
            msg = "同步失败，人员名称：" + workerInfo.getWorkerName() + "，身份证号：" + workerInfo.getIdCard() + "。失败原因：平台连接isc网络异常";
        } else if (e instanceof OpenPromptException) {
            msg = "同步失败，人员名称：" + workerInfo.getWorkerName() + "，身份证号：" + workerInfo.getIdCard() + "。失败原因：" + e.getMessage();
        } else {
            msg = "同步失败，人员名称：" + workerInfo.getWorkerName() + "，身份证号：" + workerInfo.getIdCard() + "。失败原因：下发异常";
        }
        if (ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class) != null) {
            noticeService.addUserNotice(ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class).getUserId(), msg, title, type);
        }
        hikvisionCall.updateAllFailStatusIfNull(workerInfo.getProjectSn(), workerInfo.getId(), 1);
    }

    @Async("sendWorkerExecutor")
    public void deleteWorkerForHikvisionAsync(String uniqueId, WorkerInfo workerInfo) {
        try {
            hikvisionCall.deleteWorkerForHikvision(uniqueId, workerInfo);
        } catch (Exception e) {
            log.error("海康：", e);
            sendNoticeForWorker(workerInfo, e, "删除");
        }
    }

    public void deleteWorkerForHikvision(String uniqueId, WorkerInfo workerInfo) {
        this.deleteWorkerForHikvisionAsync(uniqueId, workerInfo);
    }

    @Async("carInfoExecutor")
    public void addCarInfoForHikvisionAsync(CarInfo carInfo) {
        try {
            hikvisionCall.saveCarInfoFromHikvision(carInfo);
        } catch (Exception e) {
            log.error("海康：", e);
            sendNoticeForCar(carInfo, e, "添加");
        }
    }

    public void addCarInfoForHikvision(CarInfo carInfo) {
        this.addCarInfoForHikvisionAsync(carInfo);
    }

    private void sendNoticeForCar(CarInfo carInfo, Exception e, String action) {
        String title = action + "车辆到海康isc失败";
        String type = "24";
        String msg = null;
        if (HttpUtils.isTimeOut(e)) {
            msg = "同步失败，车牌号：" + carInfo.getCarNumber() + "。失败原因：平台连接isc网络异常";
        } else if (e instanceof OpenPromptException) {
            msg = "同步失败，车牌号：" + carInfo.getCarNumber() + "。失败原因：" + e.getMessage();
        } else {
            msg = "同步失败，车牌号：" + carInfo.getCarNumber() + "。失败原因：下发异常";
        }
        if (ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class) != null) {
            noticeService.addUserNotice(ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class).getUserId(), msg, title, type);
        }
        hikvisionCall.updateAllFailStatusIfNull(carInfo.getProjectSn(), carInfo.getId(), 2);
    }

    @Async("carInfoExecutor")
    public void editCarInfoForHikvisionAsync(CarInfo carInfo, CarInfo old) {
        try {
            hikvisionCall.editCarInfoForHikvision(carInfo, old);
        } catch (Exception e) {
            log.error("海康：", e);
            sendNoticeForCar(carInfo, e, "编辑");
        }
    }

    public void editCarInfoForHikvision(CarInfo carInfo, CarInfo old) {
        this.editCarInfoForHikvisionAsync(carInfo, old);
    }

    @Async("carInfoExecutor")
    public void deleteCarInfoAndSetBlackForHikvisionAsync(CarInfo carInfo, boolean isSetBlack) {
        try {
            hikvisionCall.deleteCarInfoForHikvision(carInfo, isSetBlack);
        } catch (Exception e) {
            log.error("海康：", e);
            sendNoticeForCar(carInfo, e, "删除");
        }
    }

    public void deleteCarInfoAndSetBlackForHikvision(CarInfo carInfo, boolean isSetBlack) {
        this.deleteCarInfoAndSetBlackForHikvisionAsync(carInfo, isSetBlack);
    }

    @Async("carInfoExecutor")
    public void addEnterpriseInfoForHikvision(EnterpriseInfo enterpriseInfo) {
        try {
            hikvisionCall.addEnterpriseInfoForHikvision(enterpriseInfo);
        } catch (Exception e) {
            log.error("海康：", e);
            sendNoticeForOrg(enterpriseInfo.getEnterpriseName(), e, "新增");
        }
    }

    private void sendNoticeForOrg(String name, Exception e, String action) {
        String title = action + "组织到海康isc失败";
        String type = "23";
        String msg;
        if (HttpUtils.isTimeOut(e)) {
            msg = "同步失败，组织名称：" + name + "。失败原因：平台连接isc网络异常";
        } else if (e instanceof OpenPromptException) {
            msg = "同步失败，组织名称：" + name + "。失败原因：" + e.getMessage();
        } else {
            msg = "同步失败，组织名称：" + name + "。失败原因：下发异常";
        }
        if (ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class) != null) {
            noticeService.addUserNotice(ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class).getUserId(), msg, title, type);
        }
        xzHikvisionCompareDataService.compareRetryFail();
    }

    @Async("carInfoExecutor")
    public void editEnterpriseInfoForHikvision(EnterpriseInfo enterpriseInfo) {
        try {
            hikvisionCall.editEnterpriseInfoForHikvision(enterpriseInfo);
        } catch (Exception e) {
            log.error("海康：", e);
            sendNoticeForOrg(enterpriseInfo.getEnterpriseName(), e, "编辑");
        }
    }

    @Async("carInfoExecutor")
    public void deleteEnterpriseInfoForHikvision(String enterpriseId, String projectSn, String enterpriseName) {
        try {
            hikvisionCall.deleteEnterpriseInfoForHikvision(enterpriseId, projectSn, enterpriseName);
        } catch (Exception e) {
            log.error("海康：", e);
            sendNoticeForOrg(enterpriseName, e, "删除");
        }
    }

    @Async("carInfoExecutor")
    public void editTeamInfoForHikvision(TeamInfo teamInfo) {
        try {
            hikvisionCall.editTeamInfoForHikvision(teamInfo);
        } catch (Exception e) {
            log.error("海康：", e);
            sendNoticeForOrg(teamInfo.getTeamName(), e, "编辑");
        }
    }

    @Async("carInfoExecutor")
    public void deleteTeamInfoForHikvision(String id, TeamInfo teamInfo) {
        try {
            hikvisionCall.deleteTeamInfoForHikvision(id, teamInfo);
        } catch (Exception e) {
            log.error("海康：", e);
            sendNoticeForOrg(teamInfo.getTeamName(), e, "删除");
        }
    }

    @Async("carInfoExecutor")
    public void addTeamInfoForHikvision(TeamInfo teamInfo) {
        try {
            hikvisionCall.addTeamInfoForHikvision(teamInfo);
        } catch (Exception e) {
            log.error("海康：", e);
            sendNoticeForOrg(teamInfo.getTeamName(), e, "新增");
        }
    }

    @Async("carInfoExecutor")
    public void editDepartmentInfoForHikvision(DepartmentInfo teamInfo) {
        try {
            hikvisionCall.editDepartmentInfoForHikvision(teamInfo);
        } catch (Exception e) {
            log.error("海康：", e);
            sendNoticeForOrg(teamInfo.getDepartmentName(), e, "编辑");
        }
    }

    @Async("carInfoExecutor")
    public void addDepartmentInfoForHikvision(DepartmentInfo teamInfo) {
        try {
            hikvisionCall.addDepartmentInfoForHikvision(teamInfo);
        } catch (Exception e) {
            log.error("海康：", e);
            sendNoticeForOrg(teamInfo.getDepartmentName(), e, "新增");
        }
    }

    @Async("carInfoExecutor")
    public void deleteDepartmentInfoForHikvision(String uniqueId, DepartmentInfo departmentInfo) {
        try {
            hikvisionCall.deleteDepartmentInfoForHikvision(uniqueId, departmentInfo);
        } catch (Exception e) {
            log.error("海康：", e);
            sendNoticeForOrg(departmentInfo.getDepartmentName(), e, "删除");
        }
    }

    @Async("carInfoExecutor")
    public void editProjectForHikvision(Project project) {
        try {
            hikvisionCall.editProjectForHikvision(project);
        } catch (Exception e) {
            log.error("海康：", e);
        }
    }

    @Async("hikvisionExecutor")
    public void addPersonAuthAsync(WorkerInfo workerInfo, String devSns) {
        try {
            StringBuilder sucSb = new StringBuilder();
            StringBuilder failSb = new StringBuilder();
            String[] devSnArr = StringUtils.split(devSns, ",");
            try {
                for (String ds : devSnArr) {
                    hikvisionCall.updatePersonAuth(workerInfo, ds, sucSb, failSb, 0);
                }
            } catch (Exception e) {
                log.error("e", e);
                if (HttpUtils.isTimeOut(e)) {
                    noticeService.addUserNotice(ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class).getUserId(), "失败原因：平台连接isc网络异常", "人员下发设备提醒", "1");
                } else {
                    noticeService.addUserNotice(ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class).getUserId(), e.getMessage(), "人员下发设备提醒", "1");
                }
                hikvisionCall.updateAllFailStatusIfNullForAuth(workerInfo.getProjectSn(), workerInfo.getId(), 1, 1);
                return;
            }

            String title = "人员下发设备提醒";
            String type = "1";
            String msg = "";
            String sucSbStr = sucSb.toString();
            if (StringUtils.isNotBlank(sucSbStr)) {
                sucSbStr = "下发权限成功：" + sucSbStr;
                msg += sucSbStr;
            }
            String failSbStr = failSb.toString();
            if (StringUtils.isNotBlank(failSbStr)) {
                failSbStr = "下发权限失败：" + failSbStr;
                msg += failSbStr;
            }
            if (ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class) != null) {
                noticeService.addUserNotice(ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class).getUserId(), StringUtils.substring(msg, 0, msg.length() - 1), title, type);
            }
            hikvisionCall.updateAllFailStatusIfNullForAuth(workerInfo.getProjectSn(), workerInfo.getId(), 1, 1);
        } catch (Exception e) {
            log.error("海康：", e);
        }
    }

    public void addPersonAuth(WorkerInfo workerInfo, String devSns) {
        this.addPersonAuthAsync(workerInfo, devSns);
    }

    @Async("hikvisionExecutor")
    public void deletePersonAuthAsync(WorkerInfo workerInfo, String devSns) {
        try {
            if (StringUtils.isBlank(devSns)) {
                return;
            }
            StringBuilder sucSb = new StringBuilder();
            StringBuilder failSb = new StringBuilder();
            String[] devSnArr = StringUtils.split(devSns, ",");
            try {
                for (String ds : devSnArr) {
                    hikvisionCall.updatePersonAuth(workerInfo, ds, sucSb, failSb, 2);
                }
            } catch (Exception e) {
                if (HttpUtils.isTimeOut(e)) {
                    noticeService.addUserNotice(ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class).getUserId(), "网络异常", "人员下发设备提醒", "1");
                } else {
                    noticeService.addUserNotice(ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class).getUserId(), e.getMessage(), "人员下发设备提醒", "1");
                }
                hikvisionCall.updateAllFailStatusIfNullForAuth(workerInfo.getProjectSn(), workerInfo.getId(), 1, 3);
                return;
            }

            String title = "人员下发设备提醒";
            String type = "1";
            String msg = "";
            String sucSbStr = sucSb.toString();
            if (StringUtils.isNotBlank(sucSbStr)) {
                sucSbStr = "移除权限成功：" + sucSbStr;
                msg += sucSbStr;
            }
            String failSbStr = failSb.toString();
            if (StringUtils.isNotBlank(failSbStr)) {
                failSbStr = "移除权限失败：" + failSbStr;
                msg += failSbStr;
            }
            if (ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class) != null) {
                noticeService.addUserNotice(ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class).getUserId(), StringUtils.substring(msg, 0, msg.length() - 1), title, type);
            }
            hikvisionCall.updateAllFailStatusIfNullForAuth(workerInfo.getProjectSn(), workerInfo.getId(), 1, 3);
        } catch (Exception e) {
            log.error("海康：", e);
        }
    }

    public void deletePersonAuth(WorkerInfo workerInfo, String devSn) {
        this.deletePersonAuthAsync(workerInfo, devSn);
    }

    @Async("getRecordForHikvisionTask")
    public void getCrossRecordsAsync(HashMap<String, Object> paramMap) {
        hikvisionCall.getCrossRecords(paramMap);
    }

    @Async("getRecordForHikvisionTask")
    public void getDoorEventsAsync(HashMap<String, Object> paramMap) {
        hikvisionCall.getDoorEvents(paramMap);
    }

    public void sendBatchWorkerInfo(List<UfaceDev> allDevList, List<WorkerInfo> workerList, List<JSONObject> workerAndDevSnList, Long userId, String projectSn) {
        this.sendBatchWorkerInfoAsync(allDevList, workerList, workerAndDevSnList, userId, projectSn);
    }

    /**
     * 批量下发人员
     *
     * @param allDevList
     * @param workerList         下发的人员
     * @param workerAndDevSnList 构建的下发的人员和设备的关系
     * @param userId
     */
    @Async("sendBatchExecutor")
    public void sendBatchWorkerInfoAsync(List<UfaceDev> allDevList, List<WorkerInfo> workerList, List<JSONObject> workerAndDevSnList, Long userId, String projectSn) {
        try {
            Map<String, WorkerInfo> workerIdMap = workerList.stream().collect(Collectors.toMap(workerInfo -> workerInfo.getId() + "", Function.identity()));
            Map<String, UfaceDev> devSnMap = allDevList.stream().collect(Collectors.toMap(UfaceDev::getDevSn, Function.identity()));
            ProjectInfoExtVo project = projectService.getProjectInfoBySn(projectSn);
            Map<String, List<JSONObject>> devSnToJoMap = workerAndDevSnList.stream().collect(Collectors.groupingBy(jsonObject -> jsonObject.getString("devSn")));
            JSONObject gdvJo = HikvisionUtil.getDoorsV2(project, HikvisionUtil.addPageParamIfAbsent(new JSONObject()));
            JSONObject gdvDataJo = HikvisionUtil.getJSONObjectData(gdvJo);
            //门禁设备编号：parentIndexCode，门禁点编号：indexCode，门禁设备资源通道号：channelNo
            Map<String, JSONObject> devSnToIscDevSnMap = gdvDataJo.getJSONArray("list").stream().collect(Collectors.toMap(o -> ((JSONObject) o).getString("indexCode"), o -> (JSONObject) o));
            Map<String, Map<String, JSONObject>> iscDevSnToMyMap = gdvDataJo.getJSONArray("list").stream().collect(Collectors.toMap(o -> ((JSONObject) o).getString("parentIndexCode"), o -> {
                HashMap<String, JSONObject> m1 = new HashMap<>();
                m1.put(((JSONObject) o).getString("channelNo"), (JSONObject) o);
                return m1;
            }, (o1, o2) -> {
                o1.putAll(o2);
                return o1;
            }));
            ArrayList<Future> futures = new ArrayList<>();
            for (Map.Entry<String, List<JSONObject>> entry : devSnToJoMap.entrySet()) {
                Future future = asyncHikvision.sendBatchWorkersForOneDevAsync(workerIdMap, devSnMap, project, devSnToIscDevSnMap, iscDevSnToMyMap, entry, projectSn);
                futures.add(future);
            }
            for (Future future : futures) {
                while (!future.isDone()) {
                }
            }
            //下发完成
            if (userId != null) {
                java.text.DateFormat format1 = new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                String redNotice = "";
                List<String> redNameList = workerList.stream().filter(w -> NumberUtils.lt(w.getSafeScore(), 80D)).map(WorkerInfo::getWorkerName).collect(Collectors.toList());
                if (CollUtil.isNotEmpty(redNameList)) {
                    redNotice = StrUtil.format("，其中{}是红码不下发", StrUtil.join(",", redNameList));
                }
                Notice notice = new Notice();
                notice.setAccountId(userId);
                notice.setMsg(StrUtil.format("已经完成批量向设备下发{}个人{}", workerList.size(), redNotice));
                notice.setTitle("人员批量下发设备提醒");
                notice.setSendTime(format1.format(new Date()));
                notice.setType("1");
                noticeService.addNotice(notice, true);
            }
        } catch (Exception e) {
            log.error("批量下发权限失败：", e);
            hikvisionCall.updateAllFailStatusIfNullForAuth(projectSn, workerList, 1, 1);
            hikvisionCall.updateAllFailStatusIfNullForAuth(projectSn, workerList, 1, 3);
        }
    }

    /**
     * 一个设备批量下发人员
     *
     * @param workerIdMap
     * @param devSnMap
     * @param project
     * @param devSnToIscDevSnMap
     * @param iscDevSnToMyMap
     * @param devSnToJoEntry
     */
    @Async("sendBatchExecutor")
    public Future sendBatchWorkersForOneDevAsync(Map<String, WorkerInfo> workerIdMap, Map<String, UfaceDev> devSnMap, ProjectInfoExtVo project, Map<String, JSONObject> devSnToIscDevSnMap, Map<String, Map<String, JSONObject>> iscDevSnToMyMap, Map.Entry<String, List<JSONObject>> devSnToJoEntry, String projectSn) {
        try {
            //【添加权限配置】（人员列表，设备列表），这个接口只要没报错，你就直接去下一步就行了。
            List<String> addAuthWorkerIds = devSnToJoEntry.getValue().stream().filter(jo -> jo.getBoolean(Cts.IS_ADD_AUTH)).map(jsonObject -> jsonObject.getString("workerId")).collect(Collectors.toList());
            List<String> deleteAuthWorkerIds = devSnToJoEntry.getValue().stream().filter(jo -> !jo.getBoolean(Cts.IS_ADD_AUTH)).map(jsonObject -> jsonObject.getString("workerId")).collect(Collectors.toList());
            if (CollUtil.isEmpty(addAuthWorkerIds) && CollUtil.isEmpty(deleteAuthWorkerIds)) {
                log.error("无权限添加或删除，跳过");
                return null;
            }
            if (CollUtil.isNotEmpty(addAuthWorkerIds)) {
                JSONObject aaRJo = HikvisionUtil.addAuth(project, getAddOrDeleteAuthParam(devSnToJoEntry, addAuthWorkerIds));
                HikvisionUtil.getJSONObjectData(aaRJo);
            }
            if (CollUtil.isNotEmpty(deleteAuthWorkerIds)) {
                JSONObject aaRJo = HikvisionUtil.deleteAuth(project, getAddOrDeleteAuthParam(devSnToJoEntry, deleteAuthWorkerIds));
                HikvisionUtil.getJSONObjectData(aaRJo);
            }
            String devSn = devSnToJoEntry.getKey();
            //然后调用【根据出入权限配置快捷下载】（设备列表）（【添加权限配置】+【快捷下发】这是一个流程，你添加了几个权限，下发成功之后，就清零了）
            JSONObject daJo = HikvisionUtil.downloadAuth(project, getQueryDownloadProgressParam(devSnToJoEntry));
            JSONObject daRtJo = HikvisionUtil.getJSONObjectData(daJo);
            //然后调用【查询下载任务进度】（上面那个的任务）
            int totalPercent = 0;
            do {
                JSONObject qdpJo = HikvisionUtil.queryDownloadProgress(project, new JoBuilder()
                        .put("taskId", daRtJo.getString("taskId"))
                        .build());
                totalPercent = HikvisionUtil.getJSONObjectData(qdpJo).getInteger("totalPercent");
                Thread.sleep(1000);
            } while (totalPercent != 100);
            //权限下发后（进度100后），用【查询权限条目列表】（人员列表，设备列表）接口去查，返回参数有权限状态，返回已下载的就是有权限
            JSONObject qaiJo = HikvisionUtil.queryAuthItem(project, getQueryAuthItemParam(devSnToJoEntry, devSnToIscDevSnMap));
            JSONObject qaiRtJo = HikvisionUtil.getJSONObjectData(qaiJo);
            JSONArray qaiList = qaiRtJo.getJSONArray("list");
            if (CollUtil.isNotEmpty(qaiList)) {
                for (int i = 0; i < qaiList.size(); i++) {
                    handlerBatchWorkersResultForAddAuth(workerIdMap, devSnMap, iscDevSnToMyMap, qaiList, i, devSn, projectSn);
                }
            }
            //处理删除权限的结果的
            //handlerBatchWorkersResultForDeleteAuth();
            if (CollUtil.isNotEmpty(deleteAuthWorkerIds)) {
                for (String workerId : deleteAuthWorkerIds) {
                    hikvisionCall.updateSuccessStatus(projectSn, Long.valueOf(workerId), 3, 3, devSn);
                    if (ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class) != null) {
                        noticeService.addUserNotice(ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class).getUserId(),
                                StrUtil.format("[{}]取消下发到[{}]{}",
                                        workerIdMap.get(workerId).getWorkerName(),
                                        devSnMap.get(devSn).getDevName(),
                                        "成功"),
                                "人员下发设备提醒", "1");
                    }
                }
            }
        } catch (Exception e) {
            log.error("批量下发权限失败：", e);
            hikvisionCall.updateAllFailStatusIfNullForAuth(projectSn, new ArrayList<>(workerIdMap.values()), 1, 1);
            hikvisionCall.updateAllFailStatusIfNullForAuth(projectSn, new ArrayList<>(workerIdMap.values()), 1, 3);
        }
        return null;
    }

    /**
     * 处理结果：一个设备批量下发人员
     *
     * @param workerIdMap
     * @param devSnMap
     * @param iscDevSnToMyMap
     * @param qaiList
     * @param i
     * @param devSn
     * @param projectSn
     */
    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRES_NEW)
    public void handlerBatchWorkersResultForAddAuth(Map<String, WorkerInfo> workerIdMap, Map<String, UfaceDev> devSnMap, Map<String, Map<String, JSONObject>> iscDevSnToMyMap, JSONArray qaiList, int i, String devSn, String projectSn) {
        JSONObject jo = qaiList.getJSONObject(i);
        String personId = jo.getString("personId");
        String resourceIndexCode = jo.getString("resourceIndexCode");
        String channelNo = jo.getString("channelNo");
        //人脸状态
        //0：已配置未下载
        //1：更新待下载
        //2：更新待删除
        //3：已下载
        //4：未配置
        Integer faceStatus = jo.getInteger("faceStatus");
        UfaceDev dev = devSnMap.get(devSn);
        if (Objects.equals(faceStatus, 3)) {
            hikvisionCall.updateSuccessStatus(projectSn, Long.valueOf(personId), 3, 1, dev.getDevSn());
        } else {
            hikvisionCall.updateFailStatus(projectSn, Long.valueOf(personId), 3, 1, dev.getDevSn());
        }
        if (ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class) != null) {
            noticeService.addUserNotice(ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class).getUserId(),
                    StrUtil.format("[{}]下发到[{}]{}",
                            workerIdMap.get(personId).getWorkerName(),
                            dev.getDevName(),
                            Objects.equals(faceStatus, 3) ? "成功" : "失败，下发异常"),
                    "人员下发设备提醒", "1");
        }
    }

    @NotNull
    private JSONObject getAddOrDeleteAuthParam(Map.Entry<String, List<JSONObject>> entry, List<String> workerIds) {
        JSONObject aaJo = new JSONObject();
        aaJo.put("personDatas", Collections.singletonList(new MapBuilder<String, Object>()
                .put("indexCodes", workerIds)
                .put("personDataType", "person")
                .build()));
        aaJo.put("resourceInfos", getDevRqParam(entry));
        return aaJo;
    }

    @NotNull
    private List<JSONObject> getDevRqParam(Map.Entry<String, List<JSONObject>> entry) {
        return Collections.singletonList(new JoBuilder()
                .put("resourceIndexCode", entry.getKey())
                .put("resourceType", "door")
                .put("channelNos", Collections.singletonList(1))
                .build());
    }

    private JSONObject getQueryDownloadProgressParam(Map.Entry<String, List<JSONObject>> entry) {
        JSONObject aaJo = new JSONObject();
        aaJo.put("taskType", 4);
        aaJo.put("resourceInfos", getDevRqParam(entry));
        return aaJo;
    }

    private JSONObject getQueryAuthItemParam(Map.Entry<String, List<JSONObject>> entry, Map<String, JSONObject> devSnToIscDevSnMap) {
        JSONObject aaJo = new JSONObject();
        aaJo.put("personIds", entry.getValue().stream().map(jsonObject -> jsonObject.getString("workerId")).collect(Collectors.toList()));
        aaJo.put("resourceInfos", Collections.singletonList(new JoBuilder()
                .put("resourceIndexCode", devSnToIscDevSnMap.get(entry.getKey()).getString("parentIndexCode"))
                .put("resourceType", "acsDevice")
                .put("channelNos", Collections.singletonList(devSnToIscDevSnMap.get(entry.getKey()).getString("channelNo")))
                .build()));
        aaJo.put("queryType", "acsDevice");
        aaJo.put("pageNo", 1);
        aaJo.put("pageSize", 1000);
        return aaJo;
    }


}