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

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.extension.plugins.pagination.Page;
import com.google.common.collect.Lists;
import java.lang.invoke.SerializedLambda;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
import com.qianwen.smartman.common.cache.RegionCache;
import com.qianwen.smartman.common.constant.CommonConstant;
import com.qianwen.smartman.common.constant.ExcelConstant;
import com.qianwen.smartman.common.utils.Lambda;
import com.qianwen.smartman.common.utils.MessageUtils;
import com.qianwen.smartman.common.utils.TimeUtils;
import com.qianwen.core.excel.util.ExcelUtil;
import com.qianwen.core.log.exception.ServiceException;
import com.qianwen.core.mp.base.BaseServiceImpl;
import com.qianwen.core.mp.support.Condition;
import com.qianwen.core.mp.support.Query;
import com.qianwen.core.oss.model.BladeFile;
import com.qianwen.core.tool.utils.DateUtil;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.smartman.modules.coproduction.convert.OrderReportRecordConvert;
import com.qianwen.smartman.modules.coproduction.convert.ReportConvert;
import com.qianwen.smartman.modules.coproduction.dto.JuxtapositionReportDTO;
import com.qianwen.smartman.modules.coproduction.dto.OrderProcessReportWorkDTO;
import com.qianwen.smartman.modules.coproduction.dto.OrderReportDTO;
import com.qianwen.smartman.modules.coproduction.dto.PlanAndOrderDTO;
import com.qianwen.smartman.modules.coproduction.dto.ReportWorkDTO;
import com.qianwen.smartman.modules.coproduction.dto.ReportWorkDetailDTO;
import com.qianwen.smartman.modules.coproduction.dto.ResultByStartDTO;
import com.qianwen.smartman.modules.coproduction.entity.OrderProcess;
import com.qianwen.smartman.modules.coproduction.entity.OrderReportRecord;
import com.qianwen.smartman.modules.coproduction.enums.CoProductionEnum;
import com.qianwen.smartman.modules.coproduction.enums.OrderReportRecordStatusEnum;
import com.qianwen.smartman.modules.coproduction.excel.OrderReportRecordExport;
import com.qianwen.smartman.modules.coproduction.mapper.OrderReportRecordMapper;
import com.qianwen.smartman.modules.coproduction.service.IOrderProcessService;
import com.qianwen.smartman.modules.coproduction.service.IOrderReportRecordService;
import com.qianwen.smartman.modules.coproduction.service.IPlanService;
import com.qianwen.smartman.modules.coproduction.vo.OpRecordExportVO;
import com.qianwen.smartman.modules.coproduction.vo.OrderChildRecordVO;
import com.qianwen.smartman.modules.coproduction.vo.OrderProcessStartWorkstationVO;
import com.qianwen.smartman.modules.coproduction.vo.OrderReportRecordResVO;
import com.qianwen.smartman.modules.coproduction.vo.OrderReportRecordSearchVO;
import com.qianwen.smartman.modules.resource.builder.oss.OssBuilder;
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/OrderReportRecordServiceImpl.class */
public class OrderReportRecordServiceImpl extends BaseServiceImpl<OrderReportRecordMapper, OrderReportRecord> implements IOrderReportRecordService {
    private final IOrderProcessService orderProcessService;
    private final IPlanService planService;
    private final OssBuilder ossBuilder;


    public OrderReportRecordServiceImpl(IOrderProcessService orderProcessService, IPlanService planService, OssBuilder ossBuilder) {
        this.orderProcessService = orderProcessService;
        this.planService = planService;
        this.ossBuilder = ossBuilder;
    }

    @Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
    public List<OrderReportRecord> generateStartRecord(ResultByStartDTO resultByStartDTO, PlanAndOrderDTO planAndOrderDTO, Date startTime, Map<Long, OrderProcessStartWorkstationVO> workstationVoMap, Long mainSequenceId, Long openSequenceId) {
        List<OrderReportRecord> orderReportRecordList = new ArrayList<>();
        resultByStartDTO.getCanStartWorkstationIdList().forEach(i -> {
            OrderReportRecord orderReportRecord = new OrderReportRecord();
            orderReportRecord.setPlanId(planAndOrderDTO.getPlan().getId());
            orderReportRecord.setOrderId(planAndOrderDTO.getOrder().getId());
            orderReportRecord.setProcessId(resultByStartDTO.getWorkstationAndOrderProcessIdMap().get(i));
            orderReportRecord.setWorkstationId(i);
            orderReportRecord.setWorkstationName(((OrderProcessStartWorkstationVO) workstationVoMap.get(i)).getWorkstationName());
            orderReportRecord.setProducerUserId(((OrderProcessStartWorkstationVO) workstationVoMap.get(i)).getProducerId());
            orderReportRecord.setProducerUserCode(((OrderProcessStartWorkstationVO) workstationVoMap.get(i)).getProducerCode());
            orderReportRecord.setProducerUserName(((OrderProcessStartWorkstationVO) workstationVoMap.get(i)).getProducerName());
            orderReportRecord.setStartTime(startTime);
            orderReportRecord.setRecordStatus(OrderReportRecordStatusEnum.STARTED.getCode());
            orderReportRecord.setMainSequenceId(mainSequenceId);
            orderReportRecord.setOpenSequenceId(openSequenceId);
            orderReportRecordList.add(orderReportRecord);
        });
        saveBatch(orderReportRecordList);
        return orderReportRecordList;
    }

    @Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
    public ReportWorkDetailDTO getReportWorkDetail(Long processId) {
    	OrderProcess orderProcess = (OrderProcess)this.orderProcessService.getById(processId);
        if (orderProcess == null)
          throw new ServiceException(MessageUtils.message("production.loading.report.detail.fail.process.is.not.exist", new Object[0])); 
        Integer whetherParallel = orderProcess.getWhetherParallel();
        ReportWorkDetailDTO reportWorkDetailDTO = new ReportWorkDetailDTO();
        OrderReportDTO orderHead = ((OrderReportRecordMapper)this.baseMapper).getOrderHead(processId);
        reportWorkDetailDTO.setReportDTO(orderHead);
        List<JuxtapositionReportDTO> juxtapositionReportList = new LinkedList<>();
        if (CoProductionEnum.WhetherParallel.YES.getCode().equals(whetherParallel)) {
          List<OrderProcess> childProcess = this.orderProcessService.list(Wrappers.<OrderProcess>lambdaQuery().eq(OrderProcess::getMainSequenceId, processId));
          Map<Long, OrderProcess> childProcessMap = (Map<Long, OrderProcess>)childProcess.stream().collect(Collectors.toMap(OrderProcess::getId, Function.identity()));
          List<OrderReportRecord> list = list(Wrappers.<OrderReportRecord>lambdaQuery()
              .eq(OrderReportRecord::getProcessId, processId)
              .eq(OrderReportRecord::getRecordStatus, CoProductionEnum.RecordStatus.NO.getCode()));
          if (Func.isNotEmpty(list)) {
            int size = list.size();
            if (size > 1)
              throw new ServiceException(MessageUtils.message("production.loading.report.detail.fail.parallel.main.process.only.one.record", new Object[0])); 
            OrderReportRecord mainOrderReportRecord = list.get(0);
            JuxtapositionReportDTO mainJuxtapositionReport = assembleReportData(mainOrderReportRecord, orderProcess.getProcessName(), orderProcess.getProcessCode());
            juxtapositionReportList.add(mainJuxtapositionReport);
            Long mainId = mainOrderReportRecord.getId();
            List<OrderReportRecord> suborderList = list(Wrappers.<OrderReportRecord>lambdaQuery().eq(OrderReportRecord::getOpenSequenceId, mainId));
            if (Func.isNotEmpty(suborderList)) {
              List<JuxtapositionReportDTO> whetherParallelProcessRecord = (List<JuxtapositionReportDTO>)suborderList.stream().map(s -> {
                    OrderProcess child = (OrderProcess)childProcessMap.get(s.getProcessId());
                    return assembleReportData(s, child.getProcessName(), child.getProcessCode());
                  }).collect(Collectors.toList());
              juxtapositionReportList.addAll(whetherParallelProcessRecord);
            } 
          } 
        } else {
          List<OrderReportRecord> commonlyList = list(Wrappers.<OrderReportRecord>lambdaQuery()
              .eq(OrderReportRecord::getProcessId, processId)
              .eq(OrderReportRecord::getRecordStatus, CoProductionEnum.RecordStatus.NO.getCode()));
          if (Func.isNotEmpty(commonlyList)) {
            List<JuxtapositionReportDTO> whetherParallelProcessRecord = (List<JuxtapositionReportDTO>)commonlyList.stream().map(commonlyProcess -> assembleReportData(commonlyProcess, orderProcess.getProcessName(), orderProcess.getProcessCode())).collect(Collectors.toList());
            juxtapositionReportList.addAll(whetherParallelProcessRecord);
          } 
        } 
        if (Func.isNotEmpty(juxtapositionReportList)) {
          reportWorkDetailDTO.setJuxtapositionReports(juxtapositionReportList);
          String workstationNames = juxtapositionReportList.stream().map(JuxtapositionReportDTO::getWorkstationName).filter(Func::isNotBlank).distinct().collect(Collectors.joining(","));
          reportWorkDetailDTO.setWorkstationNames(workstationNames);
        } 
        return reportWorkDetailDTO;
    }

    @Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
    public OrderReportRecord generateStartMainRecord(PlanAndOrderDTO planAndOrderDTO, Long orderProcessId, Date startTime) {
        OrderReportRecord orderReportRecord = new OrderReportRecord();
        orderReportRecord.setPlanId(planAndOrderDTO.getPlan().getId());
        orderReportRecord.setOrderId(planAndOrderDTO.getOrder().getId());
        orderReportRecord.setProcessId(orderProcessId);
        orderReportRecord.setStartTime(startTime);
        orderReportRecord.setRecordStatus(OrderReportRecordStatusEnum.STARTED.getCode());
        save(orderReportRecord);
        return orderReportRecord;
    }

    @Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
    @Transactional(rollbackFor = {Exception.class})
    public Boolean updateRecord(OrderProcessReportWorkDTO workDTO, OrderReportRecord orderReportRecord, OrderProcess orderProcess) {
    	int qualifyNum = workDTO.getQualifyNum().intValue() + ((orderReportRecord.getQualifyNum() == null) ? 0 : orderReportRecord.getQualifyNum().intValue());
        int scrappedNum = workDTO.getScrappedNum().intValue() + ((orderReportRecord.getScrappedNum() == null) ? 0 : orderReportRecord.getScrappedNum().intValue());
        Integer whetherParallel = orderProcess.getWhetherParallel();
        if (Func.isEmpty(orderReportRecord.getMainSequenceId()) && qualifyNum == 0 && scrappedNum == 0)
          throw new ServiceException(MessageUtils.message("production.report.fail.is.not.parallel.qualifyNum.and.scrappedNum.is.not.zero", new Object[0])); 
        return Boolean.valueOf(update(Wrappers.<OrderReportRecord>lambdaUpdate()
              .eq(OrderReportRecord::getId, orderReportRecord.getId())
              .set(OrderReportRecord::getQualifyNum, Integer.valueOf(qualifyNum))
              .set(OrderReportRecord::getScrappedNum, Integer.valueOf(scrappedNum))
              .set(OrderReportRecord::getWorkshopUserId, workDTO.getWorkshopUserId())
              .set(OrderReportRecord::getWorkshopUserCode, workDTO.getWorkshopUserCode())
              .set(OrderReportRecord::getWorkshopUserName, workDTO.getWorkshopUserName())
              .set(OrderReportRecord::getQualityUserId, workDTO.getQualityUserId())
              .set(OrderReportRecord::getQualityUserCode, workDTO.getQualityUserCode())
              .set(OrderReportRecord::getQualityUserName, workDTO.getQualityUserName())
              .set(OrderReportRecord::getRecordStatus, CoProductionEnum.RecordStatus.YES.getCode())
              .set(OrderReportRecord::getRemark, workDTO.getRemark())));
    }

    @Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
    @Transactional(rollbackFor = {Exception.class})
    public OrderReportRecord buildReportRecord(OrderProcessReportWorkDTO reportWorkDTO, OrderReportRecord orderReportRecord) {
        orderReportRecord.setQualifyNum(Integer.valueOf(reportWorkDTO.getQualifyNum().intValue() + orderReportRecord.getQualifyNum().intValue())).setScrappedNum(Integer.valueOf(reportWorkDTO.getScrappedNum().intValue() + orderReportRecord.getScrappedNum().intValue())).setWorkshopUserId(Long.valueOf(Func.toLong(reportWorkDTO.getWorkshopUserId()))).setWorkshopUserName(reportWorkDTO.getWorkshopUserName()).setWorkshopUserCode(reportWorkDTO.getWorkshopUserCode()).setQualityUserId(Long.valueOf(Func.toLong(reportWorkDTO.getQualityUserId()))).setQualityUserName(reportWorkDTO.getQualityUserName()).setQualityUserCode(reportWorkDTO.getQualityUserCode()).setRemark(reportWorkDTO.getRemark()).setRecordStatus(CoProductionEnum.RecordStatus.YES.getCode()).setQualityTime(DateUtil.now()).setWorkshopTime(DateUtil.now());
        return orderReportRecord;
    }

    @Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
    public OrderReportRecord getLatestRecord(Long planId, Long orderId, Long orderProcessId) {
    	List<OrderReportRecord> list = list(Wrappers.<OrderReportRecord>lambdaQuery()
    	        .eq(Func.isNotEmpty(planId), OrderReportRecord::getPlanId, planId)
    	        .eq(Func.isNotEmpty(orderId), OrderReportRecord::getOrderId, orderId)
    	        .eq(Func.isNotEmpty(orderProcessId), OrderReportRecord::getProcessId, orderProcessId)
    	        
    	        .eq(OrderReportRecord::getRecordStatus, CoProductionEnum.RecordStatus.YES.getCode())
    	        .orderByDesc(OrderReportRecord::getWorkshopTime));

        if (Func.isNotEmpty(list)) {
            return (OrderReportRecord) list().get(0);
        }
        return null;
    }

    @Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
    public OrderReportRecord getLatestChildProcessRecord(List<Long> processIds) {
    	List<OrderReportRecord> list = list(Wrappers.<OrderReportRecord>lambdaQuery()
    	        .in(OrderReportRecord::getProcessId, processIds)
    	        
    	        .eq(OrderReportRecord::getRecordStatus, CoProductionEnum.RecordStatus.YES.getCode())
    	        .orderByDesc(OrderReportRecord::getWorkshopTime));
    	
        if (Func.isNotEmpty(list)) {
            return (OrderReportRecord) list().get(0);
        }
        return null;
    }

    @Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
    public OrderReportRecord getEarliestChildProcessRecord(List<Long> processIds, List<Long> removeRecordIds) {
    	List<OrderReportRecord> list = list(Wrappers.<OrderReportRecord>lambdaQuery()
    	        .in(OrderReportRecord::getProcessId, processIds)
    	        .orderByDesc(OrderReportRecord::getStartTime));
    	    if (Func.isNotEmpty(list)) {
    	      List<OrderReportRecord> reportRecords = (List<OrderReportRecord>)list.stream().filter(s -> (Func.isNotEmpty(removeRecordIds) && !removeRecordIds.contains(s.getId()))).collect(Collectors.toList());
    	      if (Func.isNotEmpty(reportRecords))
    	        return reportRecords.get(0); 
    	    } 
    	    return null;
    }

    @Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
    public OrderReportRecord getEarliestRecord(Long planId, Long orderId, Long orderProcessId, List<Long> removeRecordIds) {
    	List<OrderReportRecord> list = list(Wrappers.<OrderReportRecord>lambdaQuery()
    	        .eq(Func.isNotEmpty(planId), OrderReportRecord::getPlanId, planId)
    	        .eq(Func.isNotEmpty(orderId), OrderReportRecord::getOrderId, orderId)
    	        .eq(Func.isNotEmpty(orderProcessId), OrderReportRecord::getProcessId, orderProcessId)
    	        
    	        .orderByAsc(OrderReportRecord::getStartTime));
    	    if (Func.isNotEmpty(list)) {
    	      List<OrderReportRecord> reportRecords = (List<OrderReportRecord>)list.stream().filter(s -> (removeRecordIds != null && !removeRecordIds.contains(s.getId()))).collect(Collectors.toList());
    	      if (Func.isNotEmpty(reportRecords))
    	        return reportRecords.get(0); 
    	    } 
    	    return null;
    }

    @Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
    public Integer countOpenRecord(Long processId) {
    	List<OrderReportRecord> list = list(Wrappers.<OrderReportRecord>lambdaQuery()
    	        .eq(OrderReportRecord::getProcessId, processId)
    	        .eq(OrderReportRecord::getRecordStatus, CoProductionEnum.RecordStatus.NO.getCode()));
    	    if (Func.isNotEmpty(list))
    	      return Integer.valueOf(list.size()); 
    	    return CommonConstant.ZERO;
    }

    @Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
    public Integer countDelRecord(Long processId, List<Long> removeRecordIds) {
    	List<OrderReportRecord> list = list(Wrappers.<OrderReportRecord>lambdaQuery()
    	        .eq(OrderReportRecord::getProcessId, processId)
    	        .eq(OrderReportRecord::getRecordStatus, CoProductionEnum.RecordStatus.NO.getCode()));
    	    if (Func.isNotEmpty(list)) {
    	      List<OrderReportRecord> reportRecords = (List<OrderReportRecord>)list.stream().filter(s -> !removeRecordIds.contains(s.getId())).collect(Collectors.toList());
    	      if (Func.isNotEmpty(reportRecords))
    	        return Integer.valueOf(reportRecords.size()); 
    	    } 
    	    return CommonConstant.ZERO;
    }

    @Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
    @Transactional(rollbackFor = {Exception.class})
    public Boolean removeReportRecord(Long recordId) {
        OrderReportRecord delOrderReportRecord = (OrderReportRecord) getById(recordId);
        if (delOrderReportRecord == null) {
            throw new ServiceException(MessageUtils.message("production.del.record.fail.report.is.not.exist", new Object[0]));
        }
        Long mainSequenceId = delOrderReportRecord.getMainSequenceId();
        Long processId = delOrderReportRecord.getProcessId();
        if (Func.isNotEmpty(mainSequenceId)) {
            throw new ServiceException(MessageUtils.message("production.del.record.fail.is.not.del.child.process.report.record", new Object[0]));
        }
        OrderProcess orderProcess = (OrderProcess) this.orderProcessService.getById(processId);
        if (orderProcess == null) {
            throw new ServiceException(MessageUtils.message("production.report.fail.order.process.is.not.exist", new Object[0]));
        }
        Boolean checkPlan = this.planService.checkPlanStatus(delOrderReportRecord.getPlanId());
        if (checkPlan.booleanValue()) {
            throw new ServiceException(MessageUtils.message("production.del.report.fail.plan.suspend.or.close", new Object[0]));
        }
        Integer whetherParallel = orderProcess.getWhetherParallel();
        List<OrderProcessReportWorkDTO> reportWorkDTOList = new ArrayList<>();
        ReportWorkDTO reportWorkDTO = new ReportWorkDTO();
        reportWorkDTO.setPlanId(Func.toStr(delOrderReportRecord.getPlanId()));
        reportWorkDTO.setOrderId(Func.toStr(delOrderReportRecord.getOrderId()));
        reportWorkDTOList.add(buildDelData(delOrderReportRecord.getId(), delOrderReportRecord.getProcessId(), delOrderReportRecord.getMainSequenceId(), delOrderReportRecord.getOpenSequenceId(), delOrderReportRecord.getQualifyNum(), delOrderReportRecord.getScrappedNum()));
        reportWorkDTO.setReportWorkDTOList(reportWorkDTOList);
        
        if (CoProductionEnum.WhetherParallel.YES.getCode().equals(whetherParallel)) {
            List<OrderReportRecord> list = list(Wrappers.<OrderReportRecord>lambdaQuery().eq(OrderReportRecord::getOpenSequenceId, recordId));
            if (Func.isNotEmpty(list)) {
              for (OrderReportRecord delRecord : list) {
                reportWorkDTOList.add(buildDelData(delRecord.getId(), delRecord.getProcessId(), delRecord.getMainSequenceId(), delRecord.getOpenSequenceId(), delRecord.getQualifyNum(), delRecord.getScrappedNum()));
              }
            }
        } 
        
        
        Boolean result = this.orderProcessService.delReportWork(reportWorkDTO);
        if (!result.booleanValue()) {
            throw new ServiceException(MessageUtils.message("production.del.report.fail.reduce.num.fail", new Object[0]));
        }
        return true;
    }

    private OrderProcessReportWorkDTO buildDelData(Long recordId, Long processId, Long mainSequenceId, Long openSequenceId, Integer qualifyNum, Integer scrappedNum) {
        OrderProcessReportWorkDTO orderProcessReportWorkDTO = new OrderProcessReportWorkDTO();
        orderProcessReportWorkDTO.setRecordId(Func.toStr(recordId)).setMainSequenceId(mainSequenceId).setOpenSequenceId(openSequenceId).setProcessId(Func.toStr(processId)).setQualifyNum(Integer.valueOf(-qualifyNum.intValue())).setScrappedNum(Integer.valueOf(-scrappedNum.intValue()));
        return orderProcessReportWorkDTO;
    }

    @Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
    public IPage<OrderReportRecordResVO> pageQuery(OrderReportRecordSearchVO vo) {
        Query query = vo.getQuery();
        Long productId = vo.getProductId();
        Long orderId = vo.getOrderId();
        List<Long> reportEmployeeIds = vo.getReportEmployeeIds();
        List<Long> workEmployeeIds = vo.getWorkEmployeeIds();
        LocalDate startDate = vo.getStartDate();
        String startTime = Func.notNull(startDate) ? TimeUtils.getStartTime(startDate) : "";
        LocalDate endDate = vo.getEndDate();
        String endTime = Func.notNull(endDate) ? TimeUtils.getEndTime(endDate) : "";
        IPage<OrderReportRecordResVO> page = ((OrderReportRecordMapper) this.baseMapper).pageQuery(Condition.getPage(query), getWrapper(orderId, productId, reportEmployeeIds, workEmployeeIds, startTime, endTime));
        List<OrderReportRecordResVO> records = page.getRecords();
        if (Func.isEmpty(records)) {
            return new Page();
        }
        List<Long> recordIds = (List) records.stream().map((v0) -> {
            return v0.getId();
        }).collect(Collectors.toList());
        List<OrderReportRecord> recordList = list(Lambda.in((v0) -> {
            return v0.getOpenSequenceId();
        }, recordIds));
        if (Func.isEmpty(recordList)) {
            page.setRecords((List) records.stream().peek(r -> {
                if (Func.notNull(r.getStartTime()) && Func.notNull(r.getEndTime())) {
                    r.setReportTime(Long.valueOf(DateUtil.between(r.getStartTime(), r.getEndTime()).getSeconds()));
                }
            }).collect(Collectors.toList()));
            return page;
        }
        Map<Long, List<OrderReportRecord>> recordMap = (Map) recordList.stream().collect(Collectors.groupingBy((v0) -> {
            return v0.getOpenSequenceId();
        }));
        List<OrderReportRecordResVO> vos = completeData(records, recordMap);
        page.setRecords(vos);
        return page;
    }

    @Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
    public BladeFile recordExport(OpRecordExportVO vo) {
        Long productId = vo.getProductId();
        List<Long> reportEmployeeIds = vo.getReportEmployeeIds();
        List<Long> workEmployeeIds = vo.getWorkEmployeeIds();
        LocalDate startDate = vo.getStartDate();
        LocalDate endDate = vo.getEndDate();
        String startTime = Func.notNull(startDate) ? TimeUtils.getStartTime(startDate) : "";
        String endTime = Func.notNull(endDate) ? TimeUtils.getEndTime(endDate) : "";
        List<OrderReportRecordResVO> records = ((OrderReportRecordMapper) this.baseMapper).recordExport(getWrapper(vo.getOrderId(), productId, reportEmployeeIds, workEmployeeIds, startTime, endTime));
        if (Func.isEmpty(records)) {
            return exportRecord(Lists.newArrayList());
        }
        List<Long> recordIds = (List) records.stream().map((v0) -> {
            return v0.getId();
        }).collect(Collectors.toList());
        List<OrderReportRecord> recordList = list(Lambda.in((v0) -> {
            return v0.getOpenSequenceId();
        }, recordIds));
        if (Func.isEmpty(recordList)) {
            return exportNoChildRecord(records);
        }
        return exportHasChildRecord(records, recordList);
    }

    @Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
    public List<OrderChildRecordVO> queryChildRecord(String mainRecordId) {
        List<OrderReportRecord> records = list(Lambda.eq((v0) -> {
            return v0.getOpenSequenceId();
        }, mainRecordId));
        List<Long> opIds = (List) records.stream().map((v0) -> {
            return v0.getProcessId();
        }).collect(Collectors.toList());
        List<OrderProcess> orderProcessList = this.orderProcessService.listByIds(opIds);
        Map<Long, OrderProcess> map = (Map) orderProcessList.stream().collect(Collectors.toMap((v0) -> {
            return v0.getId();
        }, v -> {
            return v;
        }));
        return (List) records.stream().map(c -> {
            return convertVO(c, map);
        }).collect(Collectors.toList());
    }

    @Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
    public List<JuxtapositionReportDTO> reportRecordsDetail(Long recordId) {
        OrderReportRecord orderReportRecord = (OrderReportRecord) getById(recordId);
        List<JuxtapositionReportDTO> juxtapositionReportDTOList = new ArrayList<>();
        if (Func.isEmpty(orderReportRecord)) {
            throw new ServiceException(MessageUtils.message("production.report.fail.record.is.not.exit", new Object[0]));
        }
        OrderProcess orderProcess = (OrderProcess) this.orderProcessService.getById(orderReportRecord.getProcessId());
        if (Func.isEmpty(orderProcess)) {
            throw new ServiceException(MessageUtils.message("production.report.fail.order.process.is.not.exist", new Object[0]));
        }
        JuxtapositionReportDTO mainProcessRecord = assembleReportData(orderReportRecord, orderProcess.getProcessName(), orderProcess.getProcessCode());
        juxtapositionReportDTOList.add(mainProcessRecord);
        Integer whetherParallel = orderProcess.getWhetherParallel();
        if (CoProductionEnum.WhetherParallel.YES.getCode().equals(whetherParallel)) {
            List<OrderReportRecord> childRecordList = list(Wrappers.<OrderReportRecord>lambdaQuery().eq(OrderReportRecord::getOpenSequenceId, recordId));
            if (Func.isNotEmpty(childRecordList)) {
              childRecordList.forEach(record -> {
                    JuxtapositionReportDTO juxtapositionReportDTO = assembleReportData(record, orderProcess.getProcessName(), orderProcess.getProcessCode());
                    juxtapositionReportDTOList.add(juxtapositionReportDTO);
                  }); 
            }
        } 
        return juxtapositionReportDTOList;
    }

    private BladeFile exportNoChildRecord(List<OrderReportRecordResVO> records) {
        List<OrderReportRecordExport> result = (List) records.stream().map(OrderReportRecordServiceImpl::getExport).collect(Collectors.toList());
        return exportRecord(result);
    }

    private BladeFile exportHasChildRecord(List<OrderReportRecordResVO> records, List<OrderReportRecord> recordList) {
        Map<Long, List<OrderReportRecord>> recordMap = (Map) recordList.stream().collect(Collectors.groupingBy((v0) -> {
            return v0.getOpenSequenceId();
        }));
        List<OrderReportRecordExport> result = Lists.newArrayList();
        List<OrderProcess> orderProcessList = this.orderProcessService.list();
        Map<Long, OrderProcess> orderProcessMap = (Map) orderProcessList.stream().collect(Collectors.toMap((v0) -> {
            return v0.getId();
        }, v -> {
            return v;
        }));
        records.forEach(rd -> {
            OrderReportRecordExport convert = getExport(rd);
            List<OrderReportRecord> childRecords = (List) recordMap.get(rd.getId());
            if (Func.isNotEmpty(childRecords)) {
                String workstationNames = (String) childRecords.stream().map((v0) -> {
                    return v0.getWorkstationName();
                }).filter((v0) -> {
                    return Func.notNull(v0);
                }).collect(Collectors.joining(","));
                String workstationName = convert.getWorkstationName();
                convert.setWorkstationName(workstationName == null ? workstationNames : String.join(",", workstationName, workstationNames));
                result.add(convert);
                childRecords.forEach(crd -> {
                    result.add(convertExport(crd, rd, orderProcessMap));
                });
                return;
            }
            result.add(convert);
        });
        return exportRecord(result);
    }

    private static OrderReportRecordExport convertExport(OrderReportRecord crd, OrderReportRecordResVO rd, Map<Long, OrderProcess> orderProcessMap) {
        OrderReportRecordExport res = OrderReportRecordExport.builder().productName(rd.getProductName()).standardModel(rd.getStandardModel()).workstationName(crd.getWorkstationName()).workEmployeeName(crd.getProducerUserName()).reportEmployeeName(crd.getWorkshopUserName()).assignNum(rd.getAssignNum()).reportNum(Integer.valueOf(convertNum(crd.getQualifyNum()).intValue() + convertNum(crd.getScrappedNum()).intValue())).qualifNum(convertNum(crd.getQualifyNum())).scrappedNum(convertNum(crd.getScrappedNum())).remark(crd.getRemark()).build();
        OrderProcess orderProcess = orderProcessMap.get(crd.getProcessId());
        if (Func.notNull(orderProcess)) {
            res.setProcessName(orderProcess.getProcessName());
        }
        completeTime(crd.getStartTime(), crd.getWorkshopTime(), res);
        return res;
    }

    private static OrderReportRecordExport getExport(OrderReportRecordResVO rd) {
        OrderReportRecordExport convert = OrderReportRecordConvert.INSTANCE.convert(rd);
        completeTime(rd.getStartTime(), rd.getEndTime(), convert);
        return convert;
    }

    private static void completeTime(Date startTime, Date endTime, OrderReportRecordExport res) {
        if (Func.notNull(startTime) && Func.notNull(endTime)) {
            res.setStartTime(DateUtil.formatDateTime(startTime));
            res.setEndTime(DateUtil.formatDateTime(endTime));
            long seconds = DateUtil.between(startTime, endTime).getSeconds();
            res.setReportTime(TimeUtils.getUseTime(seconds));
        } else if (Func.notNull(startTime)) {
            res.setStartTime(DateUtil.formatDateTime(startTime));
        } else {
            res.setEndTime(DateUtil.formatDateTime(endTime));
        }
    }

    private BladeFile exportRecord(List<OrderReportRecordExport> result) {
        String fileName = String.format("%s-%s.xlsx", ExcelConstant.ORDER_REPORT_RECORD, DateUtil.time());
        MultipartFile multipartFile = ExcelUtil.exportToMultipartFile(fileName, ExcelConstant.ORDER_REPORT_RECORD, result, OrderReportRecordExport.class);
        return this.ossBuilder.tempTemplate().putFile(multipartFile.getOriginalFilename(), multipartFile);
    }

    private <T> QueryWrapper<T> getWrapper(Long orderId, Long productId, List<Long> reportEmployeeIds, List<Long> workEmployeeIds, String startTime, String endTime) {
        QueryWrapper<T> wrapper = Wrappers.<T>query().eq(Func.notNull(productId), "bp.product_id", productId).eq(Func.notNull(orderId), "borr.order_id", orderId).in(Func.isNotEmpty(reportEmployeeIds), "borr.workshop_user_id", reportEmployeeIds).in(Func.isNotEmpty(workEmployeeIds), "borr.producer_user_id", workEmployeeIds);
        if (Func.isNotBlank(startTime) && Func.isNotBlank(endTime)) {
            wrapper.nested(nt -> {
                QueryWrapper queryWrapper = (QueryWrapper) ((QueryWrapper) ((QueryWrapper) nt.between("borr.start_time", startTime, endTime)).or()).between("borr.workshop_time", startTime, endTime);
            });
        } else if (Func.isNotBlank(startTime)) {
            wrapper.nested(nt2 -> {
                QueryWrapper queryWrapper = (QueryWrapper) ((QueryWrapper) ((QueryWrapper) nt2.gt("borr.start_time", startTime)).or()).gt("borr.start_time", startTime);
            });
        } else if (Func.isNotBlank(endTime)) {
            wrapper.nested(nt3 -> {
                QueryWrapper queryWrapper = (QueryWrapper) ((QueryWrapper) ((QueryWrapper) nt3.le("borr.workshop_time", endTime)).or()).le("borr.workshop_time", endTime);
            });
        }
        if (Func.isNotBlank(wrapper.getSqlSegment())) {
            return wrapper;
        }
        return null;
    }

    private List<OrderReportRecordResVO> completeData(List<OrderReportRecordResVO> records, Map<Long, List<OrderReportRecord>> recordMap) {
        return (List) records.stream().peek(r -> {
            if (Func.notNull(r.getStartTime()) && Func.notNull(r.getEndTime())) {
                r.setReportTime(Long.valueOf(DateUtil.between(r.getStartTime(), r.getEndTime()).getSeconds()));
            }
            List<OrderReportRecord> childRecords = (List) recordMap.get(r.getId());
            if (Func.isNotEmpty(childRecords)) {
                String workstationIds = (String) childRecords.stream().map(c -> {
                    Long workstationId = c.getWorkstationId();
                    if (workstationId == null) {
                        return null;
                    }
                    return String.valueOf(workstationId);
                }).filter((v0) -> {
                    return Func.notNull(v0);
                }).collect(Collectors.joining(","));
                Long workstationId = r.getWorkstationId();
                r.setWorkstationIds(workstationId == null ? workstationIds : String.join(",", String.valueOf(workstationId), workstationIds));
                String workstationNames = (String) childRecords.stream().map((v0) -> {
                    return v0.getWorkstationName();
                }).filter((v0) -> {
                    return Func.notNull(v0);
                }).collect(Collectors.joining(","));
                String workstationName = r.getWorkstationName();
                r.setWorkstationName(workstationName == null ? workstationNames : String.join(",", workstationName, workstationNames));
                r.setHasChildProcess(1);
            }
        }).collect(Collectors.toList());
    }

    private static Integer convertNum(Integer num) {
        return Integer.valueOf(num == null ? 0 : num.intValue());
    }

    private JuxtapositionReportDTO assembleReportData(OrderReportRecord reportRecord, String processName, String processCode) {
        JuxtapositionReportDTO juxtapositionReportDTO = new JuxtapositionReportDTO();
        juxtapositionReportDTO.setRecordId(reportRecord.getId()).setProcessId(reportRecord.getProcessId()).setProcessCode(processCode).setProcessName(processName).setQualifyNum(reportRecord.getQualifyNum()).setScrappedNum(reportRecord.getScrappedNum()).setWorkstationId(reportRecord.getWorkstationId()).setWorkstationName(reportRecord.getWorkstationName()).setMainSequenceId(reportRecord.getMainSequenceId()).setOpenSequenceId(reportRecord.getOpenSequenceId());
        return juxtapositionReportDTO;
    }

    @Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
    @Transactional(rollbackFor = {Exception.class})
    public Boolean editOrderProcessRecord(ReportWorkDTO reportWorkDTO) {
        List<OrderProcessReportWorkDTO> reportWorkDTOList = reportWorkDTO.getReportWorkDTOList();
        if (Func.isEmpty(reportWorkDTOList)) {
            throw new ServiceException(MessageUtils.message("production.report.fail.data.empty", new Object[0]));
        }
        List<String> recordIds = (List) reportWorkDTOList.stream().map((v0) -> {
            return v0.getRecordId();
        }).collect(Collectors.toList());
        Map<Long, OrderReportRecord> recordMap = getRecordMap(recordIds);
        for (OrderProcessReportWorkDTO upRecord : reportWorkDTOList) {
            OrderReportRecord oldOrderReportRecord = recordMap.get(Long.valueOf(Func.toLong(upRecord.getRecordId())));
            Integer agoQualifyNum = oldOrderReportRecord.getQualifyNum();
            Integer agoScrappedNum = oldOrderReportRecord.getScrappedNum();
            Integer upQualifyNum = upRecord.getQualifyNum();
            Integer upScrappedNum = upRecord.getScrappedNum();
            Integer newQualifyNum = Integer.valueOf(upQualifyNum.intValue() - agoQualifyNum.intValue());
            Integer newScrappedNum = Integer.valueOf(upScrappedNum.intValue() - agoScrappedNum.intValue());
            upRecord.setQualifyNum(newQualifyNum);
            upRecord.setScrappedNum(newScrappedNum);
        }
        return this.orderProcessService.editReportWork(reportWorkDTO);
    }

    @Override // org.springblade.modules.coproduction.service.IOrderReportRecordService
    @Transactional(rollbackFor = {Exception.class})
    public Boolean editParallelProcessRecord(ReportWorkDTO reportWorkDTO) {
        List<OrderProcessReportWorkDTO> reportWorkDTOList = reportWorkDTO.getReportWorkDTOList();
        if (Func.isEmpty(reportWorkDTOList)) {
            throw new ServiceException(MessageUtils.message("production.report.fail.data.empty", new Object[0]));
        }
        this.orderProcessService.parallelProcessAround(ReportConvert.INSTANCE.convertParallel(reportWorkDTOList), Boolean.TRUE);
        List<String> recordIds = (List) reportWorkDTOList.stream().map((v0) -> {
            return v0.getRecordId();
        }).distinct().collect(Collectors.toList());
        Map<Long, OrderReportRecord> recordMap = getRecordMap(recordIds);
        reportWorkDTOList.forEach(parallelRecord -> {
            OrderReportRecord record = (OrderReportRecord) recordMap.get(Long.valueOf(Func.toLong(parallelRecord.getRecordId())));
            Integer agoQualifyNum = record.getQualifyNum();
            Integer agoScrappedNum = record.getScrappedNum();
            Integer upQualifyNum = parallelRecord.getQualifyNum();
            Integer upScrappedNum = parallelRecord.getScrappedNum();
            Integer newQualifyNum = Integer.valueOf(upQualifyNum.intValue() - agoQualifyNum.intValue());
            Integer newScrappedNum = Integer.valueOf(upScrappedNum.intValue() - agoScrappedNum.intValue());
            parallelRecord.setQualifyNum(newQualifyNum);
            parallelRecord.setScrappedNum(newScrappedNum);
        });
        Boolean result = this.orderProcessService.editReportWork(reportWorkDTO);
        this.orderProcessService.dealChildProcess(reportWorkDTOList);
        this.orderProcessService.dealCompleteProcessSurplusRecords(reportWorkDTO.getOrderId());
        return result;
    }

    private Map<Long, OrderReportRecord> getRecordMap(List<String> recordIds) {
    	List<OrderReportRecord> list = list(Wrappers.<OrderReportRecord>lambdaQuery().in(OrderReportRecord::getId, Func.toLongList(recordIds)));
        if (Func.isEmpty(list)) {
          throw new ServiceException(MessageUtils.message("production.report.fail.record.is.not.exit", new Object[0])); 
        }
        return (Map<Long, OrderReportRecord>)list.stream().collect(Collectors.toMap(OrderReportRecord::getId, Function.identity()));
    }

    private OrderChildRecordVO convertVO(OrderReportRecord rd, Map<Long, OrderProcess> map) {
        OrderChildRecordVO vo = new OrderChildRecordVO();
        vo.setId(rd.getId());
        vo.setPlanId(rd.getPlanId());
        vo.setOrderId(rd.getOrderId());
        vo.setOrderProcessId(rd.getProcessId());
        vo.setWorkstationId(rd.getWorkstationId());
        vo.setWorkstationName(rd.getWorkstationName());
        vo.setWorkEmployeeId(rd.getProducerUserId());
        vo.setWorkEmployeeName(rd.getProducerUserName());
        vo.setStartTime(rd.getStartTime());
        vo.setEndTime(rd.getWorkshopTime());
        vo.setReportEmployeeId(rd.getWorkshopUserId());
        vo.setReportEmployeeName(rd.getWorkshopUserName());
        vo.setReportNum(Integer.valueOf(convertNum(rd.getQualifyNum()).intValue() + convertNum(rd.getScrappedNum()).intValue()));
        vo.setQualifNum(convertNum(rd.getQualifyNum()));
        vo.setRecordStatus(rd.getRecordStatus());
        vo.setRemark(rd.getRemark());
        vo.setScrappedNum(rd.getScrappedNum());
        OrderProcess orderProcess = map.get(rd.getProcessId());
        if (Func.notNull(orderProcess)) {
            vo.setProductCode(orderProcess.getProcessCode());
            vo.setProductName(orderProcess.getProcessName());
        }
        if (Func.notNull(vo.getStartTime()) && Func.notNull(vo.getEndTime())) {
            vo.setReportTime(Long.valueOf(DateUtil.between(vo.getStartTime(), vo.getEndTime()).getSeconds()));
        }
        return vo;
    }
}