package org.jeecg.modules.eam.service.impl;

import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.xwpf.usermodel.XWPFDocument;
import org.apache.poi.xwpf.usermodel.XWPFParagraph;
import org.apache.poi.xwpf.usermodel.XWPFTable;
import org.apache.poi.xwpf.usermodel.XWPFTableRow;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.FileUtil;
import org.jeecg.common.util.SimpleVersionGenerateUtil;
import org.jeecg.modules.eam.constant.BusinessCodeConst;
import org.jeecg.modules.eam.constant.TechnicalStatusEvaluationCheckCategoryEnum;
import org.jeecg.modules.eam.constant.TechnicalStatusEvaluationStandardStatusEnum;
import org.jeecg.modules.eam.entity.EamEquipment;
import org.jeecg.modules.eam.entity.EamTechnicalStatusEvaluationStandard;
import org.jeecg.modules.eam.entity.EamTechnicalStatusEvaluationStandardDetail;
import org.jeecg.modules.eam.mapper.EamTechnicalStatusEvaluationStandardMapper;
import org.jeecg.modules.eam.request.EamTechnicalStatusEvaluationStandardRequest;
import org.jeecg.modules.eam.service.IEamEquipmentService;
import org.jeecg.modules.eam.service.IEamTechnicalStatusEvaluationStandardDetailService;
import org.jeecg.modules.eam.service.IEamTechnicalStatusEvaluationStandardService;
import org.jeecg.modules.system.entity.BaseFactory;
import org.jeecg.modules.system.entity.BaseFactoryUser;
import org.jeecg.modules.system.service.IBaseFactoryService;
import org.jeecg.modules.system.service.IBaseFactoryUserService;
import org.jeecg.modules.system.service.ISysBusinessCodeRuleService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @Description: 技术状态鉴定规范
 * @Author: jeecg-boot
 * @Date: 2025-07-07
 * @Version: V1.0
 */
@Service
@Slf4j
public class EamTechnicalStatusEvaluationStandardServiceImpl extends ServiceImpl<EamTechnicalStatusEvaluationStandardMapper, EamTechnicalStatusEvaluationStandard> implements IEamTechnicalStatusEvaluationStandardService {

    @Autowired
    private IBaseFactoryUserService baseFactoryUserService;
    @Autowired
    private IBaseFactoryService baseFactoryService;
    @Autowired
    private IEamTechnicalStatusEvaluationStandardDetailService standardDetailService;
    @Autowired
    private IEamEquipmentService equipmentService;
    @Autowired
    private ISysBusinessCodeRuleService businessCodeRuleService;

    @Override
    public IPage<EamTechnicalStatusEvaluationStandard> queryPageList(Page<EamTechnicalStatusEvaluationStandard> page, EamTechnicalStatusEvaluationStandard query) {
        QueryWrapper<EamTechnicalStatusEvaluationStandard> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("ems.del_flag", CommonConstant.DEL_FLAG_0);
        //用户数据权限
        LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
        if (sysUser == null) {
            return page;
        }
        if (StringUtils.isNotBlank(sysUser.getEamEquipmentIds())) {
            //选择了设备，根据设备id过滤设备
            List<String> equipArr = Arrays.asList(sysUser.getEamEquipmentIds().split(","));
            queryWrapper.in("e.equipment_code", equipArr);
        } else {
            //没有选择设备，根据中心过滤设备
            List<BaseFactoryUser> baseFactoryUserList = baseFactoryUserService.
                    list(new LambdaQueryWrapper<BaseFactoryUser>().eq(BaseFactoryUser::getUserId, sysUser.getId()));
            if (!CollectionUtils.isEmpty(baseFactoryUserList)) {
                Set<String> factoryIds = baseFactoryUserList.stream().map(BaseFactoryUser::getFactoryId).collect(Collectors.toSet());
                Set<String> factoryCodeList = baseFactoryService.listByIds(factoryIds).stream().map(BaseFactory::getOrgCode).collect(Collectors.toSet());
                queryWrapper.in("e.factory_org_code", factoryCodeList);
            } else {
                return page;
            }
        }
        if (query != null) {
            //编码 模糊查询
            if (StringUtils.isNotBlank(query.getStandardCode())) {
                queryWrapper.like("ems.standard_code", query.getStandardCode());
            }
            //名称 模糊查询
            if (StringUtils.isNotBlank(query.getStandardName())) {
                queryWrapper.like("ems.standard_name", query.getStandardName());
            }
            //设备
            if (StringUtils.isNotBlank(query.getEquipmentId())) {
                queryWrapper.eq("ems.equipment_id", query.getEquipmentId());
            }

            //规范状态
            if (StringUtils.isNotBlank(query.getStandardStatus())) {
                queryWrapper.eq("ems.standard_status", query.getStandardStatus());
            }

            //设备编码
            if (StringUtils.isNotBlank(query.getKeyword())) {
                queryWrapper.and(wrapper -> wrapper.like("e.equipment_name", query.getKeyword())
                        .or()
                        .like("e.equipment_code", query.getKeyword()));
            }
        }
        queryWrapper.orderByDesc("ems.create_time");
        return this.getBaseMapper().queryPageList(page, queryWrapper);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean addEamTechnicalStatusEvaluationStandard(EamTechnicalStatusEvaluationStandardRequest request) {
        if (!CommonConstant.STATUS_1.equals(request.getHasOtherCheck()) && !CommonConstant.STATUS_1.equals(request.getHasSafetyEquipmentCheck()) && !CommonConstant.STATUS_1.equals(request.getHasPrecisionCheck())) {
            //必须要选择一个检查分类
            throw new JeecgBootException("必须要选择一个检查分类！");
        }
        EamTechnicalStatusEvaluationStandard entity = new EamTechnicalStatusEvaluationStandard();
        BeanUtils.copyProperties(request, entity);
        entity.setStandardStatus(TechnicalStatusEvaluationStandardStatusEnum.WAIT_SUBMIT.name());
        //版本递增
        entity.setStandardVersion(SimpleVersionGenerateUtil.getInitVersion());
        //设备处理
        entity.setEquipmentId(request.getEquipmentId());
        //删除标记
        entity.setDelFlag(CommonConstant.DEL_FLAG_0);
        //重复性校验
        EamTechnicalStatusEvaluationStandard exist = checkDuplicate(entity.getEquipmentId(), null);
        if (exist != null) {
            throw new JeecgBootException("规范已存在，不能重复添加！");
        }
        this.getBaseMapper().insert(entity);
        //处理明细数据
        if (CollectionUtil.isNotEmpty(request.getTableDetailList())) {
            request.getTableDetailList().forEach(tableDetail -> {
                tableDetail.setStandardId(entity.getId());
            });
            //根据分类判断是否保存
            if (CommonConstant.STATUS_1.equals(entity.getHasOtherCheck())) {
                //保存其他分类
                List<EamTechnicalStatusEvaluationStandardDetail> collect = request.getTableDetailList().stream().filter(item -> TechnicalStatusEvaluationCheckCategoryEnum.OTHER_CHECK.name().equals(item.getCheckCategory())).collect(Collectors.toList());
                if (CollectionUtils.isEmpty(collect)) {
                    throw new JeecgBootException("其他检查明细不能为空！");
                }
                standardDetailService.saveBatch(collect);
            }
            if (CommonConstant.STATUS_1.equals(entity.getHasSafetyEquipmentCheck())) {
                //保存安全装置分类
                List<EamTechnicalStatusEvaluationStandardDetail> collect = request.getTableDetailList().stream().filter(item -> TechnicalStatusEvaluationCheckCategoryEnum.SAFETY_EQUIPMENT_CHECK.name().equals(item.getCheckCategory())).collect(Collectors.toList());
                if (CollectionUtils.isEmpty(collect)) {
                    throw new JeecgBootException("安全装置检查明细不能为空！");
                }
                standardDetailService.saveBatch(collect);
            }
            if (CommonConstant.STATUS_1.equals(entity.getHasPrecisionCheck())) {
                //保存精度检验分类
                List<EamTechnicalStatusEvaluationStandardDetail> collect = request.getTableDetailList().stream().filter(item -> TechnicalStatusEvaluationCheckCategoryEnum.PRECISION_CHECK.name().equals(item.getCheckCategory())).collect(Collectors.toList());
                if (CollectionUtils.isEmpty(collect)) {
                    throw new JeecgBootException("精度检查明细不能为空！");
                }
                standardDetailService.saveBatch(collect);
            }
        }
        return true;
    }

    @Override
    public EamTechnicalStatusEvaluationStandard checkDuplicate(String equipmentId, String id) {
        LambdaQueryWrapper<EamTechnicalStatusEvaluationStandard> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(EamTechnicalStatusEvaluationStandard::getEquipmentId, equipmentId);
        queryWrapper.eq(EamTechnicalStatusEvaluationStandard::getDelFlag, CommonConstant.DEL_FLAG_0);
        //待提交、启用状态
        queryWrapper.in(EamTechnicalStatusEvaluationStandard::getStandardStatus, Arrays.asList(TechnicalStatusEvaluationStandardStatusEnum.ENABLE.name(), TechnicalStatusEvaluationStandardStatusEnum.WAIT_SUBMIT.name()));
        queryWrapper.orderByDesc(EamTechnicalStatusEvaluationStandard::getStandardVersion);
        if (StringUtils.isNotBlank(id)) {
            queryWrapper.ne(EamTechnicalStatusEvaluationStandard::getId, id);
        }
        List<EamTechnicalStatusEvaluationStandard> list = this.getBaseMapper().selectList(queryWrapper);
        if (CollectionUtil.isEmpty(list)) {
            return null;
        }
        return list.get(0);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean editEamTechnicalStatusEvaluationStandard(EamTechnicalStatusEvaluationStandardRequest request) {
        if (!CommonConstant.STATUS_1.equals(request.getHasOtherCheck()) && !CommonConstant.STATUS_1.equals(request.getHasSafetyEquipmentCheck()) && !CommonConstant.STATUS_1.equals(request.getHasPrecisionCheck())) {
            //必须要选择一个检查分类
            throw new JeecgBootException("必须要选择一个检查分类！");
        }
        EamTechnicalStatusEvaluationStandard entity = this.getBaseMapper().selectById(request.getId());
        if (entity == null) {
            throw new JeecgBootException("编辑的数据已删除，请刷新重试！");
        }
        entity.setStandardName(request.getStandardName());
        entity.setEvaluationPeriod(request.getEvaluationPeriod());
        entity.setHasOtherCheck(request.getHasOtherCheck());
        entity.setHasPrecisionCheck(request.getHasPrecisionCheck());
        entity.setHasSafetyEquipmentCheck(request.getHasSafetyEquipmentCheck());
        entity.setRemark(request.getRemark());
        this.getBaseMapper().updateById(entity);
        //处理详情
        if (CollectionUtil.isNotEmpty(request.getTableDetailList())) {
            //先删除检查项
            standardDetailService.removeByStandardId(entity.getId());
            request.getTableDetailList().forEach(tableDetail -> {
                tableDetail.setStandardId(entity.getId());
            });
            //根据分类判断是否保存
            if (CommonConstant.STATUS_1.equals(entity.getHasOtherCheck())) {
                //保存其他分类
                List<EamTechnicalStatusEvaluationStandardDetail> collect = request.getTableDetailList().stream().filter(item -> TechnicalStatusEvaluationCheckCategoryEnum.OTHER_CHECK.name().equals(item.getCheckCategory())).collect(Collectors.toList());
                if (CollectionUtils.isEmpty(collect)) {
                    throw new JeecgBootException("其他检查明细不能为空！");
                }
                standardDetailService.saveBatch(collect);
            }
            if (CommonConstant.STATUS_1.equals(entity.getHasSafetyEquipmentCheck())) {
                //保存安全装置分类
                List<EamTechnicalStatusEvaluationStandardDetail> collect = request.getTableDetailList().stream().filter(item -> TechnicalStatusEvaluationCheckCategoryEnum.SAFETY_EQUIPMENT_CHECK.name().equals(item.getCheckCategory())).collect(Collectors.toList());
                if (CollectionUtils.isEmpty(collect)) {
                    throw new JeecgBootException("安全装置检查明细不能为空！");
                }
                standardDetailService.saveBatch(collect);
            }
            if (CommonConstant.STATUS_1.equals(entity.getHasPrecisionCheck())) {
                //保存精度检验分类
                List<EamTechnicalStatusEvaluationStandardDetail> collect = request.getTableDetailList().stream().filter(item -> TechnicalStatusEvaluationCheckCategoryEnum.PRECISION_CHECK.name().equals(item.getCheckCategory())).collect(Collectors.toList());
                if (CollectionUtils.isEmpty(collect)) {
                    throw new JeecgBootException("精度检查明细不能为空！");
                }
                standardDetailService.saveBatch(collect);
            }
        }
        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean upgrade(EamTechnicalStatusEvaluationStandardRequest request) {
        if (!CommonConstant.STATUS_1.equals(request.getHasOtherCheck()) && !CommonConstant.STATUS_1.equals(request.getHasSafetyEquipmentCheck()) && !CommonConstant.STATUS_1.equals(request.getHasPrecisionCheck())) {
            //必须要选择一个检查分类
            throw new JeecgBootException("必须要选择一个检查分类！");
        }
        EamTechnicalStatusEvaluationStandard entity = this.getBaseMapper().selectById(request.getId());
        if (entity == null) {
            throw new JeecgBootException("升版的数据已删除，请刷新重试！");
        }

        //新增一个版本
        EamTechnicalStatusEvaluationStandard newEntity = new EamTechnicalStatusEvaluationStandard();
        newEntity.setStandardCode(request.getStandardCode());
        newEntity.setStandardName(request.getStandardName());
        newEntity.setEvaluationPeriod(request.getEvaluationPeriod());
        newEntity.setStandardStatus(TechnicalStatusEvaluationStandardStatusEnum.ENABLE.name());
        //版本递增
        newEntity.setStandardVersion(SimpleVersionGenerateUtil.addVersion(entity.getStandardVersion()));
        //设备处理
        newEntity.setEquipmentId(request.getEquipmentId());
        newEntity.setHasOtherCheck(request.getHasOtherCheck());
        newEntity.setHasPrecisionCheck(request.getHasPrecisionCheck());
        newEntity.setHasSafetyEquipmentCheck(request.getHasSafetyEquipmentCheck());
        //删除标记
        newEntity.setDelFlag(CommonConstant.DEL_FLAG_0);
        newEntity.setRemark(request.getRemark());
        //重复性校验
        EamTechnicalStatusEvaluationStandard exist = checkDuplicate(newEntity.getEquipmentId(), entity.getId());
        if (exist != null) {
            throw new JeecgBootException("鉴定规范已存在，不能重复添加！");
        }
        this.getBaseMapper().insert(newEntity);
        //处理明细数据
        if (CollectionUtil.isNotEmpty(request.getTableDetailList())) {
            request.getTableDetailList().forEach(tableDetail -> {
                tableDetail.setId(null);
                tableDetail.setCreateBy(null);
                tableDetail.setUpdateBy(null);
                tableDetail.setCreateTime(null);
                tableDetail.setUpdateTime(null);
                tableDetail.setStandardId(newEntity.getId());
            });
            //根据分类判断是否保存
            if (CommonConstant.STATUS_1.equals(entity.getHasOtherCheck())) {
                //保存其他分类
                List<EamTechnicalStatusEvaluationStandardDetail> collect = request.getTableDetailList().stream().filter(item -> TechnicalStatusEvaluationCheckCategoryEnum.OTHER_CHECK.name().equals(item.getCheckCategory())).collect(Collectors.toList());
                if (CollectionUtils.isEmpty(collect)) {
                    throw new JeecgBootException("其他检查明细不能为空！");
                }
                standardDetailService.saveBatch(collect);
            }
            if (CommonConstant.STATUS_1.equals(entity.getHasSafetyEquipmentCheck())) {
                //保存安全装置分类
                List<EamTechnicalStatusEvaluationStandardDetail> collect = request.getTableDetailList().stream().filter(item -> TechnicalStatusEvaluationCheckCategoryEnum.SAFETY_EQUIPMENT_CHECK.name().equals(item.getCheckCategory())).collect(Collectors.toList());
                if (CollectionUtils.isEmpty(collect)) {
                    throw new JeecgBootException("安全装置检查明细不能为空！");
                }
                standardDetailService.saveBatch(collect);
            }
            if (CommonConstant.STATUS_1.equals(entity.getHasPrecisionCheck())) {
                //保存精度检验分类
                List<EamTechnicalStatusEvaluationStandardDetail> collect = request.getTableDetailList().stream().filter(item -> TechnicalStatusEvaluationCheckCategoryEnum.PRECISION_CHECK.name().equals(item.getCheckCategory())).collect(Collectors.toList());
                if (CollectionUtils.isEmpty(collect)) {
                    throw new JeecgBootException("精度检查明细不能为空！");
                }
                standardDetailService.saveBatch(collect);
            }
        }
        //禁用原来的版本
        entity.setStandardStatus(TechnicalStatusEvaluationStandardStatusEnum.DISABLE.name());
        this.getBaseMapper().updateById(entity);
        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result<?> importSafetyEquipmentCheck(MultipartFile file) {
        String fileName = file.getOriginalFilename();
        if (StringUtils.isBlank(fileName)) {
            return Result.error(fileName + ":文件格式错误,无法解析！");
        }
        String fileSuffix = FileUtil.getFileSuffix(fileName);
        //只支持 .docx 的word文档
        if ("docx".equals(fileSuffix)) {
            try (XWPFDocument doc = new XWPFDocument(file.getInputStream())) {
                List<XWPFParagraph> paragraphs = doc.getParagraphs();
                List<XWPFTable> tables = doc.getTables();
                if (CollectionUtil.isEmpty(paragraphs) || CollectionUtil.isEmpty(tables)) {
                    return Result.error(fileName + ":此文件不符合安全装置检查模板规范，请检查！");
                }
                //获取文件标题
                StringBuilder builder = new StringBuilder();
                paragraphs.forEach(paragraph -> {
                    if (StringUtils.isNotBlank(paragraph.getText())) {
                        builder.append(paragraph.getText().trim());
                    }
                });
                if (checkImportCategory(builder.toString(), TechnicalStatusEvaluationCheckCategoryEnum.SAFETY_EQUIPMENT_CHECK)) {
                    return Result.error(fileName + ":此文件不符合安全装置检查模板规范，请检查！");
                }
                //获取设备信息
                EamEquipment equipment = extractEquipmentInfo(tables.get(0));
                //查看是否有此设备启用的规范信息
                EamTechnicalStatusEvaluationStandard originalStandard = checkDuplicate(equipment.getId(), null);
                if (originalStandard != null && TechnicalStatusEvaluationStandardStatusEnum.ENABLE.name().equals(originalStandard.getStandardStatus())) {
                    return Result.error(fileName + ":此设备已存在启用的规范，请进行编辑或升版！");
                }
                //获取检查项信息
                List<EamTechnicalStatusEvaluationStandardDetail> detailList = extractSafetyEquipmentCheckItems(tables);
                if(CollectionUtil.isEmpty(detailList)){
                    return Result.error(fileName + ":未解析到检查项内容，请检查！");
                }
                if(originalStandard != null) {
                    //已存在技术状态鉴定规范,且规范状态为已提交
                    originalStandard.setHasSafetyEquipmentCheck(CommonConstant.STATUS_1);
                    originalStandard.setStandardStatus(TechnicalStatusEvaluationStandardStatusEnum.WAIT_SUBMIT.name());
                    super.getBaseMapper().updateById(originalStandard);
                    detailList.forEach(standardDetail -> {
                        standardDetail.setStandardId(originalStandard.getId());
                    });
                    //先删除，后添加
                    standardDetailService.removeByStandardIdAndCategory(originalStandard.getId(), TechnicalStatusEvaluationCheckCategoryEnum.SAFETY_EQUIPMENT_CHECK.name());
                    //重新添加
                    standardDetailService.saveBatch(detailList);
                }else {
                    String codeSeq = businessCodeRuleService.generateBusinessCodeSeq(BusinessCodeConst.TECHNICAL_STATUS_EVALUATION_STANDARD_CODE_RULE);
                    //新增技术状态鉴定规范
                    EamTechnicalStatusEvaluationStandardRequest request = new EamTechnicalStatusEvaluationStandardRequest();
                    request.setEquipmentId(equipment.getId());
                    request.setHasSafetyEquipmentCheck(CommonConstant.STATUS_1);
                    request.setHasOtherCheck(CommonConstant.STATUS_0);
                    request.setHasPrecisionCheck(CommonConstant.STATUS_0);
                    request.setStandardCode(codeSeq);
                    request.setStandardName(equipment.getEquipmentName() + "技术状态鉴定规范");
                    request.setTableDetailList(detailList);
                    this.addEamTechnicalStatusEvaluationStandard(request);
                }
            } catch (Exception e) {
                log.error(e.getMessage(), e);
                return Result.error(fileName + ":" + e.getMessage() + "！");
            }
        } else {
            return Result.error(fileName + ":文件格式错误,无法解析！");
        }

        return Result.OK(fileName + ":导入成功！");
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result<?> importPrecisionCheck(MultipartFile file) {
        String fileName = file.getOriginalFilename();
        if (StringUtils.isBlank(fileName)) {
            return Result.error(fileName + ":文件格式错误,无法解析！");
        }
        String fileSuffix = FileUtil.getFileSuffix(fileName);
        //只支持 .docx 的word文档
        if ("docx".equals(fileSuffix)) {
            try (XWPFDocument doc = new XWPFDocument(file.getInputStream())) {
                List<XWPFParagraph> paragraphs = doc.getParagraphs();
                List<XWPFTable> tables = doc.getTables();
                if (CollectionUtil.isEmpty(paragraphs) || CollectionUtil.isEmpty(tables)) {
                    return Result.error(fileName + ":此文件不符合设备精度检查模板规范，请检查！");
                }
                //获取文件标题
                StringBuilder builder = new StringBuilder();
                paragraphs.forEach(paragraph -> {
                    if (StringUtils.isNotBlank(paragraph.getText())) {
                        builder.append(paragraph.getText().trim());
                    }
                });
                if (checkImportCategory(builder.toString(), TechnicalStatusEvaluationCheckCategoryEnum.PRECISION_CHECK)) {
                    return Result.error(fileName + ":此文件不符合设备精度检查模板规范，请检查！");
                }
                //获取设备信息
                EamEquipment equipment = extractEquipmentInfo(tables.get(0));
                //查看是否有此设备启用的规范信息
                EamTechnicalStatusEvaluationStandard originalStandard = checkDuplicate(equipment.getId(), null);
                if (originalStandard != null && TechnicalStatusEvaluationStandardStatusEnum.ENABLE.name().equals(originalStandard.getStandardStatus())) {
                    return Result.error(fileName + ":此设备已存在启用的规范，请进行编辑或升版！");
                }
                //获取检查项信息
                List<EamTechnicalStatusEvaluationStandardDetail> detailList = extractPrecisionCheckItems(tables);
                if(CollectionUtil.isEmpty(detailList)){
                    return Result.error(fileName + ":未解析到检查项内容，请检查！");
                }
                if(originalStandard != null) {
                    //已存在技术状态鉴定规范,且规范状态为已提交
                    originalStandard.setHasPrecisionCheck(CommonConstant.STATUS_1);
                    originalStandard.setStandardStatus(TechnicalStatusEvaluationStandardStatusEnum.WAIT_SUBMIT.name());
                    super.getBaseMapper().updateById(originalStandard);
                    detailList.forEach(standardDetail -> {
                        standardDetail.setStandardId(originalStandard.getId());
                    });
                    //先删除，后添加
                    standardDetailService.removeByStandardIdAndCategory(originalStandard.getId(), TechnicalStatusEvaluationCheckCategoryEnum.PRECISION_CHECK.name());
                    //重新添加
                    standardDetailService.saveBatch(detailList);
                }else {
                    String codeSeq = businessCodeRuleService.generateBusinessCodeSeq(BusinessCodeConst.TECHNICAL_STATUS_EVALUATION_STANDARD_CODE_RULE);
                    //新增技术状态鉴定规范
                    EamTechnicalStatusEvaluationStandardRequest request = new EamTechnicalStatusEvaluationStandardRequest();
                    request.setEquipmentId(equipment.getId());
                    request.setHasSafetyEquipmentCheck(CommonConstant.STATUS_0);
                    request.setHasOtherCheck(CommonConstant.STATUS_0);
                    request.setHasPrecisionCheck(CommonConstant.STATUS_1);
                    request.setStandardCode(codeSeq);
                    request.setStandardName(equipment.getEquipmentName() + "技术状态鉴定规范");
                    request.setTableDetailList(detailList);
                    this.addEamTechnicalStatusEvaluationStandard(request);
                }
            } catch (Exception e) {
                log.error(e.getMessage(), e);
                return Result.error(fileName + ":" + e.getMessage() + "！");
            }
        } else {
            return Result.error(fileName + ":文件格式错误,无法解析！");
        }

        return Result.OK(fileName + ":导入成功！");
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result<?> importOtherCheck(MultipartFile file) {
        String fileName = file.getOriginalFilename();
        if (StringUtils.isBlank(fileName)) {
            return Result.error(fileName + ":文件格式错误,无法解析！");
        }
        String fileSuffix = FileUtil.getFileSuffix(fileName);
        //只支持 .docx 的word文档
        if ("docx".equals(fileSuffix)) {
            try (XWPFDocument doc = new XWPFDocument(file.getInputStream())) {
                List<XWPFParagraph> paragraphs = doc.getParagraphs();
                List<XWPFTable> tables = doc.getTables();
                if (CollectionUtil.isEmpty(paragraphs) || CollectionUtil.isEmpty(tables)) {
                    return Result.error(fileName + ":此文件不符合安全装置检查模板规范，请检查！");
                }
                //获取文件标题
                StringBuilder builder = new StringBuilder();
                paragraphs.forEach(paragraph -> {
                    if (StringUtils.isNotBlank(paragraph.getText())) {
                        builder.append(paragraph.getText().trim());
                    }
                });
                if (checkImportCategory(builder.toString(), TechnicalStatusEvaluationCheckCategoryEnum.OTHER_CHECK)) {
                    return Result.error(fileName + ":此文件不符合其他检查模板规范，请检查！");
                }
                //获取设备信息
                EamEquipment equipment = extractEquipmentInfo(tables.get(0));
                //查看是否有此设备启用的规范信息
                EamTechnicalStatusEvaluationStandard originalStandard = checkDuplicate(equipment.getId(), null);
                if (originalStandard != null && TechnicalStatusEvaluationStandardStatusEnum.ENABLE.name().equals(originalStandard.getStandardStatus())) {
                    return Result.error(fileName + ":此设备已存在启用的规范，请进行编辑或升版！");
                }
                //获取检查项信息
                List<EamTechnicalStatusEvaluationStandardDetail> detailList = extractOtherCheckItems(tables);
                if(CollectionUtil.isEmpty(detailList)){
                    return Result.error(fileName + ":未解析到检查项内容，请检查！");
                }
                if(originalStandard != null) {
                    //已存在技术状态鉴定规范,且规范状态为已提交
                    originalStandard.setHasOtherCheck(CommonConstant.STATUS_1);
                    originalStandard.setStandardStatus(TechnicalStatusEvaluationStandardStatusEnum.WAIT_SUBMIT.name());
                    super.getBaseMapper().updateById(originalStandard);
                    detailList.forEach(standardDetail -> {
                        standardDetail.setStandardId(originalStandard.getId());
                    });
                    //先删除，后添加
                    standardDetailService.removeByStandardIdAndCategory(originalStandard.getId(), TechnicalStatusEvaluationCheckCategoryEnum.OTHER_CHECK.name());
                    //重新添加
                    standardDetailService.saveBatch(detailList);
                }else {
                    String codeSeq = businessCodeRuleService.generateBusinessCodeSeq(BusinessCodeConst.TECHNICAL_STATUS_EVALUATION_STANDARD_CODE_RULE);
                    //新增技术状态鉴定规范
                    EamTechnicalStatusEvaluationStandardRequest request = new EamTechnicalStatusEvaluationStandardRequest();
                    request.setEquipmentId(equipment.getId());
                    request.setHasSafetyEquipmentCheck(CommonConstant.STATUS_0);
                    request.setHasOtherCheck(CommonConstant.STATUS_1);
                    request.setHasPrecisionCheck(CommonConstant.STATUS_0);
                    request.setStandardCode(codeSeq);
                    request.setStandardName(equipment.getEquipmentName() + "技术状态鉴定规范");
                    request.setTableDetailList(detailList);
                    this.addEamTechnicalStatusEvaluationStandard(request);
                }
            } catch (Exception e) {
                log.error(e.getMessage(), e);
                return Result.error(fileName + ":" + e.getMessage() + "！");
            }
        } else {
            return Result.error(fileName + ":文件格式错误,无法解析！");
        }

        return Result.OK(fileName + ":导入成功！");
    }

    @Override
    public List<EamTechnicalStatusEvaluationStandard> queryListByKeyword(String keyword, String equipmentId, Integer pageSize) {
        Page<EamTechnicalStatusEvaluationStandard> page = new Page<>(1, pageSize);
        EamTechnicalStatusEvaluationStandard query = new EamTechnicalStatusEvaluationStandard();
        query.setEquipmentId(equipmentId);
        query.setKeyword(keyword);
        query.setStandardStatus(TechnicalStatusEvaluationStandardStatusEnum.ENABLE.name());
        IPage<EamTechnicalStatusEvaluationStandard> pageData = this.queryPageList(page, query);
        return pageData.getRecords();
    }

    @Override
    public EamTechnicalStatusEvaluationStandard queryEnableStandard(String equipmentId) {
        LambdaQueryWrapper<EamTechnicalStatusEvaluationStandard> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(EamTechnicalStatusEvaluationStandard::getEquipmentId, equipmentId);
        queryWrapper.eq(EamTechnicalStatusEvaluationStandard::getDelFlag, CommonConstant.DEL_FLAG_0);
        //启用状态
        queryWrapper.eq(EamTechnicalStatusEvaluationStandard::getStandardStatus, TechnicalStatusEvaluationStandardStatusEnum.ENABLE.name());
        queryWrapper.orderByDesc(EamTechnicalStatusEvaluationStandard::getStandardVersion);
        List<EamTechnicalStatusEvaluationStandard> list = this.getBaseMapper().selectList(queryWrapper);
        if (CollectionUtil.isEmpty(list)) {
            return null;
        }
        return list.get(0);
    }

    /**
     * 检查导入文件分类是否匹配
     * @param title 标题段落字符串
     * @param category 分类
     * @return true 不匹配， false  匹配
     */
    private boolean checkImportCategory(String title, TechnicalStatusEvaluationCheckCategoryEnum category) {
        switch (category) {
            case SAFETY_EQUIPMENT_CHECK:
                return !title.contains("安全装置检查");
            case PRECISION_CHECK:
                return !title.contains("精度检查单");
            case OTHER_CHECK:
                return !title.contains("其他检查");
        }
        return true;
    }


    /**
     * 提取设备基本信息
     */
    private EamEquipment extractEquipmentInfo(XWPFTable table) {
        if (table.getNumberOfRows() < 4) {
            //如果 table 小于4行 代表不符合模板规范，导入失败
            throw new JeecgBootException("此文件不符合安全装置检查模板规范，请检查");
        }
        // 提取第二行数据
        Map<String, String> row2Data = extractHeadRowData(table.getRow(1));
        //获取设备统一编码
        String equipmentCode = row2Data.get("统一编号") == null ? null : row2Data.get("统一编号").trim();
        EamEquipment eamEquipment = equipmentService.selectByEquipmentCode(equipmentCode);
        if (eamEquipment == null) {
            throw new JeecgBootException("未找到设备信息，请查看设备台账是否有此设备");
        }
        return eamEquipment;
    }

    /**
     * 表格表头数据解析
     */
    private Map<String, String> extractHeadRowData(XWPFTableRow row) {
        Map<String, String> data = new HashMap<>();
        if(CollectionUtil.isEmpty(row.getTableCells()) || row.getTableCells().size() != 4) {
            throw new JeecgBootException("此文件不符合安全装置检查模板规范，请检查");
        }
        int cellCount = row.getTableCells().size();
        for (int i = 0; i < cellCount; i += 2) {
            String key = row.getCell(i).getText().trim();
            String value = row.getCell(i + 1).getText().trim();
            if (StringUtils.isNotBlank(key) && StringUtils.isNotBlank(value)) {
                data.put(key, value);
            }
        }
        return data;
    }

    /**
     * 提取安全装置检查明细
     */
    private List<EamTechnicalStatusEvaluationStandardDetail> extractSafetyEquipmentCheckItems(List<XWPFTable> tableList) {
        List<EamTechnicalStatusEvaluationStandardDetail> items = new ArrayList<>();
        EamTechnicalStatusEvaluationStandardDetail item = null;
        //解析第一个表格，带设备信息
        XWPFTable table = tableList.get(0);
        for (int i = 0; i < table.getNumberOfRows(); i++) {
            XWPFTableRow row = table.getRow(i);
            if (row == null || CollectionUtil.isEmpty(row.getTableCells()) || row.getTableCells().size() < 2) {
                //读取到空row值
                continue;
            }
            //检查是否到检查项序号
            String firstCell = row.getCell(0).getText().trim();
            Integer itemCode = null;
            try {
                itemCode = Integer.parseInt(firstCell);
            } catch (NumberFormatException e) {
                //不是检查项内容，跳过此行
                continue;
            }
            //获取第二个单元格
            String secondCell = row.getCell(1).getText().trim();
            //如果这一行为序号则解析整行
            if (StringUtils.isNotBlank(secondCell)) {
                item = new EamTechnicalStatusEvaluationStandardDetail();
                item.setItemCode(itemCode);
                item.setItemName(secondCell);
                item.setCheckCategory(TechnicalStatusEvaluationCheckCategoryEnum.SAFETY_EQUIPMENT_CHECK.name());
                items.add(item);
            }
        }
        return items;
    }

    /**
     * 提取其他检查项明细内容
     * @param tables
     * @return
     */
    private List<EamTechnicalStatusEvaluationStandardDetail> extractOtherCheckItems(List<XWPFTable> tables) {
        List<EamTechnicalStatusEvaluationStandardDetail> items = new ArrayList<>();
        EamTechnicalStatusEvaluationStandardDetail item = null;
        //解析第一个表格，带设备信息
        XWPFTable table = tables.get(0);
        for (int i = 0; i < table.getNumberOfRows(); i++) {
            XWPFTableRow row = table.getRow(i);
            if (row == null || CollectionUtil.isEmpty(row.getTableCells()) || row.getTableCells().size() < 2) {
                //读取到空row值
                continue;
            }
            //检查是否到检查项序号
            String firstCell = row.getCell(0).getText().trim();
            Integer itemCode = null;
            try {
                itemCode = Integer.parseInt(firstCell);
            } catch (NumberFormatException e) {
                //不是检查项内容，跳过此行
                continue;
            }
            //获取第二个单元格
            String secondCell = row.getCell(1).getText().trim();
            //如果这一行为序号则解析整行
            if (StringUtils.isNotBlank(secondCell)) {
                item = new EamTechnicalStatusEvaluationStandardDetail();
                item.setItemCode(itemCode);
                item.setItemName(secondCell);
                item.setCheckCategory(TechnicalStatusEvaluationCheckCategoryEnum.OTHER_CHECK.name());
                items.add(item);
            }
        }
        return items;
    }

    private List<EamTechnicalStatusEvaluationStandardDetail> extractPrecisionCheckItems(List<XWPFTable> tables) {
        List<EamTechnicalStatusEvaluationStandardDetail> items = new ArrayList<>();
        EamTechnicalStatusEvaluationStandardDetail item = null;
        //解析第一个表格，带设备信息
        XWPFTable table = tables.get(0);
        for (int i = 0; i < table.getNumberOfRows(); i++) {
            XWPFTableRow row = table.getRow(i);
            if (row == null || CollectionUtil.isEmpty(row.getTableCells()) || row.getTableCells().size() < 2) {
                //读取到空row值
                continue;
            }
            //检查是否到检查项序号
            String firstCell = row.getCell(0).getText().trim();
            Integer itemCode = null;
            try {
                itemCode = Integer.parseInt(firstCell);
            } catch (NumberFormatException e) {
                //不是检查项内容，跳过此行
                if(item == null) {
                    continue;
                }else {
                    itemCode = item.getItemCode();
                }
            }
            //获取第二个单元格
            String itemName = row.getCell(1).getText().trim();
            if(StringUtils.isBlank(itemName)) {
                if(item != null) {
                    itemName = item.getItemName();
                }else {
                    continue;
                }
            }
            String subItemName = null;
            String toleranceValue = null;
            if(row.getTableCells().size() == 4) {
                toleranceValue = row.getCell(2).getText().trim();
            }else if(row.getTableCells().size() == 5) {
                subItemName = row.getCell(2).getText().trim();
                toleranceValue = row.getCell(3).getText().trim();
            }else {
                continue;
            }
            if(StringUtils.isBlank(toleranceValue)) {
               //允差值不存在，跳过
               if(item != null) {
                   toleranceValue = item.getToleranceValue();
               }else {
                   continue;
               }
            }
            //拼装明细数据
            item = new EamTechnicalStatusEvaluationStandardDetail();
            item.setItemCode(itemCode);
            item.setItemName(itemName);
            item.setSubItemName(subItemName);
            item.setToleranceValue(toleranceValue);
            item.setCheckCategory(TechnicalStatusEvaluationCheckCategoryEnum.PRECISION_CHECK.name());
            items.add(item);
        }
        return items;
    }

}