package com.zhgd.xmgl.task;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.http.HttpRequest;
import cn.hutool.http.HttpUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.gexin.fastjson.JSON;
import com.gexin.fastjson.JSONObject;
import com.gexin.fastjson.TypeReference;
import com.zhgd.jeecg.common.execption.OpenAlertException;
import com.zhgd.redis.lock.RedisRepository;
import com.zhgd.xmgl.modules.basicdata.service.UploadFileService;
import com.zhgd.xmgl.modules.project.entity.Project;
import com.zhgd.xmgl.modules.project.entity.ProjectEnterprise;
import com.zhgd.xmgl.modules.project.mapper.ProjectEnterpriseMapper;
import com.zhgd.xmgl.modules.project.mapper.ProjectMapper;
import com.zhgd.xmgl.modules.project.service.IProjectEnterpriseService;
import com.zhgd.xmgl.modules.worker.entity.EnterpriseInfo;
import com.zhgd.xmgl.modules.worker.entity.TeamInfo;
import com.zhgd.xmgl.modules.worker.entity.WorkerAttendance;
import com.zhgd.xmgl.modules.worker.entity.WorkerInfo;
import com.zhgd.xmgl.modules.worker.mapper.*;
import com.zhgd.xmgl.modules.worker.service.*;
import com.zhgd.xmgl.task.jzg.*;
import com.zhgd.xmgl.util.MessageUtil;
import lombok.extern.slf4j.Slf4j;
import net.javacrumbs.shedlock.core.SchedulerLock;
import org.apache.commons.codec.binary.Hex;
import org.apache.commons.collections.MapUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

import static com.zhgd.xmgl.util.EncryptUtils.decryptAes;

/**
 * 金筑工
 */
@Slf4j
@Component
@RequestMapping("/jzg")
@RestController
public class JzgTask {
    @Autowired
    private ProjectEnterpriseMapper projectEnterpriseMapper;
    @Autowired
    private ProjectMapper projectMapper;
    @Autowired
    private IEnterpriseInfoService enterpriseInfoService;
    @Autowired
    private IProjectEnterpriseService projectEnterpriseService;
    @Autowired
    private ITeamInfoService teamInfoService;
    @Autowired
    private EnterpriseInfoMapper enterpriseInfoMapper;
    @Autowired
    private TeamInfoMapper teamInfoMapper;
    @Autowired
    private DepartmentInfoMapper departmentInfoMapper;
    @Autowired
    private IDepartmentInfoService departmentInfoService;
    @Autowired
    private IWorkerInfoService workerInfoService;
    @Autowired
    private WorkerInfoMapper workerInfoMapper;
    @Autowired
    private UploadFileService uploadFileService;
    @Autowired
    private IWorkerAttendanceService workerAttendanceService;
    @Autowired
    private WorkerAttendanceMapper workerAttendanceMapper;
    @Autowired
    private RedisRepository redisRepository;
    /**
     * prefix+projectSn：time
     */
    private static final String JZG_WORKER_ATTENDANCE_LAST_TIME_PREFIX = "jzg:workerAttendance:lastTime:";

    /**
     * 实名制同步
     */
    @SchedulerLock(name = "realNameSystem", lockAtMostFor = 1000 * 60 * 60, lockAtLeastFor = 1000 * 60 * 5)
    @Scheduled(cron = "0 0 0/12 * * ?")
    @RequestMapping("/sync")
    public void realNameSystem() {
        List<Project> projects = projectMapper.selectList(null);
        for (Project project : projects) {
            asynProject(project);
        }

    }


    public void asynProject(Project project) {
        String appKey = project.getJzgAppKey();
        String appSecret = project.getJzgAppSecret();
        String projectCode = project.getJzgProjectCode();
        String projectSn = project.getProjectSn();
        if (StrUtil.isNotBlank(appKey) && StrUtil.isNotBlank(appSecret) && StrUtil.isNotBlank(projectCode)) {
            log.info("realNameSystem实名制同步开始，projectSn：{}", projectSn);
            syncEnterpriseInfo(appKey, appSecret, projectCode, projectSn);
            syncTeamInfo(appKey, appSecret, projectCode, projectSn);
            syncManagerInfo(appKey, appSecret, projectCode, projectSn);
            syncWorker(appKey, appSecret, projectCode, projectSn);
            syncWorkerAttendance(appKey, appSecret, projectCode, projectSn);

        }
    }

    private void syncWorkerAttendance(String appKey, String appSecret, String projectCode, String projectSn) {
        ArrayList<JzgWorkerAttendance> jzgList = getPostAllList(appKey, appSecret, projectCode, JzgWorkerAttendance.class, "api/v1/getAttendanceInfo");
        String key = JZG_WORKER_ATTENDANCE_LAST_TIME_PREFIX + projectSn;
        Long time = (Long) redisRepository.get(key);
        for (JzgWorkerAttendance attendance : jzgList) {
            if (time == null || attendance.getCheckDate() > time) {
                saveWorkerInfo(attendance, projectSn);
            }
        }
        Long checkDate = jzgList.stream().max((o1, o2) -> o1.getCheckDate().compareTo(o2.getCheckDate())).get().getCheckDate();
        if (time == null || checkDate > time) {
            redisRepository.set(key, checkDate);
        }
    }

    private void saveWorkerInfo(JzgWorkerAttendance jzg, String projectSn) {
        WorkerAttendance workerAttendance = new WorkerAttendance();
        WorkerInfo wi = workerInfoMapper.selectOne(new LambdaQueryWrapper<WorkerInfo>()
                .eq(WorkerInfo::getJzgUserId, jzg.getUserId()));
        if (wi == null) {
            log.info("考勤写入失败，不存在该人员：{}", JSON.toJSONString(jzg));
            return;
        }
        workerAttendance.setPersonSn(wi.getPersonSn());
        workerAttendance.setCreateTime(DateUtil.formatDateTime(new Date(jzg.getCheckDate())));
        workerAttendance.setProjectSn(projectSn);
        workerAttendance.setPassType(Integer.valueOf(jzg.getDirection()));
        workerAttendance.setCardType(getCardType(jzg.getAttendType()));
        workerAttendance.setImageUrl(uploadFileService.uploadUrlResourceRtName(jzg.getImageUrl()));
        workerAttendanceMapper.insert(workerAttendance);
    }

    private Integer getCardType(String attendType) {
        if (StrUtil.isBlank(attendType)) {
            return null;
        }
        //卡类型 1 IC卡  2人脸识别 3 指纹识别 4补卡操作，5二维码，6蓝牙,7手机打卡,8车辆通行
        switch (attendType) {
            case "2":
                return 2;
            case "3":
                return 3;
            case "5":
                return 7;
        }
        return null;
    }

    private void syncWorker(String appKey, String appSecret, String projectCode, String projectSn) {
        ArrayList<JzgWorker> jzgList = this.getPostAllList(appKey, appSecret, projectCode, JzgWorker.class, "api/v1/getWorkerInfo");
        List<WorkerInfo> records = workerInfoMapper.selectList(new LambdaQueryWrapper<WorkerInfo>()
                .eq(WorkerInfo::getProjectSn, projectSn).eq(WorkerInfo::getPersonType, 1));
        Map<String, WorkerInfo> recordMap = records.stream().collect(Collectors.toMap(o -> o.getIdCard(), Function.identity(), (o, o2) -> o));
        Map<String, JzgWorker> map = jzgList.stream().collect(Collectors.toMap(JzgWorker::getIdCardNumber, Function.identity(), (o, o2) -> o));
        for (JzgWorker jzgWorker : jzgList) {
            String idCardNumber = jzgWorker.getIdCardNumber();
            WorkerInfo info = recordMap.get(idCardNumber);
            if (info == null) {
                workerInfoService.saveWorkerInfo(getWorker(jzgWorker, null, projectSn));
            } else {
                workerInfoService.editWorkerInfo(getWorker(jzgWorker, info, projectSn));
            }
        }
        for (WorkerInfo workerInfo : records) {
            JzgWorker jzgManagerInfo = map.get(workerInfo.getIdCard());
            if (jzgManagerInfo == null) {
                workerInfoService.deleteWorkerInfo(String.valueOf(workerInfo.getId()));
            }
        }
    }

    private void syncManagerInfo(String appKey, String appSecret, String projectCode, String projectSn) {
        ArrayList<JzgManagerInfo> jzgList = getPostAllList(appKey, appSecret, projectCode, JzgManagerInfo.class, "api/v1/getManagerInfo");
        List<WorkerInfo> records = workerInfoMapper.selectList(new LambdaQueryWrapper<WorkerInfo>()
                .eq(WorkerInfo::getProjectSn, projectSn).eq(WorkerInfo::getPersonType, 2));
        Map<String, WorkerInfo> recordMap = records.stream().collect(Collectors.toMap(o -> o.getIdCard(), Function.identity(), (o, o2) -> o));
        Map<String, JzgManagerInfo> jzgEnterpriseInfoMap = jzgList.stream().collect(Collectors.toMap(JzgManagerInfo::getIdCardNumber, Function.identity()));
        for (JzgManagerInfo jzgManagerInfo : jzgList) {
            String idCardNumber = jzgManagerInfo.getIdCardNumber();
            WorkerInfo info = recordMap.get(idCardNumber);
            if (info == null) {
                workerInfoService.saveWorkerInfo(getManagerInfo(jzgManagerInfo, null, projectSn));
            } else {
                workerInfoService.editWorkerInfo(getManagerInfo(jzgManagerInfo, info, projectSn));
            }
        }
        for (WorkerInfo workerInfo : records) {
            JzgManagerInfo jzgManagerInfo = jzgEnterpriseInfoMap.get(workerInfo.getIdCard());
            if (jzgManagerInfo == null) {
                workerInfoService.deleteWorkerInfo(String.valueOf(workerInfo.getId()));
            }
        }
    }

    private WorkerInfo getWorker(JzgWorker jzg, WorkerInfo owi, String projectSn) {
        WorkerInfo wi = new WorkerInfo();
        wi.setId(owi != null ? owi.getId() : null);
        wi.setWorkerName(jzg.getName());
        wi.setIdCard(jzg.getIdCardNumber());
        wi.setProjectSn(projectSn);
        EnterpriseInfo ei = enterpriseInfoMapper.selectOne(new LambdaQueryWrapper<EnterpriseInfo>()
                .eq(EnterpriseInfo::getSocialCode, jzg.getCorpCode()));
        wi.setEnterpriseId(ei.getId());
        wi.setSex(Integer.valueOf(jzg.getGender()));
        wi.setNation(jzg.getNation());
        if (StrUtil.isNotBlank(jzg.getIssueCardPicUrl())) {
            wi.setFieldAcquisitionUrl(uploadFileService.uploadUrlResourceRtName(jzg.getIssueCardPicUrl()));
        }
        if (StrUtil.isNotBlank(jzg.getHeadImageUrl())) {
            wi.setIdCardBigPhotoUrl(uploadFileService.uploadUrlResourceRtName(jzg.getHeadImageUrl()));
        }
        if (StrUtil.isNotBlank(jzg.getPositiveIdCardImageUrl())) {
            wi.setIdCardUpPhotoUrl(uploadFileService.uploadUrlResourceRtName(jzg.getPositiveIdCardImageUrl()));
        }
        if (StrUtil.isNotBlank(jzg.getNegativeIdCardImageUrl())) {
            wi.setIdCardDownPhotoUrl(uploadFileService.uploadUrlResourceRtName(jzg.getNegativeIdCardImageUrl()));
        }
        wi.setPhoneNumber(jzg.getCellPhone());
        wi.setIssuingAuthorityForIdcard(jzg.getGrantOrg());
        wi.setNowPlace(jzg.getAddress());
        wi.setEducational(getEducational(jzg.getCultureLevelType()));
        wi.setPoliticsStatus(getPoliticsStatus(jzg.getPoliticsType()));
        wi.setIdCardEndDate(DateUtil.formatDate(new Date(jzg.getExpiryDate())));
        //wi.setPersonSn();
        wi.setEnterDate(DateUtil.formatDate(new Date(jzg.getStartDate())));
        wi.setInserviceType(Integer.valueOf(jzg.getInOrOut()));
        wi.setPersonType(1);
        TeamInfo ti = teamInfoMapper.selectOne(new LambdaQueryWrapper<TeamInfo>()
                .eq(TeamInfo::getJzgTeamSn, jzg.getTeamSysNo()));
        if (ti != null) {
            wi.setTeamId(ti.getId());
        }
        if (jzg.getExitTime() != null) {
            wi.setExitDate(DateUtil.formatDate(new Date(jzg.getExitTime())));
        }
        wi.setJzgUserId(jzg.getUserId());
        return wi;
    }

    private WorkerInfo getManagerInfo(JzgManagerInfo jzg, WorkerInfo owi, String projectSn) {
        WorkerInfo wi = new WorkerInfo();
        wi.setId(owi != null ? owi.getId() : null);
        wi.setWorkerName(jzg.getName());
        wi.setIdCard(jzg.getIdCardNumber());
        wi.setProjectSn(projectSn);
        EnterpriseInfo ei = enterpriseInfoMapper.selectOne(new LambdaQueryWrapper<EnterpriseInfo>()
                .eq(EnterpriseInfo::getSocialCode, jzg.getCorpCode()));
        wi.setEnterpriseId(ei.getId());
        wi.setSex(Integer.valueOf(jzg.getGender()));
        wi.setNativePlace(jzg.getAreaCode());
        wi.setNation(jzg.getNation());
        wi.setPhoneNumber(jzg.getCellPhone());
        wi.setIssuingAuthorityForIdcard(jzg.getGrantOrg());
        wi.setNowPlace(jzg.getAddress());
        wi.setEducational(getEducational(jzg.getCultureLevelType()));
        wi.setPoliticsStatus(getPoliticsStatus(jzg.getPoliticsType()));
        wi.setIdCardEndDate(DateUtil.formatDate(new Date(jzg.getExpiryDate())));
        //wi.setPersonSn();
        wi.setEnterDate(DateUtil.formatDate(new Date(jzg.getStartDate())));
        wi.setInserviceType(Integer.valueOf(jzg.getInOrOut()));
        wi.setPersonType(2);
        //wi.setTeamId();
        //wi.setDepartmentId();
        wi.setJobName(getJobName(jzg.getJobType()));
        if (jzg.getExitTime() != null) {
            wi.setExitDate(DateUtil.formatDate(new Date(jzg.getExitTime())));
        }
        return wi;
    }

    private String getJobName(String jobType) {
        if (StrUtil.isBlank(jobType)) {
            return null;
        }
        switch (jobType) {
            case "1001":
                return "总监理工程师";
            case "1002":
                return "副总监理工程师";
            case "1003":
                return "安全监理工程师";
            case "1004":
                return "专业监理工程师";
            case "1005":
                return "监理工程师";
            case "1006":
                return "监理员";
            case "1007":
                return "监理安全员";
            case "1008":
                return "项目总工程师";
            case "1009":
                return "项目经理";
            case "1010":
                return "工程经理";
            case "1011":
                return "项目技术负责人";
            case "1012":
                return "项目工程师";
            case "1013":
                return "项目管理员";
            case "1014":
                return "项目副经理";
            case "1015":
                return "项目总监";
            case "1016":
                return "施工员";
            case "1017":
                return "质量员";
            case "1018":
                return "安全员";
            case "1019":
                return "标准员";
            case "1020":
                return "材料员";
            case "1021":
                return "机械员";
            case "1022":
                return "劳务员";
            case "1023":
                return "资料员";
            case "1024":
                return "总监理工程师代表";
            case "1025":
                return "测量员";
            case "1026":
                return "试验员";
            case "1027":
                return "造价员";
            case "1028":
                return "质量负责人";
            case "1029":
                return "安全负责人";
            case "1030":
                return "技术负责人";
            case "1031":
                return "生产经理";
            case "1032":
                return "物资材料工程师";
            case "1099":
                return "其他";
        }
        return null;
    }

    private Integer getPoliticsStatus(String politicsType) {
        if (StrUtil.isBlank(politicsType)) {
            return null;
        }
        //政治面貌：1.中共党员 2.共青团团员 3.普通居民 4.其他党派人士
        switch (politicsType) {
            case "1":
                return 1;
            case "3":
                return 2;
            case "12":
                return 3;
            default:
                return 4;
        }
    }

    private String getEducational(String cultureLevelType) {
        if (StrUtil.isBlank(cultureLevelType)) {
            return null;
        }
        //1小学、2初中、3中专、4高中、5大专、6本科、7研究生、8博士、9博士后
        switch (cultureLevelType) {
            case "1":
                return "1";
            case "2":
                return "2";
            case "3":
                return "4";
            case "4":
                return "3";
            case "5":
                return "5";
            case "6":
                return "6";
            case "7":
                return "7";
            case "8":
                return "8";
        }
        return null;
    }


    private void syncTeamInfo(String appKey, String appSecret, String projectCode, String projectSn) {
        ArrayList<JzgTeamInfo> jzgList = getPostAllList(appKey, appSecret, projectCode, JzgTeamInfo.class, "api/v1/getTeamInfo");
        HashMap<String, Object> eMap = new HashMap<>();
        eMap.put("projectSn", projectSn);
        eMap.put("pageNo", "1");
        eMap.put("pageSize", "9999999");
        List<TeamInfo> records = teamInfoService.getProjectTeamList(eMap);
        Map<String, TeamInfo> recordMap = records.stream().collect(Collectors.toMap(o -> o.getJzgTeamSn(), Function.identity(), (o, o2) -> o));
        Map<String, JzgTeamInfo> jzgEnterpriseInfoMap = jzgList.stream().collect(Collectors.toMap(JzgTeamInfo::getTeamSysNo, Function.identity()));
        for (JzgTeamInfo teamInfo : jzgList) {
            String teamSysNo = teamInfo.getTeamSysNo();
            TeamInfo info = recordMap.get(teamSysNo);
            if (info == null) {
                saveTeamInfo(getTeamInfo(teamInfo, null, projectSn));
            } else {
                editTeamInfo(getTeamInfo(teamInfo, info, projectSn));
            }
        }
        for (TeamInfo teamInfo : records) {
            JzgTeamInfo jzgTeamInfo = jzgEnterpriseInfoMap.get(teamInfo.getJzgTeamSn());
            if (jzgTeamInfo == null) {
                teamInfoMapper.deleteById(teamInfo.getId());
            }
        }
    }

    private <T> ArrayList<T> getPostAllList(String appKey, String appSecret, String projectCode, Class<T> clz, String uri) {
        Integer total = 0;
        Integer page = 1;
        ArrayList<T> jzgList = new ArrayList<>();
        do {
            Date date = new Date();
            JSONObject bodyQuery = new JSONObject();
            bodyQuery.put("limit", "50");
            bodyQuery.put("page", page + "");
            bodyQuery.put("startDate", DateUtil.formatDate(DateUtil.offsetDay(date, -1)));
            bodyQuery.put("endDate", DateUtil.formatDate(date));
            JzgRt jzgRt = jzgPost(appKey, appSecret, projectCode, uri, bodyQuery);
            if (jzgRt == null) {
                return new ArrayList<>();
            }
            String data = jzgRt.getData();
            JSONObject jo = JSON.parseObject(data);
            total = jo.getInteger("total");
            List<T> l = JSON.parseArray(jo.getString("list"), clz);
            jzgList.addAll(l);
        } while (total > (page++ * 50));
        log.info("getPostAllList projectCode:{},total:{},uri:{}", projectCode, total, uri);
        return jzgList;
    }

    private void editTeamInfo(TeamInfo teamInfo) {
        QueryWrapper<TeamInfo> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(TeamInfo::getProjectSn, teamInfo.getProjectSn())
                .eq(TeamInfo::getTeamName, teamInfo.getTeamName())
                .eq(TeamInfo::getEnterpriseId, teamInfo.getEnterpriseId())
                .ne(TeamInfo::getId, teamInfo.getId());
        int count = teamInfoMapper.selectCount(queryWrapper);
        if (count > 0) {
            throw new OpenAlertException(MessageUtil.get("existsTeamErr"));
        }
        teamInfoMapper.updateById(teamInfo);
    }

    private void saveTeamInfo(TeamInfo teamInfo) {
        QueryWrapper<TeamInfo> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(TeamInfo::getProjectSn, teamInfo.getProjectSn())
                .eq(TeamInfo::getEnterpriseId, teamInfo.getEnterpriseId())
                .eq(TeamInfo::getTeamName, teamInfo.getTeamName());
        int count = teamInfoMapper.selectCount(queryWrapper);
        if (count > 0) {
            throw new OpenAlertException(MessageUtil.get("existsTeamErr"));
        }
        String uuid = UUID.randomUUID().toString().replace("-", "").toUpperCase();
        teamInfo.setTeamSn(uuid);
        teamInfoMapper.insert(teamInfo);
    }

    private TeamInfo getTeamInfo(JzgTeamInfo jzgTeamInfo, TeamInfo oT, String projectSn) {
        TeamInfo ti = new TeamInfo();
        ti.setId(oT != null ? oT.getId() : null);
        ti.setTeamName(jzgTeamInfo.getTeamName());
        ti.setLeaderName(jzgTeamInfo.getResponsiblePersonName());
        ti.setLeaderIdCard(jzgTeamInfo.getResponsiblePersonIdNumber());
        ti.setLeaderPhone(jzgTeamInfo.getResponsiblePersonPhone());
        //ti.setWorkerTypeId();
        //ti.setTeamType();
        ti.setProjectSn(projectSn);
        ti.setTeamSn(oT != null ? oT.getTeamSn() : null);
        if (oT == null) {
            EnterpriseInfo enterpriseInfo = enterpriseInfoMapper.selectOne(new LambdaQueryWrapper<EnterpriseInfo>()
                    .eq(EnterpriseInfo::getSocialCode, jzgTeamInfo.getCorpCode()));
            ti.setEnterpriseId(enterpriseInfo.getId());
        } else {
            ti.setEnterpriseId(oT.getEnterpriseId());
        }
        ti.setJzgTeamSn(jzgTeamInfo.getTeamSysNo());
        return ti;
    }

    private void syncEnterpriseInfo(String appKey, String appSecret, String projectCode, String projectSn) {
        JzgRt jzgRt = jzgPost(appKey, appSecret, projectCode, "api/v1/getCompanyInfo", new JSONObject());
        String data = jzgRt.getData();
        HashMap<String, Object> eMap = new HashMap<>();
        eMap.put("projectSn", projectSn);
        eMap.put("pageNo", "1");
        eMap.put("pageSize", "9999999");
        List<EnterpriseInfo> records = projectEnterpriseService.selectProjectEnterprisePage(eMap).getRecords();
        Map<String, EnterpriseInfo> recordMap = records.stream().collect(Collectors.toMap(o -> o.getSocialCode(), Function.identity()));
        ArrayList<JzgEnterpriseInfo> jzgEnterpriseInfos = JSON.parseObject(data, new TypeReference<ArrayList<JzgEnterpriseInfo>>() {
        });
        Map<String, JzgEnterpriseInfo> jzgEnterpriseInfoMap = jzgEnterpriseInfos.stream().collect(Collectors.toMap(JzgEnterpriseInfo::getCorpCode, Function.identity()));
        for (JzgEnterpriseInfo jzgEnterpriseInfo : jzgEnterpriseInfos) {
            String corpCode = jzgEnterpriseInfo.getCorpCode();
            EnterpriseInfo enterpriseInfo = recordMap.get(corpCode);
            if (enterpriseInfo == null) {
                enterpriseInfoService.saveEnterpriseInfo(getEnterpriseInfo(jzgEnterpriseInfo, null, projectSn));
            } else {
                enterpriseInfoService.updateEnterpriseInfo(getEnterpriseInfo(jzgEnterpriseInfo, enterpriseInfo, projectSn));
            }
        }
        for (EnterpriseInfo enterpriseInfo : records) {
            JzgEnterpriseInfo jzgEnterpriseInfo = jzgEnterpriseInfoMap.get(enterpriseInfo.getSocialCode());
            if (jzgEnterpriseInfo == null) {
                HashMap<String, Object> edMap = new HashMap<>();
                edMap.put("enterpriseId", enterpriseInfo.getId());
                edMap.put("projectSn", projectSn);
                removeEnterpriseInfo(edMap);
            }
        }
    }

    private void removeEnterpriseInfo(HashMap<String, Object> map) {
        QueryWrapper<ProjectEnterprise> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(ProjectEnterprise::getEnterpriseId, MapUtils.getString(map, "enterpriseId"))
                .eq(ProjectEnterprise::getProjectSn, MapUtils.getString(map, "projectSn"));
        ProjectEnterprise projectEnterprise = projectEnterpriseMapper.selectOne(queryWrapper);
        if (projectEnterprise != null) {
            projectEnterpriseMapper.deleteById(projectEnterprise.getId());
        }
    }

    private EnterpriseInfo getEnterpriseInfo(JzgEnterpriseInfo jzgEnterpriseInfo, EnterpriseInfo enterpriseInfo, String projectSn) {
        EnterpriseInfo ei = new EnterpriseInfo();
        ei.setId(enterpriseInfo != null ? enterpriseInfo.getId() : null);
        ei.setEnterpriseName(jzgEnterpriseInfo.getCompanyName());
        ei.setEnterpriseLegalPerson(jzgEnterpriseInfo.getLegalMan());
        ei.setSocialCode(jzgEnterpriseInfo.getCorpCode());
        ei.setEnterpriseProperty(getEnterpriseProperty(jzgEnterpriseInfo.getOrganizationType()));
        ei.setEnterpriseSn(enterpriseInfo != null ? enterpriseInfo.getEnterpriseSn() : null);
        ei.setProjectSn(projectSn);
        return ei;
    }

    private Integer getEnterpriseProperty(String organizationType) {
        if (StrUtil.isBlank(organizationType)) {
            return null;
        }
        //单位性质 1.国有企业 2三资企业 3集体企业 4私营企业
        switch (organizationType) {
            case "110":
                return 1;
            case "200":
                return 2;
            case "120":
                return 3;
            case "170":
                return 4;
        }
        return null;
    }

    private JzgRt jzgPost(String appKey, String appSecret, String projectCode, String uri, JSONObject jsonObject) {
        try {
            Map<String, String> params = new HashMap<>();
            String nonce = RandomUtil.randomString(16);
            String timestamp = String.valueOf(System.currentTimeMillis() / 1000);
            params.put("appKey", appKey);
            params.put("nonce", nonce);
            params.put("timestamp", timestamp);
            params.put("projectCode", projectCode);
            //签名
            String splicingStr = (nonce + "&" + timestamp + "&" + appKey + "&" + projectCode).toUpperCase(Locale.ROOT);
            SecretKey key = new SecretKeySpec(appSecret.getBytes(StandardCharsets.UTF_8), "HmacMD5");
            Mac mac = Mac.getInstance(key.getAlgorithm());
            mac.init(key);
            byte[] code = mac.doFinal(splicingStr.getBytes(StandardCharsets.UTF_8));
            String sign = Hex.encodeHexString(code);
            params.put("sign", sign);
            String toParams = HttpUtil.toParams(params);
            //发送请求
            String url = "http://lznmg.xinyegk.com/" + uri + "?" + toParams;
            log.info("jzgPost url: {}", url);
            String body = jsonObject.toJSONString();
            log.info("jzgPost body: {}", body);
            String bodyResult = HttpRequest.post(url)
                    .header("Content-Type", "application/json")
                    .body(body)
                    .execute()
                    .body();
            JSONObject result = JSON.parseObject(bodyResult);
            //不能请求过快
            Thread.sleep(2000);
            log.info("jzgPost result: {}", result);
            //成功之后进行数据解密
            if ("0".equals(result.getString("code")) && result.get("data") != null) {
                String data = decryptAes(appSecret, result.getString("data"));
                log.info("jzgPost 解密之后的数据:" + data);
                JzgRt jzgRt = new JzgRt();
                jzgRt.setMsg(result.getString("msg"));
                jzgRt.setCode(result.getInteger("code"));
                jzgRt.setData(data);
                return jzgRt;
            } else {
                log.error("jzgPost err:{}", result);
            }
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return null;
    }
}