package com.zhgd.xmgl.task;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.io.FileUtil;
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.*;
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.EnvironmentUtil;
import com.zhgd.xmgl.util.IdCardUtils;
import com.zhgd.xmgl.util.MessageUtil;
import io.swagger.annotations.Api;
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.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
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.io.File;
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("/xmgl/jzg")
@RestController
@Api(tags = "金筑工实名制同步api")
public class JzgTask {
    @Value("${basePath}")
    private String path;
    @Autowired
    private UfaceDevMapper ufaceDevMapper;
    @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 WorkerTypeMapper workerTypeMapper;
    @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 WorkerAttendancePresenceMapper workerAttendancePresenceMapper;
    @Autowired
    private RedisRepository redisRepository;
    @Autowired
    private EnvironmentUtil environmentUtil;
    /**
     * 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/1 * * ?")
    @RequestMapping("/sync")
    public void realNameSystem() {
        if (environmentUtil.isDev()) {
            return;
        }
        List<Project> projects = projectMapper.selectList(null);
        for (Project project : projects) {
            syncProject(project);
        }

    }


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

    private void syncWorkerAttendance(String appKey, String appSecret, String projectCode, String projectSn, String host) {
        ArrayList<JzgWorkerAttendance> jzgList = getPostAllList(appKey, appSecret, projectCode, JzgWorkerAttendance.class, "/api/v1/getAttendanceInfo", host);
        String key = JZG_WORKER_ATTENDANCE_LAST_TIME_PREFIX + projectSn;
        Long time = (Long) redisRepository.get(key);
        workerAttendancePresenceMapper.delete(new LambdaQueryWrapper<WorkerAttendancePresence>().eq(WorkerAttendancePresence::getProjectSn, projectSn));
        List<UfaceDev> ufaceDevs = ufaceDevMapper.selectList(new LambdaQueryWrapper<UfaceDev>()
                .eq(UfaceDev::getProjectSn, projectSn));
        for (JzgWorkerAttendance attendance : jzgList) {
            try {
                if (time == null || attendance.getCheckDate() > time) {
                    saveWorkerAttendance(attendance, projectSn, ufaceDevs);
                }
            } catch (Exception e) {
                log.error("err:", e);
            }
        }
        if (CollUtil.isNotEmpty(jzgList)) {
            Long checkDate = jzgList.stream().max((o1, o2) -> o1.getCheckDate().compareTo(o2.getCheckDate())).get().getCheckDate();
            if (time == null || checkDate > time) {
                redisRepository.set(key, checkDate);
            }
        }
        setPresence(projectSn);
    }

    private void setPresence(String projectSn) {
        HashMap<String, Object> map = new HashMap<>();
        map.put("projectSn", projectSn);

        //计算在场
        List<WorkerAttendance> presenceList = workerAttendanceMapper.queryPresenceList(map);
        for (WorkerAttendance workerAttendance : presenceList) {
            WorkerAttendancePresence p = new WorkerAttendancePresence();
            p.setPersonSn(workerAttendance.getPersonSn());
            p.setCreateTime(DateUtil.now());
            p.setProjectSn(projectSn);
            workerAttendancePresenceMapper.insert(p);
        }
    }

    private void saveWorkerAttendance(JzgWorkerAttendance jzg, String projectSn, List<UfaceDev> ufaceDevs) {
        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()));
        for (UfaceDev ufaceDev : ufaceDevs) {
            Integer passType = workerAttendance.getPassType();
            if (Objects.equals(passType, 1) && Objects.equals(ufaceDev.getIsEnter(), 1)) {
                workerAttendance.setDevSn(ufaceDev.getDevSn());
                break;
            }
            if (Objects.equals(passType, 2) && Objects.equals(ufaceDev.getIsOut(), 1)) {
                workerAttendance.setDevSn(ufaceDev.getDevSn());
                break;
            }
        }
        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, String host) {
        ArrayList<JzgWorker> jzgList = this.getPostAllList(appKey, appSecret, projectCode, JzgWorker.class, "/api/v1/getWorkerInfo", host);
        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) {
            try {
                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));
                }
            } catch (Exception e) {
                log.error("err:", e);
            }
        }
        for (WorkerInfo workerInfo : records) {
            try {
                JzgWorker jzgManagerInfo = map.get(workerInfo.getIdCard());
                if (jzgManagerInfo == null) {
                    workerInfoService.deleteWorkerInfo(String.valueOf(workerInfo.getId()));
                }
            } catch (Exception e) {
                log.error("err:", e);
            }
        }
    }

    private void syncManagerInfo(String appKey, String appSecret, String projectCode, String projectSn, String host) {
        ArrayList<JzgManagerInfo> jzgList = getPostAllList(appKey, appSecret, projectCode, JzgManagerInfo.class, "/api/v1/getManagerInfo", host);
        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) {
            try {
                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));
                }
            } catch (Exception e) {
                log.error("err:", e);
            }
        }
        for (WorkerInfo workerInfo : records) {
            try {
                JzgManagerInfo jzgManagerInfo = jzgEnterpriseInfoMap.get(workerInfo.getIdCard());
                if (jzgManagerInfo == null) {
                    workerInfoService.deleteWorkerInfo(String.valueOf(workerInfo.getId()));
                }
            } catch (Exception e) {
                log.error("err:", e);
            }
        }
    }

    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(getNation(jzg.getNation()));
        if (StrUtil.isNotBlank(jzg.getIssueCardPicUrl())) {
            if (owi != null) {
                deleteFile(owi.getFieldAcquisitionUrl());
            }
            wi.setFieldAcquisitionUrl(uploadFileService.uploadUrlResourceRtName(jzg.getIssueCardPicUrl()));
        }
        if (StrUtil.isNotBlank(jzg.getHeadImageUrl())) {
            if (owi != null) {
                deleteFile(owi.getIdCardBigPhotoUrl());
            }
            wi.setIdCardBigPhotoUrl(uploadFileService.uploadUrlResourceRtName(jzg.getHeadImageUrl()));
        }
        if (StrUtil.isNotBlank(jzg.getPositiveIdCardImageUrl())) {
            if (owi != null) {
                deleteFile(owi.getIdCardUpPhotoUrl());
            }
            wi.setIdCardUpPhotoUrl(uploadFileService.uploadUrlResourceRtName(jzg.getPositiveIdCardImageUrl()));
        }
        if (StrUtil.isNotBlank(jzg.getNegativeIdCardImageUrl())) {
            if (owi != null) {
                deleteFile(owi.getIdCardDownPhotoUrl());
            }
            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());
        wi.setBirthday(MapUtils.getString(IdCardUtils.getBirthdayAgeSex(jzg.getIdCardNumber()), "birthday"));
        return wi;
    }

    private void deleteFile(String file) {
        if (StrUtil.isNotBlank(file)) {
            FileUtil.del(new File(path, file));
        }
    }

    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(getNation(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()));
        wi.setJobType(getJobType(jzg.getJobType()));
        if (jzg.getExitTime() != null) {
            wi.setExitDate(DateUtil.formatDate(new Date(jzg.getExitTime())));
        }
        wi.setBirthday(MapUtils.getString(IdCardUtils.getBirthdayAgeSex(jzg.getIdCardNumber()), "birthday"));
        return wi;
    }

    private String getJobType(String jobType) {
        if (StrUtil.isBlank(jobType)) {
            return null;
        }
        switch (jobType) {
            case "1001":
                return "19";
            case "1002":
                return "19";
            case "1003":
                return "19";
            case "1004":
                return "19";
            case "1005":
                return "19";
            case "1006":
                return "19";
            case "1007":
                return "19";
            case "1008":
                return "5";
            case "1009":
                return "5";
            case "1010":
                return "5";
            case "1011":
                return "5";
            case "1012":
                return "5";
            case "1013":
                return "5";
            case "1014":
                return "5";
            case "1015":
                return "5";
            case "1016":
                return "26";
            case "1017":
                return "26";
            case "1018":
                return "26";
            case "1019":
                return "26";
            case "1020":
                return "26";
            case "1021":
                return "26";
            case "1022":
                return "26";
            case "1023":
                return "26";
            case "1024":
                return "26";
            case "1025":
                return "26";
            case "1026":
                return "26";
            case "1027":
                return "26";
            case "1028":
                return "26";
            case "1029":
                return "26";
            case "1030":
                return "26";
            case "1031":
                return "26";
            case "1032":
                return "26";
            case "1099":
                return "26";
        }
        return null;
    }

    private String getNation(String nation) {
        if (StrUtil.isBlank(nation)) {
            return null;
        }
        switch (nation) {
            case "1":
                return "汉";
            case "2":
                return "蒙古";
            case "3":
                return "回";
            case "4":
                return "藏";
            case "5":
                return "维吾尔";
            case "6":
                return "苗";
            case "7":
                return "彝";
            case "8":
                return "壮";
            case "9":
                return "布依";
            case "10":
                return "朝鲜";
            case "11":
                return "满";
            case "12":
                return "侗";
            case "13":
                return "瑶";
            case "14":
                return "白";
            case "15":
                return "土家";
            case "16":
                return "哈尼";
            case "17":
                return "哈萨克";
            case "18":
                return "傣";
            case "19":
                return "黎";
            case "20":
                return "傈僳";
            case "21":
                return "佤";
            case "22":
                return "畲";
            case "23":
                return "高山";
            case "24":
                return "拉祜";
            case "25":
                return "水";
            case "26":
                return "东乡";
            case "27":
                return "纳西";
            case "28":
                return "景颇";
            case "29":
                return "柯尔克孜";
            case "30":
                return "土";
            case "31":
                return "达翰尔";
            case "32":
                return "仫佬";
            case "33":
                return "羌";
            case "34":
                return "布朗";
            case "35":
                return "撒拉";
            case "36":
                return "毛南";
            case "37":
                return "仡佬";
            case "38":
                return "锡伯";
            case "39":
                return "阿昌";
            case "40":
                return "普米";
            case "41":
                return "塔吉克";
            case "42":
                return "怒";
            case "43":
                return "乌孜别克";
            case "44":
                return "俄罗斯";
            case "45":
                return "鄂温克";
            case "46":
                return "德昂";
            case "47":
                return "保安";
            case "48":
                return "裕固";
            case "49":
                return "京";
            case "50":
                return "塔塔尔";
            case "51":
                return "独龙";
            case "52":
                return "鄂伦春";
            case "53":
                return "赫哲";
            case "54":
                return "门巴";
            case "55":
                return "珞巴";
            case "56":
                return "基诺";
            case "57":
                return "其他";
            case "58":
                return "外国血统中国人士";
        }
        return null;
    }

    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 syncTeamInfoAndWorkType(String appKey, String appSecret, String projectCode, String projectSn, String host) {
        ArrayList<JzgTeamInfo> jzgList = getPostAllList(appKey, appSecret, projectCode, JzgTeamInfo.class, "/api/v1/getTeamInfo", host);
        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) {
            try {
                String teamSysNo = teamInfo.getTeamSysNo();
                TeamInfo info = recordMap.get(teamSysNo);
                if (info == null) {
                    saveTeamInfoAndWorkType(getTeamInfo(teamInfo, null, projectSn));
                } else {
                    editTeamInfoAndWorkType(getTeamInfo(teamInfo, info, projectSn));
                }
            } catch (Exception e) {
                log.error("err:", e);
            }
        }
        for (TeamInfo teamInfo : records) {
            try {
                JzgTeamInfo jzgTeamInfo = jzgEnterpriseInfoMap.get(teamInfo.getJzgTeamSn());
                if (jzgTeamInfo == null) {
                    teamInfoMapper.deleteById(teamInfo.getId());
                    workerTypeMapper.deleteById(teamInfo.getWorkerTypeId());
                }
            } catch (Exception e) {
                log.error("err:", e);
            }
        }
    }

    private <T> ArrayList<T> getPostAllList(String appKey, String appSecret, String projectCode, Class<T> clz, String uri, String host) {
        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, host);
            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 editTeamInfoAndWorkType(TeamInfo teamInfo) {
        WorkerType wt = new WorkerType();
        wt.setId(teamInfo.getWorkerTypeId());
        wt.setTypeName(teamInfo.getTeamName());
        wt.setProjectSn(teamInfo.getProjectSn());
        workerTypeMapper.updateById(wt);

        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 saveTeamInfoAndWorkType(TeamInfo teamInfo) {
        WorkerType wt = new WorkerType();
        wt.setTypeName(teamInfo.getTeamName());
        wt.setProjectSn(teamInfo.getProjectSn());
        workerTypeMapper.insert(wt);
        teamInfo.setWorkerTypeId(wt.getId());

        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, String host) {
        JzgRt jzgRt = jzgPost(appKey, appSecret, projectCode, "/api/v1/getCompanyInfo", new JSONObject(), host);
        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, JzgEnterpriseInfo> jzgEnterpriseInfoMap = new HashMap<>();
        if (jzgRt != null) {
            String data = jzgRt.getData();
            Map<String, EnterpriseInfo> recordMap = records.stream().collect(Collectors.toMap(o -> o.getSocialCode(), Function.identity()));
            ArrayList<JzgEnterpriseInfo> jzgEnterpriseInfos = JSON.parseObject(data, new TypeReference<ArrayList<JzgEnterpriseInfo>>() {
            });
            jzgEnterpriseInfoMap = jzgEnterpriseInfos.stream().collect(Collectors.toMap(JzgEnterpriseInfo::getCorpCode, Function.identity()));
            for (JzgEnterpriseInfo jzgEnterpriseInfo : jzgEnterpriseInfos) {
                try {
                    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));
                    }
                } catch (Exception e) {
                    log.error("err:", e);
                }
            }
        }

        for (EnterpriseInfo enterpriseInfo : records) {
            try {
                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);
                }
            } catch (Exception e) {
                log.error("err:", e);
            }
        }
    }

    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);
        ei.setEnterpriseTypeId(Long.valueOf(jzgEnterpriseInfo.getCorpType()));
        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, String host) {
        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 = host + 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) {
            log.error("error：", e);
        } catch (InvalidKeyException e) {
            log.error("error：", e);
        } catch (InterruptedException e) {
            log.error("error：", e);
        }
        return null;
    }
}