package com.zhgd.xmgl.async;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
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.worker.entity.*;
import com.zhgd.xmgl.modules.worker.mapper.*;
import com.zhgd.xmgl.util.Base64Util;
import com.zhgd.xmgl.util.IdCardUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.UUID;

/**
 * @program: wisdomSite
 * @description:
 * @author: Mr.Peng
 * @create: 2022-05-27 16:21
 **/
@Slf4j
@Component
public class AsyncProjectWork {
    @Autowired
    private WorkerInfoMapper workerInfoMapper;
    @Autowired
    private ProjectMapper projectMapper;
    @Autowired
    private TeamInfoMapper teamInfoMapper;
    @Autowired
    private EnterpriseInfoMapper enterpriseInfoMapper;
    @Autowired
    private ProjectEnterpriseMapper projectEnterpriseMapper;
    @Autowired
    private EnterpriseTypeMapper enterpriseTypeMapper;
    @Autowired
    private DepartmentInfoMapper departmentInfoMapper;
    @Autowired
    private WorkerTypeMapper workerTypeMapper;
    @Autowired
    private UploadFileService uploadFileService;

    @Async("sendWorkerExecutor")
    public void updateOrAddProjectWorkerData(Map<String, Object> map) {
        if(map!=null) {
            String projectSn = MapUtils.getString(map, "projectSn");
            String projectName = MapUtils.getString(map, "projectName");
            QueryWrapper<Project> queryWrapper=new QueryWrapper<>();
            queryWrapper.lambda().eq(Project::getProjectSn,projectSn);
            int count=projectMapper.selectCount(queryWrapper);
            if(count>0){
                log.info("---开始同步项目人员数据-----"+projectName+"------编号："+projectSn);
                List<Map<String, Object>> list= (List<Map<String, Object>>) map.get("list");
                if(list!=null&&list.size()>0){
                    for(Map<String, Object> data:list){
                        addOrEditProjectWork(data,projectSn);
                    }
                    log.info("---同步项目人员数据完成-----"+projectName+"------编号："+projectSn);
                }else{
                    log.info("---未获取到需要同步的人员数据-----"+projectName+"------编号："+projectSn);
                }
            }else{
                log.info("---未找到对应的项目，同步老项目版人员数据失败-----"+projectName+"------编号："+projectSn);
            }
        }
    }

    public void addOrEditProjectWork(Map<String,Object> info,String projectSn){
        try {
            log.info("---同步人员开始-----"+MapUtils.getString(info, "workerName")+"------项目编号："+projectSn);
            WorkerInfo workerInfo = new WorkerInfo();
            workerInfo.setWorkerName(MapUtils.getString(info, "workerName"));
            if (StringUtils.isNotEmpty(MapUtils.getString(info, "workerNumber"))) {
                workerInfo.setAttendanceNumber(MapUtils.getString(info, "workerNumber"));
            } else {
                workerInfo.setAttendanceNumber(MapUtils.getString(info, "idCard"));
            }
            workerInfo.setIdCard(MapUtils.getString(info, "idCard"));
            workerInfo.setProjectSn(projectSn);
            if (StringUtils.isNotEmpty(workerInfo.getIdCard())) {
                Map<String, String> idCardInfoMap = IdCardUtils.getBirthdayAgeSex(workerInfo.getIdCard());
                workerInfo.setSex(MapUtils.getInteger(idCardInfoMap, "sex"));
                workerInfo.setBirthday(MapUtils.getString(idCardInfoMap, "birthday"));
            }

            workerInfo.setNativePlace(MapUtils.getString(info, "nativePlace"));
            workerInfo.setNation(MapUtils.getString(info, "nationId"));
            workerInfo.setPhoneNumber(MapUtils.getString(info, "phoneNumber"));
            workerInfo.setIssuingAuthorityForIdcard(MapUtils.getString(info, "issuingAuthorityForIdcard"));
            workerInfo.setEducational(MapUtils.getString(info, "educational"));

            workerInfo.setPoliticsStatus(MapUtils.getInteger(info, "politicsStatus"));
            workerInfo.setEmergentPerson(MapUtils.getString(info, "emergentPerson"));
            workerInfo.setEmergentPhone(MapUtils.getString(info, "emergentPhone"));
            if (StringUtils.isNotEmpty(MapUtils.getString(info, "idCardEndDate"))) {
                if (MapUtils.getString(info, "idCardEndDate").indexOf("长期") >= 0) {
                    workerInfo.setLongTerm(1);
                } else {
                    workerInfo.setIdCardEndDate(MapUtils.getString(info, "idCardEndDate"));
                }
            }
            workerInfo.setPersonSn(MapUtils.getString(info, "workInfoSn"));
            workerInfo.setEnterDate(MapUtils.getString(info, "enterDate"));
            workerInfo.setPayRollBankNumber(MapUtils.getString(info, "bankCode"));
            workerInfo.setPayRollBankName(MapUtils.getString(info, "payRollBankName"));
            workerInfo.setInserviceType(1);

            QueryWrapper<EnterpriseInfo> queryWrapper = new QueryWrapper<>();
            queryWrapper.lambda().eq(EnterpriseInfo::getSocialCode, MapUtils.getString(info, "socialCode"));
            EnterpriseInfo tempEnterpriseInfo = enterpriseInfoMapper.selectOne(queryWrapper);
            QueryWrapper<EnterpriseType> enterpriseTypeQueryWrapper = new QueryWrapper<>();
            enterpriseTypeQueryWrapper.lambda().eq(EnterpriseType::getCompanyTypeName, MapUtils.getString(info, "companyTypeName"));
            EnterpriseType oldEnterpriseType = enterpriseTypeMapper.selectOne(enterpriseTypeQueryWrapper);
            String enterpriseName = "";
            if (tempEnterpriseInfo != null) {
                QueryWrapper<ProjectEnterprise> queryWrapper1 = new QueryWrapper<>();
                queryWrapper1.lambda().eq(ProjectEnterprise::getEnterpriseId, tempEnterpriseInfo.getId())
                        .eq(ProjectEnterprise::getProjectSn, projectSn);
                int count = projectEnterpriseMapper.selectCount(queryWrapper1);
                if (count == 0) {
                    ProjectEnterprise projectEnterprise = new ProjectEnterprise();
                    projectEnterprise.setEnterpriseId(tempEnterpriseInfo.getId());
                    projectEnterprise.setProjectSn(projectSn);
                    if (oldEnterpriseType != null) {
                        projectEnterprise.setEnterpriseTypeId(oldEnterpriseType.getId());
                    } else {
                        projectEnterprise.setEnterpriseTypeId(12L);
                    }
                    projectEnterpriseMapper.insert(projectEnterprise);
                }
                workerInfo.setEnterpriseId(tempEnterpriseInfo.getId());
                enterpriseName = tempEnterpriseInfo.getEnterpriseName();
            } else {
                EnterpriseInfo enterpriseInfo = new EnterpriseInfo();
                enterpriseInfo.setEnterpriseSn(MapUtils.getString(info, "companysn"));
                enterpriseInfo.setProjectSn(projectSn);
                enterpriseInfo.setSocialCode(MapUtils.getString(info, "socialCode"));
                enterpriseInfo.setEnterpriseName(MapUtils.getString(info, "companyName"));
                enterpriseInfoMapper.insert(enterpriseInfo);
                ProjectEnterprise projectEnterprise = new ProjectEnterprise();
                projectEnterprise.setEnterpriseId(enterpriseInfo.getId());
                projectEnterprise.setProjectSn(enterpriseInfo.getProjectSn());
                if (oldEnterpriseType != null) {
                    projectEnterprise.setEnterpriseTypeId(oldEnterpriseType.getId());
                } else {
                    projectEnterprise.setEnterpriseTypeId(12L);
                }
                projectEnterpriseMapper.insert(projectEnterprise);
                workerInfo.setEnterpriseId(enterpriseInfo.getId());
                enterpriseName = enterpriseInfo.getEnterpriseName();
            }
            Integer personType = MapUtils.getInteger(info, "personType");
            workerInfo.setPersonType(personType);
            workerInfo.setFieldAcquisitionUrl(getImageUrl(MapUtils.getString(info, "workFieldAcquisitionUrl")));
            workerInfo.setIdCardUpPhotoUrl(getImageUrl(MapUtils.getString(info, "idCardUpPhotoUrl")));
            workerInfo.setIdCardBigPhotoUrl(getImageUrl(MapUtils.getString(info, "idCardBigPhotoUrl")));
            workerInfo.setIdCardDownPhotoUrl(getImageUrl(MapUtils.getString(info, "idCardDownPhotoUrl")));
            if (personType == 2) {
                String teamName = "";
                if (StringUtils.isNotEmpty(MapUtils.getString(info, "teamName"))) {
                    teamName = MapUtils.getString(info, "teamName");
                } else {
                    teamName = "其它";
                }
                teamName = teamName + "-" + enterpriseName;
                QueryWrapper<DepartmentInfo> departmentInfoQueryWrapper = new QueryWrapper<>();
                departmentInfoQueryWrapper.lambda().eq(DepartmentInfo::getProjectSn, workerInfo.getProjectSn())
                        .eq(DepartmentInfo::getEnterpriseId, workerInfo.getEnterpriseId())
                        .eq(DepartmentInfo::getDepartmentName, teamName);
                DepartmentInfo oldDepartmentInfo = departmentInfoMapper.selectOne(departmentInfoQueryWrapper);
                if (oldDepartmentInfo != null) {
                    workerInfo.setDepartmentId(oldDepartmentInfo.getId());
                } else {
                    DepartmentInfo departmentInfo = new DepartmentInfo();
                    departmentInfo.setDepartmentName(teamName);
                    departmentInfo.setProjectSn(workerInfo.getProjectSn());
                    departmentInfo.setEnterpriseId(workerInfo.getEnterpriseId());
                    departmentInfoMapper.insert(departmentInfo);
                    workerInfo.setDepartmentId(departmentInfo.getId());
                }
            } else if (personType == 1) {
                String teamName = "";
                if (StringUtils.isNotEmpty(MapUtils.getString(info, "teamName"))) {
                    teamName = MapUtils.getString(info, "teamName");
                } else {
                    teamName = "其它";
                }
                teamName = teamName + "-" + enterpriseName;
                QueryWrapper<TeamInfo> teamInfoQueryWrapper = new QueryWrapper<>();
                teamInfoQueryWrapper.lambda().eq(TeamInfo::getProjectSn, workerInfo.getProjectSn())
                        .eq(TeamInfo::getTeamName, teamName);
                TeamInfo oldTeamInfo = teamInfoMapper.selectOne(teamInfoQueryWrapper);
                if (oldTeamInfo != null) {
                    workerInfo.setTeamId(oldTeamInfo.getId());
                } else {
                    String typeName = "";
                    if (StringUtils.isNotEmpty(MapUtils.getString(info, "typeName"))) {
                        typeName = MapUtils.getString(info, "typeName");
                    } else {
                        teamName = "其它";
                    }
                    QueryWrapper<WorkerType> workerTypeQueryWrapper = new QueryWrapper<>();
                    workerTypeQueryWrapper.lambda().eq(WorkerType::getProjectSn, workerInfo.getProjectSn())
                            .eq(WorkerType::getTypeName, typeName);
                    WorkerType oldWorkerType = workerTypeMapper.selectOne(workerTypeQueryWrapper);
                    TeamInfo teamInfo = new TeamInfo();
                    if (oldWorkerType != null) {
                        teamInfo.setWorkerTypeId(oldWorkerType.getId());
                    } else {
                        WorkerType workerType = new WorkerType();
                        workerType.setProjectSn(workerInfo.getProjectSn());
                        workerType.setTypeName(typeName);
                        workerTypeMapper.insert(workerType);
                        teamInfo.setWorkerTypeId(workerType.getId());
                    }

                    teamInfo.setTeamName(teamName);
                    teamInfo.setProjectSn(workerInfo.getProjectSn());
                    teamInfo.setEnterpriseId(workerInfo.getEnterpriseId());
                    String uuid = UUID.randomUUID().toString().replace("-", "").toUpperCase();
                    teamInfo.setTeamSn(uuid);
                    //teamInfo.setTeamSn(MapUtils.getString(info,"teamSn"));
                    teamInfoMapper.insert(teamInfo);
                    workerInfo.setTeamId(teamInfo.getId());
                }
            }
            QueryWrapper<WorkerInfo> queryWrapper1 = new QueryWrapper<>();
            queryWrapper1.lambda().eq(WorkerInfo::getProjectSn, workerInfo.getProjectSn())
                    .eq(WorkerInfo::getPersonSn, workerInfo.getPersonSn());
            WorkerInfo oldWorkerInfo = workerInfoMapper.selectOne(queryWrapper1);
            if (oldWorkerInfo != null) {
                workerInfo.setId(oldWorkerInfo.getId());
                workerInfoMapper.updateById(workerInfo);
            } else {
                workerInfo.setAddTime(new Date());
                workerInfoMapper.insert(workerInfo);
            }
        }catch (Exception e){
            log.error("---同步人员失败-----"+MapUtils.getString(info, "workerName")+"------项目编号："+projectSn+"----原因："+e.getMessage());
        }
    }

    private String getImageUrl(String imageData){
        String imageUrl=null;
        try {
            if (StringUtils.isNotEmpty(imageData)) {
                String img = Base64Util.getFileToBase64(imageData);
                if (!img.startsWith("data:image")) {
                    img = "data:image/jpg;base64," + img;
                }
                Map<String, Object> result2 = uploadFileService.uploadBase64Image(img);
                if ("SUCCESS".equals(MapUtils.getString(result2, "status"))) {
                    Map<String, Object> dataMap = (Map<String, Object>) result2.get("data");
                    imageUrl=MapUtils.getString(dataMap, "imageUrl");
                }
            }
        }catch (Exception e){
            log.error(e.getMessage());
        }
        return imageUrl;
    }

}