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

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

import javax.servlet.http.HttpServletResponse;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.qianwen.core.excel.util.ExcelUtil;
import com.qianwen.core.log.exception.ServiceException;
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.secure.utils.AuthUtil;
import com.qianwen.core.tool.utils.CollectionUtil;
import com.qianwen.core.tool.utils.DateUtil;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.smartman.common.utils.LocalDateTimeUtils;
import com.qianwen.smartman.common.utils.MessageUtils;
import com.qianwen.smartman.modules.cps.dto.DeviceSimpleDTO;
import com.qianwen.smartman.modules.cps.entity.MaintainProject;
import com.qianwen.smartman.modules.cps.entity.MaintainProjectItem;
import com.qianwen.smartman.modules.cps.service.IMachineService;
import com.qianwen.smartman.modules.cps.service.IMaintainProjectItemService;
import com.qianwen.smartman.modules.cps.service.IMaintainProjectService;
import com.qianwen.smartman.modules.cps.service.IMaintainRecordItemService;
import com.qianwen.smartman.modules.cps.vo.MaintainPlanBatchVO;
import com.qianwen.smartman.modules.cps.vo.MaintainRecordAddVO;
import com.qianwen.smartman.modules.cps.vo.MaintainRecordExportVO;
import com.qianwen.smartman.modules.cps.vo.MaintainRecordIdListVO;
import com.qianwen.smartman.modules.cps.vo.MaintainRecordSearchVO;
import com.qianwen.smartman.modules.cps.vo.MaintainRecordUpdateVO;
import com.qianwen.smartman.modules.cps.vo.RepairRecordMaterialAddVO;
import com.qianwen.smartman.modules.resource.builder.oss.OssBuilder;
import com.qianwen.smartman.modules.system.service.ICodeGeneratorService;
import com.qianwen.smartman.modules.tpm.convert.DeviceMaterialRecordConvert;
import com.qianwen.smartman.modules.tpm.convert.MaintainRecordConvert;
import com.qianwen.smartman.modules.tpm.convert.MaintainRecordItemConvert;
import com.qianwen.smartman.modules.tpm.entity.DeviceMaterialRecord;
import com.qianwen.smartman.modules.tpm.entity.MaintainPlan;
import com.qianwen.smartman.modules.tpm.entity.MaintainRecord;
import com.qianwen.smartman.modules.tpm.entity.MaintainRecordItem;
import com.qianwen.smartman.modules.tpm.enums.BizTypeEnum;
import com.qianwen.smartman.modules.tpm.enums.ExecuteEnum;
import com.qianwen.smartman.modules.tpm.enums.MaintainPlanIsAutoEnum;
import com.qianwen.smartman.modules.tpm.enums.MaintainPlanStatusEnum;
import com.qianwen.smartman.modules.tpm.enums.MaintainRecordStatusEnum;
import com.qianwen.smartman.modules.tpm.enums.MetaTypeEnum;
import com.qianwen.smartman.modules.tpm.enums.PlanDelayStatusEnum;
import com.qianwen.smartman.modules.tpm.enums.RepairNatureEnum;
import com.qianwen.smartman.modules.tpm.mapper.MaintainRecordMapper;
import com.qianwen.smartman.modules.tpm.service.IDeviceMaterialRecordService;
import com.qianwen.smartman.modules.tpm.service.IMaintainPlanService;
import com.qianwen.smartman.modules.tpm.service.IMaintainRecordService;
import com.qianwen.smartman.modules.tpm.vo.MaintainPlanExpireQueryVO;
import com.qianwen.smartman.modules.tpm.vo.MaintainPlanVO;
import com.qianwen.smartman.modules.tpm.vo.MaintainRecordItemVO;
import com.qianwen.smartman.modules.tpm.vo.MaintainRecordVO;
import com.qianwen.smartman.modules.tpm.vo.MaintainStatisticsVO;
import com.qianwen.smartman.modules.tpm.vo.MaintainVO;
import com.qianwen.smartman.modules.tpm.vo.RepairRecordMaterialVO;
import com.qianwen.smartman.modules.tpm.vo.excel.MaintainRecordExcel;

@Service
public class MaintainRecordServiceImpl extends ServiceImpl<MaintainRecordMapper, MaintainRecord> implements IMaintainRecordService {
    private static final Logger log = LoggerFactory.getLogger(MaintainRecordServiceImpl.class);
    @Autowired
    private OssBuilder ossBuilder;
    @Autowired
    private ICodeGeneratorService codeGeneratorService;
    @Autowired
    private IMaintainRecordItemService maintainRecordItemService;
    @Autowired
    private IDeviceMaterialRecordService deviceMaterialRecordService;
    @Autowired
    @Lazy
    private IMaintainPlanService maintainPlanService;
    @Autowired
    private IMachineService machineService;
    @Autowired
    @Lazy
    private IMaintainProjectService maintainProjectService;
    @Autowired
    private IMaintainProjectItemService maintainProjectItemService;


    @Override // org.springblade.modules.tpm.service.IMaintainRecordService
    @Transactional(rollbackFor = {Exception.class})
    public MaintainRecord createMaintainRecord(MaintainRecordAddVO MaintainRecordAddVO) {
        if (Func.isBlank(MaintainRecordAddVO.getRecordCode())) {
            codeGenerator(MaintainRecordAddVO);
        }
        LocalDateTime now = LocalDateTime.now();
        MaintainPlan plan = this.maintainPlanService.getById(MaintainRecordAddVO.getPlanId());
        if (Func.isNull(plan)) {
            throw new ServiceException(MessageUtils.message("cps.common.the.current.object.does.not.exist", new Object[0]));
        }
        if (MaintainPlanStatusEnum.T3.getType() != plan.getPlanStatus().intValue()) {
            throw new ServiceException(MessageUtils.message("cps.tpm.maintain.record.can.not.add", new Object[0]));
        }
        MaintainRecord maintainRecord = MaintainRecordConvert.INSTANCE.convert(MaintainRecordAddVO);
        if (checkCodeIsExist(maintainRecord.getRecordCode(), null)) {
            throw new ServiceException(MessageUtils.message("cps.common.duplicate.code.can.not.add", new Object[0]));
        }
        maintainRecord.setCreateTime(LocalDateTimeUtils.LocalDateTimeToDate(now));
        maintainRecord.setPlanCode(plan.getCode());
        maintainRecord.setDeviceId(plan.getDeviceId());
        maintainRecord.setDeviceCode(plan.getDeviceCode());
        maintainRecord.setDeviceName(plan.getDeviceName());
        maintainRecord.setDeviceTypeId(plan.getDeviceTypeId());
        maintainRecord.setDeviceTypeName(plan.getDeviceTypeName());
        maintainRecord.setProjectId(plan.getProjectId());
        maintainRecord.setProjectCode(plan.getProjectCode());
        maintainRecord.setProjectName(plan.getProjectName());
        maintainRecord.setRecordStatus(Integer.valueOf(MaintainRecordStatusEnum.T1.getType()));
        save(maintainRecord);
        plan.setPlanStatus(Integer.valueOf(MaintainPlanStatusEnum.T4.getType()));
        plan.setUpdateTime(LocalDateTimeUtils.LocalDateTimeToDate(now));
        this.maintainPlanService.updateById(plan);
        List<MaintainRecordItem> maintainRecordItemList = new ArrayList<>();
        MaintainRecordAddVO.getMaintainRecordItemAddVOList().forEach(i -> {
            MaintainRecordItem maintainRecordItem = MaintainRecordItemConvert.INSTANCE.convert(i);
            maintainRecordItem.setRecordId(maintainRecord.getId());
            maintainRecordItemList.add(maintainRecordItem);
        });
        if (CollectionUtil.isNotEmpty(maintainRecordItemList)) {
            this.maintainRecordItemService.saveBatch(maintainRecordItemList);
        }
        List<RepairRecordMaterialAddVO> repairRecordMaterialAddVOList = new ArrayList<>();
        MaintainRecordAddVO.getRepairRecordMaterialAddVOList().forEach(i2 -> {
            RepairRecordMaterialAddVO repairRecordMaterialAddDTO = new RepairRecordMaterialAddVO();
            repairRecordMaterialAddDTO.setRecordId(maintainRecord.getId());
            repairRecordMaterialAddDTO.setMaterialId(i2.getMaterialId());
            repairRecordMaterialAddDTO.setMaterialCode(i2.getMaterialCode());
            repairRecordMaterialAddDTO.setMaterialName(i2.getMaterialName());
            repairRecordMaterialAddDTO.setRecordNumber(i2.getRecordNumber());
            repairRecordMaterialAddDTO.setDeviceId(maintainRecord.getDeviceId());
            repairRecordMaterialAddDTO.setBizType(Integer.valueOf(BizTypeEnum.T2.getType()));
            repairRecordMaterialAddDTO.setUserId(maintainRecord.getMaintainUserId());
            repairRecordMaterialAddDTO.setUserName(maintainRecord.getMaintainUserName());
            if (Func.isNotEmpty(maintainRecord.getEndTime())) {
                repairRecordMaterialAddDTO.setUsageTime(LocalDateTimeUtils.LocalDateTimeToDate(maintainRecord.getEndTime()));
            }
            repairRecordMaterialAddVOList.add(repairRecordMaterialAddDTO);
        });
        if (CollectionUtil.isNotEmpty(repairRecordMaterialAddVOList)) {
            this.deviceMaterialRecordService.createDeviceMaterialRecord(repairRecordMaterialAddVOList);
        }
        this.machineService.updateDeviceMaintainStatus(plan.getDeviceId(), plan.getId(), null);
        return maintainRecord;
    }

    @Override // org.springblade.modules.tpm.service.IMaintainRecordService
    @Transactional(rollbackFor = {Exception.class})
    public MaintainRecord editMaintainRecord(MaintainRecordUpdateVO maintainRecordUpdateVO) {
        LocalDateTime now = LocalDateTime.now();
        MaintainRecord maintainRecord = (MaintainRecord) getById(maintainRecordUpdateVO.getId());
        if (Func.isNull(maintainRecord)) {
            throw new ServiceException(MessageUtils.message("cps.common.the.current.object.does.not.exist", new Object[0]));
        }
        MaintainRecord maintainRecordUp = MaintainRecordConvert.INSTANCE.convert(maintainRecordUpdateVO);
        maintainRecordUp.setUpdateTime(LocalDateTimeUtils.LocalDateTimeToDate(now));
        updateById(maintainRecordUp);
        this.maintainRecordItemService.remove(Wrappers.<MaintainRecordItem>query().lambda().in(MaintainRecordItem::getRecordId, new Object[] { maintainRecord.getId() }));
        /*
        this.maintainRecordItemService.remove((Wrapper) Wrappers.query().lambda().in((v0) -> {
            return v0.getRecordId();
        }, new Object[]{maintainRecord.getId()}));*/
        List<MaintainRecordItem> maintainRecordItemList = new ArrayList<>();
        maintainRecordUpdateVO.getMaintainRecordItemAddVOList().forEach(i -> {
            MaintainRecordItem maintainRecordItem = MaintainRecordItemConvert.INSTANCE.convert(i);
            maintainRecordItem.setRecordId(maintainRecordUp.getId());
            maintainRecordItemList.add(maintainRecordItem);
        });
        this.maintainRecordItemService.saveBatch(maintainRecordItemList);
        List<RepairRecordMaterialAddVO> repairRecordMaterialAddVOList = new ArrayList<>();
        maintainRecordUpdateVO.getRepairRecordMaterialAddVOList().forEach(i2 -> {
            RepairRecordMaterialAddVO repairRecordMaterialAddDTO = new RepairRecordMaterialAddVO();
            repairRecordMaterialAddDTO.setRecordId(maintainRecordUp.getId());
            repairRecordMaterialAddDTO.setMaterialId(i2.getMaterialId());
            repairRecordMaterialAddDTO.setMaterialCode(i2.getMaterialCode());
            repairRecordMaterialAddDTO.setMaterialName(i2.getMaterialName());
            repairRecordMaterialAddDTO.setRecordNumber(i2.getRecordNumber());
            repairRecordMaterialAddDTO.setDeviceId(maintainRecord.getDeviceId());
            repairRecordMaterialAddDTO.setBizType(Integer.valueOf(BizTypeEnum.T2.getType()));
            repairRecordMaterialAddDTO.setUserId(maintainRecordUp.getMaintainUserId());
            repairRecordMaterialAddDTO.setUserName(maintainRecordUp.getMaintainUserName());
            if (Func.isNotEmpty(maintainRecordUp.getEndTime())) {
                repairRecordMaterialAddDTO.setUsageTime(LocalDateTimeUtils.LocalDateTimeToDate(maintainRecordUp.getEndTime()));
            }
            repairRecordMaterialAddVOList.add(repairRecordMaterialAddDTO);
        });
        if (CollectionUtil.isNotEmpty(repairRecordMaterialAddVOList)) {
            this.deviceMaterialRecordService.updateDeviceMaterialRecord(repairRecordMaterialAddVOList);
        }
        if (CollectionUtil.isEmpty(repairRecordMaterialAddVOList)) {
            this.deviceMaterialRecordService.deleteDeviceMaterialRecordByRecordId(Arrays.asList(maintainRecordUp.getId()));
        }
        return maintainRecordUp;
    }

    @Override // org.springblade.modules.tpm.service.IMaintainRecordService
    public MaintainRecordVO getMaintainRecord(Long id) {
        MaintainRecord maintainRecord = (MaintainRecord) getById(id);
        MaintainRecordVO maintainRecordVo = MaintainRecordConvert.INSTANCE.convert(maintainRecord);
        maintainRecordVo.setIsDelayName(PlanDelayStatusEnum.getDescDetail(maintainRecordVo.getIsDelay()));
        maintainRecordVo.setMaintainNatureName(RepairNatureEnum.getDescDetail(maintainRecordVo.getMaintainNature()));
        List<MaintainRecordItem> maintainRecordItemList = this.maintainRecordItemService.list(Wrappers.<MaintainRecordItem>query().lambda()
        		.in(MaintainRecordItem::getRecordId, new Object[] { maintainRecord.getId() }));
        /*
        List<MaintainRecordItem> maintainRecordItemList = this.maintainRecordItemService.list((Wrapper) Wrappers.query().lambda().in((v0) -> {
            return v0.getRecordId();
        }, new Object[]{maintainRecord.getId()}));*/
        List<MaintainRecordItemVO> maintainRecordItemVoList = MaintainRecordItemConvert.INSTANCE.convert(maintainRecordItemList);
        maintainRecordItemVoList.forEach(i -> {
            i.setIsExecuteName(ExecuteEnum.getDescDetail(i.getIsExecute()));
        });
        maintainRecordVo.setMaintainRecordItemVOList(maintainRecordItemVoList);
        List<DeviceMaterialRecord> deviceMaterialRecordList = this.deviceMaterialRecordService.list(Wrappers.<DeviceMaterialRecord>query().lambda()
        		.in(DeviceMaterialRecord::getRecordId, new Object[] { maintainRecord.getId() }));
        /*
        List<DeviceMaterialRecord> deviceMaterialRecordList = this.deviceMaterialRecordService.list((Wrapper) Wrappers.query().lambda().in((v0) -> {
            return v0.getRecordId();
        }, new Object[]{maintainRecord.getId()}));*/
        List<RepairRecordMaterialVO> recordByRecord = DeviceMaterialRecordConvert.INSTANCE.convert(deviceMaterialRecordList);
        maintainRecordVo.setRepairRecordMaterialVOList(recordByRecord);
        return maintainRecordVo;
    }

    @Override // org.springblade.modules.tpm.service.IMaintainRecordService
    public List<MaintainRecordVO> queryMaintainRecordList(MaintainRecordSearchVO maintainRecordSearchVO) {
    	List<MaintainRecord> list = new ArrayList<>();
        if (!maintainRecordSearchVO.getFilterPlus().booleanValue()) {
        	list = list(Wrappers.<MaintainRecord>query().lambda()
        	          .in((maintainRecordSearchVO.getDeviceTypeId() != null), MaintainRecord::getDeviceTypeId, new Object[] { maintainRecordSearchVO.getDeviceTypeId() })
        	          .eq(Func.isNotEmpty(maintainRecordSearchVO.getDeviceId()), MaintainRecord::getDeviceId, maintainRecordSearchVO.getDeviceId())
        	          .eq(Func.isNotEmpty(maintainRecordSearchVO.getRecordStatus()), MaintainRecord::getRecordStatus, maintainRecordSearchVO.getRecordStatus())
        	          .and(Func.isNotEmpty(maintainRecordSearchVO.getKeyWord()), i -> i.likeRight(MaintainRecord::getDeviceName, maintainRecordSearchVO.getKeyWord()).or().likeRight(MaintainRecord::getRecordCode, maintainRecordSearchVO.getKeyWord()).or().likeRight(MaintainRecord::getDeviceCode, maintainRecordSearchVO.getKeyWord()))
        	          
        	          .orderByDesc(MaintainRecord::getRecordStatus));
        	
        	/*
            list = list((Wrapper) Wrappers.query().lambda().in(maintainRecordSearchVO.getDeviceTypeId() != null, (v0) -> {
                return v0.getDeviceTypeId();
            }, new Object[]{maintainRecordSearchVO.getDeviceTypeId()}).eq(Func.isNotEmpty(maintainRecordSearchVO.getDeviceId()), (v0) -> {
                return v0.getDeviceId();
            }, maintainRecordSearchVO.getDeviceId()).eq(Func.isNotEmpty(maintainRecordSearchVO.getRecordStatus()), (v0) -> {
                return v0.getRecordStatus();
            }, maintainRecordSearchVO.getRecordStatus()).and(Func.isNotEmpty(maintainRecordSearchVO.getKeyWord()), i -> {
                LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) i.likeRight((v0) -> {
                    return v0.getDeviceName();
                }, maintainRecordSearchVO.getKeyWord())).or()).likeRight((v0) -> {
                    return v0.getRecordCode();
                }, maintainRecordSearchVO.getKeyWord())).or()).likeRight((v0) -> {
                    return v0.getDeviceCode();
                }, maintainRecordSearchVO.getKeyWord());
            }).orderByDesc((v0) -> {
                return v0.getRecordStatus();
            }));*/
        } else {
        	list = list(Condition.getQueryWrapper(maintainRecordSearchVO.getParam(), MaintainRecord.class).lambda()
        	          .in((maintainRecordSearchVO.getDeviceTypeId() != null), MaintainRecord::getDeviceTypeId, new Object[] { maintainRecordSearchVO.getDeviceTypeId() })
        	          .eq(Func.isNotEmpty(maintainRecordSearchVO.getDeviceId()), MaintainRecord::getDeviceId, maintainRecordSearchVO.getDeviceId())
        	          .eq(Func.isNotEmpty(maintainRecordSearchVO.getRecordStatus()), MaintainRecord::getRecordStatus, maintainRecordSearchVO.getRecordStatus())
        	          .and(Func.isNotEmpty(maintainRecordSearchVO.getKeyWord()), i -> i.likeRight(MaintainRecord::getDeviceName, maintainRecordSearchVO.getKeyWord()).or().likeRight(MaintainRecord::getRecordCode, maintainRecordSearchVO.getKeyWord()).or().likeRight(MaintainRecord::getDeviceCode, maintainRecordSearchVO.getKeyWord()))
        	          
        	          .orderByDesc(MaintainRecord::getRecordStatus));
        	/*
            list = list((Wrapper) Condition.getQueryWrapper(maintainRecordSearchVO.getParam(), MaintainRecord.class).lambda().in(maintainRecordSearchVO.getDeviceTypeId() != null, (v0) -> {
                return v0.getDeviceTypeId();
            }, new Object[]{maintainRecordSearchVO.getDeviceTypeId()}).eq(Func.isNotEmpty(maintainRecordSearchVO.getDeviceId()), (v0) -> {
                return v0.getDeviceId();
            }, maintainRecordSearchVO.getDeviceId()).eq(Func.isNotEmpty(maintainRecordSearchVO.getRecordStatus()), (v0) -> {
                return v0.getRecordStatus();
            }, maintainRecordSearchVO.getRecordStatus()).and(Func.isNotEmpty(maintainRecordSearchVO.getKeyWord()), i2 -> {
                LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) i2.likeRight((v0) -> {
                    return v0.getDeviceName();
                }, maintainRecordSearchVO.getKeyWord())).or()).likeRight((v0) -> {
                    return v0.getRecordCode();
                }, maintainRecordSearchVO.getKeyWord())).or()).likeRight((v0) -> {
                    return v0.getDeviceCode();
                }, maintainRecordSearchVO.getKeyWord());
            }).orderByDesc((v0) -> {
                return v0.getRecordStatus();
            }));*/
        }
        List<MaintainRecordVO> result = MaintainRecordConvert.INSTANCE.convert(list);
        result.forEach(bean -> {
            bean.setRecordStatusName(MaintainRecordStatusEnum.getDescDetail(bean.getRecordStatus()));
            bean.setIsDelayName(PlanDelayStatusEnum.getDescDetail(bean.getIsDelay()));
            bean.setMaintainNatureName(RepairNatureEnum.getDescDetail(bean.getMaintainNature()));
        });
        return result;
    }

    @Override // org.springblade.modules.tpm.service.IMaintainRecordService
    public IPage<MaintainRecordVO> queryMaintainRecordPage(MaintainRecordSearchVO maintainRecordSearchVO, Query query) {
        IPage<MaintainRecord> pages;
        if (!maintainRecordSearchVO.getFilterPlus().booleanValue()) {
        	pages = page(Condition.getPage(query), Wrappers.<MaintainRecord>query().lambda()
        	          .in((maintainRecordSearchVO.getDeviceTypeId() != null), MaintainRecord::getDeviceTypeId, new Object[] { maintainRecordSearchVO.getDeviceTypeId() })
        	          .eq(Func.isNotEmpty(maintainRecordSearchVO.getDeviceId()), MaintainRecord::getDeviceId, maintainRecordSearchVO.getDeviceId())
        	          .eq(Func.isNotEmpty(maintainRecordSearchVO.getRecordStatus()), MaintainRecord::getRecordStatus, maintainRecordSearchVO.getRecordStatus())
        	          .and(Func.isNotEmpty(maintainRecordSearchVO.getKeyWord()), i -> i.likeRight(MaintainRecord::getDeviceName, maintainRecordSearchVO.getKeyWord()).or().likeRight(MaintainRecord::getRecordCode, maintainRecordSearchVO.getKeyWord()).or().likeRight(MaintainRecord::getDeviceCode, maintainRecordSearchVO.getKeyWord()))
        	          
        	          .orderByDesc(MaintainRecord::getCreateTime).orderByDesc(MaintainRecord::getId));
        	/*
            pages = page(Condition.getPage(query), (Wrapper) ((LambdaQueryWrapper) Wrappers.query().lambda().in(maintainRecordSearchVO.getDeviceTypeId() != null, (v0) -> {
                return v0.getDeviceTypeId();
            }, new Object[]{maintainRecordSearchVO.getDeviceTypeId()}).eq(Func.isNotEmpty(maintainRecordSearchVO.getDeviceId()), (v0) -> {
                return v0.getDeviceId();
            }, maintainRecordSearchVO.getDeviceId()).eq(Func.isNotEmpty(maintainRecordSearchVO.getRecordStatus()), (v0) -> {
                return v0.getRecordStatus();
            }, maintainRecordSearchVO.getRecordStatus()).and(Func.isNotEmpty(maintainRecordSearchVO.getKeyWord()), i -> {
                LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) i.likeRight((v0) -> {
                    return v0.getDeviceName();
                }, maintainRecordSearchVO.getKeyWord())).or()).likeRight((v0) -> {
                    return v0.getRecordCode();
                }, maintainRecordSearchVO.getKeyWord())).or()).likeRight((v0) -> {
                    return v0.getDeviceCode();
                }, maintainRecordSearchVO.getKeyWord());
            }).orderByDesc((v0) -> {
                return v0.getCreateTime();
            })).orderByDesc((v0) -> {
                return v0.getId();
            }));*/
        } else {
        	pages = page(Condition.getPage(query), Condition.getQueryWrapper(maintainRecordSearchVO.getParam(), MaintainRecord.class)
        	          
        	          .lambda().in((maintainRecordSearchVO.getDeviceTypeId() != null), MaintainRecord::getDeviceTypeId, new Object[] { maintainRecordSearchVO.getDeviceTypeId() })
        	          .eq(Func.isNotEmpty(maintainRecordSearchVO.getDeviceId()), MaintainRecord::getDeviceId, maintainRecordSearchVO.getDeviceId())
        	          .eq(Func.isNotEmpty(maintainRecordSearchVO.getRecordStatus()), MaintainRecord::getRecordStatus, maintainRecordSearchVO.getRecordStatus())
        	          .and(Func.isNotEmpty(maintainRecordSearchVO.getKeyWord()), i -> i.likeRight(MaintainRecord::getDeviceName, maintainRecordSearchVO.getKeyWord()).or().likeRight(MaintainRecord::getRecordCode, maintainRecordSearchVO.getKeyWord()).or().likeRight(MaintainRecord::getDeviceCode, maintainRecordSearchVO.getKeyWord()))
        	          
        	          .orderByDesc(MaintainRecord::getCreateTime).orderByDesc(MaintainRecord::getId));
        	/*
            pages = page(Condition.getPage(query), (Wrapper) ((LambdaQueryWrapper) Condition.getQueryWrapper(maintainRecordSearchVO.getParam(), MaintainRecord.class).lambda().in(maintainRecordSearchVO.getDeviceTypeId() != null, (v0) -> {
                return v0.getDeviceTypeId();
            }, new Object[]{maintainRecordSearchVO.getDeviceTypeId()}).eq(Func.isNotEmpty(maintainRecordSearchVO.getDeviceId()), (v0) -> {
                return v0.getDeviceId();
            }, maintainRecordSearchVO.getDeviceId()).eq(Func.isNotEmpty(maintainRecordSearchVO.getRecordStatus()), (v0) -> {
                return v0.getRecordStatus();
            }, maintainRecordSearchVO.getRecordStatus()).and(Func.isNotEmpty(maintainRecordSearchVO.getKeyWord()), i2 -> {
                LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) i2.likeRight((v0) -> {
                    return v0.getDeviceName();
                }, maintainRecordSearchVO.getKeyWord())).or()).likeRight((v0) -> {
                    return v0.getRecordCode();
                }, maintainRecordSearchVO.getKeyWord())).or()).likeRight((v0) -> {
                    return v0.getDeviceCode();
                }, maintainRecordSearchVO.getKeyWord());
            }).orderByDesc((v0) -> {
                return v0.getCreateTime();
            })).orderByDesc((v0) -> {
                return v0.getId();
            }));*/
        }
        IPage<MaintainRecordVO> result = MaintainRecordConvert.INSTANCE.convert((IPage) pages);
        result.getRecords().forEach(bean -> {
            bean.setRecordStatusName(MaintainRecordStatusEnum.getDescDetail(bean.getRecordStatus()));
            bean.setIsDelayName(PlanDelayStatusEnum.getDescDetail(bean.getIsDelay()));
            bean.setMaintainNatureName(RepairNatureEnum.getDescDetail(bean.getMaintainNature()));
        });
        return result;
    }

    @Override // org.springblade.modules.tpm.service.IMaintainRecordService
    public List<MaintainRecordItemVO> queryMaintainRecordItemList(Long recordId) {
        return this.maintainRecordItemService.getMaintainRecordItemListByRecordId(recordId, AuthUtil.getTenantId());
    }

    @Override // org.springblade.modules.tpm.service.IMaintainRecordService
    public IPage<MaintainRecordItemVO> queryMaintainRecordItemListPage(Long recordId, Query query) {
        return this.maintainRecordItemService.queryMaintainRecordItemListPage(recordId, AuthUtil.getTenantId(), query);
    }

    @Override // org.springblade.modules.tpm.service.IMaintainRecordService
    @Transactional(rollbackFor = {Exception.class})
    public Boolean deleteMaintainRecord(MaintainRecordIdListVO maintainRecordIdListVO) {
        List<MaintainRecord> maintainRecordList = listByIds(maintainRecordIdListVO.getIdList());
        List<MaintainRecord> notDeleteList = maintainRecordList.stream().filter(i -> (i.getRecordStatus().intValue() != MaintainRecordStatusEnum.T1.getType())).collect(Collectors.toList());
        /*
        List<MaintainRecord> notDeleteList = (List) maintainRecordList.stream().filter(i -> {
            return i.getRecordStatus().intValue() != MaintainRecordStatusEnum.T1.getType();
        }).collect(Collectors.toList());*/
        if (!notDeleteList.isEmpty()) {
            throw new ServiceException(MessageUtils.message("cps.tpm.maintain.record.have.been.confirmed.can.not.delete", new Object[0]));
        }
        removeByIds(maintainRecordIdListVO.getIdList());
        this.maintainRecordItemService.remove(Wrappers.<MaintainRecordItem>query().lambda().in(MaintainRecordItem::getRecordId, maintainRecordIdListVO.getIdList()));
        /*
        this.maintainRecordItemService.remove((Wrapper) Wrappers.query().lambda().in((v0) -> {
            return v0.getRecordId();
        }, maintainRecordIdListVO.getIdList()));*/
        this.deviceMaterialRecordService.deleteDeviceMaterialRecordByRecordId(maintainRecordIdListVO.getIdList());
        List<Long> planIdList = maintainRecordList.stream().map((v0) -> {
            return v0.getPlanId();
        }).distinct().collect(Collectors.toList());
        for (Long planId : planIdList) {
            MaintainPlan plan = (MaintainPlan) this.maintainPlanService.getById(planId);
            plan.setPlanStatus(Integer.valueOf(MaintainPlanStatusEnum.T3.getType()));
            this.maintainPlanService.updateById(plan);
            this.machineService.updateDeviceMaintainStatus(plan.getDeviceId(), plan.getId(), null);
        }
        return true;
    }

    @Override // org.springblade.modules.tpm.service.IMaintainRecordService
    @Transactional(rollbackFor = {Exception.class})
    public Boolean confirmMaintainRecord(Long id) {
        LocalDateTime now = LocalDateTime.now();
        MaintainRecord maintainRecord = (MaintainRecord) getById(id);
        if (Func.isNull(maintainRecord)) {
            throw new ServiceException(MessageUtils.message("cps.common.the.current.object.does.not.exist", new Object[0]));
        }
        maintainRecord.setRecordStatus(Integer.valueOf(MaintainRecordStatusEnum.T2.getType()));
        maintainRecord.setUpdateTime(LocalDateTimeUtils.LocalDateTimeToDate(now));
        updateById(maintainRecord);
        MaintainPlan plan = (MaintainPlan) this.maintainPlanService.getById(maintainRecord.getPlanId());
        if (Func.isNull(plan)) {
            throw new ServiceException(MessageUtils.message("cps.common.the.current.object.does.not.exist", new Object[0]));
        }
        plan.setPlanStatus(Integer.valueOf(MaintainPlanStatusEnum.T5.getType()));
        plan.setUpdateTime(LocalDateTimeUtils.LocalDateTimeToDate(now));
        this.maintainPlanService.updateById(plan);
        this.machineService.updateDeviceMaintainStatus(plan.getDeviceId(), plan.getId(), maintainRecord.getEndTime());
        if (plan.getIsAuto().intValue() == MaintainPlanIsAutoEnum.T1.getType()) {
            MaintainProject maintainProject = (MaintainProject) this.maintainProjectService.getById(plan.getProjectId());
            if (maintainProject == null) {
                return true;
            }
            List<MaintainProjectItem> maintainProjectItemList = this.maintainProjectItemService.list(Wrappers.<MaintainProjectItem>query().lambda()
            		.in(MaintainProjectItem::getProjectId, new Object[] { plan.getProjectId() }));
            /*
            List<MaintainProjectItem> maintainProjectItemList = this.maintainProjectItemService.list((Wrapper) Wrappers.query().lambda().in((v0) -> {
                return v0.getProjectId();
            }, new Object[]{plan.getProjectId()}));*/
            if (CollectionUtil.isEmpty(maintainProjectItemList)) {
                return true;
            }
            DeviceSimpleDTO deviceSimpleDTO = new DeviceSimpleDTO();
            deviceSimpleDTO.setDeviceId(plan.getDeviceId());
            deviceSimpleDTO.setCode(plan.getDeviceCode());
            deviceSimpleDTO.setName(plan.getDeviceName());
            deviceSimpleDTO.setDeviceTypeId(plan.getDeviceTypeId());
            deviceSimpleDTO.setDeviceTypeName(plan.getDeviceTypeName());
            MaintainPlanBatchVO maintainPlanBatchVO = MaintainPlanBatchVO.builder().deviceSimpleDTO(deviceSimpleDTO).maintainProject(maintainProject).maintainProjectItemList(maintainProjectItemList).lastTime(maintainRecord.getEndTime()).remark(plan.getRemark()).maintainUserId(plan.getMaintainUserId()).maintainUserName(plan.getMaintainUserName()).maintainNature(plan.getMaintainNature()).build();
            this.maintainPlanService.createMaintainPlanBatch(maintainPlanBatchVO);
        }
        return true;
    }

    @Override // org.springblade.modules.tpm.service.IMaintainRecordService
    public BladeFile exportMaintainRecord(MaintainRecordExportVO maintainRecordExportVO, HttpServletResponse response) {
        List<MaintainRecordExcel> list = this.baseMapper.export(maintainRecordExportVO, null);
        list.forEach(i -> {
            i.setIsDelay(PlanDelayStatusEnum.getDescDetail(Integer.valueOf(i.getIsDelay())));
        });
        String fileName = String.format("%s-%s.xlsx", "保养记录数据", DateUtil.time());
        MultipartFile multipartFile = ExcelUtil.exportToMultipartFile(fileName, "保养记录数据表", list, MaintainRecordExcel.class);
        return this.ossBuilder.tempTemplate().putFile(multipartFile.getOriginalFilename(), multipartFile);
    }

    @Override // org.springblade.modules.tpm.service.IMaintainRecordService
    public MaintainStatisticsVO maintainStatisticsNum() {
        MaintainStatisticsVO maintainStatisticsVo = new MaintainStatisticsVO();
        MaintainStatisticsVO maintainPlanStatisticsNum = this.maintainPlanService.maintainPlanStatisticsNum();
        maintainStatisticsVo.setDelayNum(maintainPlanStatisticsNum.getDelayNum());
        maintainStatisticsVo.setTodayNum(maintainPlanStatisticsNum.getTodayNum());
        maintainStatisticsVo.setWarningNum(maintainPlanStatisticsNum.getWarningNum());
        Long recordNum = Long.valueOf(count(Wrappers.<MaintainRecord>query().lambda().eq(MaintainRecord::getRecordStatus, Integer.valueOf(MaintainRecordStatusEnum.T1.getType()))
                .eq(Func.isNotBlank(AuthUtil.getTenantId()), MaintainRecord::getTenantId, AuthUtil.getTenantId())));
        /*
        Long recordNum = Long.valueOf(count(((LambdaQueryWrapper) Wrappers.query().lambda().eq((v0) -> {
            return v0.getRecordStatus();
        }, Integer.valueOf(MaintainRecordStatusEnum.T1.getType()))).eq(Func.isNotBlank(AuthUtil.getTenantId()), (v0) -> {
            return v0.getTenantId();
        }, AuthUtil.getTenantId())));*/
        maintainStatisticsVo.setRecordNum(recordNum);
        return maintainStatisticsVo;
    }

    @Override // org.springblade.modules.tpm.service.IMaintainRecordService
    public IPage<MaintainRecordVO> pageMaintainPlanConfirmed(Query query, MaintainPlanExpireQueryVO maintainPlanExpireQueryVO) {
    	IPage<MaintainRecord> page = page(Condition.getPage(query), Wrappers.<MaintainRecord>lambdaQuery()
    	        .eq(MaintainRecord::getTenantId, AuthUtil.getTenantId())
    	        .eq(MaintainRecord::getRecordStatus, Integer.valueOf(MaintainRecordStatusEnum.T1.getType()))
    	        .likeRight(Func.isNotBlank(maintainPlanExpireQueryVO.getCode()), MaintainRecord::getRecordCode, maintainPlanExpireQueryVO.getCode())
    	        .likeRight(Func.isNotBlank(maintainPlanExpireQueryVO.getDeviceCode()), MaintainRecord::getDeviceCode, maintainPlanExpireQueryVO.getDeviceCode())
    	        .likeRight(Func.isNotBlank(maintainPlanExpireQueryVO.getDeviceName()), MaintainRecord::getDeviceName, maintainPlanExpireQueryVO.getDeviceName())
    	        .likeRight(Func.isNotBlank(maintainPlanExpireQueryVO.getProjectName()), MaintainRecord::getProjectName, maintainPlanExpireQueryVO.getProjectName())
    	        .orderByDesc(MaintainRecord::getRecordStatus));
    	
    	/*
        IPage<MaintainRecord> page = page(Condition.getPage(query), (Wrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getTenantId();
        }, AuthUtil.getTenantId())).eq((v0) -> {
            return v0.getRecordStatus();
        }, Integer.valueOf(MaintainRecordStatusEnum.T1.getType()))).likeRight(Func.isNotBlank(maintainPlanExpireQueryVO.getCode()), (v0) -> {
            return v0.getRecordCode();
        }, maintainPlanExpireQueryVO.getCode()).likeRight(Func.isNotBlank(maintainPlanExpireQueryVO.getDeviceCode()), (v0) -> {
            return v0.getDeviceCode();
        }, maintainPlanExpireQueryVO.getDeviceCode()).likeRight(Func.isNotBlank(maintainPlanExpireQueryVO.getDeviceName()), (v0) -> {
            return v0.getDeviceName();
        }, maintainPlanExpireQueryVO.getDeviceName()).likeRight(Func.isNotBlank(maintainPlanExpireQueryVO.getProjectName()), (v0) -> {
            return v0.getProjectName();
        }, maintainPlanExpireQueryVO.getProjectName()).orderByDesc((v0) -> {
            return v0.getRecordStatus();
        }));*/
        IPage<MaintainRecordVO> voiPage = MaintainRecordConvert.INSTANCE.convert(page);
        if (Func.isNotEmpty(voiPage.getRecords())) {
            List<MaintainRecordVO> collect = voiPage.getRecords().stream().map(o -> {
                o.setRecordStatusName(MaintainRecordStatusEnum.T1.getDesc());
                o.setIsDelayName(PlanDelayStatusEnum.getDescDetail(o.getIsDelay()));
                o.setMaintainNatureName(RepairNatureEnum.getDescDetail(o.getMaintainNature()));
                return o;
            }).collect(Collectors.toList());
            voiPage.setRecords(collect);
        }
        return voiPage;
    }

    @Override // org.springblade.modules.tpm.service.IMaintainRecordService
    public MaintainVO getMaintainDetail(String id) {
        MaintainVO result = new MaintainVO();
        MaintainPlanVO maintainPlanVO = this.maintainPlanService.getMaintainPlan(Long.valueOf(id));
        result.setMaintainPlanVO(maintainPlanVO);
        
        MaintainRecord maintainRecord = getOne(Wrappers.<MaintainRecord>query().lambda().eq(Func.isNotEmpty(AuthUtil.getTenantId()), MaintainRecord::getTenantId, AuthUtil.getTenantId()).eq(MaintainRecord::getPlanId, id));
        /*
        MaintainRecord maintainRecord = (MaintainRecord) getOne((Wrapper) Wrappers.query().lambda().eq(Func.isNotEmpty(AuthUtil.getTenantId()), (v0) -> {
            return v0.getTenantId();
        }, AuthUtil.getTenantId()).eq((v0) -> {
            return v0.getPlanId();
        }, id));*/
        if (maintainRecord != null) {
            MaintainRecordVO maintainRecordVO = getMaintainRecord(maintainRecord.getId());
            result.setMaintainRecordVO(maintainRecordVO);
        }
        return result;
    }

    private boolean checkCodeIsExist(String code, Long id) {
    	List<MaintainRecord> maintainRecordList = this.baseMapper.selectList(Wrappers.<MaintainRecord>query().lambda()
    			.eq(Func.isNotEmpty(AuthUtil.getTenantId()), MaintainRecord::getTenantId, AuthUtil.getTenantId())
    			.in(MaintainRecord::getRecordCode, Func.toStrList(code))
    			.notIn(Func.isNotEmpty(id), MaintainRecord::getId, new Object[] { id }));
    	/*
        List<MaintainRecord> maintainRecordList = this.baseMapper.selectList(((LambdaQueryWrapper) Wrappers.query().lambda().eq(Func.isNotEmpty(AuthUtil.getTenantId()), (v0) -> {
            return v0.getTenantId();
        }, AuthUtil.getTenantId()).in((v0) -> {
            return v0.getRecordCode();
        }, Func.toStrList(code))).notIn(Func.isNotEmpty(id), (v0) -> {
            return v0.getId();
        }, new Object[]{id}));*/
        return maintainRecordList != null && maintainRecordList.size() > 0;
    }

    private void codeGenerator(MaintainRecordAddVO MaintainRecordAddVO) {
        String code = this.codeGeneratorService.getGeneratorCode(MaintainRecordAddVO, MetaTypeEnum.MAINTAIN_RECORD.getCode());
        log.info("保养记录编码规则生成的code:{}", code + " ," + code.length());
        MaintainRecordAddVO.setRecordCode(code);
    }
}