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

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
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 com.jeecg.weibo.exception.BusinessException;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.ss.usermodel.*;
import org.apache.shiro.SecurityUtils;
import org.flowable.engine.TaskService;
import org.flowable.task.api.Task;
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.modules.eam.base.entity.BaseFactory;
import org.jeecg.modules.eam.base.entity.BaseFactoryUser;
import org.jeecg.modules.eam.base.service.IBaseFactoryService;
import org.jeecg.modules.eam.base.service.IBaseFactoryUserService;
import org.jeecg.modules.eam.constant.BusinessCodeConst;
import org.jeecg.modules.eam.constant.MaintenanceStandardStatusEnum;
import org.jeecg.modules.eam.entity.EamEquipment;
import org.jeecg.modules.eam.entity.EamMaintenanceStandard;
import org.jeecg.modules.eam.entity.EamMaintenanceStandardDetail;
import org.jeecg.modules.eam.mapper.EamMaintenanceStandardMapper;
import org.jeecg.modules.eam.request.EamMaintenanceStandardRequest;
import org.jeecg.modules.eam.service.IEamEquipmentService;
import org.jeecg.modules.eam.service.IEamMaintenanceStandardDetailService;
import org.jeecg.modules.eam.service.IEamMaintenanceStandardService;
import org.jeecg.modules.eam.vo.*;
import org.jeecg.modules.flowable.apithird.business.entity.FlowMyBusiness;
import org.jeecg.modules.flowable.apithird.business.service.IFlowMyBusinessService;
import org.jeecg.modules.flowable.apithird.service.FlowCallBackServiceI;
import org.jeecg.modules.flowable.apithird.service.FlowCommonService;
import org.jeecg.modules.flowable.service.IFlowDefinitionService;
import org.jeecg.modules.flowable.service.IFlowTaskService;
import org.jeecg.modules.system.service.ISysUserService;
import org.jeecg.modules.system.vo.UserSelector;
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 javax.annotation.Resource;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * @Description: 保养标准
 * @Author: jeecg-boot
 * @Date:   2025-03-26
 * @Version: V1.0
 */
@Service("IEamMaintenanceStandardService")
public class EamMaintenanceStandardServiceImpl extends ServiceImpl<EamMaintenanceStandardMapper, EamMaintenanceStandard> implements IEamMaintenanceStandardService , FlowCallBackServiceI {

    @Resource
    private EamMaintenanceStandardMapper eamMaintenanceStandardMapper;
    @Autowired
    private IEamMaintenanceStandardDetailService eamMaintenanceStandardDetailService;
    @Autowired
    private IBaseFactoryUserService baseFactoryUserService;
    @Autowired
    private IBaseFactoryService baseFactoryService;
    @Resource
    private FlowCommonService flowCommonService;
    @Resource
    private IFlowDefinitionService flowDefinitionService;
    @Autowired
    private IFlowTaskService flowTaskService;
    @Autowired
    private TaskService taskService;
    @Autowired
    private IFlowMyBusinessService flowMyBusinessService;
    @Autowired
    private ISysUserService sysUserService;
    @Autowired
    private IEamEquipmentService eamEquipmentService;
    @Override
    public IPage<EamMaintenanceStandard> queryPageList(Page<EamMaintenanceStandard> page, EamMaintenanceStandard eamMaintenanceStandard) {
        QueryWrapper<EamMaintenanceStandard> 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)){
                List<String> factoryIds = baseFactoryUserList.stream().map(BaseFactoryUser::getFactoryId).collect(Collectors.toList());
                List<String> factoryCode= baseFactoryService.listByIds(factoryIds).stream().map(BaseFactory::getFactoryCode).collect(Collectors.toList());
                queryWrapper.in("e.factory_code", factoryCode);
            }
        }
        if(eamMaintenanceStandard != null) {
            //编码 模糊查询
            if(StringUtils.isNotBlank(eamMaintenanceStandard.getStandardCode())) {
                queryWrapper.like("ems.standard_code", eamMaintenanceStandard.getStandardCode());
            }
            //名称 模糊查询
            if(StringUtils.isNotBlank(eamMaintenanceStandard.getStandardName())) {
                queryWrapper.like("ems.standard_name", eamMaintenanceStandard.getStandardName());
            }
            //设备
            if(StringUtils.isNotBlank(eamMaintenanceStandard.getEquipmentId())) {
                queryWrapper.eq("ems.equipment_id", eamMaintenanceStandard.getEquipmentId());
            }
            //保养分类
            if(StringUtils.isNotBlank(eamMaintenanceStandard.getMaintenanceCategory())) {
                queryWrapper.eq("ems.maintenance_category", eamMaintenanceStandard.getMaintenanceCategory());
            }
            //保养分类
            if(StringUtils.isNotBlank(eamMaintenanceStandard.getStandardStatus())) {
                queryWrapper.eq("ems.standard_status", eamMaintenanceStandard.getStandardStatus());
            }
            //设备编码
            if(StringUtils.isNotBlank(eamMaintenanceStandard.getKeyword())) {
                queryWrapper.and(wrapper -> wrapper.like("e.equipment_name", eamMaintenanceStandard.getKeyword())
                        .or()
                        .like("e.equipment_code", eamMaintenanceStandard.getKeyword()));
            }
            //id
            if(StringUtils.isNotBlank(eamMaintenanceStandard.getId())) {
                queryWrapper.eq("ems.id", eamMaintenanceStandard.getId());
            }
        }
        queryWrapper.orderByDesc("ems.create_time");
        return eamMaintenanceStandardMapper.queryPageList(page, queryWrapper);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean addMaintenanceStandard(EamMaintenanceStandardRequest standardRequest) {
        EamMaintenanceStandard entity = new EamMaintenanceStandard();
        BeanUtils.copyProperties(standardRequest, entity);
        entity.setStandardStatus(MaintenanceStandardStatusEnum.WAIT_SUBMIT.name());
        //版本递增
        entity.setStandardVersion("v"+CommonConstant.OPERATE_TYPE_1);
        //设备处理
        entity.setEquipmentId(standardRequest.getEquipmentId());
        //删除标记
        entity.setDelFlag(CommonConstant.DEL_FLAG_0);
        //重复性校验
        EamMaintenanceStandard exist = checkDuplicate(entity.getEquipmentId(), entity.getMaintenanceCategory());
        if(exist != null){
            throw new JeecgBootException("设备标准已存在，不能重复添加！");
        }
        eamMaintenanceStandardMapper.insert(entity);
        //处理明细数据
        if(CollectionUtil.isNotEmpty(standardRequest.getTableDetailList())) {
            standardRequest.getTableDetailList().forEach(tableDetail -> {
                tableDetail.setStandardId(entity.getId());
            });
            eamMaintenanceStandardDetailService.saveBatch(standardRequest.getTableDetailList());
        }
        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean editMaintenanceStandard(EamMaintenanceStandardRequest standardRequest) {
        EamMaintenanceStandard entity = eamMaintenanceStandardMapper.selectById(standardRequest.getId());
        if(entity == null){
            throw new JeecgBootException("编辑的数据已删除，请刷新重试！");
        }
        entity.setStandardName(standardRequest.getStandardName());
        entity.setMaintenancePeriod(standardRequest.getMaintenancePeriod());
        eamMaintenanceStandardMapper.updateById(entity);
        //处理详情
        if(CollectionUtil.isNotEmpty(standardRequest.getTableDetailList())) {
            List<EamMaintenanceStandardDetail> addList = new ArrayList<>();
            List<EamMaintenanceStandardDetail> updateList = new ArrayList<>();
            standardRequest.getTableDetailList().forEach(tableDetail -> {
                tableDetail.setStandardId(entity.getId());
                if(tableDetail.getId() == null){
                    addList.add(tableDetail);
                }else {
                    updateList.add(tableDetail);
                }
            });
            if(CollectionUtil.isNotEmpty(addList)){
                eamMaintenanceStandardDetailService.saveBatch(addList);
            }
            if(CollectionUtil.isNotEmpty(updateList)){
                eamMaintenanceStandardDetailService.updateBatchById(updateList);
            }
        }
        if(CollectionUtil.isNotEmpty(standardRequest.getRemoveDetailList())) {
            List<String> ids = standardRequest.getRemoveDetailList().stream().map(EamMaintenanceStandardDetail::getId).collect(Collectors.toList());
            eamMaintenanceStandardDetailService.removeBatchByIds(ids);
        }
        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean upgradeMaintenanceStandard(EamMaintenanceStandardRequest standardRequest) {
        EamMaintenanceStandard entity = eamMaintenanceStandardMapper.selectById(standardRequest.getId());
        if(entity == null){
            throw new JeecgBootException("编辑的数据已删除，请刷新重试！");
        }

        //新增一个版本
        EamMaintenanceStandard newEntity = new EamMaintenanceStandard();
        newEntity.setStandardCode(standardRequest.getStandardCode());
        newEntity.setStandardName(standardRequest.getStandardName());
        newEntity.setMaintenanceCategory(standardRequest.getMaintenanceCategory());
        newEntity.setMaintenancePeriod(standardRequest.getMaintenancePeriod());
        newEntity.setInitialDate(standardRequest.getInitialDate());
        newEntity.setStandardStatus(MaintenanceStandardStatusEnum.WAIT_SUBMIT.name());
        //版本递增
        //获取数字
        Pattern pattern = Pattern.compile("(\\d+)(?:\\.\\d+)*$");
        Matcher matcher = pattern.matcher(entity.getStandardVersion());
        if (matcher.find()) {
            try {
                int mainVersion = Integer.parseInt(matcher.group(1));
                newEntity.setStandardVersion("v"+(mainVersion+1));
            } catch (NumberFormatException ignored) {
            }
        }
        //设备处理
        newEntity.setEquipmentId(standardRequest.getEquipmentId());
        //删除标记
        newEntity.setDelFlag(CommonConstant.DEL_FLAG_0);
        //重复性校验
        EamMaintenanceStandard exist = checkDuplicate(newEntity.getEquipmentId(), newEntity.getMaintenanceCategory());
        if(exist != null){
            throw new JeecgBootException("设备标准已存在，不能重复添加！");
        }
        eamMaintenanceStandardMapper.insert(newEntity);
        //处理明细数据
        if(CollectionUtil.isNotEmpty(standardRequest.getTableDetailList())) {
            standardRequest.getTableDetailList().forEach(tableDetail -> {
                tableDetail.setId(null);
                tableDetail.setCreateBy(null);
                tableDetail.setUpdateBy(null);
                tableDetail.setCreateTime(null);
                tableDetail.setUpdateTime(null);
                tableDetail.setStandardId(newEntity.getId());
            });
            eamMaintenanceStandardDetailService.saveBatch(standardRequest.getTableDetailList());
        }
        return true;
    }

    @Override
    public EamMaintenanceStandard checkDuplicate(String equipmentId, String maintenanceCategory) {
        LambdaQueryWrapper<EamMaintenanceStandard> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(EamMaintenanceStandard::getEquipmentId, equipmentId);
        queryWrapper.eq(EamMaintenanceStandard::getMaintenanceCategory, maintenanceCategory);
        queryWrapper.eq(EamMaintenanceStandard::getDelFlag, CommonConstant.DEL_FLAG_0);
        queryWrapper.eq(EamMaintenanceStandard::getStandardStatus, MaintenanceStandardStatusEnum.WAIT_SUBMIT.name());
        queryWrapper.orderByDesc(EamMaintenanceStandard::getStandardVersion);

        List<EamMaintenanceStandard> list = eamMaintenanceStandardMapper.selectList(queryWrapper);
        if(CollectionUtil.isEmpty(list)) {
            return null;
        }
        return list.get(0);
    }

    /**
     * 查询标准列表-前端展示该用户拥有的标准
     * @param keyword 设备编号
     * @param maintenanceCategory 保养类型
     * @return
     */
    @Override
    public List<EamMaintenanceStandard> queryListByKeywordAndCategory(String keyword, String equipmentId, Integer pageSize, String maintenanceCategory){
        Page<EamMaintenanceStandard> page = new Page<EamMaintenanceStandard>(1, pageSize);
        EamMaintenanceStandard query = new EamMaintenanceStandard();
        query.setEquipmentId(equipmentId);
        query.setKeyword(keyword);
        query.setMaintenanceCategory(maintenanceCategory);
        query.setStandardStatus(MaintenanceStandardStatusEnum.START.name());
        IPage<EamMaintenanceStandard> pageData = this.queryPageList(page, query);
        return pageData.getRecords();
    }

    @Override
    public List<EamMaintenanceStandard> queryListByCategory(String maintenanceCategory) {
        LambdaQueryWrapper<EamMaintenanceStandard> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(EamMaintenanceStandard::getDelFlag, CommonConstant.DEL_FLAG_0);
        queryWrapper.eq(EamMaintenanceStandard::getMaintenanceCategory, maintenanceCategory);
        queryWrapper.eq(EamMaintenanceStandard::getStandardStatus, MaintenanceStandardStatusEnum.WAIT_SUBMIT.name());
        return eamMaintenanceStandardMapper.selectList(queryWrapper);
    }


    /*流程业务代码--------------------------开始*/

    /**
     * 流程启动,保存对应的数据
     * @param id
     * @return
     */
    @Override
    public Result<?> saveEamMaintenanceStandardProcess(String id){
        LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
        EamMaintenanceStandard maintenanceStandard=this.getById(id);
        if (maintenanceStandard==null){
            return Result.error("未找到对应保养标准");
        }
        System.out.println("保养规范流程：" + maintenanceStandard.getId());
        flowCommonService.initActBusiness(maintenanceStandard.getStandardName()+"规范进行流程审核",
                maintenanceStandard.getId(), "IEamMaintenanceStandardService", "eam_maintenance_standard", null);
        Map<String, Object> variables = new HashMap<>();
        variables.put("dataId", maintenanceStandard.getId());
        variables.put("organization", "保养规范启动流程");
        variables.put("comment", "保养规范启动流程");
        variables.put("proofreading",true);
        Result result= flowDefinitionService.startProcessInstanceByKey("eam_maintenance_standard", variables);
        if (!result.isSuccess()) {
            super.removeById(maintenanceStandard.getId());
        }else {
            maintenanceStandard.setStandardStatus(MaintenanceStandardStatusEnum.WAIT_REPAIR_DIRECTOR.name());
            maintenanceStandard.setDesigner(user.getUsername());
            maintenanceStandard.setDesignTime(new Date());
            eamMaintenanceStandardMapper.updateById(maintenanceStandard);
            //获取flow的流程实例id,设置下一步的处理人员
            List<FlowMyBusiness> businessList = flowMyBusinessService.list(
                    new QueryWrapper<FlowMyBusiness>()
                            .eq("data_id", maintenanceStandard.getId())
            );
            if (businessList.isEmpty()) {
                return Result.error("流程记录不存在");
            }
            FlowMyBusiness flowMyBusiness = businessList.get(0);
            EamEquipment eamEquipment=eamEquipmentService.getById(maintenanceStandard.getEquipmentId());
            BaseFactory baseFactory=baseFactoryService.getOne(new QueryWrapper<BaseFactory>().eq("org_code", eamEquipment.getFactoryOrgCode()));
            List<UserSelector> userSelectorList=sysUserService.selectOperatorFactoryList(eamEquipment.getEquipmentCode(),baseFactory.getId(), BusinessCodeConst.PCR0007);
            if (!CollectionUtils.isEmpty(userSelectorList)) {
                List<String> usernameList=userSelectorList.stream().map(UserSelector::getUsername).collect(Collectors.toList());
                flowMyBusiness.setTodoUsers(JSON.toJSONString(usernameList));
                flowMyBusinessService.updateById(flowMyBusiness);
            }
        }
        return result;
    }

    /**
     * 审批操作
     * @param eamMaintenanceStandardVo
     * @return
     */
    @Override
    public Result<?> auditEamMaintenanceStandard(EamMaintenanceStandardVo eamMaintenanceStandardVo){
        try {
            // 参数校验
            if (StrUtil.isEmpty(eamMaintenanceStandardVo.getTaskId()) || StrUtil.isEmpty(eamMaintenanceStandardVo.getDataId())) {
                return Result.error("参数错误");
            }
            LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
            String userId = user.getId();
            eamMaintenanceStandardVo.setAssignee(user.getUsername());
            if (StrUtil.isEmpty(userId)) {
                return Result.error("未找到对应用户");
            }

            // 数据查询
            EamMaintenanceStandard eamMaintenanceStandard = this.getById(eamMaintenanceStandardVo.getDataId());
            if (eamMaintenanceStandard == null) {
                return Result.error("未找到对应保养标准");
            }

            // 2. 查询流程业务记录（处理空结果）
            List<FlowMyBusiness> businessList = flowMyBusinessService.list(
                    new QueryWrapper<FlowMyBusiness>()
                            .eq("process_instance_id", eamMaintenanceStandardVo.getInstanceId())
            );
            if (businessList.isEmpty()) {
                return Result.error("流程记录不存在");
            }
            FlowMyBusiness flowMyBusiness = businessList.get(0);

            // 3. 校验用户是否为候选处理人
            List<String> todoUsers = JSON.parseArray(flowMyBusiness.getTodoUsers(), String.class);
            if (todoUsers == null || !todoUsers.contains(user.getUsername())) {
                return Result.error("用户无权操作此任务");
            }

            // 4. 认领任务（处理已被认领的情况）
            String taskId = flowMyBusiness.getTaskId();
            Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
            if (task == null) {
                return Result.error("任务不存在或已完成");
            }
            if (task.getAssignee() != null && !task.getAssignee().equals(user.getUsername())) {
                return Result.error("任务已被他人认领");
            }
            taskService.claim(taskId, user.getUsername());

            // 设置流程变量
            Map<String, Object> values = setProcessVariables(eamMaintenanceStandard, userId, eamMaintenanceStandardVo);
            eamMaintenanceStandardVo.setValues(values);
            eamMaintenanceStandardVo.setComment(values.get("comment").toString());
            // 完成流程任务
            Result result = flowTaskService.complete(eamMaintenanceStandardVo);
            if (result.isSuccess()) {
                if (eamMaintenanceStandardVo.getRepairManagerApproveResult() != null) {
                    if (eamMaintenanceStandardVo.getRepairManagerApproveResult().equals("1")){
                        List<FlowMyBusiness> newbusinessList = flowMyBusinessService.list(
                                new QueryWrapper<FlowMyBusiness>()
                                        .eq("process_instance_id", eamMaintenanceStandardVo.getInstanceId()));
                        FlowMyBusiness newflowMyBusiness = newbusinessList.get(0);
                        eamMaintenanceStandard.setStandardStatus(MaintenanceStandardStatusEnum.WAIT_TECHNICAL_DIRECTOR.name());
                        //获取flow的流程实例id,设置下一步的处理人员
                        EamMaintenanceStandard maintenanceStandard=this.getById(eamMaintenanceStandardVo.getDataId());
                        EamEquipment eamEquipment=eamEquipmentService.getById(maintenanceStandard.getEquipmentId());
                        BaseFactory baseFactory=baseFactoryService.getOne(new QueryWrapper<BaseFactory>().eq("org_code", eamEquipment.getFactoryOrgCode()));
                        List<UserSelector> userSelectorList=sysUserService.selectOperatorFactoryList(eamEquipment.getEquipmentCode(),baseFactory.getId(), BusinessCodeConst.PCR0008);
                        if (!CollectionUtils.isEmpty(userSelectorList)) {
                            List<String> usernameList=userSelectorList.stream().map(UserSelector::getUsername).collect(Collectors.toList());
                            newflowMyBusiness.setTodoUsers(JSON.toJSONString(usernameList));
                            flowMyBusinessService.updateById(newflowMyBusiness);
                        }
                    }else {
                        eamMaintenanceStandard.setStandardStatus(MaintenanceStandardStatusEnum.WAIT_SUBMIT.name());
                    }
                    eamMaintenanceStandard.setRepairManager(user.getUsername());
                    eamMaintenanceStandard.setRepairManagerApproveResult(eamMaintenanceStandardVo.getRepairManagerApproveResult());
                    eamMaintenanceStandard.setRepairManagerApproveTime(new Date());
                    eamMaintenanceStandard.setRepairManagerApproveComment(eamMaintenanceStandardVo.getComment());
                }
                if (eamMaintenanceStandardVo.getTechnicalManagerApproveResult() != null) {
                    if (eamMaintenanceStandardVo.getTechnicalManagerApproveResult().equals("1")){
                        eamMaintenanceStandard.setStandardStatus(MaintenanceStandardStatusEnum.START.name());
                        //判断是否进行升版，通过设备编号、保养分类、状态进行筛选
                        EamMaintenanceStandard maintenanceStandard=this.getById(eamMaintenanceStandardVo.getDataId());
                        QueryWrapper<EamMaintenanceStandard> queryWrapper=new QueryWrapper<>();
                        queryWrapper.eq("equipment_id", maintenanceStandard.getEquipmentId());
                        queryWrapper.eq("maintenance_category", maintenanceStandard.getMaintenanceCategory());
                        queryWrapper.eq("standard_status", MaintenanceStandardStatusEnum.START.name());
                        List<EamMaintenanceStandard> list=eamMaintenanceStandardMapper.selectList(queryWrapper);
                        if (!CollectionUtils.isEmpty(list)) {
                            //作废原有
                            for (EamMaintenanceStandard eamMaintenanceStandard1 : list) {
                                eamMaintenanceStandard1.setStandardStatus(MaintenanceStandardStatusEnum.ABOLISH.name());
                                this.updateById(eamMaintenanceStandard1);
                            }
                        }
                    }else {
                        eamMaintenanceStandard.setStandardStatus(MaintenanceStandardStatusEnum.WAIT_SUBMIT.name());
                    }
                    eamMaintenanceStandard.setTechnicalManager(user.getUsername());
                    eamMaintenanceStandard.setTechnicalManagerApproveResult(eamMaintenanceStandardVo.getTechnicalManagerApproveResult());
                    eamMaintenanceStandard.setTechnicalManagerApproveTime(new Date());
                    eamMaintenanceStandard.setTechnicalManagerApproveComment(eamMaintenanceStandardVo.getComment());
                }
                this.updateById(eamMaintenanceStandard);
            } else {
                return result;
            }
            return Result.OK("操作成功");
        } catch (Exception e) {
            return Result.error("操作失败：" + e.getMessage());
        }
    }

    private Map<String, Object> setProcessVariables(EamMaintenanceStandard eamMaintenanceStandard, String userId, EamMaintenanceStandardVo eamMaintenanceStandardVo) {
        Map<String, Object> values = new HashMap<>();
        values.put("dataId", eamMaintenanceStandard.getId());
        values.put("assignee", userId);
        if (eamMaintenanceStandardVo.getRepairManagerApproveResult() != null) {
            values.put("repairManagerApproveResult", eamMaintenanceStandardVo.getRepairManagerApproveResult());
            values.put("organization", eamMaintenanceStandardVo.getRepairManagerApproveComment());
            values.put("comment", eamMaintenanceStandardVo.getRepairManagerApproveComment());
        }
        if (eamMaintenanceStandardVo.getTechnicalManagerApproveResult() != null) {
            values.put("technicalManagerApproveResult", eamMaintenanceStandardVo.getTechnicalManagerApproveResult());
            values.put("organization", eamMaintenanceStandardVo.getTechnicalManagerApproveComment());
            values.put("comment", eamMaintenanceStandardVo.getTechnicalManagerApproveComment());
        }
        return values;
    }


    @Override
    public void afterFlowHandle(FlowMyBusiness business) {
        business.getTaskNameId();//接下来审批的节点
        business.getValues();//前端传进来的参数
        business.getActStatus();
    }

    @Override
    public Object getBusinessDataById(String dataId) {
        return this.getById(dataId);
    }

    @Override
    public Map<String, Object> flowValuesOfTask(String taskNameId, Map<String, Object> values) {
        return null;
    }

    @Override
    public List<String> flowCandidateUsernamesOfTask(String taskNameId, Map<String, Object> values) {
        //业务是否干预流程，业务干预，流程干预，指定人员进行处理
        return null;
    }

    /*流程业务代码--------------------------结束*/


    /*导入文件--------------------------开始*/
    /**
        * 点检表导入入口
    */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result<?> importPointInspectionExcel(MultipartFile file) {
        try (Workbook workbook = WorkbookFactory.create(file.getInputStream())) {
            Sheet sheet = workbook.getSheetAt(0);

            // 提取名称
            String name = extractInspectionTitle(file) + "点检表";

            // 1. 提取设备信息
            EamMaintenanceStandard eamMaintenanceStandard = extractDeviceInfo(sheet);
            if (eamMaintenanceStandard == null) {
                throw new BusinessException("设备信息提取失败");
            }

            eamMaintenanceStandard.setStandardName(name);
            eamMaintenanceStandardMapper.insert(eamMaintenanceStandard);

            // 2. 提取每日点检项目
            List<EamMaintenanceStandardDetail> dailyDetails = extractDailyItems(sheet, eamMaintenanceStandard);

            // 3. 提取周保养项目
            List<EamMaintenanceStandardDetail> weeklyDetails = extractWeeklyItems(sheet, eamMaintenanceStandard);

            // 合并并保存所有项目
            List<EamMaintenanceStandardDetail> allDetails = new ArrayList<>();
            allDetails.addAll(dailyDetails);
            allDetails.addAll(weeklyDetails);

            if (!CollectionUtils.isEmpty(allDetails)) {
                eamMaintenanceStandardDetailService.saveBatch(allDetails);
            }

            return Result.OK("点检表导入成功");

        } catch (Exception e) {
            throw new BusinessException("点检表导入失败: " + e.getMessage());
        }
    }

    /**
        * 提取点检表标题
    */
    private String extractInspectionTitle(MultipartFile file) {
        try (Workbook workbook = WorkbookFactory.create(file.getInputStream())) {
            Sheet sheet = workbook.getSheetAt(0);
            Row firstRow = sheet.getRow(0);

            if (firstRow == null) {
                return "未找到标题";
            }

            Cell firstCell = firstRow.getCell(0);
            if (firstCell == null) {
                return "";
            }

            String title = getCellStringValue(firstCell);
            return extractTextBeforeInspection(title);

        } catch (Exception e) {
            return "";
        }
    }

    /**
        * 提取点检表之前的文字
     */
    private String extractTextBeforeInspection(String title) {
        if (StringUtils.isBlank(title)) {
            return "";
        }

        int index = title.indexOf("点检表");
        return index > 0 ? title.substring(0, index).trim() : title;
    }

    /**
        * 提取设备信息
    */
    private EamMaintenanceStandard extractDeviceInfo(Sheet sheet) {
        Row headerRow = sheet.getRow(0);
        if (headerRow == null) {
            return null;
        }

        String headerText = getCellStringValue(headerRow.getCell(0));
        if (StringUtils.isBlank(headerText)) {
            return null;
        }

        EamMaintenanceStandard standard = new EamMaintenanceStandard();
        standard.setEquipmentName(extractField(headerText, "设备名称[:：]\\s*(\\S+)"));
        standard.setEquipmentId(extractField(headerText, "设备型号[:：]\\s*(\\S+)"));
        standard.setStandardCode(extractField(headerText, "统一编号[:：]\\s*(\\S+)"));

        // 日期处理
        String dateStr = extractField(headerText, "日期[:：]\\s*(\\S+)");
        if (StringUtils.isNotBlank(dateStr)) {
            try {
                // 支持多种日期格式
                Date date = parseDate(dateStr);
                standard.setDesignTime(date);
                standard.setInitialDate(date);
            } catch (ParseException ignored) {

            }
        }

        standard.setMaintenanceCategory("POINT_INSPECTION");
        standard.setPeriodUnit("天");
        standard.setStandardStatus(MaintenanceStandardStatusEnum.START.name());
        standard.setStandardVersion("v" + CommonConstant.OPERATE_TYPE_1);
        standard.setDelFlag(0);

        return standard;
    }

    /**
        * 解析日期字符串
     */
    private Date parseDate(String dateStr) throws ParseException {
        // 尝试多种日期格式
        String[] patterns = {
                "yyyy年MM月",
                "yyyy-MM",
                "yyyy/MM",
                "yyyyMM",
                "yyyy年M月"
        };

        for (String pattern : patterns) {
            try {
                SimpleDateFormat sdf = new SimpleDateFormat(pattern);
                sdf.setLenient(false);
                return sdf.parse(dateStr);
            } catch (ParseException e) {
                // 尝试下一个格式
            }
        }

        throw new ParseException("无法解析日期: " + dateStr, 0);
    }

    /**
        * 提取每日点检项目
    */
    private List<EamMaintenanceStandardDetail> extractDailyItems(Sheet sheet, EamMaintenanceStandard standard) {
        return extractItems(sheet, standard, "点检项目", "完成数据/要求", "DAY_INSPECTION");
    }

    /**
        * 提取周保养项目
    */
    private List<EamMaintenanceStandardDetail> extractWeeklyItems(Sheet sheet, EamMaintenanceStandard standard) {
        return extractItems(sheet, standard, "周保养项目", "检查标准", "WEEK_INSPECTION");
    }

    /**
        * 通用项目提取方法
    */
    private List<EamMaintenanceStandardDetail> extractItems(Sheet sheet, EamMaintenanceStandard standard,
                                                            String primaryHeader, String secondaryHeader,
                                                            String itemCategory) {
        int[] section = findTableSection(sheet, primaryHeader, secondaryHeader);
        if (section == null) {
            return Collections.emptyList();
        }

        List<EamMaintenanceStandardDetail> details = new ArrayList<>();
        for (int rowIdx = section[0]; rowIdx <= section[1]; rowIdx++) {
            Row row = sheet.getRow(rowIdx);
            if (row == null || isEmptyRow(row)) {
                continue;
            }

            // 确保第一列是序号（数字）
            Cell seqCell = row.getCell(0);
            if (seqCell == null || seqCell.getCellType() != CellType.NUMERIC) {
                continue;
            }

            // 创建项目详情
            EamMaintenanceStandardDetail detail = new EamMaintenanceStandardDetail();
            detail.setStandardId(standard.getId());
            detail.setItemName(getCellStringValue(row.getCell(1)));
            detail.setItemCategory(itemCategory);

            // 根据项目类型设置需求字段
            if ("DAY_INSPECTION".equals(itemCategory)) {
                detail.setItemDemand(getCellStringValue(row.getCell(2)));
            } else if ("WEEK_INSPECTION".equals(itemCategory)) {
                detail.setItemDemand(getCellStringValue(row.getCell(2)));
            }

            details.add(detail);
        }

        return details;
    }

    /**
        * 查找表格区域
     */
    private int[] findTableSection(Sheet sheet, String primaryHeader, String secondaryHeader) {
        for (int rowIdx = 0; rowIdx <= sheet.getLastRowNum(); rowIdx++) {
            Row row = sheet.getRow(rowIdx);
            if (row == null) continue;

            if (isHeaderRow(row, primaryHeader, secondaryHeader)) {
                int startRow = rowIdx + 1;
                int endRow = findDataEnd(sheet, startRow);
                return new int[]{startRow, endRow};
            }
        }
        return null;
    }

    /**
        * 检查是否为表头行
    */
    private boolean isHeaderRow(Row row, String header1, String header2) {
        boolean foundHeader1 = false;
        boolean foundHeader2 = false;

        for (int colIdx = 0; colIdx < row.getLastCellNum(); colIdx++) {
            Cell cell = row.getCell(colIdx);
            if (cell == null) continue;

            String cellValue = getCellStringValue(cell);
            if (cellValue.contains(header1)) foundHeader1 = true;
            if (cellValue.contains(header2)) foundHeader2 = true;
        }

        return foundHeader1 && foundHeader2;
    }

    /**
        * 查找数据结束位置
     */
    private int findDataEnd(Sheet sheet, int startRow) {
        for (int rowIdx = startRow; rowIdx <= sheet.getLastRowNum(); rowIdx++) {
            Row row = sheet.getRow(rowIdx);
            if (row == null) return rowIdx - 1;

            // 检查是否结束标志行（如签字行）
            if (isSignatureRow(row)) {
                return rowIdx - 1;
            }

            // 检查是否新的表头开始
            if (isNewHeaderStart(row)) {
                return rowIdx - 1;
            }
        }
        return sheet.getLastRowNum();
    }

    /**
        * 识别签字行特征
    */
    private boolean isSignatureRow(Row row) {
        for (int colIdx = 0; colIdx < row.getLastCellNum(); colIdx++) {
            Cell cell = row.getCell(colIdx);
            if (cell == null) continue;

            String value = getCellStringValue(cell);
            if (value.contains("签字") || value.contains("责任人") ||
                    value.contains("执行") || value.contains("确认")) {
                return true;
            }
        }
        return false;
    }

    /**
        * 识别新表头开始
    */
    private boolean isNewHeaderStart(Row row) {
        for (int colIdx = 0; colIdx < row.getLastCellNum(); colIdx++) {
            Cell cell = row.getCell(colIdx);
            if (cell == null) continue;

            String value = getCellStringValue(cell);
            if ("序号".equals(value) || "点检项目".equals(value) || "周保养项目".equals(value)) {
                return true;
            }
        }
        return false;
    }

    /**
        * 检查行是否为空
    */
    private boolean isEmptyRow(Row row) {
        if (row == null) return true;
        for (int colIdx = 0; colIdx < row.getLastCellNum(); colIdx++) {
            Cell cell = row.getCell(colIdx);
            if (cell != null && cell.getCellType() != CellType.BLANK) {
                String value = getCellStringValue(cell);
                if (StringUtils.isNotBlank(value)) {
                    return false;
                }
            }
        }
        return true;
    }

    /**
        * 使用正则提取字段
    */
    private String extractField(String text, String regex) {
        if (StringUtils.isBlank(text)) return "";

        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(text);
        return matcher.find() ? matcher.group(1) : "";
    }

    /**
        * 获取单元格字符串值
    */
    private String getCellStringValue(Cell cell) {
        if (cell == null) return "";

        switch (cell.getCellType()) {
            case STRING:
                return cell.getStringCellValue().trim();
            case NUMERIC:
                if (DateUtil.isCellDateFormatted(cell)) {
                    return new SimpleDateFormat("yyyy年MM月").format(cell.getDateCellValue());
                }
                return String.valueOf((int) cell.getNumericCellValue());
            case BOOLEAN:
                return String.valueOf(cell.getBooleanCellValue());
            case FORMULA:
                return handleFormulaCell(cell);
            default:
                return "";
        }
    }

    /**
        * 处理公式单元格
    */
    private String handleFormulaCell(Cell cell) {
        try {
            FormulaEvaluator evaluator = cell.getSheet().getWorkbook().getCreationHelper().createFormulaEvaluator();
            CellValue cellValue = evaluator.evaluate(cell);

            if (cellValue == null) return "";

            switch (cellValue.getCellType()) {
                case STRING: return cellValue.getStringValue();
                case NUMERIC: return String.valueOf((int) cellValue.getNumberValue());
                case BOOLEAN: return String.valueOf(cellValue.getBooleanValue());
                default: return "";
            }
        } catch (Exception e) {
            return "";
        }
    }
    /*导入文件--------------------------结束*/
}