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

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import java.lang.invoke.SerializedLambda;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.qianwen.smartman.common.cache.RegionCache;
import com.qianwen.smartman.common.constant.NotifyConstant;
import com.qianwen.smartman.common.utils.AbstractSqlAdapter;
import com.qianwen.smartman.common.utils.Lambda;
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.mp.support.Condition;
import com.qianwen.core.mp.support.Query;
import com.qianwen.core.tool.utils.DateUtil;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.smartman.modules.andon.convert.AndonRecordConvert;
import com.qianwen.smartman.modules.andon.convert.AndonRecordReasonConvert;
import com.qianwen.smartman.modules.andon.entity.AndonRecord;
import com.qianwen.smartman.modules.andon.entity.AndonRecordReason;
import com.qianwen.smartman.modules.andon.enums.AndonRecordStatusEnum;
import com.qianwen.smartman.modules.andon.enums.AndonStatusEnum;
import com.qianwen.smartman.modules.andon.mapper.AndonRecordMapper;
import com.qianwen.smartman.modules.andon.service.IAndonRecordReasonService;
import com.qianwen.smartman.modules.andon.service.IAndonRecordService;
import com.qianwen.smartman.modules.andon.vo.AndonFinishRecordVO;
import com.qianwen.smartman.modules.andon.vo.AndonMessageSendVO;
import com.qianwen.smartman.modules.andon.vo.AndonReceiveEditRecordVO;
import com.qianwen.smartman.modules.andon.vo.AndonReceiveRecordVO;
import com.qianwen.smartman.modules.andon.vo.AndonRecordReasonVO;
import com.qianwen.smartman.modules.andon.vo.AndonRecordSearchVO;
import com.qianwen.smartman.modules.andon.vo.AndonRecordVO;
import com.qianwen.smartman.modules.andon.vo.AndonStatisticalCardVO;
import com.qianwen.smartman.modules.andon.vo.AndonTableStatisticalVO;
import com.qianwen.smartman.modules.andon.vo.HmiAndonVO;
import com.qianwen.smartman.modules.cps.entity.Workstation;
import com.qianwen.smartman.modules.cps.service.IWorkstationService;
import com.qianwen.smartman.modules.notify.business.BusinessSend;
import com.qianwen.smartman.modules.notify.business.BusinessSendFactory;
import com.qianwen.smartman.modules.notify.dto.NotifyBusinessSendDTO;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/andon/service/impl/AndonRecordServiceImpl.class */
public class AndonRecordServiceImpl extends BaseServiceImpl<AndonRecordMapper, AndonRecord> implements IAndonRecordService {
    private static final Logger log = LoggerFactory.getLogger(AndonRecordServiceImpl.class);
    private final IAndonRecordReasonService recordReasonService;
    private final IWorkstationService workstationService;
    private final BusinessSendFactory businessSendFactory;

    public AndonRecordServiceImpl(final IAndonRecordReasonService recordReasonService, final IWorkstationService workstationService, final BusinessSendFactory businessSendFactory) {
        this.recordReasonService = recordReasonService;
        this.workstationService = workstationService;
        this.businessSendFactory = businessSendFactory;
    }

    @Override // org.springblade.modules.andon.service.IAndonRecordService
    public IPage<AndonRecordVO> pageReceiveList(AndonRecordSearchVO andonRecordSearchVO, Query query) {
    	
    	List<AndonRecordReason> list = this.recordReasonService.list();
        Map<Long, List<AndonRecordReason>> recordReasonMap = null;
        if (Func.isNotEmpty(list))
          recordReasonMap = (Map<Long, List<AndonRecordReason>>)list.stream().collect(Collectors.groupingBy(AndonRecordReason::getRecordId)); 
        Map<Long, Workstation> workstationMap = (Map<Long, Workstation>)this.workstationService.list().stream().collect(Collectors.toMap(Workstation::getId, Function.identity()));
        Integer andonStatus = andonRecordSearchVO.getAndonStatus();
        List<Integer> recordStatus = new ArrayList<>();
        if (AndonRecordStatusEnum.FINISH.getCode().equals(andonStatus)) {
          List<Integer> toBeAndReceiveStatus = Arrays.asList(new Integer[] { AndonRecordStatusEnum.TO_BE_RECEIVED.getCode(), AndonRecordStatusEnum.RECEIVED.getCode() });
          recordStatus.addAll(toBeAndReceiveStatus);
        } else {
          recordStatus.add(andonStatus);
        } 
        IPage<AndonRecord> page = page(Condition.getPage(query), Wrappers.<AndonRecord>lambdaQuery()
            .eq(Func.isNotEmpty(andonRecordSearchVO.getTypeId()), AndonRecord::getTypeId, andonRecordSearchVO.getTypeId())
            .in(Func.isNotEmpty(andonRecordSearchVO.getCallEmpIds()), AndonRecord::getCallEmpId, andonRecordSearchVO.getCallEmpIds())
            .in(Func.isNotEmpty(andonRecordSearchVO.getHandEmpIds()), AndonRecord::getHandEmpId, andonRecordSearchVO.getHandEmpIds())
            .in(Func.isNotEmpty(andonRecordSearchVO.getWorkstationIds()), AndonRecord::getWorkstationId, andonRecordSearchVO.getWorkstationIds())
            .in(Func.isNotEmpty(recordStatus), AndonRecord::getCurStatus, recordStatus)
            .between((Func.isNotEmpty(andonRecordSearchVO.getStartTime()) && Func.isNotEmpty(andonRecordSearchVO.getEndTime())), AndonRecord::getCallTime, andonRecordSearchVO.getStartTime(), andonRecordSearchVO.getEndTime())
            .orderByAsc(AndonRecord::getCallTime));
        IPage<AndonRecordVO> andonRecordPage = AndonRecordConvert.INSTANCE.convert(page);
        List<AndonRecordVO> records = andonRecordPage.getRecords();
        if (Func.isNotEmpty(records)) {
          Map<Long, List<AndonRecordReason>> finalRecordReasonMap = recordReasonMap;
          records.forEach(record -> {
                if (!workstationMap.isEmpty()) {
                  Workstation workstation = (Workstation)workstationMap.get(record.getWorkstationId());
                  if (workstation != null)
                    record.setAvatar(workstation.getAvatar()); 
                } 
                if (!finalRecordReasonMap.isEmpty()) {
                  List<AndonRecordReason> recordReasons = (List<AndonRecordReason>)finalRecordReasonMap.get(record.getId());
                  if (Func.isNotEmpty(recordReasons)) {
                    String reason = recordReasons.stream().map(AndonRecordReason::getReasonName).collect(Collectors.joining(";"));
                    record.setReasons(reason);
                  } 
                } 
              });
        } 
        return andonRecordPage;
        /*
        List<AndonRecordReason> list = this.recordReasonService.list();
        Map<Long, List<AndonRecordReason>> recordReasonMap = null;
        if (Func.isNotEmpty(list)) {
            recordReasonMap = (Map) list.stream().collect(Collectors.groupingBy((v0) -> {
                return v0.getRecordId();
            }));
        }
        Map<Long, Workstation> workstationMap = (Map) this.workstationService.list().stream().collect(Collectors.toMap((v0) -> {
            return v0.getId();
        }, Function.identity()));
        Integer andonStatus = andonRecordSearchVO.getAndonStatus();
        List<Integer> recordStatus = new ArrayList<>();
        if (AndonRecordStatusEnum.FINISH.getCode().equals(andonStatus)) {
            List<Integer> toBeAndReceiveStatus = Arrays.asList(AndonRecordStatusEnum.TO_BE_RECEIVED.getCode(), AndonRecordStatusEnum.RECEIVED.getCode());
            recordStatus.addAll(toBeAndReceiveStatus);
        } else {
            recordStatus.add(andonStatus);
        }
        IPage<AndonRecord> page = page(Condition.getPage(query), (Wrapper) Wrappers.lambdaQuery().eq(Func.isNotEmpty(andonRecordSearchVO.getTypeId()), (v0) -> {
            return v0.getTypeId();
        }, andonRecordSearchVO.getTypeId()).in(Func.isNotEmpty(andonRecordSearchVO.getCallEmpIds()), (v0) -> {
            return v0.getCallEmpId();
        }, andonRecordSearchVO.getCallEmpIds()).in(Func.isNotEmpty(andonRecordSearchVO.getHandEmpIds()), (v0) -> {
            return v0.getHandEmpId();
        }, andonRecordSearchVO.getHandEmpIds()).in(Func.isNotEmpty(andonRecordSearchVO.getWorkstationIds()), (v0) -> {
            return v0.getWorkstationId();
        }, andonRecordSearchVO.getWorkstationIds()).in(Func.isNotEmpty(recordStatus), (v0) -> {
            return v0.getCurStatus();
        }, recordStatus).between(Func.isNotEmpty(andonRecordSearchVO.getStartTime()) && Func.isNotEmpty(andonRecordSearchVO.getEndTime()), (v0) -> {
            return v0.getCallTime();
        }, andonRecordSearchVO.getStartTime(), andonRecordSearchVO.getEndTime()).orderByAsc((v0) -> {
            return v0.getCallTime();
        }));
        IPage<AndonRecordVO> andonRecordPage = AndonRecordConvert.INSTANCE.convert(page);
        List<AndonRecordVO> records = andonRecordPage.getRecords();
        if (Func.isNotEmpty(records)) {
            Map<Long, List<AndonRecordReason>> finalRecordReasonMap = recordReasonMap;
            records.forEach(record -> {
                Workstation workstation;
                if (!workstationMap.isEmpty() && (workstation = (Workstation) workstationMap.get(record.getWorkstationId())) != null) {
                    record.setAvatar(workstation.getAvatar());
                }
                if (!finalRecordReasonMap.isEmpty()) {
                    List<AndonRecordReason> recordReasons = (List) finalRecordReasonMap.get(record.getId());
                    if (Func.isNotEmpty(recordReasons)) {
                        String reason = (String) recordReasons.stream().map((v0) -> {
                            return v0.getReasonName();
                        }).collect(Collectors.joining(";"));
                        record.setReasons(reason);
                    }
                }
            });
        }
        return andonRecordPage;
        */
    }

    @Override // org.springblade.modules.andon.service.IAndonRecordService
    public AndonReceiveRecordVO receiveRecordDetail(String id) {
    	AndonRecord andonRecord = (AndonRecord)getById(id);
        if (Func.isEmpty(andonRecord))
          throw new ServiceException(MessageUtils.message("andon.record.detail.loading.fail", new Object[0])); 
        List<AndonRecordReason> recordReasonsList = null;
        List<AndonRecordReason> list = this.recordReasonService.list(Wrappers.<AndonRecordReason>lambdaQuery().eq(AndonRecordReason::getRecordId, andonRecord.getId()));
        if (Func.isNotEmpty(list))
          recordReasonsList = list; 
        return buildAndonDetail(andonRecord, recordReasonsList);/*
        AndonRecord andonRecord = (AndonRecord) getById(id);
        if (Func.isEmpty(andonRecord)) {
            throw new ServiceException(MessageUtils.message("andon.record.detail.loading.fail", new Object[0]));
        }
        List<AndonRecordReason> recordReasonsList = null;
        List<AndonRecordReason> list = this.recordReasonService.list((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getRecordId();
        }, andonRecord.getId()));
        if (Func.isNotEmpty(list)) {
            recordReasonsList = list;
        }
        return buildAndonDetail(andonRecord, recordReasonsList);
        */
    }

    private AndonReceiveRecordVO buildAndonDetail(AndonRecord andonRecord, List<AndonRecordReason> recordReasons) {
        AndonReceiveRecordVO andonReceiveRecordVO = AndonRecordConvert.INSTANCE.convertVO(andonRecord);
        andonReceiveRecordVO.setReasonList(AndonRecordReasonConvert.INSTANCE.convert(recordReasons));
        return andonReceiveRecordVO;
    }

    @Override // org.springblade.modules.andon.service.IAndonRecordService
    @Transactional(rollbackFor = {Exception.class})
    public Boolean batchReceiveAndonRecord(List<Long> ids) {
    	List<Integer> invalidAndonStatus = Arrays.asList(new Integer[] { AndonRecordStatusEnum.RECEIVED.getCode(), AndonRecordStatusEnum.FINISH.getCode() });
        List<AndonRecord> list = list(Wrappers.<AndonRecord>lambdaQuery().in(AndonRecord::getId, ids));
        checkBatchReceive(list, invalidAndonStatus);
        List<AndonRecord> andonRecordUpdateList = (List<AndonRecord>)list.stream().peek(s -> {
              s.setCurStatus(AndonRecordStatusEnum.RECEIVED.getCode());
              s.setResponseTime(DateUtil.now());
            }).collect(Collectors.toList());
        return updateBatchById(andonRecordUpdateList);
    	/*
        List<Integer> invalidAndonStatus = Arrays.asList(AndonRecordStatusEnum.RECEIVED.getCode(), AndonRecordStatusEnum.FINISH.getCode());
        List<AndonRecord> list = list((Wrapper) Wrappers.lambdaQuery().in((v0) -> {
            return v0.getId();
        }, ids));
        checkBatchReceive(list, invalidAndonStatus);
        List<AndonRecord> andonRecordUpdateList = (List) list.stream().peek(s -> {
            s.setCurStatus(AndonRecordStatusEnum.RECEIVED.getCode());
            s.setResponseTime(DateUtil.now());
        }).collect(Collectors.toList());
        return Boolean.valueOf(updateBatchById(andonRecordUpdateList));
        */
    }

    private void checkBatchReceive(List<AndonRecord> list, List<Integer> invalidAndonStatus) {
        if (Func.isEmpty(list)) {
            throw new ServiceException(MessageUtils.message("andon.record.is.not.exist", new Object[0]));
        }
        long count = list.stream().filter(s -> {
            return invalidAndonStatus.contains(s.getCurStatus());
        }).count();
        if (count > 0) {
            throw new ServiceException(MessageUtils.message("andon.record.take.over.fail", new Object[0]));
        }
    }

    @Override // org.springblade.modules.andon.service.IAndonRecordService
    @Transactional(rollbackFor = {Exception.class})
    public Boolean delReceiveAndonRecord(String id) {
        AndonRecord andonRecord = (AndonRecord) getById(id);
        checkDelReceive(andonRecord);
        return Boolean.valueOf(removeById(andonRecord));
    }

    private void checkDelReceive(AndonRecord andonRecord) {
        if (andonRecord == null) {
            throw new ServiceException(MessageUtils.message("andon.record.is.not.exist", new Object[0]));
        }
        if (!AndonRecordStatusEnum.TO_BE_RECEIVED.getCode().equals(andonRecord.getCurStatus())) {
            throw new ServiceException(MessageUtils.message("andon.record.del.fail", new Object[0]));
        }
    }

    @Override // org.springblade.modules.andon.service.IAndonRecordService
    @Transactional(rollbackFor = {Exception.class})
    public AndonReceiveRecordVO editReceiveRecord(AndonReceiveEditRecordVO andonReceiveEditRecordVO) {
    	Long recordId = andonReceiveEditRecordVO.getId();
        AndonRecord andonRecord = (AndonRecord)getById(recordId);
        checkEditReceiveRecord(andonRecord, andonReceiveEditRecordVO);
        andonRecord
          .setTypeId(andonReceiveEditRecordVO.getTypeId())
          .setTypeName(andonReceiveEditRecordVO.getTypeName())
          .setTypeCode(andonReceiveEditRecordVO.getTypeCode())
          .setHandEmpId(andonReceiveEditRecordVO.getHandEmpId())
          .setHandEmpCode(andonReceiveEditRecordVO.getHandEmpCode())
          .setHandEmpName(andonReceiveEditRecordVO.getHandEmpName())
          .setRemark(andonReceiveEditRecordVO.getRemark());
        updateById(andonRecord);
        List<AndonRecordReason> removeList = this.recordReasonService.list(Wrappers.<AndonRecordReason>lambdaQuery().eq(AndonRecordReason::getRecordId, andonRecord.getId()));
        if (Func.isNotEmpty(removeList))
          this.recordReasonService.removeBatchByIds(removeList); 
        List<AndonRecordReasonVO> reasonList = andonReceiveEditRecordVO.getReasonList();
        if (Func.isNotEmpty(reasonList))
          saveAndonRecordReason(andonRecord.getId(), reasonList); 
        NotifyBusinessSendDTO notifyBusinessSendDTO = NotifyBusinessSendDTO.builder().empIds(Collections.singletonList(andonRecord.getHandEmpId())).build();
        AndonMessageSendVO andonMessageSendVO = buildSendMessage(andonRecord, reasonList);
        sendMessage(andonMessageSendVO, notifyBusinessSendDTO);
        return buildEditData(andonRecord, reasonList);
    }

    private void checkEditReceiveRecord(AndonRecord andonRecord, AndonReceiveEditRecordVO andonReceiveEditRecordVO) {
    	if (andonRecord == null)
	      throw new ServiceException(MessageUtils.message("andon.record.is.not.exist", new Object[0])); 
	    if (!AndonRecordStatusEnum.TO_BE_RECEIVED.getCode().equals(andonRecord.getCurStatus()))
	      throw new ServiceException(MessageUtils.message("andon.record.update.fail", new Object[0])); 
	    List<AndonRecord> andonRecordList = checkWorkstationAndonType(andonReceiveEditRecordVO.getWorkstationId(), Long.valueOf(Func.toLong(andonReceiveEditRecordVO.getTypeId())));
	    if (andonRecordList != null)
	      andonRecordList = andonRecordList.stream().filter(s -> !andonReceiveEditRecordVO.getId().equals(s.getId())).collect(Collectors.toList()); 
	    Boolean result = Func.isEmpty(andonRecordList) ? Boolean.FALSE : Boolean.TRUE;
	    if (result.booleanValue())
	      throw new ServiceException(MessageUtils.message("andon.please.repeat.launch.call", new Object[0])); 
    	/*
        if (andonRecord == null) {
            throw new ServiceException(MessageUtils.message("andon.record.is.not.exist", new Object[0]));
        }
        if (!AndonRecordStatusEnum.TO_BE_RECEIVED.getCode().equals(andonRecord.getCurStatus())) {
            throw new ServiceException(MessageUtils.message("andon.record.update.fail", new Object[0]));
        }
        List<AndonRecord> andonRecordList = checkWorkstationAndonType(andonReceiveEditRecordVO.getWorkstationId(), Long.valueOf(Func.toLong(andonReceiveEditRecordVO.getTypeId())));
        if (andonRecordList != null) {
            andonRecordList = (List) andonRecordList.stream().filter(s -> {
                return !andonReceiveEditRecordVO.getId().equals(s.getId());
            }).collect(Collectors.toList());
        }
        Boolean result = Func.isEmpty(andonRecordList) ? Boolean.FALSE : Boolean.TRUE;
        if (result.booleanValue()) {
            throw new ServiceException(MessageUtils.message("andon.please.repeat.launch.call", new Object[0]));
        }
        */
    }

    private AndonReceiveRecordVO buildEditData(AndonRecord andonRecord, List<AndonRecordReasonVO> reasonList) {
        AndonReceiveRecordVO andonReceiveRecordVO = AndonRecordConvert.INSTANCE.convertVO(andonRecord);
        andonReceiveRecordVO.setReasonList(reasonList);
        return andonReceiveRecordVO;
    }

    private void sendMessage(AndonMessageSendVO andonMessageSendVO, NotifyBusinessSendDTO notifyBusinessSend) {
        
        BusinessSend businessSend = this.businessSendFactory.getBusinessSend(NotifyConstant.ANDON_TAKE_OVER);
        businessSend.saveState(andonMessageSendVO, notifyBusinessSend);
    }

    @Override // org.springblade.modules.andon.service.IAndonRecordService
    @Transactional(rollbackFor = {Exception.class})
    public Boolean toBeOrReceivedAndonRecord(AndonFinishRecordVO andonFinishRecordVO) {
        String id = andonFinishRecordVO.getId();
        AndonRecord andonRecord = (AndonRecord) getById(id);
        if (AndonRecordStatusEnum.FINISH.getCode().equals(andonRecord.getCurStatus())) {
            throw new ServiceException(MessageUtils.message("andon.record.to.be.received.trigger.can.not.finish", new Object[0]));
        }
        if (AndonRecordStatusEnum.TO_BE_RECEIVED.getCode().equals(andonRecord.getCurStatus()) && andonRecord.getResponseTime() == null) {
            andonRecord.setResponseTime(DateUtil.now());
        }
        andonRecord.setCurStatus(AndonRecordStatusEnum.FINISH.getCode()).setEndTime(DateUtil.now()).setCompleteEmpId(Long.valueOf(Func.toLong(andonFinishRecordVO.getCompletedById()))).setCompleteEmpCode(andonFinishRecordVO.getCompletedByCode()).setCompleteEmpName(andonFinishRecordVO.getCompletedByName());
        return Boolean.valueOf(updateById(andonRecord));
    }

    @Override // org.springblade.modules.andon.service.IAndonRecordService
    @Transactional(rollbackFor = {Exception.class})
    public Boolean initiateAndonCall(AndonReceiveRecordVO andonReceiveRecordVO) {
        boolean isSamePeople = andonReceiveRecordVO.getCallEmpId().equals(andonReceiveRecordVO.getHandEmpId());
        if (isSamePeople) {
            throw new ServiceException(MessageUtils.message("andon.deal.person.with.call.person.is.not.same", new Object[0]));
        }
        List<AndonRecord> andonRecordList = checkWorkstationAndonType(andonReceiveRecordVO.getWorkstationId(), Long.valueOf(Func.toLong(andonReceiveRecordVO.getTypeId())));
        Boolean result = andonRecordList == null ? Boolean.FALSE : Boolean.TRUE;
        if (result.booleanValue()) {
            throw new ServiceException(MessageUtils.message("andon.please.repeat.launch.call", new Object[0]));
        }
        AndonRecord andonRecord = setRecord(andonReceiveRecordVO);
        boolean saveStatus = save(andonRecord);
        List<AndonRecordReasonVO> reasonList = andonReceiveRecordVO.getReasonList();
        if (Func.isNotEmpty(reasonList)) {
            saveAndonRecordReason(andonRecord.getId(), andonReceiveRecordVO.getReasonList());
        }
        NotifyBusinessSendDTO notifyBusinessSendDTO = NotifyBusinessSendDTO.builder().empIds(Collections.singletonList(andonReceiveRecordVO.getHandEmpId())).build();
        AndonMessageSendVO andonMessageSendVO = buildSendMessage(andonRecord, reasonList);
        sendMessage(andonMessageSendVO, notifyBusinessSendDTO);
        return Boolean.valueOf(saveStatus);
    }

    private AndonMessageSendVO buildSendMessage(AndonRecord andonRecord, List<AndonRecordReasonVO> reasonList) {
        AndonMessageSendVO andonMessageSendVO = new AndonMessageSendVO();
        andonMessageSendVO.setId(andonRecord.getId()).setTypeId(andonRecord.getTypeId()).setTypeName(andonRecord.getTypeName()).setTypeCode(andonRecord.getTypeCode()).setWorkstationId(andonRecord.getWorkstationId()).setWorkstationCode(andonRecord.getWorkstationCode()).setWorkstationName(andonRecord.getWorkstationName()).setCallEmpId(andonRecord.getCallEmpId()).setCallEmpCode(andonRecord.getCallEmpCode()).setCallEmpName(andonRecord.getCallEmpName()).setCallTime(andonRecord.getCallTime()).setCurStatus(andonRecord.getCurStatus()).setRemark(andonRecord.getRemark()).setReasonList(reasonList);
        return andonMessageSendVO;
    }

    private AndonRecord setRecord(AndonReceiveRecordVO andonReceiveRecordVO) {
        AndonRecord andonRecord = new AndonRecord();
        andonRecord.setTypeId(Long.valueOf(Func.toLong(andonReceiveRecordVO.getTypeId()))).setTypeCode(andonReceiveRecordVO.getTypeCode()).setTypeName(andonReceiveRecordVO.getTypeName()).setWorkstationId(andonReceiveRecordVO.getWorkstationId()).setWorkstationName(andonReceiveRecordVO.getWorkstationName()).setWorkstationCode(andonReceiveRecordVO.getWorkstationCode()).setCallEmpId(andonReceiveRecordVO.getCallEmpId()).setCallEmpCode(andonReceiveRecordVO.getCallEmpCode()).setCallEmpName(andonReceiveRecordVO.getCallEmpName()).setHandEmpId(andonReceiveRecordVO.getHandEmpId()).setHandEmpCode(andonReceiveRecordVO.getHandEmpCode()).setHandEmpName(andonReceiveRecordVO.getHandEmpName()).setCallTime(DateUtil.now()).setCurStatus(AndonRecordStatusEnum.TO_BE_RECEIVED.getCode()).setRemark(andonReceiveRecordVO.getRemark());
        return andonRecord;
    }

    private void saveAndonRecordReason(Long recordId, List<AndonRecordReasonVO> reasonList) {
        List<AndonRecordReason> andonRecordReasonList = reasonList.stream().map(reasonVO -> {
            AndonRecordReason andonRecordReason = new AndonRecordReason();
            andonRecordReason.setRecordId(recordId).setReasonId(reasonVO.getReasonId()).setReasonCode(reasonVO.getReasonCode()).setReasonName(reasonVO.getReasonName());
            return andonRecordReason;
        }).collect(Collectors.toList());
        this.recordReasonService.saveBatch(andonRecordReasonList);
    }

    private List<AndonRecord> checkWorkstationAndonType(Long workstationId, Long typeId) {
    	List<Integer> andonStatus = Arrays.asList(AndonRecordStatusEnum.TO_BE_RECEIVED.getCode(), AndonRecordStatusEnum.RECEIVED.getCode());
        List<AndonRecord> list = list(Wrappers.<AndonRecord>lambdaQuery()
            .eq(Func.isNotEmpty(workstationId), AndonRecord::getWorkstationId, workstationId)
            .eq(Func.isNotEmpty(typeId), AndonRecord::getTypeId, typeId).in(AndonRecord::getCurStatus, andonStatus));
        if (Func.isNotEmpty(list))
          return list; 
        
        return null;
    	/*
        List<Integer> andonStatus = Arrays.asList(AndonRecordStatusEnum.TO_BE_RECEIVED.getCode(), AndonRecordStatusEnum.RECEIVED.getCode());
        List<AndonRecord> list = list((Wrapper) Wrappers.lambdaQuery().eq(Func.isNotEmpty(workstationId), (v0) -> {
            return v0.getWorkstationId();
        }, workstationId).eq(Func.isNotEmpty(typeId), (v0) -> {
            return v0.getTypeId();
        }, typeId).in((v0) -> {
            return v0.getCurStatus();
        }, andonStatus));
        if (Func.isNotEmpty(list)) {
            return list;
        }
        return null;
        */
    }

    @Override // org.springblade.modules.andon.service.IAndonRecordService
    public List<HmiAndonVO> hmiWorkstationLoginAndon(String workstationId) {
        List<AndonRecord> andonRecordList = checkWorkstationAndonType(Long.valueOf(Func.toLong(workstationId)), null);
        if (andonRecordList != null) {
            return andonRecordList.stream().map(s -> {
                HmiAndonVO hmiAndonVO = new HmiAndonVO();
                hmiAndonVO.setId(Func.toStr(s.getId())).setTypeId(Func.toStr(s.getTypeId())).setTypeCode(s.getTypeCode()).setTypeName(s.getTypeName()).setCurStatus(s.getCurStatus());
                return hmiAndonVO;
            }).collect(Collectors.toList());
        }
        return null;
        /*

        if (andonRecordList != null)
          return (List<HmiAndonVO>)andonRecordList.stream().map(s -> {
                HmiAndonVO hmiAndonVO = new HmiAndonVO();
                hmiAndonVO.setId(Func.toStr(s.getId())).setTypeId(Func.toStr(s.getTypeId())).setTypeCode(s.getTypeCode()).setTypeName(s.getTypeName()).setCurStatus(s.getCurStatus());
                return hmiAndonVO;
              }).collect(Collectors.toList()); 
        return null;
        */
    }

    @Override // org.springblade.modules.andon.service.IAndonRecordService
    public AndonStatisticalCardVO queryCard(List<Long> workstations, Date startTime, Date endTime) {
        return ((AndonRecordMapper) this.baseMapper).queryCard(workstations, DateUtil.formatDateTime(startTime), DateUtil.formatDateTime(endTime));
    }

    @Override // org.springblade.modules.andon.service.IAndonRecordService
    public IPage<AndonTableStatisticalVO> getTableAndon(Query query, Date startTime, Date endTime, List<Long> workstationIds) {
        return ((AndonRecordMapper) this.baseMapper).getTableAndon(Condition.getPage(query), DateUtil.formatDateTime(startTime), DateUtil.formatDateTime(endTime), workstationIds);
    }

    @Override // org.springblade.modules.andon.service.IAndonRecordService
    public List<AndonRecord> queryCallTime(Date startTime, Date endTime, List<Long> workstationIds) {
    	QueryWrapper<AndonRecord> wrapper = AbstractSqlAdapter.dateBetweenAdapter(Lambda.getName(AndonRecord::getCallTime), startTime, endTime);
        wrapper.in(Lambda.getName(AndonRecord::getWorkstationId), workstationIds)
          .eq(Lambda.getName(AndonRecord::getCurStatus), AndonStatusEnum.COMPLETE.getStatus());
        return this.baseMapper.selectList(wrapper);
        
    	/*
        Wrapper dateBetweenAdapter = AbstractSqlAdapter.dateBetweenAdapter(Lambda.getName((v0) -> {
            return v0.getCallTime();
        }), startTime, endTime);
        ((QueryWrapper) dateBetweenAdapter.in(Lambda.getName((v0) -> {
            return v0.getWorkstationId();
        }), workstationIds)).eq(Lambda.getName((v0) -> {
            return v0.getCurStatus();
        }), AndonStatusEnum.COMPLETE.getStatus());
        return ((AndonRecordMapper) this.baseMapper).selectList(dateBetweenAdapter);
        */
    }
}