package com.qianwen.smartman.modules.coproduction.service.impl;

import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.invoke.SerializedLambda;
import java.lang.reflect.Field;
import java.text.ParseException;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import org.apache.commons.lang3.time.DateUtils;
import org.apache.poi.ss.usermodel.Workbook;
import org.jetbrains.annotations.NotNull;
import com.qianwen.smartman.common.cache.CodeRuleCache;
import com.qianwen.smartman.common.cache.RegionCache;
import com.qianwen.smartman.common.constant.CommonConstant;
import com.qianwen.smartman.common.constant.DateConstant;
import com.qianwen.smartman.common.constant.ExcelConstant;
import com.qianwen.smartman.common.utils.ExcelUtils;
import com.qianwen.smartman.common.utils.MessageUtils;
import com.qianwen.core.log.exception.ServiceException;
import com.qianwen.core.mp.base.BaseServiceImpl;
import com.qianwen.core.oss.model.BladeFile;
import com.qianwen.core.tool.utils.CollectionUtil;
import com.qianwen.core.tool.utils.DateUtil;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.core.tool.utils.StringUtil;
import com.qianwen.smartman.modules.coproduction.convert.PlanConvert;
import com.qianwen.smartman.modules.coproduction.convert.PlanProcessConvert;
import com.qianwen.smartman.modules.coproduction.dto.CheckParamDTO;
import com.qianwen.smartman.modules.coproduction.dto.CheckResultDTO;
import com.qianwen.smartman.modules.coproduction.dto.OrderProcessReportWorkDTO;
import com.qianwen.smartman.modules.coproduction.dto.PlanCraftDTO;
import com.qianwen.smartman.modules.coproduction.dto.PlanImportCheckMapDTO;
import com.qianwen.smartman.modules.coproduction.dto.PlanProcessDTO;
import com.qianwen.smartman.modules.coproduction.dto.PlanProcessInfoDTO;
import com.qianwen.smartman.modules.coproduction.dto.PlanProductTypeDTO;
import com.qianwen.smartman.modules.coproduction.entity.Order;
import com.qianwen.smartman.modules.coproduction.entity.OrderProcess;
import com.qianwen.smartman.modules.coproduction.entity.OrderReportRecord;
import com.qianwen.smartman.modules.coproduction.entity.OrderWorkstation;
import com.qianwen.smartman.modules.coproduction.entity.Plan;
import com.qianwen.smartman.modules.coproduction.entity.PlanProcess;
import com.qianwen.smartman.modules.coproduction.enums.CoProductionEnum;
import com.qianwen.smartman.modules.coproduction.enums.OrderProcessStatusEnum;
import com.qianwen.smartman.modules.coproduction.enums.OrderReportRecordStatusEnum;
import com.qianwen.smartman.modules.coproduction.enums.OrderStatusEnum;
import com.qianwen.smartman.modules.coproduction.enums.PlanCategoryEnum;
import com.qianwen.smartman.modules.coproduction.enums.PlanStatusEnum;
import com.qianwen.smartman.modules.coproduction.enums.WorkstationStatusEnum;
import com.qianwen.smartman.modules.coproduction.mapper.OrderReportRecordMapper;
import com.qianwen.smartman.modules.coproduction.mapper.PlanMapper;
import com.qianwen.smartman.modules.coproduction.mapper.PlanProcessMapper;
import com.qianwen.smartman.modules.coproduction.service.IOrderProcessService;
import com.qianwen.smartman.modules.coproduction.service.IOrderReportRecordService;
import com.qianwen.smartman.modules.coproduction.service.IOrderService;
import com.qianwen.smartman.modules.coproduction.service.IOrderWorkstationService;
import com.qianwen.smartman.modules.coproduction.service.IPlanProcessService;
import com.qianwen.smartman.modules.coproduction.service.IPlanService;
import com.qianwen.smartman.modules.coproduction.vo.OrderEditWorkstationVO;
import com.qianwen.smartman.modules.coproduction.vo.OrderProcessEditWorkStationVO;
import com.qianwen.smartman.modules.coproduction.vo.PlanAppendVO;
import com.qianwen.smartman.modules.coproduction.vo.PlanBomVO;
import com.qianwen.smartman.modules.coproduction.vo.PlanCraftVO;
import com.qianwen.smartman.modules.coproduction.vo.PlanCraftVersionVO;
import com.qianwen.smartman.modules.coproduction.vo.PlanExportVO;
import com.qianwen.smartman.modules.coproduction.vo.PlanImportVO;
import com.qianwen.smartman.modules.coproduction.vo.PlanModifyVO;
import com.qianwen.smartman.modules.coproduction.vo.PlanQueryVO;
import com.qianwen.smartman.modules.coproduction.vo.PlanStatusCountVO;
import com.qianwen.smartman.modules.coproduction.vo.PlanSubmitVO;
import com.qianwen.smartman.modules.cps.entity.BomVersion;
import com.qianwen.smartman.modules.cps.entity.CraftRouting;
import com.qianwen.smartman.modules.cps.entity.Product;
import com.qianwen.smartman.modules.cps.entity.ProductionCraftVersion;
import com.qianwen.smartman.modules.cps.service.IBomVersionService;
import com.qianwen.smartman.modules.cps.service.ICraftRoutingService;
import com.qianwen.smartman.modules.cps.service.IProductService;
import com.qianwen.smartman.modules.cps.service.IProductionCraftVersionService;
import com.qianwen.smartman.modules.cps.vo.CraftRoutingDetailVO;
import com.qianwen.smartman.modules.resource.builder.oss.OssBuilder;
import com.qianwen.smartman.modules.system.constant.FieldConstant;
import com.qianwen.smartman.modules.system.constant.SystemFieldConstant;
import com.qianwen.smartman.modules.system.dto.CustomTemplateFieldRelationDTO;
import com.qianwen.smartman.modules.system.entity.CustomTemplate;
import com.qianwen.smartman.modules.system.entity.CustomTemplateBusiness;
import com.qianwen.smartman.modules.system.enums.BusinessTypeEnums;
import com.qianwen.smartman.modules.system.enums.ConfigTypeEnum;
import com.qianwen.smartman.modules.system.handler.field.HandlerFieldSqlParse;
import com.qianwen.smartman.modules.system.mapper.CustomTemplateFieldRelationMapper;
import com.qianwen.smartman.modules.system.service.ICodeGeneratorService;
import com.qianwen.smartman.modules.system.service.ICustomTemplateBusinessService;
import com.qianwen.smartman.modules.system.service.ICustomTemplateFieldService;
import com.qianwen.smartman.modules.system.service.ICustomTemplateService;
import com.qianwen.smartman.modules.system.vo.CustomTemplateFieldColumnVO;
import com.qianwen.smartman.modules.tpm.enums.MetaTypeEnum;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

@Service
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/coproduction/service/impl/PlanServiceImpl.class */
public class PlanServiceImpl extends BaseServiceImpl<PlanMapper, Plan> implements IPlanService {
    @Autowired
    private ICodeGeneratorService codeGeneratorService;
    @Autowired
    @Lazy
    private IOrderService orderService;
    @Autowired
    private IOrderProcessService orderProcessService;
    @Autowired
    private ICustomTemplateFieldService customTemplateFieldService;
    @Autowired
    private ICustomTemplateBusinessService customTemplateBusinessService;
    @Autowired
    private OssBuilder ossBuilder;
    @Autowired
    @Lazy
    private IOrderReportRecordService orderReportRecordService;
    @Autowired
    private IOrderWorkstationService orderWorkstationService;
    @Autowired
    private ICustomTemplateService templateService;
    @Autowired
    private PlanProcessMapper planProcessMapper;
    @Autowired
    private IPlanProcessService planProcessService;
    @Autowired
    private HandlerFieldSqlParse handlerFieldSqlParse;
    @Autowired
    private IProductService productService;
    @Autowired
    private IProductionCraftVersionService productionCraftVersionService;
    @Autowired
    private OrderReportRecordMapper orderReportRecordMapper;
    @Autowired
    private PlanMapper planMapper;
    @Autowired
    private ICraftRoutingService craftRoutingService;
    @Autowired
    private IBomVersionService bomVersionService;
    @Autowired
    private CustomTemplateFieldRelationMapper customTemplateFieldRelationMapper;
    private static final String CODE_RULE = "CoPlan";
    private static final String PLAN_TYPE_CODE = "typeId";
    static final List<Integer> CHECK_STATUS_LIST = Arrays.asList(PlanStatusEnum.WAIT_MACHINE.getCode(), PlanStatusEnum.PAUSE.getCode(), PlanStatusEnum.MACH_ING.getCode());

    @Override // org.springblade.modules.coproduction.service.IPlanService
    @Transactional(rollbackFor = {Exception.class})
    public boolean remove(Long id) {
        Plan plan = (Plan) getById(id);
        Integer planStatus = plan.getPlanStatus();
        if (!Func.equals(planStatus, PlanStatusEnum.WAIT_PUBLISH.getCode())) {
            
        	List<Order> list = this.orderService.list(
        	          Wrappers.<Order>lambdaQuery()
        	          .eq(Order::getPlanId, id)
        	          .eq(Order::getStatus, CommonConstant.ENABLE));
        	List<Long> orderIds = (List<Long>)list.stream().map(Order::getId).collect(Collectors.toList());
        	Long num = this.orderReportRecordMapper.selectCount(Wrappers.<OrderReportRecord>lambdaQuery().in(OrderReportRecord::getOrderId, orderIds)
        	          .eq(OrderReportRecord::getRecordStatus, CommonConstant.DEACTIVATE));
        	if (Func.isNotEmpty(num) && num.longValue() > 0L) {
        	        throw new ServiceException(MessageUtils.message("cps.plan.can.not.remove", new Object[0])); 
        	}
            this.orderService.remove(orderIds, plan.getId());
        }
        return removeById(id);
    }

    @Override // org.springblade.modules.coproduction.service.IPlanService
    @Transactional(rollbackFor = {Exception.class})
    public void pause(Long planId) {
        Plan plan = (Plan) getById(planId);
        List<Order> orders = this.orderService.list(Wrappers.<Order>lambdaQuery().eq(Order::getStatus, CommonConstant.ENABLE).eq(Order::getPlanId, planId));
        /*
        List<Order> orders = this.orderService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getStatus();
        }, CommonConstant.ENABLE)).eq((v0) -> {
            return v0.getPlanId();
        }, planId));*/
        checkPause(plan, orders);
        plan.setPlanStatusBefore(plan.getPlanStatus());
        plan.setPlanStatus(PlanStatusEnum.PAUSE.getCode());
        updateById(plan);
        
        List<OrderProcess> orderProcesses = this.orderProcessService.list(Wrappers.<OrderProcess>lambdaQuery().eq(OrderProcess::getStatus, CommonConstant.ENABLE).eq(OrderProcess::getPlanId, planId));
        /*
        List<OrderProcess> orderProcesses = this.orderProcessService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getStatus();
        }, CommonConstant.ENABLE)).eq((v0) -> {
            return v0.getPlanId();
        }, planId));*/
        pauseOrderAndProcesses(orders, orderProcesses);
    }

    private void pauseOrderAndProcesses(List<Order> orders, List<OrderProcess> orderProcesses) {
        orders.forEach(item -> {
            item.setOrderStatusBefore(item.getOrderStatus());
        });
        orderProcesses.forEach(item2 -> {
            item2.setProcessStatusBefore(item2.getProcessStatus());
        });
        orders.forEach(item3 -> {
            item3.setOrderStatus(OrderProcessStatusEnum.SUSPEND.getCode());
        });
        orderProcesses.forEach(item4 -> {
            item4.setProcessStatus(OrderProcessStatusEnum.SUSPEND.getCode());
        });
        this.orderService.updateBatchById(orders);
        this.orderProcessService.updateBatchById(orderProcesses);
    }

    private void checkPause(Plan plan, List<Order> orders) {
        List<Integer> status = new ArrayList<>();
        status.add(PlanStatusEnum.MACH_ING.getCode());
        status.add(PlanStatusEnum.WAIT_MACHINE.getCode());
        status.add(PlanStatusEnum.WAIT_PUBLISH.getCode());
        Integer planStatus = plan.getPlanStatus();
        if (!status.contains(planStatus)) {
            throw new ServiceException(MessageUtils.message("cps.plan.can.not.pause", new Object[0]));
        }
        if (Func.equals(planStatus, PlanStatusEnum.MACH_ING.getCode())) {
        	List<Order> list = orders.stream().filter(item -> Func.equals(item.getOrderStatus(), OrderStatusEnum.IN_EXECUTION.getCode())).collect(Collectors.toList());
            List<Long> orderIds = list.stream().map(Order::getId).collect(Collectors.toList());
            if (Func.isNotEmpty(list)) {
              List<OrderReportRecord> orderReportRecords = this.orderReportRecordMapper.selectList(
                  Wrappers.<OrderReportRecord>lambdaQuery().in(OrderReportRecord::getOrderId, orderIds)
                  .eq(OrderReportRecord::getRecordStatus, CommonConstant.DEACTIVATE));
              if (Func.isNotEmpty(orderReportRecords)) {
                throw new ServiceException(MessageUtils.message("cps.plan.can.not.pause", new Object[0])); 
              }
            } 
        }
    }

    @Override // org.springblade.modules.coproduction.service.IPlanService
    @Transactional(rollbackFor = {Exception.class})
    public void reboot(Long planId) {
        Plan plan = (Plan) getById(planId);
        checkReboot(plan);
        
        List<Order> orders = this.orderService.list(
                Wrappers.<Order>lambdaQuery()
                .eq(Order::getStatus, CommonConstant.ENABLE)
                .eq(Order::getPlanId, planId));
        /*
        List<Order> orders = this.orderService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getStatus();
        }, CommonConstant.ENABLE)).eq((v0) -> {
            return v0.getPlanId();
        }, planId));*/
        
        List<OrderProcess> orderProcesses = this.orderProcessService.list(
                Wrappers.<OrderProcess>lambdaQuery()
                .eq(OrderProcess::getStatus, CommonConstant.ENABLE)
                .eq(OrderProcess::getPlanId, planId));
        /*
        List<OrderProcess> orderProcesses = this.orderProcessService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getStatus();
        }, CommonConstant.ENABLE)).eq((v0) -> {
            return v0.getPlanId();
        }, planId));*/
        plan.setPlanStatus(plan.getPlanStatusBefore());
        orders.forEach(item -> {
            item.setOrderStatus(item.getOrderStatusBefore());
        });
        orderProcesses.forEach(item2 -> {
            item2.setProcessStatus(item2.getProcessStatusBefore());
        });
        updateById(plan);
        this.orderService.updateBatchById(orders);
        this.orderProcessService.updateBatchById(orderProcesses);
    }

    private void checkReboot(Plan plan) {
        Integer planStatus = plan.getPlanStatus();
        if (!Func.equals(planStatus, PlanStatusEnum.PAUSE.getCode())) {
            throw new ServiceException(MessageUtils.message("cps.plan.can.not.reboot", new Object[0]));
        }
    }

    @Override // org.springblade.modules.coproduction.service.IPlanService
    @Transactional(rollbackFor = {Exception.class})
    public void append(PlanAppendVO planAppendVO) {
        Long planId = planAppendVO.getPlanId();
        Plan sourcePlan = (Plan) getById(planId);
        if (!Func.equals(sourcePlan.getPlanStatus(), PlanStatusEnum.CLOSE.getCode()) && !Func.equals(sourcePlan.getPlanStatus(), PlanStatusEnum.FINISHED.getCode())) {
            throw new ServiceException(MessageUtils.message(MessageUtils.message("cps.plan.can.not.append", new Object[0]), new Object[0]));
        }
        Integer num = planAppendVO.getNum();
        if (num.intValue() <= 0) {
            throw new ServiceException(MessageUtils.message("plan.num.must.greater.than.zero", new Object[0]));
        }
        checkPlanTime(planAppendVO.getPlanStartTime(), planAppendVO.getPlanEndTime());
        Plan plan = PlanConvert.INSTANCE.copyNewPlan(sourcePlan, planAppendVO);
        if (CodeRuleCache.existCodeRule(CODE_RULE)) {
            plan.setCode(planCodeGenerator(new PlanSubmitVO()));
        } else {
            String planCode = planAppendVO.getPlanCode();
            if (Func.isEmpty(planCode)) {
                throw new ServiceException(MessageUtils.message("cps.plan.code.can.not.null", new Object[0]));
            }
            plan.setCode(planAppendVO.getPlanCode());
        }
        save(plan);
        appendProcesses(planAppendVO, plan);
    }

    /* JADX WARN: Multi-variable type inference failed */
    private void appendProcesses(PlanAppendVO planAppendVO, Plan plan) {
        List<PlanProcessDTO> planProcess = planAppendVO.getPlanProcess();
        if (Func.isEmpty(planProcess)) {
            throw new ServiceException(MessageUtils.message("cps.plan.process.can.not.null", new Object[0]));
        }
        List<Long> processIds = new ArrayList<>();
        planProcess.forEach(item -> {
            processIds.add(item.getPlanProcessId());
        });
        
        Map<Long, PlanProcessDTO> map = (Map<Long, PlanProcessDTO>)planProcess.stream().collect(Collectors.toMap(PlanProcessDTO::getPlanProcessId, item -> item));
       
        List<PlanProcess> planProcesses = this.planProcessService.list(Wrappers.<PlanProcess>lambdaQuery().in(PlanProcess::getId, processIds).orderByAsc(PlanProcess::getSort));
        /*
        List<PlanProcess> planProcesses = this.planProcessService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().in((v0) -> {
            return v0.getId();
        }, processIds)).orderByAsc((v0) -> {
            return v0.getSort();
        }));
        */
        if (Func.isEmpty(planProcesses)) {
            throw new ServiceException(MessageUtils.message("production.plan.process.not.exists", new Object[0]));
        }
        Set<Long> mainProcessesIds = planProcesses.stream().map(PlanProcess::getMainSequenceId).collect(Collectors.toSet());
        /*
        Set<Long> mainProcessesIds = (Set) planProcesses.stream().map((v0) -> {
            return v0.getMainSequenceId();
        }).collect(Collectors.toSet());
        */
        
        Map<Long, PlanProcess> mainMap = MapUtil.newHashMap();
        Map<String, Long> newMainMap = MapUtil.newHashMap();
        if (Func.isNotEmpty(mainProcessesIds)) {
            List<PlanProcess> mainProcessesList = this.planProcessService.listByIds(mainProcessesIds);
            if (Func.isNotEmpty(mainProcessesList)) {
            	/*
                mainMap = (Map) mainProcessesList.stream().collect(Collectors.toMap((v0) -> {
                    return v0.getId();
                }, item3 -> {
                    return item3;
                }));*/
            	mainMap = mainProcessesList.stream().collect(Collectors.toMap(PlanProcess::getId, item -> item)); 
            }
            mainProcessesList.forEach(item4 -> {
                PlanProcessDTO planProcessDTO = (PlanProcessDTO) map.get(item4.getId());
                item4.setId(null);
                item4.setPlanId(plan.getId());
                if (Func.isNotEmpty(planProcessDTO)) {
                    item4.setWorkstationId(planProcessDTO.getWorkstationIds());
                    item4.setWorkstationName(planProcessDTO.getWorkstationNames());
                }
            });
            this.planProcessService.saveBatch(mainProcessesList);
            if (Func.isNotEmpty(mainProcessesList)) {
            	newMainMap = mainProcessesList.stream().collect(Collectors.toMap(this::getProcessKey, PlanProcess::getId)); 
            	/*
                newMainMap = (Map) mainProcessesList.stream().collect(Collectors.toMap(this::getProcessKey, (v0) -> {
                    return v0.getId();
                }));*/
            }
        }
        Map<Long, PlanProcess> finalMainMap = mainMap;
        Map<String, Long> finalNewMainMap = newMainMap;
        planProcesses.forEach(item5 -> {
            PlanProcessDTO planProcessDTO = (PlanProcessDTO) map.get(item5.getId());
            item5.setId(null);
            item5.setPlanId(plan.getId());
            item5.setWorkstationId(planProcessDTO.getWorkstationIds());
            item5.setWorkstationName(planProcessDTO.getWorkstationNames());
            if (Func.isEmpty(item5.getMainSequenceId())) {
                return;
            }
            Long mainSequenceId = item5.getMainSequenceId();
            if (finalMainMap.containsKey(mainSequenceId)) {
                PlanProcess process = (PlanProcess) finalMainMap.get(mainSequenceId);
                if (finalNewMainMap.containsKey(getProcessKey(process))) {
                    Long mainId = (Long) finalNewMainMap.get(getProcessKey(process));
                    item5.setMainSequenceId(mainId);
                }
            }
        });
        this.planProcessService.saveBatch(planProcesses);
    }

    private String getProcessKey(PlanProcess process) {
        return process.getCode() + "-" + process.getSort();
    }

    @Override // org.springblade.modules.coproduction.service.IPlanService
    @Transactional(rollbackFor = {Exception.class})
    public BladeFile planImport(Long templateId, MultipartFile file) {
        try {
            ExcelUtils.ExcelDataDTO excelDataDTO = ExcelUtils.readExcel(file.getInputStream());
            List<Map<String, String>> data = excelDataDTO.getData();
            List<Map<String, String>> sysData = new ArrayList<>();
            List<CheckResultDTO> checkResultDTOS = this.templateService.checkImport(getCheckFunction(sysData), BusinessTypeEnums.PLAN_ORDER.getCode(), data);
            if (Func.isEmpty(checkResultDTOS)) {
                throw new ServiceException("cps.plan.table.data.error");
            }
            List<PlanImportVO> cover = cover(sysData);
            List<Plan> plans = checkAndHandleSysPlan(checkResultDTOS, cover);
            BladeFile bladeFile = putImportFail(excelDataDTO, checkResultDTOS);
            if (Func.isNotEmpty(bladeFile)) {
                return bladeFile;
            }
            saveList(plans);
            return new BladeFile();
        } catch (Exception e) {
            throw new ServiceException(MessageUtils.message("cps.plan.table.data.error", new Object[0]));
        }
    }

    private void saveList(List<Plan> plans) {
        plans.forEach(plan -> {
            plan.setPlanStatus(PlanStatusEnum.WAIT_PUBLISH.getCode());
        });
        saveBatch(plans);
        plans.forEach(this::saveProcessBatch);
    }

    private BladeFile putImportFail(ExcelUtils.ExcelDataDTO excelDataDTO, List<CheckResultDTO> checkResultDTOS) {
        int pass = CommonConstant.ENABLE.intValue();
        Iterator<CheckResultDTO> it = checkResultDTOS.iterator();
        while (true) {
            if (it.hasNext()) {
                if (Func.equals(it.next().getCode(), CommonConstant.DEACTIVATE)) {
                    pass = CommonConstant.DEACTIVATE.intValue();
                    break;
                }
            } else {
                break;
            }
        }
        if (Func.equals(Integer.valueOf(pass), CommonConstant.ENABLE)) {
            return null;
        }
        List<Map<String, String>> data = excelDataDTO.getData();
        for (int i = 0; i < data.size(); i++) {
            Map<String, String> map = data.get(i);
            CheckResultDTO checkResultDTO = checkResultDTOS.get(i);
            if (Func.equals(checkResultDTO.getCode(), CommonConstant.DEACTIVATE)) {
                map.put(ExcelConstant.FAIL_REASON, checkResultDTO.getError());
            }
        }
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        Workbook workbook = ExcelUtils.generateFail(excelDataDTO);
        try {
            workbook.write(bos);
        } catch (IOException e) {
            e.printStackTrace();
        }
        InputStream is = new ByteArrayInputStream(bos.toByteArray());
        return this.ossBuilder.systemTemplate().putFile("计划导入模板错误.xlsx", is);
    }

    List<PlanImportVO> cover(List<Map<String, String>> sysData) {
        List<PlanImportVO> planImportVOS = new ArrayList<>();
        sysData.forEach(item -> {
            PlanImportVO planImportVO = new PlanImportVO();
            planImportVOS.add(planImportVO);
            item.forEach((k, v) -> {
                Field[] declaredFields = PlanImportVO.class.getDeclaredFields();
                for (Field field : declaredFields) {
                    try {
                        if (Func.equals(field.getName(), k)) {
                            field.setAccessible(true);
                            field.set(planImportVO, v);
                        }
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }
            });
        });
        return planImportVOS;
    }

    private Function<List<Map<String, String>>, List<CheckParamDTO>> getCheckFunction(List<Map<String, String>> map) {
        return dto -> {
            CustomTemplate customTemplate;
            map.addAll(dto);
            List<CheckParamDTO> checkParamDTOS = new ArrayList<>();
            List<String> types = new ArrayList<>();
            map.forEach(item -> {
                if (item.containsKey(PLAN_TYPE_CODE)) {
                    String typeId = (String) item.get(PLAN_TYPE_CODE);
                    if (Func.isNotBlank(typeId)) {
                        types.add(typeId);
                    }
                }
            });
            LambdaQueryWrapper<CustomTemplate> lambdaQueryWrapper = new LambdaQueryWrapper<>();
            lambdaQueryWrapper.eq(CustomTemplate::getBusinessType, BusinessTypeEnums.PLAN_ORDER.getCode());
 
            
            lambdaQueryWrapper.and(wrapper -> {
                (wrapper.in(types.size() > 0, (v0) -> {
                    return v0.getTemplateName();
                }, types).or()).eq((v0) -> {
                    return v0.getDefaultTemplate();
                }, CommonConstant.ENABLE);
            });
            List<CustomTemplate> templates = this.templateService.list(lambdaQueryWrapper);
            Optional<CustomTemplate> customTemplateOptional = templates.stream().filter(item2 -> {
                return Func.equals(item2.getDefaultTemplate(), CommonConstant.ENABLE);
            }).findFirst();
            CustomTemplate defaultTemplate = null;
            if (customTemplateOptional.isPresent()) {
                defaultTemplate = customTemplateOptional.get();
            }
     
            Map<String, CustomTemplate> templateMap = templates.stream().collect(Collectors.toMap((v0) -> {
                return v0.getTemplateName();
            }, item3 -> {
                return item3;
            }));
            List<Long> templateIds = templates.stream().map(CustomTemplate::getId).collect(Collectors.toList());
            
            List<CustomTemplateFieldRelationDTO> customTemplateFieldRelationDTOS = this.customTemplateFieldRelationMapper.getImportFields(templateIds);
            Map<Long, List<CustomTemplateFieldRelationDTO>> relation = (Map) customTemplateFieldRelationDTOS.stream().collect(Collectors.groupingBy((v0) -> {
                return v0.getTemplateId();
            }));
            for (int i = 0; i < dto.size(); i++) {
                CheckParamDTO checkParamDTO = new CheckParamDTO();
                checkParamDTOS.add(checkParamDTO);
                Map<String, String> specialData = MapUtil.newHashMap();
                Map<String, String> item4 = (Map) dto.get(i);
                if (item4.containsKey(PLAN_TYPE_CODE)) {
                    String typeId = item4.get(PLAN_TYPE_CODE);
                    if (Func.isBlank(typeId)) {
                        customTemplate = defaultTemplate;
                        specialData.put(PLAN_TYPE_CODE, customTemplate.getTemplateName());
                    } else if (!templateMap.containsKey(typeId)) {
                        break;
                    } else {
                        customTemplate = templateMap.get(typeId);
                    }
                } else {
                    customTemplate = defaultTemplate;
                }
                List<CustomTemplateFieldRelationDTO> relations = relation.get(customTemplate.getId());
                Map<String, CustomTemplateFieldRelationDTO> relationDTOMap = (Map) relations.stream().collect(Collectors.toMap((v0) -> {
                    return v0.getFieldCode();
                }, j -> {
                    return j;
                }));
                checkParamDTO.setRelationMap(relationDTOMap);
                checkParamDTO.setCustomTemplate(customTemplate);
                checkParamDTO.setSpecialData(specialData);
            }
            return checkParamDTOS;
        };
    }

    /* JADX WARN: Multi-variable type inference failed */
    private List<Plan> checkAndHandleSysPlan(List<CheckResultDTO> checkResultDTOS, List<PlanImportVO> planExcels) {
        PlanImportCheckMapDTO mapDTO = getCraftVersionMap(planExcels);
        Map<String, CraftRouting> craftMap = mapDTO.getCraftMap();
        Map<String, BomVersion> bomVersionMap = mapDTO.getBomVersionMap();
        Map<String, Product> productMap = mapDTO.getProductMap();
        Map<Long, List<Long>> planTypeProductMap = mapDTO.getPlanTypeProductMap();
        Map<String, CustomTemplate> planTypeMap = mapDTO.getPlanTypeMap();
        Map<Long, Map<String, Long>> craftVersionMap = mapDTO.getCraftVersionMap();
        List<String> codes = new ArrayList<>();
        List<Plan> list = list(Wrappers.<Plan>lambdaQuery().select(Plan::getCode));
        /*
        List<Plan> list = list(Wrappers.lambdaQuery().select(new SFunction[]{(v0) -> {
            return v0.getCode();
        }}));*/
        if (Func.isNotEmpty(list)) {
        	codes = list.stream().map(Plan::getCode).collect(Collectors.toList()); 
        	/*
            codes = (List) list.stream().map((v0) -> {
                return v0.getCode();
            }).collect(Collectors.toList());
            */
        }
        List<Plan> plans = new ArrayList<>();
        for (int i = 0; i < planExcels.size(); i++) {
            CheckResultDTO checkResultDTO = checkResultDTOS.get(i);
            if (!Func.equals(CommonConstant.DEACTIVATE, checkResultDTO.getCode())) {
                String extendField = checkResultDTO.getJson();
                Plan plan = new Plan();
                plan.setExtendField(extendField);
                PlanImportVO excelVO = planExcels.get(i);
                plan.setCode(excelVO.getCode());
                if (Func.isNotEmpty(plan.getCode()) && codes.contains(plan.getCode())) {
                    checkResultDTO.error(MessageUtils.message("plan.code.already.exist", new Object[0]));
                } else {
                    try {
                        plan.setPlanStartTime(DateUtils.parseDate(excelVO.getPlanStartTime(), new String[]{DateConstant.PATTERN_DATE_TIME, DateConstant.PATTERN_DATE}));
                        plan.setPlanEndTime(DateUtils.parseDate(excelVO.getPlanEndTime(), new String[]{DateConstant.PATTERN_DATE_TIME, DateConstant.PATTERN_DATE}));
                        checkPlanTime(plan.getPlanStartTime(), plan.getPlanEndTime());
                        String categoryLabel = excelVO.getCategoryLabel();
                        plan.setCategory(PlanCategoryEnum.of(categoryLabel));
                        if (Func.isEmpty(plan.getCategory())) {
                            checkResultDTO.error(MessageUtils.message("cps.plan.category.data.error", new Object[0]));
                        } else if (!craftMap.containsKey(excelVO.getCraftId())) {
                            checkResultDTO.error(MessageUtils.message("cps.plan.craft.routing.non-existent", new Object[0]));
                        } else {
                            CraftRouting craftRouting = craftMap.get(excelVO.getCraftId());
                            plan.setCraftId(craftRouting.getId());
                            plan.setCraftName(craftRouting.getName());
                            if (!craftVersionMap.containsKey(craftRouting.getId())) {
                                checkResultDTO.error(MessageUtils.message("cps.plan.craft.version.non-existent", new Object[0]));
                            } else {
                                Map<String, Long> versionMap = craftVersionMap.get(craftRouting.getId());
                                if (!versionMap.containsKey(excelVO.getCraftVersion())) {
                                    checkResultDTO.error(MessageUtils.message("cps.plan.craft.routing.and.craft.version.mismatch", new Object[0]));
                                } else {
                                    Long craftVersionId = versionMap.get(excelVO.getCraftVersion());
                                    plan.setCraftVersion(craftVersionId);
                                    plan.setCraftVersionName(excelVO.getCraftVersion());
                                    CustomTemplate customTemplate = null;
                                    if (Func.isNotBlank(excelVO.getTypeId())) {
                                        if (!planTypeMap.containsKey(excelVO.getTypeId())) {
                                            checkResultDTO.error(MessageUtils.message("cps.plan.type.not.exist", new Object[0]));
                                        } else {
                                            customTemplate = planTypeMap.get(excelVO.getTypeId());
                                            plan.setTypeId(customTemplate.getId());
                                        }
                                    } else {
                                        Collection<CustomTemplate> customTemplates = planTypeMap.values();
                                        customTemplates.forEach(item -> {
                                            if (Func.equals(item.getDefaultTemplate(), CommonConstant.ENABLE)) {
                                                plan.setTypeId(item.getId());
                                            }
                                        });
                                    }
                                    if (Func.equals(plan.getCategory(), PlanCategoryEnum.PRODUCTION.getCode())) {
                                        if (Func.isEmpty(excelVO.getProductId())) {
                                            checkResultDTO.error(MessageUtils.message("cps.product.code.can.not.be.empty", new Object[0]));
                                        } else if (!productMap.containsKey(excelVO.getProductId())) {
                                            checkResultDTO.error(MessageUtils.message("cps.product.code.not.exist", new Object[0]));
                                        } else {
                                            Product product = productMap.get(excelVO.getProductId());
                                            plan.setProductId(product.getId());
                                            plan.setProductName(product.getName());
                                            plan.setProductCode(product.getCode());
                                            if (Func.isNotEmpty(customTemplate) && Func.equals(customTemplate.getDefaultTemplate(), CommonConstant.DEACTIVATE) && Func.isNotEmpty(planTypeProductMap) && planTypeProductMap.containsKey(customTemplate.getId())) {
                                                List<Long> itemIds = planTypeProductMap.get(customTemplate.getId());
                                                if (!itemIds.contains(product.getTypeId())) {
                                                    checkResultDTO.error(MessageUtils.message("cps.plan.type.and.product.mismatch", new Object[0]));
                                                }
                                            }
                                            if (!Func.equals(craftRouting.getProductId(), plan.getProductId())) {
                                                checkResultDTO.error(MessageUtils.message("cps.plan.craft.routing.and.product.mismatch", new Object[0]));
                                            } else if (Func.isNotBlank(excelVO.getBomVersion())) {
                                                if (!bomVersionMap.containsKey(craftRouting.getId() + "-" + excelVO.getCraftVersion())) {
                                                    checkResultDTO.error(MessageUtils.message("cps.plan.bom.and.craft.routing.and.craft.version.mismatch", new Object[0]));
                                                } else {
                                                    BomVersion bomVersion = bomVersionMap.get(craftRouting.getId() + "-" + excelVO.getCraftVersion());
                                                    if (!Func.equals(bomVersion.getVersion(), excelVO.getBomVersion())) {
                                                        checkResultDTO.error(MessageUtils.message("cps.plan.bom.and.craft.routing.and.craft.version.mismatch", new Object[0]));
                                                    } else {
                                                        plan.setBomId(bomVersion.getId());
                                                        plan.setBomVersion(bomVersion.getVersion());
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    String planNum = excelVO.getPlanNum();
                                    if (Func.isNumeric(excelVO.getPlanNum()) && Integer.parseInt(planNum) > 0) {
                                        plan.setPlanNum(Integer.valueOf(Integer.parseInt(planNum)));
                                        plan.setStandardModel(excelVO.getStandardModel());
                                        plan.setIndentCode(excelVO.getIndentCode());
                                        plan.setUnassignedNum(plan.getPlanNum());
                                        plans.add(plan);
                                    } else {
                                        checkResultDTO.error(MessageUtils.message("cps.plan.bom.and.craft.routing.and.craft.version.mismatch", new Object[0]));
                                    }
                                }
                            }
                        }
                    } catch (ParseException e) {
                        e.printStackTrace();
                        checkResultDTO.error(MessageUtils.message("excel.import.machine.time.error", new Object[0]));
                    }
                }
            }
        }
        return plans;
    }

    private PlanImportCheckMapDTO getCraftVersionMap(List<PlanImportVO> planExcels) {
        List<CustomTemplate> customTemplates;
        PlanImportCheckMapDTO craftRoutingDTO = new PlanImportCheckMapDTO();
        List<String> productCodes = new ArrayList<>();
        List<String> craftNames = new ArrayList<>();
        List<String> bomVersions = new ArrayList<>();
        List<String> craftVersions = new ArrayList<>();
        List<String> planTypes = new ArrayList<>();
        planExcels.forEach(item -> {
            if (Func.isNotEmpty(item.getProductId())) {
                productCodes.add(item.getProductId());
            }
            if (Func.isNotEmpty(item.getCraftId())) {
                craftNames.add(item.getCraftId());
            }
            if (Func.isNotEmpty(item.getCraftVersion())) {
                craftVersions.add(item.getCraftVersion());
            }
            if (Func.isNotEmpty(item.getBomVersion())) {
                bomVersions.add(item.getBomVersion());
            }
            if (Func.isNotEmpty(item.getTypeId())) {
                planTypes.add(item.getTypeId());
            }
        });
        if (Func.isNotEmpty(productCodes)) {
        	List<Product> products = this.productService.list(Wrappers.<Product>lambdaQuery().in(Product::getCode, productCodes));
        	/*
            List<Product> products = this.productService.list((Wrapper) Wrappers.lambdaQuery().in((v0) -> {
                return v0.getCode();
            }, productCodes));*/
        	
        	craftRoutingDTO.setProductMap(products.stream().collect(Collectors.toMap(Product::getCode, item -> item)));
        	/*
            craftRoutingDTO.setProductMap((Map) products.stream().collect(Collectors.toMap((v0) -> {
                return v0.getCode();
            }, item2 -> {
                return item2;
            })));*/
        }
        if (Func.isNotEmpty(planTypes)) {
        	customTemplates = this.templateService.list(
        	          Wrappers.<CustomTemplate>lambdaQuery()
        	          .eq(CustomTemplate::getBusinessType, BusinessTypeEnums.PLAN_ORDER.getCode())
        	          .in(CustomTemplate::getTemplateName, planTypes));
        	/*
            customTemplates = this.templateService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
                return v0.getBusinessType();
            }, BusinessTypeEnums.PLAN_ORDER.getCode())).in((v0) -> {
                return v0.getTemplateName();
            }, planTypes));
            */
        } else {
        	customTemplates = this.templateService.list(
        	          Wrappers.<CustomTemplate>lambdaQuery()
        	          .eq(CustomTemplate::getBusinessType, BusinessTypeEnums.PLAN_ORDER.getCode())
        	          .eq(CustomTemplate::getDefaultTemplate, CommonConstant.ENABLE));
        	/*
            customTemplates = this.templateService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
                return v0.getBusinessType();
            }, BusinessTypeEnums.PLAN_ORDER.getCode())).eq((v0) -> {
                return v0.getDefaultTemplate();
            }, CommonConstant.ENABLE));
            */
        }
        if (Func.isNotEmpty(customTemplates)) {
        	craftRoutingDTO.setPlanTypeMap(customTemplates.stream().collect(Collectors.toMap(CustomTemplate::getTemplateName, item -> item)));
            
        	List<Long> templateIds = (List<Long>)customTemplates.stream().map(CustomTemplate::getId).collect(Collectors.toList());
        	
        	List<CustomTemplateBusiness> businesses = this.customTemplateBusinessService.list(Wrappers.<CustomTemplateBusiness>lambdaQuery()
        	          .select(CustomTemplateBusiness::getTemplateId, CustomTemplateBusiness::getRelationId).eq(CustomTemplateBusiness::getBusinessType, BusinessTypeEnums.PLAN_ORDER.getCode())
        	          .in(CustomTemplateBusiness::getTemplateId, templateIds));
        	craftRoutingDTO.setPlanTypeProductMap(businesses.stream().collect(Collectors.groupingBy(CustomTemplateBusiness::getTemplateId, Collectors.mapping(CustomTemplateBusiness::getRelationId, Collectors.toList()))));
            /*
            List<CustomTemplateBusiness> businesses = this.customTemplateBusinessService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().select(new SFunction[]{(v0) -> {
                return v0.getTemplateId();
            }, (v0) -> {
                return v0.getRelationId();
            }}).eq((v0) -> {
                return v0.getBusinessType();
            }, BusinessTypeEnums.PLAN_ORDER.getCode())).in((v0) -> {
                return v0.getTemplateId();
            }, templateIds));
           
            craftRoutingDTO.setPlanTypeProductMap((Map) businesses.stream().collect(Collectors.groupingBy((v0) -> {
                return v0.getTemplateId();
            }, Collectors.mapping((v0) -> {
                return v0.getRelationId();
            }, Collectors.toList()))));
             */
        }
        if (Func.isEmpty(craftNames)) {
            return craftRoutingDTO;
        }
        List<CraftRouting> craftRoutingList = this.craftRoutingService.list(Wrappers.<CraftRouting>lambdaQuery().in(CraftRouting::getName, craftNames));
        if (Func.isEmpty(craftRoutingList)) {
            return craftRoutingDTO;
        }
        
        craftRoutingDTO.setCraftMap(craftRoutingList.stream().collect(Collectors.toMap(CraftRouting::getName, item -> item)));
        
        Set<Long> craftIds = craftRoutingList.stream().map(CraftRouting::getId).collect(Collectors.toSet());
        if (Func.isEmpty(craftVersions)) {
            return craftRoutingDTO;
        }
        List<ProductionCraftVersion> versions = this.productionCraftVersionService.list(Wrappers.<ProductionCraftVersion>lambdaQuery().in(ProductionCraftVersion::getCraftId, craftIds));
        /*
        List<ProductionCraftVersion> versions = this.productionCraftVersionService.list((Wrapper) Wrappers.lambdaQuery().in((v0) -> {
            return v0.getCraftId();
        }, craftIds));*/
        if (Func.isEmpty(versions)) {
            return craftRoutingDTO;
        }
        craftRoutingDTO.setCraftVersionMap(versions.stream().collect(Collectors.groupingBy(ProductionCraftVersion::getCraftId, Collectors.toMap(ProductionCraftVersion::getName, ProductionCraftVersion::getId))));
        
        List<String> craftVersionNames = versions.stream().map(ProductionCraftVersion::getName).collect(Collectors.toList());
        if (Func.isNotEmpty(bomVersions)) {
        	List<BomVersion> bomVersionList = this.bomVersionService.list(Wrappers.<BomVersion>lambdaQuery().in(BomVersion::getCraftId, craftIds).in(BomVersion::getCraftVersion, craftVersionNames));
            craftRoutingDTO.setBomVersionMap(bomVersionList.stream().collect(Collectors.toMap(item -> item.getCraftId() + "-" + item.getCraftVersion(), item -> item)));
        }
        return craftRoutingDTO;
    }

    @Override // org.springblade.modules.coproduction.service.IPlanService
    public BladeFile planExport(PlanQueryVO planQueryVO) {
        Long planTypeId = planQueryVO.getTypeId();
        List<CustomTemplateFieldColumnVO> columns = this.customTemplateFieldService.getColumns(planTypeId, ConfigTypeEnum.VIEW_PAGE.getCode());
        Map<String, CustomTemplateFieldColumnVO> fieldCodeMap = (Map) columns.stream().collect(Collectors.toMap((v0) -> {
            return v0.getFieldCode();
        }, item -> {
            return item;
        }));
        IPage<Plan> planPage = listPage(Page.of(1L, -1L), planQueryVO);
        List<Plan> plans = planPage.getRecords();
        ExcelUtils.ExcelExportDTO excelExportDTO = ExcelUtils.buildExcelExportDTO();
        columns.forEach(item2 -> {
            if (Func.equals(item2.getSystemField(), CommonConstant.ENABLE)) {
                if (Func.equals(item2.getSupportExport(), CommonConstant.ENABLE)) {
                    excelExportDTO.addTableHead(item2.getFieldName(), Func.equals(item2.getMustField(), CommonConstant.ENABLE));
                    return;
                }
                return;
            }
            excelExportDTO.addTableHead(item2.getFieldName(), Func.equals(item2.getMustField(), CommonConstant.ENABLE));
        });
        List<PlanExportVO> planExports = (List) plans.stream().map(item3 -> {
            PlanExportVO planExportVO = new PlanExportVO();
            planExportVO.setCategoryLabel(PlanCategoryEnum.of(item3.getCategory()));
            planExportVO.setProductTypeLabel(item3.getProductTypeLabel());
            if (Func.isNotEmpty(item3.getPlanStartTime())) {
                planExportVO.setPlanStartTime(DateUtil.DATE_FORMAT.format(item3.getPlanStartTime()));
            }
            if (Func.isNotEmpty(item3.getPlanEndTime())) {
                planExportVO.setPlanEndTime(DateUtil.DATE_FORMAT.format(item3.getPlanEndTime()));
            }
            planExportVO.setReportSituation(item3.getReportSituation());
            if (Func.isNotEmpty(item3.getReportNum())) {
                planExportVO.setReportNum(String.valueOf(item3.getReportNum()));
            }
            if (Func.isNotEmpty(item3.getQualifyNum())) {
                planExportVO.setQualifyNum(String.valueOf(item3.getQualifyNum()));
            }
            if (Func.isNotEmpty(item3.getStartTime())) {
                planExportVO.setStartTime(DateUtil.format(item3.getStartTime(), DateConstant.PATTERN_DATE_TIME1));
            }
            if (Func.isNotEmpty(item3.getEndTime())) {
                planExportVO.setEndTime(DateUtil.format(item3.getEndTime(), DateConstant.PATTERN_DATE_TIME1));
            }
            planExportVO.setCode(item3.getCode());
            planExportVO.setIndentCode(item3.getIndentCode());
            planExportVO.setPlanStatusLabel(PlanStatusEnum.of(item3.getPlanStatus()).getName());
            if (Func.isNotEmpty(item3.getPlanProgress())) {
                planExportVO.setPlanProgress(Double.valueOf(item3.getPlanProgress()) + "%");
            }
            planExportVO.setProductCode(item3.getProductCode());
            planExportVO.setStandardModel(item3.getStandardModel());
            planExportVO.setPlanNum("" + item3.getPlanNum());
            planExportVO.setExtendField(item3.getExtendField());
            return planExportVO;
        }).collect(Collectors.toList());
        Field[] fields = PlanExportVO.class.getDeclaredFields();
        for (PlanExportVO plan : planExports) {
            Map<String, String> item4 = MapUtil.newHashMap();
            excelExportDTO.addData(item4);
            for (Field field : fields) {
                field.setAccessible(true);
                try {
                    if (fieldCodeMap.containsKey(field.getName())) {
                        CustomTemplateFieldColumnVO customTemplateFieldColumnVO = fieldCodeMap.get(field.getName());
                        if (!Func.equals(customTemplateFieldColumnVO.getSystemField(), CommonConstant.ENABLE) || !Func.equals(customTemplateFieldColumnVO.getSupportExport(), CommonConstant.ENABLE)) {
                            break;
                        }
                        Object o = field.get(plan);
                        if (Func.isNotEmpty(o)) {
                            item4.put(customTemplateFieldColumnVO.getFieldName(), String.valueOf(o));
                        } else {
                            item4.put(customTemplateFieldColumnVO.getFieldName(), "");
                        }
                    }
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
            String extendField = plan.getExtendField();
            JSONObject jsonObject = JSONUtil.parseObj(extendField);
            jsonObject.forEach((key, value) -> {
                if (!fieldCodeMap.containsKey(key)) {
                    return;
                }
                CustomTemplateFieldColumnVO customTemplateFieldColumnVO2 = (CustomTemplateFieldColumnVO) fieldCodeMap.get(key);
                String fieldName = customTemplateFieldColumnVO2.getFieldName();
                String v = value.toString();
                if (JSONUtil.isJsonArray(value.toString())) {
                    List<String> vs = JSONUtil.toList(JSONUtil.parseArray(value.toString()), String.class);
                    v = StringUtil.join(vs, ",");
                }
                item4.put(fieldName, v);
            });
        }
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        Workbook workbook = ExcelUtils.generateExport(excelExportDTO);
        try {
            workbook.write(bos);
        } catch (IOException e2) {
            e2.printStackTrace();
        }
        InputStream is = new ByteArrayInputStream(bos.toByteArray());
        return this.ossBuilder.systemTemplate().putFile("计划数据.xlsx", is);
    }

    @Override // org.springblade.modules.coproduction.service.IPlanService
    public BladeFile planTemplate(Long templateId) {
        return this.templateService.getTemplate(BusinessTypeEnums.PLAN_ORDER.getCode());
    }

    @Override // org.springblade.modules.coproduction.service.IPlanService
    @Transactional(rollbackFor = {Exception.class})
    public void create(PlanSubmitVO planVO) {
        checkPlanIsCreate(planVO);
        Plan plan = PlanConvert.INSTANCE.convert(PlanConvert.INSTANCE.convert(planVO));
        plan.setPlanStatus(PlanStatusEnum.WAIT_PUBLISH.getCode());
        plan.setUnassignedNum(plan.getPlanNum());
        CustomTemplate customTemplate = (CustomTemplate) this.templateService.getById(plan.getTypeId());
        plan.setName(!Objects.isNull(customTemplate) ? customTemplate.getTemplateName() : "");
        save(plan);
        saveProcessBatch(plan);
    }

    private void saveProcessBatch(Plan plan) {
        List<PlanProcessInfoDTO> planProcesses = this.planProcessMapper.getProcessByCraftIdAndVersionId(plan.getCraftId(), plan.getCraftVersion());
        if (Func.isEmpty(planProcesses)) {
            return;
        }
        Map<Long, PlanProcessInfoDTO> dtoMap = planProcesses.stream().collect(Collectors.toMap(PlanProcessInfoDTO::getCraftProcessId, p -> p, (old, newVal) -> old));
        planProcesses.forEach(planProcess -> {
            planProcess.setPlanId(plan.getId());
            planProcess.setTypeName(plan.getName());
            if (Func.isEmpty(planProcess.getMainSequenceId())) {
                return;
            }
            PlanProcessInfoDTO planProcessInfoDTO = (PlanProcessInfoDTO) dtoMap.get(planProcess.getMainSequenceId());
            if (Func.isEmpty(planProcessInfoDTO)) {
                return;
            }
            planProcess.setMainSequenceId(planProcessInfoDTO.getId());
        });
        this.planProcessService.saveBatch(PlanProcessConvert.INSTANCE.convertDTO(planProcesses));
    }

    private void checkPlanIsCreate(PlanSubmitVO planVO) {
        planBaseCheck(planVO.getPlanNum(), planVO.getPlanStartTime(), planVO.getPlanEndTime(), planVO.getExtendField());
        if (Func.isEmpty(planVO.getCode())) {
            planVO.setCode(planCodeGenerator(planVO));
        }
        if (planCodeIsDuplicate(planVO).booleanValue()) {
            throw new ServiceException(MessageUtils.message("plan.code.already.exist", new Object[0]));
        }
    }

    private void checkPlanTime(Date planStartTime, Date planEndTime) {
        if (planStartTime.after(planEndTime) || DateUtil.toDate(LocalDate.now()).after(planEndTime)) {
            throw new ServiceException(MessageUtils.message("cps.plan.start.time.cannot.be.greater.than.the.end.time", new Object[0]));
        }
    }

    private Boolean planCodeIsDuplicate(PlanSubmitVO planSubmitVO) {
    	long count = count(Wrappers.<Plan>lambdaQuery().eq(Plan::getCode, planSubmitVO.getCode()).ne(Func.isNotEmpty(planSubmitVO.getId()), Plan::getId, planSubmitVO.getId()));
        return Boolean.valueOf(count > 0);
    }

    private String planCodeGenerator(PlanSubmitVO planSubmitVO) {
        String code = this.codeGeneratorService.getGeneratorCode(planSubmitVO, MetaTypeEnum.PLAN.getCode());
        if (StrUtil.isEmpty(code)) {
            throw new ServiceException(MessageUtils.message("cps.tpm.maintain.coding.rules", new Object[0]));
        }
        return code;
    }

    @Override // org.springblade.modules.coproduction.service.IPlanService
    @Transactional(rollbackFor = {Exception.class})
    public Boolean finish(Long planId) {
        Plan plan = checkFinishConditionBefore(planId);
        List<OrderReportRecord> insertRecordList = new ArrayList<>();
        List<OrderProcess> updateProcessList = new ArrayList<>();
        List<Order> planOrderList = this.orderService.list(Wrappers.<Order>lambdaQuery().eq(Order::getPlanId, planId).ne(Order::getOrderStatus, OrderStatusEnum.COMPLETE.getCode()));
        List<OrderProcess> planOrderProcessList = this.orderProcessService.list(Wrappers.<OrderProcess>lambdaQuery().eq(OrderProcess::getPlanId, planId).isNull(OrderProcess::getMainSequenceId));
        if (Func.isNotEmpty(planOrderProcessList)) {
        	Map<Long, List<OrderProcess>> orderProcessListMap = planOrderProcessList.stream().collect(Collectors.groupingBy(OrderProcess::getOrderId));
            
            Date now = DateUtil.now();
            for (Order order : planOrderList) {
                List<OrderProcess> currentProcessList = orderProcessListMap.get(order.getId());
                if (!Func.isEmpty(currentProcessList)) {
                    currentProcessList.sort(Comparator.comparing((v0) -> {
                        return v0.getSort();
                    }));
                    Integer currentInputNum = order.getAssignNum();
                    for (OrderProcess orderProcess : currentProcessList) {
                        if (!currentInputNum.equals(0) && currentInputNum.intValue() > orderProcess.getQualifyNum().intValue() + orderProcess.getScrappedNum().intValue()) {
                            insertRecordList.add(packageRecord(order.getPlanId(), order, Integer.valueOf(currentInputNum.intValue() - (orderProcess.getQualifyNum().intValue() + orderProcess.getScrappedNum().intValue())), orderProcess, now));
                        }
                        orderProcess.setProcessStatus(OrderProcessStatusEnum.TO_BE_FINISHED.getCode());
                        orderProcess.setEndTime(Func.isEmpty(orderProcess.getEndTime()) ? now : orderProcess.getEndTime());
                        orderProcess.setStartTime(Func.isEmpty(orderProcess.getStartTime()) ? now : orderProcess.getStartTime());
                        orderProcess.setInputNum(currentInputNum);
                        orderProcess.setScrappedNum(Integer.valueOf(currentInputNum.intValue() - orderProcess.getQualifyNum().intValue()));
                        updateProcessList.add(orderProcess);
                        currentInputNum = orderProcess.getQualifyNum();
                    }
                }
            }
        }
        if (Func.isNotEmpty(insertRecordList)) {
            this.orderReportRecordService.saveBatch(insertRecordList);
        }
        if (Func.isNotEmpty(updateProcessList)) {
            this.orderProcessService.updateBatchById(updateProcessList);
        }
        this.orderService.update(Wrappers.<Order>lambdaUpdate().eq(Order::getPlanId, planId).ne(Order::getOrderStatus, OrderStatusEnum.COMPLETE.getCode())
                .set(Order::getOrderStatus, OrderStatusEnum.COMPLETE.getCode()).set(Order::getEndTime, new Date())
                .setSql("scrapped_num = assign_num - qualify_num"));
        /*
        this.orderService.update((Wrapper) ((LambdaUpdateWrapper) ((LambdaUpdateWrapper) ((LambdaUpdateWrapper) ((LambdaUpdateWrapper) Wrappers.lambdaUpdate().eq((v0) -> {
            return v0.getPlanId();
        }, planId)).ne((v0) -> {
            return v0.getOrderStatus();
        }, OrderStatusEnum.COMPLETE.getCode())).set((v0) -> {
            return v0.getOrderStatus();
        }, OrderStatusEnum.COMPLETE.getCode())).set((v0) -> {
            return v0.getEndTime();
        }, new Date())).setSql("scrapped_num = assign_num - qualify_num"));
        */
        return Boolean.valueOf(update(Wrappers.<Plan>lambdaUpdate().eq(Plan::getId, planId).set(Plan::getPlanStatus, PlanStatusEnum.FINISHED.getCode()).set(Plan::getReportNum, plan.getPlanNum())
                .set(Plan::getEndTime, new Date()).setSql("scrapped_num = scrapped_num + (plan_num - " + plan.getReportNum() + ")")));
    }

    @NotNull
    private Plan checkFinishConditionBefore(Long planId) {
    	Plan plan = getOne(Wrappers.<Plan>lambdaQuery().eq(Plan::getId, planId));
    	long count = this.orderReportRecordService.count(Wrappers.<OrderReportRecord>lambdaQuery().eq(OrderReportRecord::getPlanId, planId).eq(OrderReportRecord::getRecordStatus, CommonConstant.DISABLE));
        if (Func.isEmpty(plan) || !CHECK_STATUS_LIST.contains(plan.getPlanStatus()) || count > 0) {
            throw new ServiceException(MessageUtils.message("cps.plan.can.not.finish", new Object[0]));
        }
        if (plan.getUnassignedNum().intValue() > 0) {
            throw new ServiceException(MessageUtils.message("cps.plan.distributed.before.finish", new Object[0]));
        }
        
        List<OrderReportRecord> planOrderRecordList = this.orderReportRecordService.list(Wrappers.<OrderReportRecord>lambdaQuery().eq(OrderReportRecord::getPlanId, planId));
       
        if (Func.isNotEmpty(planOrderRecordList) && planOrderRecordList.stream().anyMatch(record -> {
            return record.getRecordStatus().equals(OrderReportRecordStatusEnum.STARTED.getCode());
        })) {
            throw new ServiceException(MessageUtils.message("cps.plan.can.not.finish", new Object[0]));
        }
        return plan;
    }

    private OrderReportRecord packageRecord(Long planId, Order order, Integer scrappedNum, OrderProcess orderProcess, Date now) {
        OrderReportRecord orderReportRecord = new OrderReportRecord();
        orderReportRecord.setSystemOrOrdinary(CoProductionEnum.SystemOrOrdinaryStatus.SYSTEM.getCode());
        orderReportRecord.setPlanId(planId);
        orderReportRecord.setOrderId(order.getId());
        orderReportRecord.setProcessId(orderProcess.getId());
        orderReportRecord.setRecordStatus(OrderReportRecordStatusEnum.FINISHED.getCode());
        orderReportRecord.setWorkshopTime(now);
        orderReportRecord.setStartTime(now);
        orderReportRecord.setQualifyNum(0);
        orderReportRecord.setScrappedNum(scrappedNum);
        return orderReportRecord;
    }

    @Override // org.springblade.modules.coproduction.service.IPlanService
    @Transactional(rollbackFor = {Exception.class})
    public Boolean close(Long planId) {
        checkPlanIsClose(planId);
        this.orderService.update(Wrappers.<Order>lambdaUpdate().set(Order::getOrderStatus, OrderStatusEnum.CLOSE.getCode()).eq(Order::getPlanId, planId));
        this.orderProcessService.update(Wrappers.<OrderProcess>lambdaUpdate().set(OrderProcess::getProcessStatus, OrderProcessStatusEnum.CLOSE.getCode()).eq(OrderProcess::getPlanId, planId));
        return Boolean.valueOf(update(Wrappers.<Plan>lambdaUpdate().set(Plan::getPlanStatus, PlanStatusEnum.CLOSE.getCode()).eq(Plan::getId, planId)));
    }

    private void checkPlanIsClose(Long planId) {
        Plan plan = getPlan(String.valueOf(planId));
        boolean flag = plan.getPlanStatus().equals(PlanStatusEnum.CLOSE.getCode()) || plan.getPlanStatus().equals(PlanStatusEnum.FINISHED.getCode());
        long count = this.orderReportRecordService.count(Wrappers.<OrderReportRecord>lambdaQuery().eq(OrderReportRecord::getPlanId, planId).eq(OrderReportRecord::getRecordStatus, CommonConstant.DISABLE));
        
        if (flag || count > 0) {
            throw new ServiceException(MessageUtils.message("cps.plan.can.not.close", new Object[0]));
        }
    }

    @Override // org.springblade.modules.coproduction.service.IPlanService
    @Transactional(rollbackFor = {Exception.class})
    public Boolean editWorkstation(OrderEditWorkstationVO orderEditWorkstationVO) {
    	Order order = (Order)this.orderService.getOne(Wrappers.<Order>lambdaQuery().eq(Order::getId, orderEditWorkstationVO.getOrderId()));
    	
        if (Func.isEmpty(order) || OrderStatusEnum.CLOSE.getCode().equals(order.getOrderStatus()) || OrderStatusEnum.COMPLETE.getCode().equals(order.getOrderStatus())) {
            throw new ServiceException(MessageUtils.message("cps.plan.order.can.not.edit", new Object[0]));
        }
        List<OrderProcess> orderProcessUpdateList = new ArrayList<>();
        List<OrderWorkstation> orderWorkstationSaveList = new ArrayList<>();
        List<OrderWorkstation> delOrderWorkstations = new ArrayList<>();
        List<OrderProcessEditWorkStationVO> processWorkstationList = orderEditWorkstationVO.getOrderProcessEditWorkStationVOList();
        List<OrderWorkstation> oldOrderWorkstations = this.orderWorkstationService.list(Wrappers.<OrderWorkstation>lambdaQuery()
                .eq(OrderWorkstation::getOrderId, orderEditWorkstationVO.getOrderId()));
        /*
        List<OrderWorkstation> oldOrderWorkstations = this.orderWorkstationService.list((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getOrderId();
        }, orderEditWorkstationVO.getOrderId()));*/
        Map<Long, List<OrderWorkstation>> oldOrderWorkstationMap = Func.isNotEmpty(oldOrderWorkstations) ? (Map) oldOrderWorkstations.stream().collect(Collectors.groupingBy((v0) -> {
            return v0.getProcessId();
        })) : new HashMap<>(16);
        for (OrderProcessEditWorkStationVO orderProcessEditWorkStationVO : processWorkstationList) {
            List<String> workIds = Func.toStrList(",", orderProcessEditWorkStationVO.getWorkstationId());
            List<OrderWorkstation> oldWorkstations = oldOrderWorkstationMap.containsKey(orderProcessEditWorkStationVO.getOrderProcessId()) ? oldOrderWorkstationMap.get(orderProcessEditWorkStationVO.getOrderProcessId()) : new ArrayList<>();
            if (oldWorkstations.stream().anyMatch(workstation -> {
                return workstation.getWorkstationStatus().equals(WorkstationStatusEnum.started.getCode()) && !workIds.contains(String.valueOf(workstation.getWorkstationId()));
            })) {
                throw new ServiceException(MessageUtils.message("cps.plan.order.workstaion.already.work", new Object[0]));
            }
            OrderProcess orderProcess = new OrderProcess();
            orderProcess.setId(orderProcessEditWorkStationVO.getOrderProcessId());
            orderProcess.setWorkstationId(orderProcessEditWorkStationVO.getWorkstationId());
            orderProcess.setWorkstationName(orderProcessEditWorkStationVO.getWorkstationName());
            orderProcessUpdateList.add(orderProcess);
            packageProcessWorkstation(order, orderWorkstationSaveList, oldWorkstations, orderProcess);
            oldWorkstations.forEach(old -> {
                if (!workIds.contains(String.valueOf(old.getWorkstationId()))) {
                    delOrderWorkstations.add(old);
                }
            });
        }
        if (Func.isNotEmpty(delOrderWorkstations)) {
            this.orderWorkstationService.removeBatchByIds(delOrderWorkstations);
        }
        if (Func.isNotEmpty(orderWorkstationSaveList)) {
            this.orderWorkstationService.saveBatch(orderWorkstationSaveList);
        }
        return Boolean.valueOf(this.orderProcessService.updateBatchById(orderProcessUpdateList));
    }

    private void packageProcessWorkstation(Order order, List<OrderWorkstation> orderWorkstationSaveList, List<OrderWorkstation> oldWorkstations, OrderProcess orderProcess) {
        if (Func.isNotEmpty(orderProcess.getWorkstationId())) {
            List<Long> oldWorkstationIds = (List) oldWorkstations.stream().map((v0) -> {
                return v0.getWorkstationId();
            }).collect(Collectors.toList());
            String[] workstationIdSplit = orderProcess.getWorkstationId().split(",");
            String[] workstationNameSplit = orderProcess.getWorkstationName().split(",");
            for (int i = 0; i < workstationIdSplit.length; i++) {
                if (!oldWorkstationIds.contains(Long.valueOf(workstationIdSplit[i]))) {
                    OrderWorkstation orderWorkstation = new OrderWorkstation();
                    orderWorkstation.setWorkstationId(Long.valueOf(workstationIdSplit[i]));
                    if (Func.isNotEmpty(workstationNameSplit) && workstationNameSplit.length == workstationIdSplit.length) {
                        orderWorkstation.setWorkstationName(workstationNameSplit[i]);
                    }
                    orderWorkstation.setWorkstationStatus(WorkstationStatusEnum.UNDRESSED.getCode());
                    orderWorkstation.setPlanId(order.getPlanId());
                    orderWorkstation.setOrderId(order.getId());
                    orderWorkstation.setProcessId(orderProcess.getId());
                    orderWorkstationSaveList.add(orderWorkstation);
                }
            }
        }
    }

    @Override // org.springblade.modules.coproduction.service.IPlanService
    public IPage<Plan> listPage(IPage<Plan> page, PlanQueryVO planQueryVO) {
        QueryWrapper<Plan> queryWrapper = new QueryWrapper<>();
        handlerSystemField(planQueryVO, queryWrapper);
        String extraFiledSql = this.handlerFieldSqlParse.getExtraFiledSql(planQueryVO.getFilter(), BusinessTypeEnums.PLAN_ORDER.getCode());
        queryWrapper.apply(Func.isNotEmpty(extraFiledSql), extraFiledSql, new Object[0]);
        order(planQueryVO.getSortName(), planQueryVO.getOrder(), queryWrapper);
        IPage<Plan> page2 = page(page, queryWrapper);
        List<Plan> records = page2.getRecords();
        Map<Long, List<Order>> orderMap = getOrderMap(records);
        Map<String, String> productTypeMap = getProductTypeNameMap(records);
        for (Plan plan : records) {
            String fieldResult = this.handlerFieldSqlParse.handlerFieldQueryResult(planQueryVO.getTypeId(), plan.getExtendField());
            plan.setExtendField(fieldResult);
            List<Order> orders = orderMap.get(plan.getId());
            if (Func.isNotEmpty(orders)) {
                String reportSituation = (String) orders.stream().map(order -> {
                    return String.valueOf(order.getQualifyNum().intValue() + order.getScrappedNum().intValue());
                }).collect(Collectors.joining("/"));
                plan.setReportSituation(reportSituation);
            }
            String productTypeName = productTypeMap.get(String.valueOf(plan.getProductId()));
            plan.setProductTypeLabel(productTypeName);
            plan.setHavePlanOrder(Boolean.valueOf(Func.isNotEmpty(orders)));
        }
        return page2;
    }

    private void order(String sortName, String order, QueryWrapper<Plan> queryWrapper) {
        if (Func.isNotEmpty(sortName) && Func.isNotEmpty(order)) {
            queryWrapper.orderBy(Boolean.TRUE.booleanValue(), order.equals(FieldConstant.ASC), StrUtil.toUnderlineCase(sortName));
        } else {
            queryWrapper.orderByDesc(SystemFieldConstant.CREATE_TIME, new String[]{"code"});
        }
    }

    /* JADX WARN: Multi-variable type inference failed */
    private Map<Long, List<Order>> getOrderMap(List<Plan> plans) {
        Map<Long, List<Order>> orderMap = new HashMap<>(10);
        if (Func.isNotEmpty(plans)) {
        	List<Long> planIds = plans.stream().map(Plan::getId).collect(Collectors.toList());
        	List<Order> orderList = this.orderService.list(Wrappers.<Order>lambdaQuery().in(CollectionUtil.isNotEmpty(planIds), Order::getPlanId, planIds));
        	/*
            List<Order> orderList = this.orderService.list((Wrapper) Wrappers.lambdaQuery().in(CollectionUtil.isNotEmpty(planIds), (v0) -> {
                return v0.getPlanId();
            }, planIds));
           
            orderMap = (Map) orderList.stream().collect(Collectors.groupingBy((v0) -> {
                return v0.getPlanId();
            })); */
            orderMap = orderList.stream().collect(Collectors.groupingBy(Order::getPlanId));
        }
        return orderMap;
    }

    /* JADX WARN: Multi-variable type inference failed */
    private Map<String, String> getProductTypeNameMap(List<Plan> plans) {
        Map<String, String> productTypeMap = new HashMap<>(10);
        List<Long> products = (List) plans.stream().map((v0) -> {
            return v0.getProductId();
        }).filter((v0) -> {
            return Func.isNotEmpty(v0);
        }).collect(Collectors.toList());
        if (Func.isNotEmpty(products)) {
            List<PlanProductTypeDTO> productTypeRes = this.planMapper.getProductType(products);
            productTypeMap = (Map) productTypeRes.stream().collect(Collectors.toMap((v0) -> {
                return v0.getProductId();
            }, (v0) -> {
                return v0.getProductTypeName();
            }));
        }
        return productTypeMap;
    }

    private void handlerSystemField(PlanQueryVO planQueryVO, QueryWrapper<Plan> wrapper) {
        wrapper.eq(Func.isNotEmpty(planQueryVO.getTypeId()), SystemFieldConstant.TYPE_ID, planQueryVO.getTypeId()).eq(Func.isNotEmpty(planQueryVO.getCategory()), SystemFieldConstant.CATEGORY, planQueryVO.getCategory()).likeRight(Func.isNotEmpty(planQueryVO.getCode()), "code", planQueryVO.getCode()).likeRight(Func.isNotEmpty(planQueryVO.getIndentCode()), SystemFieldConstant.INDENT_CODE, planQueryVO.getIndentCode()).likeRight(Func.isNotEmpty(planQueryVO.getStandardModel()), SystemFieldConstant.STANDARD_MODEL, planQueryVO.getStandardModel()).in(Func.isNotEmpty(planQueryVO.getPlanStatus()), SystemFieldConstant.PLAN_STATUS, planQueryVO.getPlanStatus()).ge(Func.isNotEmpty(planQueryVO.getPlanStartTime()), SystemFieldConstant.PLAN_START_TIME, planQueryVO.getPlanStartTime()).le(Func.isNotEmpty(planQueryVO.getPlanEndTime()), SystemFieldConstant.PLAN_END_TIME, planQueryVO.getPlanEndTime()).likeRight(Func.isNotEmpty(planQueryVO.getProductName()), SystemFieldConstant.PRODUCT_NAME, planQueryVO.getProductName());
        if (Func.isNotEmpty(planQueryVO.getProductTypeIds())) {
            List<Long> productIds = getProductIds(planQueryVO.getProductTypeIds());
            wrapper.in(Func.isNotEmpty(productIds), SystemFieldConstant.PRODUCT_ID, productIds);
        }
    }

    private List<Long> getProductIds(List<Long> productTypeIds) {
    	List<Product> products = this.productService.list(Wrappers.<Product>lambdaQuery().in(CollectionUtil.isNotEmpty(productTypeIds), Product::getTypeId, productTypeIds));
        if (CollectionUtil.isEmpty(products)) {
            return new ArrayList<>();
        }
        return products.stream().map(Product::getId).collect(Collectors.toList());
    }

    @Override // org.springblade.modules.coproduction.service.IPlanService
    @Transactional(rollbackFor = {Exception.class})
    public Plan modify(PlanModifyVO planModifyVO) {
        Plan historyPlan = getPlan(String.valueOf(planModifyVO.getId()));
        checkPlanIsEditable(historyPlan, planModifyVO);
        Plan plan = PlanConvert.INSTANCE.convertModifyPlan(planModifyVO);
        plan.setUnassignedNum(Integer.valueOf(planModifyVO.getPlanNum().intValue() - historyPlan.getAssignedNum().intValue()));
        plan.setStartTime(historyPlan.getStartTime());
        plan.setEndTime(historyPlan.getEndTime());
        if (plan.getUnassignedNum().equals(plan.getPlanNum())) {
            plan.setPlanStatus(PlanStatusEnum.WAIT_PUBLISH.getCode());
        } else if (plan.getPlanNum().equals(Integer.valueOf(historyPlan.getQualifyNum().intValue() + historyPlan.getScrappedNum().intValue())) && plan.getUnassignedNum().equals(CommonConstant.ZERO)) {
        	plan.setPlanStatus(PlanStatusEnum.FINISHED.getCode());
            Order order = this.orderService.getOne(Wrappers.<Order>lambdaQuery()
                .eq(Order::getPlanId, plan.getId())
                .eq(Order::getOrderStatus, OrderStatusEnum.COMPLETE.getCode())
                .orderByDesc(Order::getEndTime), Boolean.FALSE.booleanValue());
            
            plan.setEndTime(order.getEndTime());
        }
        updateById(plan);
        return plan;
    }

    @Override // org.springblade.modules.coproduction.service.IPlanService
    public Plan getPlan(String id) {
        if (Func.isEmpty(id)) {
            throw new ServiceException(MessageUtils.message("plan.not.found", new Object[0]));
        }
        Plan plan = (Plan) getById(id);
        if (Func.isEmpty(plan)) {
            throw new ServiceException(MessageUtils.message("plan.not.found", new Object[0]));
        }
        return plan;
    }

    @Override // org.springblade.modules.coproduction.service.IPlanService
    public List<PlanStatusCountVO> statusCount(String templateId) {
        List<PlanStatusCountVO> result = new ArrayList<>();
        List<Plan> list = list(Wrappers.<Plan>lambdaQuery().select(Plan::getPlanStatus).eq(Plan::getTypeId, templateId));
        Map<Integer, Integer> countMap = new HashMap<>(8);
        if (Func.isNotEmpty(list)) {
        	countMap = list.stream().collect(Collectors.groupingBy(Plan::getPlanStatus, Collectors.mapping(Plan::getPlanStatus, Collectors.reducing(Integer.valueOf(0), e -> Integer.valueOf(1), Integer::sum)))); 
        }
        packageStatusCountInfo(countMap, result, PlanStatusEnum.WAIT_PUBLISH);
        packageStatusCountInfo(countMap, result, PlanStatusEnum.WAIT_MACHINE);
        packageStatusCountInfo(countMap, result, PlanStatusEnum.MACH_ING);
        packageStatusCountInfo(countMap, result, PlanStatusEnum.PAUSE);
        packageStatusCountInfo(countMap, result, PlanStatusEnum.FINISHED);
        packageStatusCountInfo(countMap, result, PlanStatusEnum.CLOSE);
        return result;
    }

    @Override // org.springblade.modules.coproduction.service.IPlanService
    public void updatePlanByStart(Plan plan, Date startTime) {
        if (PlanStatusEnum.WAIT_MACHINE.getCode().equals(plan.getPlanStatus())) {
            plan.setPlanStatus(PlanStatusEnum.MACH_ING.getCode());
            if (Func.isEmpty(plan.getStartTime())) {
                plan.setStartTime(startTime);
            }
            updateById(plan);
        }
    }

    @Override // org.springblade.modules.coproduction.service.IPlanService
    public Boolean checkPlanStatus(Long planId) {
        boolean result = false;
        Plan plan = (Plan) getById(planId);
        if (plan == null) {
            throw new ServiceException("计划不存在");
        }
        List<Integer> planStatus = Arrays.asList(PlanStatusEnum.PAUSE.getCode(), PlanStatusEnum.CLOSE.getCode());
        if (planStatus.contains(plan.getPlanStatus())) {
            result = true;
        }
        return Boolean.valueOf(result);
    }

    @Override // org.springblade.modules.coproduction.service.IPlanService
    public List<PlanCraftVO> listCraft() {
        List<PlanCraftDTO> planCrafts = this.planMapper.getListCraft();
        if (Func.isEmpty(planCrafts)) {
            return Collections.emptyList();
        }
        List<PlanCraftVO> result = new ArrayList<>();
        Map<Long, List<PlanCraftDTO>> craftMap = planCrafts.stream().collect(Collectors.groupingBy(PlanCraftDTO::getCraftId));
       
        craftMap.forEach((craftId, crafts) -> {
            if (Func.isEmpty(crafts)) {
                return;
            }
            PlanCraftDTO planCraftData = (PlanCraftDTO) crafts.get(CommonConstant.ZERO.intValue());
            PlanCraftVO planCraftVO = PlanConvert.INSTANCE.convertCraft(planCraftData);
            List<PlanCraftVersionVO> versionList = new ArrayList<>();
            crafts.forEach(c -> {
                versionList.add(c.getCraftVersion());
            });
            planCraftVO.setCraftVersions(versionList);
            result.add(planCraftVO);
        });
        return result;
    }

    @Override // org.springblade.modules.coproduction.service.IPlanService
    public List<PlanBomVO> listBom(Long id) {
        if (Func.isEmpty(id)) {
        	return new ArrayList<>(); 
        }
        List<BomVersion> list = this.bomVersionService.list(Wrappers.<BomVersion>lambdaQuery().eq(BomVersion::getCraftId, id)
                .eq(BomVersion::getVersionStatus, CommonConstant.ENABLE));
        return PlanConvert.INSTANCE.convertBom(list);
    }

    @Override // org.springblade.modules.coproduction.service.IPlanService
    public CraftRoutingDetailVO getCraftPlan(Long id) {
        if (Func.isEmpty(id)) {
            return new CraftRoutingDetailVO();
        }
        Plan plan = getPlan(String.valueOf(id));
        if (Func.isEmpty(plan.getCraftId())) {
            return new CraftRoutingDetailVO();
        }
        return this.craftRoutingService.detailCraft(plan.getCraftId());
    }

    private void packageStatusCountInfo(Map<Integer, Integer> countMap, List<PlanStatusCountVO> result, PlanStatusEnum planStatusEnum) {
        PlanStatusCountVO fVO = new PlanStatusCountVO();
        fVO.setPlanStatus(planStatusEnum.getCode());
        fVO.setPlanStatusStr(planStatusEnum.getName());
        if (countMap.containsKey(planStatusEnum.getCode())) {
            fVO.setCount(countMap.get(planStatusEnum.getCode()));
        }
        result.add(fVO);
    }

    private void checkPlanIsEditable(Plan plan, PlanModifyVO planModifyVO) {
        planBaseCheck(planModifyVO.getPlanNum(), planModifyVO.getPlanStartTime(), planModifyVO.getPlanEndTime(), planModifyVO.getExtendField());
        Integer planStatus = plan.getPlanStatus();
        if (planStatus.equals(PlanStatusEnum.PAUSE.getCode()) || planStatus.equals(PlanStatusEnum.CLOSE.getCode()) || planStatus.equals(PlanStatusEnum.FINISHED.getCode())) {
            throw new ServiceException(MessageUtils.message("plan.status.not.modify", new Object[0]));
        }
        if (Func.isEmpty(planModifyVO.getPlanNum()) || planModifyVO.getPlanNum().intValue() < plan.getAssignedNum().intValue()) {
            throw new ServiceException(MessageUtils.message("plan.num.not.less.than.have.been.distributed.num", new Object[0]));
        }
    }

    private void planBaseCheck(Integer planNum, Date startTime, Date endTime, String exJson) {
        if (planNum.intValue() <= 0) {
            throw new ServiceException(MessageUtils.message("plan.num.must.greater.than.zero", new Object[0]));
        }
        if (endTime.compareTo((Date) cn.hutool.core.date.DateUtil.parseDate(LocalDate.now().toString())) < 0) {
            throw new ServiceException(MessageUtils.message("cps.plan.start.time.cannot.be.greater.than.the.end.time", new Object[0]));
        }
        if (startTime.compareTo(endTime) > 0) {
            throw new ServiceException(MessageUtils.message("cps.plan.start.time.not.be.greater.than.end.time", new Object[0]));
        }
        this.handlerFieldSqlParse.handlerFieldSaveOrUpdateCheck(exJson, BusinessTypeEnums.PLAN_ORDER.getCode());
    }

    @Override // org.springblade.modules.coproduction.service.IPlanService
    @Transactional(rollbackFor = {Exception.class})
    public void reportPlan(Plan plan, Integer orderQualifyNum, Integer orderScrappedNum, Boolean isDel) {
        Long planId = plan.getId();
        Integer oldQualifyNum = Func.isNotEmpty(plan.getQualifyNum()) ? plan.getQualifyNum() : CommonConstant.ZERO;
        Integer oldScrappedNum = Func.isNotEmpty(plan.getScrappedNum()) ? plan.getScrappedNum() : CommonConstant.ZERO;
        Integer planNum = plan.getPlanNum();
        Integer newQualifyNum = Integer.valueOf(oldQualifyNum.intValue() + orderQualifyNum.intValue());
        Integer newScrappedNum = Integer.valueOf(oldScrappedNum.intValue() + orderScrappedNum.intValue());
        Integer newReportNum = Integer.valueOf(newQualifyNum.intValue() + newScrappedNum.intValue());
        if (planNum.intValue() < newReportNum.intValue()) {
            throw new ServiceException(MessageUtils.message("production.report.fail.report.num.less.than.plan.num", new Object[0]));
        }
        plan.setQualifyNum(newQualifyNum);
        plan.setScrappedNum(newScrappedNum);
        plan.setReportNum(newReportNum);
        
        LambdaUpdateWrapper<Plan> planLambdaUpdateWrapper = Wrappers.<Plan>lambdaUpdate().eq(Plan::getId, planId);
        
        boolean completePlan = false;
        if (planNum.equals(newReportNum)) {
            completePlan = true;
        }
        if (completePlan) {
            planLambdaUpdateWrapper.set((v0) -> {
                return v0.getPlanStatus();
            }, PlanStatusEnum.FINISHED.getCode());
            Date endTime = null;
            OrderReportRecord latestRecord = this.orderReportRecordService.getLatestRecord(planId, null, null);
            if (latestRecord != null) {
                endTime = latestRecord.getWorkshopTime();
            }
            if (endTime == null) {
                endTime = new Date();
            }
            plan.setEndTime(endTime);
        }
        if (planNum.intValue() > newReportNum.intValue() && PlanStatusEnum.FINISHED.getCode().equals(plan.getPlanStatus())) {
        	planLambdaUpdateWrapper.set(Plan::getPlanStatus, PlanStatusEnum.MACH_ING.getCode());
            planLambdaUpdateWrapper.set(Plan::getPlanEndTime, null);
        }
        if (isDel.booleanValue()) {
            updatePlanStartTime(plan, planLambdaUpdateWrapper);
        }
        update(plan, planLambdaUpdateWrapper);
    }

    private void updatePlanStartTime(Plan plan, LambdaUpdateWrapper<Plan> planLambdaUpdateWrapper) {
        Date startTime = null;
        OrderReportRecord earliestRecord = this.orderReportRecordService.getEarliestRecord(plan.getId(), null, null, null);
        if (earliestRecord != null) {
            startTime = earliestRecord.getStartTime();
        }
        if (startTime == null) {
        	planLambdaUpdateWrapper.set(Plan::getStartTime, null);
            planLambdaUpdateWrapper.set(Plan::getPlanStatus, PlanStatusEnum.WAIT_MACHINE.getCode());
            
        }
        if (!plan.getStartTime().equals(startTime)) {
        	planLambdaUpdateWrapper.set(Plan::getStartTime, startTime); 
        }
    }

    @Override // org.springblade.modules.coproduction.service.IPlanService
    @Transactional(rollbackFor = {Exception.class})
    public Plan reportCurrentPlan(List<OrderProcessReportWorkDTO> reportWorkDTOList, Plan plan, Integer orderQualityNum) {
        List<OrderProcessReportWorkDTO> reportRecords = (List) reportWorkDTOList.stream().filter(s -> {
            return Func.isEmpty(s.getMainSequenceId());
        }).collect(Collectors.toList());
        Integer reportScrappedNum = (Integer) reportRecords.stream().map((v0) -> {
            return v0.getScrappedNum();
        }).reduce(0, (v0, v1) -> {
            return Integer.sum(v0, v1);
        });
        Integer planNum = plan.getPlanNum();
        Integer newQualifyNum = Integer.valueOf(plan.getQualifyNum().intValue() + (orderQualityNum == null ? 0 : orderQualityNum.intValue()));
        Integer newScrappedNum = Integer.valueOf(plan.getScrappedNum().intValue() + reportScrappedNum.intValue());
        Integer newReportNum = Integer.valueOf(newQualifyNum.intValue() + newScrappedNum.intValue());
        if (planNum.intValue() < newReportNum.intValue()) {
            throw new ServiceException(MessageUtils.message("production.report.fail.report.num.less.than.plan.num", new Object[0]));
        }
        boolean completePlan = false;
        if (planNum.equals(newReportNum)) {
            completePlan = true;
        }
        if (completePlan) {
            plan.setPlanStatus(PlanStatusEnum.FINISHED.getCode());
            plan.setReportNum(newReportNum);
            Date endTime = null;
            OrderReportRecord latestRecord = this.orderReportRecordService.getLatestRecord(plan.getId(), null, null);
            if (latestRecord != null) {
                endTime = latestRecord.getWorkshopTime();
            }
            if (endTime == null) {
                endTime = new Date();
            }
            plan.setEndTime(endTime);
        } else {
            plan.setPlanStatus(PlanStatusEnum.MACH_ING.getCode());
            plan.setEndTime(null);
        }
        plan.setReportNum(newReportNum);
        plan.setQualifyNum(newQualifyNum);
        plan.setScrappedNum(newScrappedNum);
        return plan;
    }

    @Override // org.springblade.modules.coproduction.service.IPlanService
    public Plan delReportRecordCurrentPlan(List<OrderProcessReportWorkDTO> reportWorkDTOList, Plan plan, Order order, List<Long> removeRecordIds) {
        List<OrderProcessReportWorkDTO> reportRecords = (List) reportWorkDTOList.stream().filter(s -> {
            return Func.isEmpty(s.getMainSequenceId());
        }).collect(Collectors.toList());
        Integer reportScrappedNum = (Integer) reportRecords.stream().map((v0) -> {
            return v0.getScrappedNum();
        }).reduce(0, (v0, v1) -> {
            return Integer.sum(v0, v1);
        });
        Integer delNum = Integer.valueOf(order.getDelOrderNum() == null ? 0 : order.getDelOrderNum().intValue());
        Integer planNum = plan.getPlanNum();
        Integer newQualifyNum = Integer.valueOf(plan.getQualifyNum().intValue() + delNum.intValue());
        Integer newScrappedNum = Integer.valueOf(plan.getScrappedNum().intValue() + reportScrappedNum.intValue());
        Integer newReportNum = Integer.valueOf(newQualifyNum.intValue() + newScrappedNum.intValue());
        if (planNum.intValue() < newReportNum.intValue()) {
            throw new ServiceException(MessageUtils.message("production.report.fail.report.num.less.than.plan.num", new Object[0]));
        }
        if (planNum.intValue() == newQualifyNum.intValue() + newScrappedNum.intValue()) {
            plan.setPlanStatus(PlanStatusEnum.FINISHED.getCode());
            plan.setReportNum(newReportNum);
            plan.setEndTime(cn.hutool.core.date.DateUtil.date());
        } else {
            plan.setPlanStatus(PlanStatusEnum.MACH_ING.getCode());
            plan.setEndTime(null);
        }
        boolean completePlan = false;
        if (planNum.equals(newReportNum)) {
            completePlan = true;
        }
        if (!completePlan) {
            plan.setEndTime(null);
        }
        plan.setQualifyNum(newQualifyNum);
        plan.setScrappedNum(newScrappedNum);
        plan.setReportNum(newReportNum);
        delRecordPlanStartTime(plan, removeRecordIds);
        return plan;
    }

    private void delRecordPlanStartTime(Plan plan, List<Long> removeRecordIds) {
        Date startTime = null;
        OrderReportRecord earliestRecord = this.orderReportRecordService.getEarliestRecord(plan.getId(), null, null, removeRecordIds);
        if (earliestRecord != null) {
            startTime = earliestRecord.getStartTime();
        }
        if (startTime == null) {
            plan.setStartTime(null);
            plan.setPlanStatus(PlanStatusEnum.WAIT_MACHINE.getCode());
        }
        Date planStartTime = plan.getStartTime();
        if (startTime != null && planStartTime != null && !planStartTime.equals(startTime)) {
            plan.setStartTime(startTime);
        }
    }
}