package com.ruoyi.system.service.enterpriseManage.impl;

import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.ruoyi.common.config.RuoYiConfig;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.file.FileUploadUtils;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.system.domain.query.EnterpriseInfoSelectByConditionDBQuery;
import com.ruoyi.system.domain.req.*;
import com.ruoyi.system.domain.resp.*;
import com.ruoyi.system.entity.CountProvinceDataDO;
import com.ruoyi.system.entity.EnterpriseManageCompanyInfo;
import com.ruoyi.system.entity.EnterpriseManageTechnologyType;
import com.ruoyi.system.entity.ValidityStateUpdateDO;
import com.ruoyi.system.enums.DeleteStatusEnum;
import com.ruoyi.system.enums.MajorHazardSourceEnum;
import com.ruoyi.system.enums.ValidityStateEnum;
import com.ruoyi.system.enums.CertificateTypeEnum;
import com.ruoyi.system.service.baseService.EnterpriseManageCompanyInfoService;
import com.ruoyi.system.service.baseService.EnterpriseManageTechnologyTypeService;
import com.ruoyi.system.service.company.ICompanyInfoService;
import com.ruoyi.system.service.enterpriseManage.EnterpriseManageService;
import com.ruoyi.system.utils.EnterpriseParamIsValidUtil;
import org.apache.commons.lang3.BooleanUtils;
import org.apache.ibatis.annotations.Options;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

@Service
public class EnterpriseManageServiceImpl implements EnterpriseManageService {

    private static SimpleDateFormat dateFormat = new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss:sss");

    private final Logger logger = LoggerFactory.getLogger(EnterpriseManageServiceImpl.class);

    @Autowired
    private RedissonClient redissonClient;

    @Autowired
    private ICompanyInfoService companyInfoService;

    @Autowired
    private EnterpriseManageCompanyInfoService enterpriseManageCompanyInfoService;

    @Autowired
    private EnterpriseManageTechnologyTypeService technologyTypeService;

    /**
     * @description 新增企业信息
     */
    @Override
    public AjaxResult saveEnterpriseInfo(LoginUser user,EnterpriseInfoAddReqDTO infoAddReqDTO, MultipartFile companyImageFile,
                                         MultipartFile businessLicenseFile, MultipartFile securityCertificateFile) {
        Date date = new Date();
        if (infoAddReqDTO == null){
            return  AjaxResult.error("新增企业信息参数不能为空");
        }
        EnterpriseManageCompanyInfo companyInfo = new EnterpriseManageCompanyInfo();
        BeanUtils.copyProperties(infoAddReqDTO,companyInfo);
        EnterpriseParamIsValidUtil.ParamIsValid(companyInfo);

        String lockName = "XJ_ENTERPRISE_INFORMATION_ADD_"+companyInfo.getCertificateNum();
        RLock xjEnterpriseInformationAddLock = redissonClient.getLock(lockName);
        xjEnterpriseInformationAddLock.lock(3, TimeUnit.SECONDS);

        EnterpriseManageCompanyInfo selectResult = enterpriseManageCompanyInfoService.getEnterpriseInfoByCertificateNum(companyInfo.getCertificateNum());
        if (selectResult != null){
            return AjaxResult.error("数据已存在，请检查证书编号是否填写正确！");
        }
        initFileInfo(companyInfo, companyImageFile, businessLicenseFile, securityCertificateFile);
        companyInfo.setCreateBy(user.getUsername());
        companyInfo.setCreateTime(date);
        companyInfo.setUpdateBy(user.getUsername());
        companyInfo.setUpdateTime(date);
        companyInfo.setIsDelete(DeleteStatusEnum.DELECT_NO.getStatus());
        companyInfo.setValidityState(judgeValidityState(companyInfo.getValidityDateEnd()));
        boolean saveResult = enterpriseManageCompanyInfoService.save(companyInfo);

        xjEnterpriseInformationAddLock.unlock();

        if (saveResult){
            return AjaxResult.success("企业信息新增成功!");
        }else {
            return AjaxResult.error("企业信息新增失败!");
        }

    }

    /**
     * @description 删除企业信息通过id
     */
    @Transactional
    @Override
    public AjaxResult deleteEnterpriseInfoById(LoginUser user, EnterpriseInfoDeleteByIdReqDTO deleteByIdReqDTO) {
        Long id = deleteByIdReqDTO.getId();
        if (id == null){
            return AjaxResult.error("企业id不能为空");
        }

        String lockName = "XJ_ENTERPRISE_INFORMATION_DELETE_"+id;
        RLock xjEnterpriseInformationDeleteLock = redissonClient.getLock(lockName);
        xjEnterpriseInformationDeleteLock.lock(3, TimeUnit.SECONDS);

        EnterpriseManageCompanyInfo manageCompanyInfo = enterpriseManageCompanyInfoService.getEnterpriseInfoById(id);
        if (manageCompanyInfo == null){
            return AjaxResult.error("企业不存在，删除失败!");
        }
        EnterpriseManageCompanyInfo companyInfo = new EnterpriseManageCompanyInfo();
        companyInfo.setId(id);
        companyInfo.setIsDelete(DeleteStatusEnum.DELECT_YES.getStatus());
        companyInfo.setUpdateTime(new Date());
        companyInfo.setUpdateBy(user.getUsername());
        deleteImage(manageCompanyInfo);
        boolean updateResult = enterpriseManageCompanyInfoService.updateById(companyInfo);

        xjEnterpriseInformationDeleteLock.unlock();

        if (updateResult){
            return AjaxResult.success("企业删除成功!");
        }else {
            return AjaxResult.error("企业删除失败!");
        }
    }

    /**
     * @description 修改企业信息
     */
    @Override
    public AjaxResult updateEnterpriseInfoById(LoginUser user, EnterpriseInfoUpdateByIdReqDTO updateByIdReqDTO,MultipartFile companyImageFile,
                                               MultipartFile businessLicenseFile, MultipartFile securityCertificateFile) {
        Date date = new Date();
        if (updateByIdReqDTO == null){
            return  AjaxResult.error("修改企业信息参数不能为空");
        }
        EnterpriseManageCompanyInfo companyInfo = new EnterpriseManageCompanyInfo();
        BeanUtils.copyProperties(updateByIdReqDTO,companyInfo);
        EnterpriseParamIsValidUtil.ParamIsValid(companyInfo);

        String lockName = "XJ_ENTERPRISE_INFORMATION_UPDATE_"+companyInfo.getCertificateNum();
        RLock xjEnterpriseInformationUpdateLock = redissonClient.getLock(lockName);
        xjEnterpriseInformationUpdateLock.lock(3, TimeUnit.SECONDS);

        EnterpriseManageCompanyInfo selectResult = enterpriseManageCompanyInfoService.getEnterpriseInfoByCertificateNum(companyInfo.getCertificateNum());
        if (selectResult != null){
            if (updateByIdReqDTO.getId() != selectResult.getId()) {
                return AjaxResult.error("数据已存在，请检查证书编号是否填写正确！");
            }
        }

        if (!BooleanUtils.isTrue(companyInfo.getDeleteCompanyImage())){
            companyInfo.setCompanyImage(null);
        }
        if (!BooleanUtils.isTrue(companyInfo.getDeleteBusinessLicense())){
            companyInfo.setBusinessLicense(null);
        }
        if (!BooleanUtils.isTrue(companyInfo.getDeleteSecurityCertificate())){
            companyInfo.setSecurityCertificate(null);
        }
        deleteImage(companyInfo);

        initFileInfo(companyInfo, companyImageFile, businessLicenseFile, securityCertificateFile);
        companyInfo.setUpdateTime(date);
        companyInfo.setUpdateBy(user.getUsername());
        companyInfo.setValidityState(judgeValidityState(companyInfo.getValidityDateEnd()));
        boolean updateResult = enterpriseManageCompanyInfoService.updateById(companyInfo);

        xjEnterpriseInformationUpdateLock.unlock();

        if (updateResult){
            return AjaxResult.success("企业修改成功!");
        }else {
            return AjaxResult.error("企业修改失败!");
        }
    }

    /**
     * @description 查询企业信息通过id
     */
    @Override
    public AjaxResult getEnterpriseInfoById(LoginUser user, EnterpriseInfoSelectByIdReqDTO selectById) {
        Long id = selectById.getId();
        if (id == null){
            return AjaxResult.error("企业信息id不能为空");
        }
        EnterpriseManageCompanyInfo enterpriseInfo = enterpriseManageCompanyInfoService.getEnterpriseInfoById(id);
        if (enterpriseInfo == null){
            return AjaxResult.success(enterpriseInfo);
        }
        EnterpriseInfoByIdSelectRespDTO respDTO = new EnterpriseInfoByIdSelectRespDTO();
        BeanUtils.copyProperties(enterpriseInfo,respDTO);

        EnterpriseManageTechnologyType technologyType = technologyTypeService.getValidTechnologyTypeById(respDTO.getTechnologyType());
        if (technologyType != null){
            respDTO.setTechnologyName(technologyType.getTechnologyName());
        }
        if (CertificateTypeEnum.PRODUCE.getStatus().equals(respDTO.getCertificateType())){
            respDTO.setCertificateTypeName(CertificateTypeEnum.PRODUCE.getDesc());
        }
        if (CertificateTypeEnum.MANAGE.getStatus().equals(respDTO.getCertificateType())){
            respDTO.setCertificateTypeName(CertificateTypeEnum.MANAGE.getDesc());
        }
        return AjaxResult.success(respDTO);
    }

    /**
     * @description 查询各地市的企业信息
     */
    @Override
    public AjaxResult getEnterpriseInfoByCity(LoginUser user, EnterpriseInfoSelectByCityReqDTO selectByCityReqDTO) {
        String city = selectByCityReqDTO.getCity();
        if (StringUtils.isBlank(city)){
            return AjaxResult.error("城市不能为空");
        }
        EnterpriseInfoSelectByCityResultRespDTO resultRespDTO = new EnterpriseInfoSelectByCityResultRespDTO();
        resultRespDTO.setCity(city);

        Byte validityState = selectByCityReqDTO.getValidityState();
        List<EnterpriseManageCompanyInfo> companyInfos = enterpriseManageCompanyInfoService.getEnterpriseInfoByCity(city,validityState);
        if (CollectionUtils.isEmpty(companyInfos)){
            return AjaxResult.success(companyInfos);
        }

        resultRespDTO.setOneMonthEnterpriseNum(countEnterpriseNumByCityAndValidity(companyInfos,ValidityStateEnum.STATE_30_DAYS.getStatus()));
        resultRespDTO.setTwoMonthEnterpriseNum(countEnterpriseNumByCityAndValidity(companyInfos,ValidityStateEnum.STATE_60_DAYS.getStatus()));
        resultRespDTO.setThreeMonthEnterpriseNum(countEnterpriseNumByCityAndValidity(companyInfos,ValidityStateEnum.STATE_90_DAYS.getStatus()));

        Map<String, List<EnterpriseManageCompanyInfo>> companyInfoMap =
                companyInfos.stream().collect(Collectors.groupingBy(EnterpriseManageCompanyInfo::getCompanyArea));

        List<EnterpriseInfoSelectByCityRespDTO> companyInfoResults = new ArrayList<>();
        companyInfoMap.keySet().forEach(area -> {
            List<EnterpriseManageCompanyInfo> enterpriseManageCompanyInfosByArea = companyInfoMap.get(area);
            EnterpriseInfoSelectByCityRespDTO companyInfoResult = new EnterpriseInfoSelectByCityRespDTO();
            companyInfoResult.setCity(enterpriseManageCompanyInfosByArea.get(0).getCompanyCity());
            companyInfoResult.setArea(enterpriseManageCompanyInfosByArea.get(0).getCompanyArea());
            companyInfoResult.setEnterpriseNum(enterpriseManageCompanyInfosByArea.size());
            List<EnterpriseInfoByCityRespDTO> enterprises = enterpriseManageCompanyInfosByArea.stream().map((enterpriseInfo)->{
                EnterpriseInfoByCityRespDTO enterprise = new EnterpriseInfoByCityRespDTO();
                BeanUtils.copyProperties(enterpriseInfo,enterprise);
                enterprise.setMajorHazardSourceLevel(judgeMajorHazardSource(enterpriseInfo));
                return enterprise;
            }).collect(Collectors.toList());
            companyInfoResult.setEnterprises(enterprises);
            companyInfoResults.add(companyInfoResult);
        });
        resultRespDTO.setCompanyInfoResults(companyInfoResults);
        return AjaxResult.success(resultRespDTO);
    }

    /**
     * @description 统计全省的数据
     */
    @Override
    public AjaxResult countProvinceData(LoginUser user) {
        CountProvinceDataDO provinceDataDO = enterpriseManageCompanyInfoService.countProvinceData();
        if (provinceDataDO == null){
            return AjaxResult.success(provinceDataDO);
        }
        CountProvinceDataRespDTO respDTO = new CountProvinceDataRespDTO();
        BeanUtils.copyProperties(provinceDataDO,respDTO);
        return AjaxResult.success(respDTO);
    }

    /**
     * @description 根据条件查询企业信息
     */
    @Override
    public AjaxResult getEnterpriseInfoByCondition(LoginUser user, EnterpriseInfoSelectByConditionReqDTO conditionReqDTO) {
        EnterpriseInfoSelectByConditionDBQuery dbQuery = new EnterpriseInfoSelectByConditionDBQuery();
        BeanUtils.copyProperties(conditionReqDTO,dbQuery);
        List<EnterpriseManageCompanyInfo> companyInfos = enterpriseManageCompanyInfoService.getEnterpriseInfoByCondition(dbQuery);
        if (CollectionUtils.isEmpty(companyInfos)){
            return AjaxResult.success(companyInfos);
        }
        Map<String, List<EnterpriseManageCompanyInfo>> companyCityInfoMap =
                companyInfos.stream().collect(Collectors.groupingBy(EnterpriseManageCompanyInfo::getCompanyCity));

        List<EnterpriseInfoSelectByConditionResultRespDTO> conditionResultRespDTOS = new ArrayList<>();

        companyCityInfoMap.keySet().forEach(city -> {

            EnterpriseInfoSelectByConditionResultRespDTO conditionResultRespDTO = new EnterpriseInfoSelectByConditionResultRespDTO();
            conditionResultRespDTO.setCity(city);

            List<EnterpriseManageCompanyInfo> enterpriseManageCompanyInfosByCity = companyCityInfoMap.get(city);

            Map<String, List<EnterpriseManageCompanyInfo>> enterpriseManageCompanyInfosByArea =
                    enterpriseManageCompanyInfosByCity.stream().collect(Collectors.groupingBy(EnterpriseManageCompanyInfo::getCompanyArea));

            List<EnterpriseInfoSelectByConditionRespDTO> companyInfoResults = new ArrayList<>();

            enterpriseManageCompanyInfosByArea.keySet().forEach(area -> {
                List<EnterpriseManageCompanyInfo> enterpriseManageCompanyInfo = enterpriseManageCompanyInfosByArea.get(area);

                EnterpriseInfoSelectByConditionRespDTO companyInfoResult = new EnterpriseInfoSelectByConditionRespDTO();
                companyInfoResult.setCity(enterpriseManageCompanyInfo.get(0).getCompanyCity());
                companyInfoResult.setArea(enterpriseManageCompanyInfo.get(0).getCompanyArea());
                companyInfoResult.setEnterpriseNum(enterpriseManageCompanyInfo.size());
                List<EnterpriseInfoByConditionRespDTO> enterprises = enterpriseManageCompanyInfo.stream().map((enterpriseInfo)->{
                    EnterpriseInfoByConditionRespDTO enterprise = new EnterpriseInfoByConditionRespDTO();
                    BeanUtils.copyProperties(enterpriseInfo,enterprise);
                    enterprise.setMajorHazardSourceLevel(judgeMajorHazardSource(enterpriseInfo));
                    return enterprise;
                }).collect(Collectors.toList());
                companyInfoResult.setEnterprises(enterprises);
                companyInfoResults.add(companyInfoResult);
            });
            conditionResultRespDTO.setCompanyInfoResults(companyInfoResults);
            conditionResultRespDTOS.add(conditionResultRespDTO);
        });
        return AjaxResult.success(conditionResultRespDTOS);
    }

    /**
     * @description 获取所有的企业id和许可证截止时间进行判断，距离到期还有多久
     */
    @Transactional
    @Override
    public void ValidityStateUpdate(){
        List<ValidityStateUpdateDO> validityStateUpdateDOS = enterpriseManageCompanyInfoService.getInfoIdAndValidityEndTime();
        if (CollectionUtils.isNotEmpty(validityStateUpdateDOS)){
            logger.info("【更新许可证状态执行ing】 " + dateFormat.format(new Date())+"  有效数据数："+validityStateUpdateDOS.size());
           List<EnterpriseManageCompanyInfo> companyInfos =  validityStateUpdateDOS.stream().map((validityStateUpdateDO)->{
                EnterpriseManageCompanyInfo companyInfo = new EnterpriseManageCompanyInfo();
                BeanUtils.copyProperties(validityStateUpdateDO,companyInfo);
                companyInfo.setValidityState(judgeValidityState(validityStateUpdateDO.getValidityDateEnd()));
                return companyInfo;
            }).collect(Collectors.toList());
            boolean updateResult = enterpriseManageCompanyInfoService.updateBatchById(companyInfos);
            if (!updateResult){
                throw new RuntimeException("许可证状态批量更新失败");
            }
            logger.info("【更新许可证状态执行ing】 " + dateFormat.format(new Date())+"  更新数据："+companyInfos.size());
        }
    }

    /**
     * @description 批量导入企业信息
     */
    @Override
    @Transactional
    public AjaxResult importData(LoginUser user, MultipartFile file) {
        String username = user.getUsername();
        Date date = new Date();
        if (file == null){
            return AjaxResult.error("请上传需导入的Excel文件!");
        }
        ExcelUtil<CompanyInfoReqDTO> util = new ExcelUtil<>(CompanyInfoReqDTO.class);
        List<CompanyInfoReqDTO> companyInfos;
        try {
            companyInfos = util.importExcel(file.getInputStream());
        } catch (Exception e) {
            return AjaxResult.error("导入失败，请检查导入文件格式是否正确");
        }
        if (CollectionUtils.isEmpty(companyInfos)){
            return AjaxResult.error("导入失败，请检查导入文件格式是否正确");
        }
        //新传入的工艺类型名称
        List<String> technologyTypeNames = companyInfos.stream().map((companyInfoReqDTO -> {
            return companyInfoReqDTO.getTechnologyType().trim();
        })).collect(Collectors.toList());

        if (CollectionUtils.isEmpty(technologyTypeNames)){
            return AjaxResult.error("导入失败，工艺类型不能为空");
        }

        List<EnterpriseManageTechnologyType> technologyTypes = technologyTypeService.selectTechnologyTypeList();
        List<EnterpriseManageTechnologyType> newManageTechnologyTypes;

        if (CollectionUtils.isEmpty(technologyTypes)){
            newManageTechnologyTypes = technologyTypeNames.stream().map((technologyTypeName)->{
                EnterpriseManageTechnologyType technologyType = new EnterpriseManageTechnologyType();
                technologyType.setTechnologyName(technologyTypeName);
                technologyType.setIsDelete(DeleteStatusEnum.DELECT_NO.getStatus());
                technologyType.setUpdateBy(username);
                technologyType.setUpdateTime(date);
                technologyType.setCreateBy(username);
                technologyType.setCreateTime(date);
                return technologyType;
            }).collect(Collectors.toList());
            technologyTypeService.saveBatch(newManageTechnologyTypes);
        }else {
            //数据库中现有的工艺类型
            List<String> oldTechnologyName = technologyTypes.stream().map(EnterpriseManageTechnologyType::getTechnologyName).collect(Collectors.toList());
            HashSet newHashSet = new HashSet(technologyTypeNames);
            HashSet oldHashSet = new HashSet(oldTechnologyName);
            newHashSet.removeAll(oldHashSet);
            List<String> listTechnologyTypes = new ArrayList<String>();
            listTechnologyTypes.addAll(newHashSet);
            if (CollectionUtils.isNotEmpty(listTechnologyTypes)){
                newManageTechnologyTypes = listTechnologyTypes.stream().map((listTechnologyType)->{
                    EnterpriseManageTechnologyType technologyType = new EnterpriseManageTechnologyType();
                    technologyType.setTechnologyName(listTechnologyType);
                    technologyType.setIsDelete(DeleteStatusEnum.DELECT_NO.getStatus());
                    technologyType.setUpdateBy(username);
                    technologyType.setUpdateTime(date);
                    technologyType.setCreateBy(username);
                    technologyType.setCreateTime(date);
                    return technologyType;
                }).collect(Collectors.toList());
                technologyTypeService.saveBatch(newManageTechnologyTypes);
            }
        }
        List<EnterpriseManageTechnologyType> nowTchnologyTypes = technologyTypeService.selectTechnologyTypeList();
        if (CollectionUtils.isEmpty(nowTchnologyTypes)){
            return AjaxResult.error("工艺类型为空,无法导入");
        }
        Map<String,Integer> technologyTypeMap = nowTchnologyTypes.stream()
                .collect(Collectors.toMap(EnterpriseManageTechnologyType::getTechnologyName,EnterpriseManageTechnologyType::getId));

        List<EnterpriseManageCompanyInfo> importData = companyInfos.stream().map((companyInfoReqDTO)->{
            AjaxResult paramIsValid = EnterpriseParamIsValidUtil.tableParamIsValid(companyInfoReqDTO);
            companyInfoReqDTO = (CompanyInfoReqDTO) paramIsValid.get("data");
            EnterpriseManageCompanyInfo manageCompanyInfo = new EnterpriseManageCompanyInfo();
            BeanUtils.copyProperties(companyInfoReqDTO,manageCompanyInfo);
            if (CertificateTypeEnum.PRODUCE.getDesc().equals(companyInfoReqDTO.getCertificateType())){
                manageCompanyInfo.setCertificateType(CertificateTypeEnum.PRODUCE.getStatus());
            }else if (CertificateTypeEnum.MANAGE.getDesc().equals(companyInfoReqDTO.getCertificateType())){
                manageCompanyInfo.setCertificateType(CertificateTypeEnum.MANAGE.getStatus());
            }else {
                manageCompanyInfo.setCertificateType(null);
            }
            manageCompanyInfo.setValidityState(judgeValidityState(companyInfoReqDTO.getValidityDateEnd()));
            Integer integer = technologyTypeMap.get(companyInfoReqDTO.getTechnologyType());
            if (integer == null){
                manageCompanyInfo.setTechnologyType(null);
            }else {
                manageCompanyInfo.setTechnologyType(integer);
            }
            if (manageCompanyInfo.getLevelOneMajorHazardSourceSum() == null){
                manageCompanyInfo.setLevelOneMajorHazardSourceSum(0);
            }
            if (manageCompanyInfo.getLevelTwoMajorHazardSourceSum() == null){
                manageCompanyInfo.setLevelTwoMajorHazardSourceSum(0);
            }
            if (manageCompanyInfo.getLevelThreeMajorHazardSourceSum() == null){
                manageCompanyInfo.setLevelThreeMajorHazardSourceSum(0);
            }
            if (manageCompanyInfo.getLevelFourMajorHazardSourceSum() == null){
                manageCompanyInfo.setLevelFourMajorHazardSourceSum(0);
            }
            manageCompanyInfo.setIsDelete(DeleteStatusEnum.DELECT_NO.getStatus());
            manageCompanyInfo.setUpdateBy(username);
            manageCompanyInfo.setUpdateTime(date);
            manageCompanyInfo.setCreateBy(username);
            manageCompanyInfo.setCreateTime(date);
            return manageCompanyInfo;
        }).collect(Collectors.toList());
        //表格的数据量
        int tableSize = importData.size();

        List<EnterpriseManageCompanyInfo> duplicateRemoveImportData =  importData.stream().distinct().collect(Collectors.collectingAndThen(
                Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(EnterpriseManageCompanyInfo::getCertificateNum))), ArrayList::new));

        if (CollectionUtils.isEmpty(duplicateRemoveImportData)){
            return AjaxResult.success("导入成功,导入成功条数 0 条.");
        }

        for (EnterpriseManageCompanyInfo enterpriseManageCompanyInfo : duplicateRemoveImportData) {
            if (enterpriseManageCompanyInfo.getCertificateType() == null){
                return AjaxResult.error(enterpriseManageCompanyInfo.getCompanyName()+"许可证类型不属于生产、经营,许可证类型异常!");
            }
            if (enterpriseManageCompanyInfo.getTechnologyType() == null){
                return AjaxResult.error(enterpriseManageCompanyInfo.getCompanyName()+"工艺类型异常!");
            }
        }

        //表格中去除重复数据后的条数
        int duplicateRemoveImportDataSize = duplicateRemoveImportData.size();

        List<EnterpriseManageCompanyInfo> companyInfosFromDB = enterpriseManageCompanyInfoService.listEnterpriseInfo();
        if (CollectionUtils.isEmpty(companyInfosFromDB)){
            boolean saveResult = enterpriseManageCompanyInfoService.saveBatch(duplicateRemoveImportData);
            return AjaxResult.success("表格数据总条数: "+tableSize+" ,去除重复后的数据条数："+duplicateRemoveImportDataSize+" ,与数据库比对去重后新增: "+duplicateRemoveImportDataSize + ".");
        }else {
            List<String> certificateNumFromDB = companyInfosFromDB.stream().map(EnterpriseManageCompanyInfo -> EnterpriseManageCompanyInfo.getCertificateNum()).collect(Collectors.toList());

            List<EnterpriseManageCompanyInfo> data = new ArrayList<>();
            for (EnterpriseManageCompanyInfo ImportData : duplicateRemoveImportData) {
                if (!certificateNumFromDB.contains(ImportData.getCertificateNum())){
                    data.add(ImportData);
                }
            }
            enterpriseManageCompanyInfoService.saveBatch(data);
            int dataSize = 0;
            if (data != null){
                dataSize = data.size();
            }
            return AjaxResult.success("表格数据总共: "+tableSize+" ,去除重复后的数据条数："+duplicateRemoveImportDataSize+" ,与数据库比对去重后新增: "+dataSize + ".");
        }
    }


    /**
     * @description 统计某市各许可证期限数量  validityState（4-正常在期(非临期);3-90天内到期;2-60天内到期;1-30天内到期;0-已到期）
     */
    private Long countEnterpriseNumByCityAndValidity(List<EnterpriseManageCompanyInfo> companyInfos,Byte validityState){
        long count = companyInfos.stream()
                .filter(companyInfo -> Optional.ofNullable(companyInfo.getValidityState()).orElse((byte) 6) == validityState)
                .collect(Collectors.toList()).stream()
                .count();
        return count;
    }

    /**
     * @description 重大危险源等级判断
     */
    private Byte judgeMajorHazardSource(EnterpriseManageCompanyInfo enterpriseInfo){
        if (enterpriseInfo != null){
            if (enterpriseInfo.getLevelOneMajorHazardSourceSum() > 0){
                return MajorHazardSourceEnum.ONE_LEVEL.getStatus();
            }
            if (enterpriseInfo.getLevelTwoMajorHazardSourceSum() > 0){
                return MajorHazardSourceEnum.TWO_LEVEL.getStatus();
            }
            if (enterpriseInfo.getLevelThreeMajorHazardSourceSum() > 0){
                return MajorHazardSourceEnum.THREE_LEVEL.getStatus();
            }
            if (enterpriseInfo.getLevelFourMajorHazardSourceSum() > 0){
                return MajorHazardSourceEnum.FOUR_LEVEL.getStatus();
            }
            return MajorHazardSourceEnum.ZERO_LEVEL.getStatus();
        }
        return null;
    }

    /**
     * @description 图片删除
     */
    public static void deleteImage(EnterpriseManageCompanyInfo manageCompanyInfo){
        List<String> imageAddress = new ArrayList<>();
        if (StringUtils.isNoneBlank(manageCompanyInfo.getCompanyImage())){
            imageAddress.add(manageCompanyInfo.getCompanyImage());
        }
        if (StringUtils.isNoneBlank(manageCompanyInfo.getBusinessLicense())){
            imageAddress.add(manageCompanyInfo.getBusinessLicense());
        }
        if (StringUtils.isNoneBlank(manageCompanyInfo.getSecurityCertificate())){
            imageAddress.add(manageCompanyInfo.getSecurityCertificate());
        }
        if (CollectionUtils.isNotEmpty(imageAddress)){
            for (String address : imageAddress) {
                File image = null;
                try {
                    address = address.replaceFirst("/profile/","/");
                    image = FileUploadUtils.getAbsoluteFile(FileUploadUtils.getDefaultBaseDir(), address);
                } catch (IOException e) {
                    throw new RuntimeException("获取图片地址失败");
                }
                if (image != null){
                    if (!image.delete()){
                        throw new RuntimeException("图片删除失败");
                    }
                }
            }
        }
    }


    /**
     * @description 新增时候对许可证进行一次有效期判断
     */
    private Byte judgeValidityState(Date validityDateEnd){
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(validityDateEnd);
        calendar.set(Calendar.HOUR_OF_DAY,23);
        calendar.set(Calendar.MINUTE,59);
        calendar.set(Calendar.SECOND,59);
        validityDateEnd = calendar.getTime();

        Date date = new Date();
        if (validityDateEnd.compareTo(date)<0){
            return ValidityStateEnum.STATE_EXPIRED.getStatus();
        }
        int days = (int) ((validityDateEnd.getTime() - date.getTime()) / (1000*3600*24));
        if (days <= 30){
            return ValidityStateEnum.STATE_30_DAYS.getStatus();
        }
        if (days > 30 && days <= 60){
            return ValidityStateEnum.STATE_60_DAYS.getStatus();
        }
        if (days > 60 && days <= 90){
            return ValidityStateEnum.STATE_90_DAYS.getStatus();
        }
        return ValidityStateEnum.STATE_NORMAL.getStatus();
    }


    /**
     * @description 图片保存功能
     */
    public void initFileInfo(EnterpriseManageCompanyInfo companyInfo, MultipartFile companyImage,
                             MultipartFile businessLicense, MultipartFile securityCertificate) {

        if (BooleanUtils.isTrue(companyInfo.getDeleteCompanyImage())) {
            companyInfo.setCompanyImage("");
        }
        if (BooleanUtils.isTrue(companyInfo.getDeleteBusinessLicense())) {
            companyInfo.setBusinessLicense("");
        }
        if (BooleanUtils.isTrue(companyInfo.getDeleteSecurityCertificate())) {
            companyInfo.setSecurityCertificate("");
        }

        if (companyImage != null) {
            // 上传文件路径
            String filePath = RuoYiConfig.getUploadPath();
            // 上传并返回新文件名称
            String fileName = null;
            try {
                fileName = FileUploadUtils.upload(filePath, companyImage);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            companyInfo.setCompanyImage(fileName);
        }

        if (businessLicense != null) {
            // 上传文件路径
            String filePath = RuoYiConfig.getUploadPath();
            // 上传并返回新文件名称
            String fileName = null;
            try {
                fileName = FileUploadUtils.upload(filePath, businessLicense);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            companyInfo.setBusinessLicense(fileName);
        }

        if (securityCertificate != null) {
            // 上传文件路径
            String filePath = RuoYiConfig.getUploadPath();
            // 上传并返回新文件名称
            String fileName = null;
            try {
                fileName = FileUploadUtils.upload(filePath, securityCertificate);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            companyInfo.setSecurityCertificate(fileName);
        }
    }
}