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

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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.log.exception.ServiceException;
import com.qianwen.core.mp.support.Condition;
import com.qianwen.core.mp.support.Query;
import com.qianwen.core.secure.utils.AuthUtil;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.smartman.common.utils.MessageUtils;
import com.qianwen.smartman.modules.cps.service.IMachineService;
import com.qianwen.smartman.modules.cps.vo.RepairRecordMaterialAddVO;
import com.qianwen.smartman.modules.system.service.ICodeGeneratorService;
import com.qianwen.smartman.modules.tpm.convert.MaterialRecordConvert;
import com.qianwen.smartman.modules.tpm.convert.RepairApplyFileConvert;
import com.qianwen.smartman.modules.tpm.convert.RepairRecordConvert;
import com.qianwen.smartman.modules.tpm.convert.RepairRecordDetailConvert;
import com.qianwen.smartman.modules.tpm.convert.RepairRecordFileConvert;
import com.qianwen.smartman.modules.tpm.dto.RepairApplyFileAddDTO;
import com.qianwen.smartman.modules.tpm.dto.RepairRecordFileAddDTO;
import com.qianwen.smartman.modules.tpm.dto.RepairRecordSearchDTO;
import com.qianwen.smartman.modules.tpm.entity.DeviceMaterialRecord;
import com.qianwen.smartman.modules.tpm.entity.RepairApply;
import com.qianwen.smartman.modules.tpm.entity.RepairApplyFile;
import com.qianwen.smartman.modules.tpm.entity.RepairRecord;
import com.qianwen.smartman.modules.tpm.entity.RepairRecordFile;
import com.qianwen.smartman.modules.tpm.enums.ActionEnum;
import com.qianwen.smartman.modules.tpm.enums.DeviceRepairStatusEnum;
import com.qianwen.smartman.modules.tpm.enums.MetaTypeEnum;
import com.qianwen.smartman.modules.tpm.enums.RepairApplyStatusEnum;
import com.qianwen.smartman.modules.tpm.enums.RepairRecordEnum;
import com.qianwen.smartman.modules.tpm.enums.RepairRecordTypeEnum;
import com.qianwen.smartman.modules.tpm.enums.UrgencyEnum;
import com.qianwen.smartman.modules.tpm.mapper.RepairRecordMapper;
import com.qianwen.smartman.modules.tpm.service.IDeviceMaterialRecordService;
import com.qianwen.smartman.modules.tpm.service.IRepairApplyFileService;
import com.qianwen.smartman.modules.tpm.service.IRepairApplyService;
import com.qianwen.smartman.modules.tpm.service.IRepairRecordFileService;
import com.qianwen.smartman.modules.tpm.service.IRepairRecordService;
import com.qianwen.smartman.modules.tpm.utils.DateUtils;
import com.qianwen.smartman.modules.tpm.vo.ApplyRecordMaterialVO;
import com.qianwen.smartman.modules.tpm.vo.MaterialVO;
import com.qianwen.smartman.modules.tpm.vo.RepairApplyDetailVO;
import com.qianwen.smartman.modules.tpm.vo.RepairRecordAddVO;
import com.qianwen.smartman.modules.tpm.vo.RepairRecordDetailVO;
import com.qianwen.smartman.modules.tpm.vo.RepairRecordExportVO;
import com.qianwen.smartman.modules.tpm.vo.RepairRecordLookVO;
import com.qianwen.smartman.modules.tpm.vo.RepairRecordMaterialVO;
import com.qianwen.smartman.modules.tpm.vo.RepairRecordTodaySearchVO;
import com.qianwen.smartman.modules.tpm.vo.RepairRecordUpdateVO;
import com.qianwen.smartman.modules.tpm.vo.RepairRecordVO;
import com.qianwen.smartman.modules.tpm.vo.excel.RepairRecordExcelVO;

@Service
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/tpm/service/impl/RepairRecordServiceImpl.class */
public class RepairRecordServiceImpl extends ServiceImpl<RepairRecordMapper, RepairRecord> implements IRepairRecordService {
    private static final Logger log = LoggerFactory.getLogger(RepairRecordServiceImpl.class);
    private final IRepairApplyService repairApplyService;
    private final IRepairApplyFileService repairApplyFileService;
    private final IRepairRecordFileService repairRecordFileService;
    private final IDeviceMaterialRecordService deviceMaterialRecordService;
    private final IMachineService machineService;
    private final RepairRecordMapper repairRecordMapper;
    private final ICodeGeneratorService codeGeneratorService;


    public RepairRecordServiceImpl(final IRepairApplyService repairApplyService, final IRepairApplyFileService repairApplyFileService, final IRepairRecordFileService repairRecordFileService, final IDeviceMaterialRecordService deviceMaterialRecordService, final IMachineService machineService, final RepairRecordMapper repairRecordMapper, final ICodeGeneratorService codeGeneratorService) {
        this.repairApplyService = repairApplyService;
        this.repairApplyFileService = repairApplyFileService;
        this.repairRecordFileService = repairRecordFileService;
        this.deviceMaterialRecordService = deviceMaterialRecordService;
        this.machineService = machineService;
        this.repairRecordMapper = repairRecordMapper;
        this.codeGeneratorService = codeGeneratorService;
    }

    @Override // org.springblade.modules.tpm.service.IRepairRecordService
    @Transactional(rollbackFor = {Exception.class})
    public RepairRecord createRepairRecord(RepairRecordAddVO repairRecordAddVO) {
        RepairRecord repairRecord = RepairRecordConvert.INSTANCE.convert(repairRecordAddVO);
        if (Func.isBlank(repairRecord.getRecordCode())) {
            String code = this.codeGeneratorService.getGeneratorCode(repairRecordAddVO, MetaTypeEnum.REPAIR_RECORD.getCode());
            log.info("维修记录编码规则生成的code:{}", code + " ," + code.length());
            repairRecord.setRecordCode(code);
        }
        if (checkRecordCode(repairRecord.getRecordCode())) {
            throw new ServiceException(MessageUtils.message("cps.tpm.record.apply.code.already.exists", new Object[0]));
        }
        if (repairRecordAddVO.getRecordType().equals(Integer.valueOf(RepairRecordTypeEnum.T1.getType()))) {
            repairRecord.setRecordType(Integer.valueOf(RepairRecordTypeEnum.T1.getType()));
        } else {
            repairRecord.setRecordType(Integer.valueOf(RepairRecordTypeEnum.T2.getType()));
            if (!checkApplyCode(repairRecordAddVO.getRepairApplyId())) {
                throw new ServiceException(MessageUtils.message("cps.tpm.repair.apply.num.already.registered", new Object[0]));
            }
            repairRecord.setRepairApplyId(repairRecordAddVO.getRepairApplyId());
            RepairApply repairApply = (RepairApply) this.repairApplyService.getById(repairRecordAddVO.getRepairApplyId());
            if (Func.isNull(repairApply)) {
                throw new ServiceException(MessageUtils.message("cps.tpm.repair.apply.not.exists", new Object[0]));
            }
            repairApply.setApplyStatus(Integer.valueOf(RepairApplyStatusEnum.Y3.getType()));
            this.repairApplyService.updateById(repairApply);
        }
        repairRecord.setRecordStatus(Integer.valueOf(RepairRecordEnum.R1.getType()));
        this.machineService.renewMachineRepairStatus(repairRecord.getDeviceId(), Integer.valueOf(DeviceRepairStatusEnum.TO_BE_CONFIRM.getType()));
        save(repairRecord);
        if (Func.isNotEmpty(repairRecordAddVO.getRecordFileList())) {
            List<RepairRecordFile> repairApplyFileList = RepairRecordFileConvert.INSTANCE.convert(repairRecordAddVO.getRecordFileList());
            repairApplyFileList.forEach(s -> {
                s.setRepairRecordId(repairRecord.getId());
            });
            this.repairRecordFileService.saveBatch(repairApplyFileList);
        }
        if (Func.isNotEmpty(repairRecordAddVO.getMaterialVOList())) {
            List<RepairRecordMaterialAddVO> materialAddDTOList = repairRecordAddVO.getMaterialVOList();
            materialAddDTOList.forEach(i -> {
                i.setRecordId(repairRecord.getId());
                i.setBizType(1);
                i.setDeviceId(repairRecord.getDeviceId());
                i.setUserId(repairRecordAddVO.getRepairUserId());
                i.setUserName(repairRecordAddVO.getRepairUserName());
                i.setUsageTime(new Date());
            });
            this.deviceMaterialRecordService.createDeviceMaterialRecord(materialAddDTOList);
        }
        return repairRecord;
    }

    @Override // org.springblade.modules.tpm.service.IRepairRecordService
    @Transactional(rollbackFor = {Exception.class})
    public RepairRecord updateRepairRecord(RepairRecordUpdateVO repairRecordUpdateVO) {
        if (!checkRecordStatus(repairRecordUpdateVO.getId())) {
            throw new ServiceException(MessageUtils.message("cps.tpm.repair.record.status.is.edit", new Object[0]));
        }
        RepairRecord repairRecord = RepairRecordConvert.INSTANCE.convert(repairRecordUpdateVO);
        updateById(repairRecord);
        if (Func.isNotEmpty(repairRecordUpdateVO.getRecordFileList())) {
        	List<RepairRecordFile> oldFiles = this.repairRecordFileService.list(Wrappers.<RepairRecordFile>query().lambda().eq(RepairRecordFile::getRepairRecordId, repairRecordUpdateVO.getId()));
        	/*
            List<RepairRecordFile> oldFiles = this.repairRecordFileService.list((Wrapper) Wrappers.query().lambda().eq((v0) -> {
                return v0.getRepairRecordId();
            }, repairRecordUpdateVO.getId()));
            if (!Func.isNull(oldFiles)) {
                this.repairRecordFileService.removeByIds((Collection) oldFiles.stream().map((v0) -> {
                    return v0.getId();
                }).collect(Collectors.toList()));
            }*/
            List<RepairRecordFile> newFiles = RepairRecordFileConvert.INSTANCE.convert(repairRecordUpdateVO.getRecordFileList());
            newFiles.forEach(s -> {
                s.setRepairRecordId(repairRecord.getId());
            });
            this.repairRecordFileService.saveBatch(newFiles);
        } else {
        	List<RepairRecordFile> oldFiles2 = this.repairRecordFileService.list(Wrappers.<RepairRecordFile>query().lambda().eq(RepairRecordFile::getRepairRecordId, repairRecordUpdateVO.getId()));
        	/*
            List<RepairRecordFile> oldFiles2 = this.repairRecordFileService.list((Wrapper) Wrappers.query().lambda().eq((v0) -> {
                return v0.getRepairRecordId();
            }, repairRecordUpdateVO.getId()));*/
            if (!Func.isNull(oldFiles2)) {
                this.repairRecordFileService.removeByIds(oldFiles2.stream().map((v0) -> {
                    return v0.getId();
                }).collect(Collectors.toList()));
            }
        }
        RepairApply repairApply = this.repairApplyService.getById(repairRecord.getRepairApplyId());
        if (Func.isNotEmpty(repairRecordUpdateVO.getMaterialVOList())) {
            List<RepairRecordMaterialAddVO> materialAddDTOList = repairRecordUpdateVO.getMaterialVOList();
            materialAddDTOList.forEach(i -> {
                i.setRecordId(repairRecord.getId());
            });
            this.deviceMaterialRecordService.updateDeviceMaterialRecord(materialAddDTOList);
        } else {
            this.deviceMaterialRecordService.deleteDeviceMaterialRecordByRecordId(Collections.singletonList(repairRecord.getId()));
        }
        return repairRecord;
    }

    @Override // org.springblade.modules.tpm.service.IRepairRecordService
    public IPage<RepairRecordVO> getPageRecord(RepairRecordSearchDTO repairRecordSearchDTO, Query query) {
    	IPage<RepairRecord> pages = page(Condition.getPage(query), Wrappers.<RepairRecord>lambdaQuery()
    	        .eq(Func.isNotEmpty(AuthUtil.getTenantId()), RepairRecord::getTenantId, AuthUtil.getTenantId())
    	        .and(Func.isNotEmpty(repairRecordSearchDTO.getDeviceTypeId()), i -> i.eq(RepairRecord::getDeviceTypeId, repairRecordSearchDTO.getDeviceTypeId()))
    	        .and(Func.isNotEmpty(repairRecordSearchDTO.getRecordStatus()), i -> i.eq(RepairRecord::getRecordStatus, repairRecordSearchDTO.getRecordStatus()))
    	        .and(Func.isNotEmpty(repairRecordSearchDTO.getKeyWords()), i -> i.like(RepairRecord::getRecordCode, repairRecordSearchDTO.getKeyWords()).or().like(RepairRecord::getDeviceCode, repairRecordSearchDTO.getKeyWords()).or().like(RepairRecord::getRepairApplyId, getApplyId(repairRecordSearchDTO.getKeyWords())).or().like(RepairRecord::getDeviceName, repairRecordSearchDTO.getKeyWords())));
    	
    	/*
        IPage<RepairRecord> pages = page(Condition.getPage(query), Wrappers.lambdaQuery().eq(Func.isNotEmpty(AuthUtil.getTenantId()), (v0) -> {
            return v0.getTenantId();
        }, AuthUtil.getTenantId()).and(Func.isNotEmpty(repairRecordSearchDTO.getDeviceTypeId()), i -> {
            LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) i.eq((v0) -> {
                return v0.getDeviceTypeId();
            }, repairRecordSearchDTO.getDeviceTypeId());
        }).and(Func.isNotEmpty(repairRecordSearchDTO.getRecordStatus()), i2 -> {
            LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) i2.eq((v0) -> {
                return v0.getRecordStatus();
            }, repairRecordSearchDTO.getRecordStatus());
        }).and(Func.isNotEmpty(repairRecordSearchDTO.getKeyWords()), i3 -> {
            LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) i3.like((v0) -> {
                return v0.getRecordCode();
            }, repairRecordSearchDTO.getKeyWords())).or()).like((v0) -> {
                return v0.getDeviceCode();
            }, repairRecordSearchDTO.getKeyWords())).or()).like((v0) -> {
                return v0.getRepairApplyId();
            }, getApplyId(repairRecordSearchDTO.getKeyWords()))).or()).like((v0) -> {
                return v0.getDeviceName();
            }, repairRecordSearchDTO.getKeyWords());
        }));*/
        IPage<RepairRecordVO> repairRecordVoIPage = RepairRecordConvert.INSTANCE.convert( pages);
        repairRecordVoIPage.getRecords().forEach(i4 -> {
            if (Func.isNotEmpty(i4.getRepairApplyId())) {
                Long repairApplyId = i4.getRepairApplyId();
                RepairApply repairApply = (RepairApply) this.repairApplyService.getById(repairApplyId);
                if (Func.isNotEmpty(repairApply)) {
                    i4.setApplyCode(repairApply.getApplyCode());
                    i4.setUrgency(repairApply.getUrgency());
                    i4.setApplyUserId(repairApply.getApplyUserId());
                    i4.setApplyUserName(repairApply.getApplyUserName());
                    i4.setDescription(repairApply.getDescription());
                }
            }
        });
        List<RepairRecordVO> records = repairRecordVoIPage.getRecords();
        
        records.sort(Comparator.comparing(RepairRecordVO::getRepairStartTime, Comparator.nullsFirst(Date::compareTo)).reversed());
        records.sort(Comparator.comparing(RepairRecordVO::getUrgency, Comparator.nullsFirst(Integer::compareTo)).reversed());
        records.sort(Comparator.comparing(RepairRecordVO::getRecordStatus, Comparator.nullsFirst(Integer::compareTo)));
        
        /*
        records.sort(Comparator.comparing((v0) -> {
            return v0.getRepairStartTime();
        }, Comparator.nullsFirst((v0, v1) -> {
            return v0.compareTo(v1);
        })).reversed());
        records.sort(Comparator.comparing((v0) -> {
            return v0.getUrgency();
        }, Comparator.nullsFirst((v0, v1) -> {
            return v0.compareTo(v1);
        })).reversed());
        records.sort(Comparator.comparing((v0) -> {
            return v0.getRecordStatus();
        }, Comparator.nullsFirst((v0, v1) -> {
            return v0.compareTo(v1);
        })));*/
        repairRecordVoIPage.setRecords(records);
        return repairRecordVoIPage;
    }

    @Override // org.springblade.modules.tpm.service.IRepairRecordService
    public IPage<RepairRecordVO> getPageRepairRecord(RepairRecordLookVO searchDTO, Query query) {
        IPage<RepairRecordVO> page = Condition.getPage(query);
        List<RepairRecordVO> repairRecordPages = this.repairRecordMapper.getRepairRecordPages(searchDTO, page);
        if (Func.isNotEmpty(repairRecordPages)) {
            return page.setRecords(repairRecordPages);
        }
        return page.setRecords(new ArrayList());
    }

    private Long getApplyId(String applyCode) {
    	RepairApply one = this.repairApplyService.getOne(Wrappers.<RepairApply>query().lambda().eq(RepairApply::getApplyCode, applyCode));
    	/*
        RepairApply one = (RepairApply) this.repairApplyService.getOne((Wrapper) Wrappers.query().lambda().eq((v0) -> {
            return v0.getApplyCode();
        }, applyCode));*/
        if (Func.isNotEmpty(one)) {
            return one.getId();
        }
        return null;
    }

    @Override // org.springblade.modules.tpm.service.IRepairRecordService
    public RepairRecordDetailVO detailRecord(Long id) {
        RepairRecord repairRecord = (RepairRecord) getById(id);
        if (Func.isEmpty(repairRecord)) {
            throw new ServiceException(MessageUtils.message("cps.tpm.repair.record.not.exists", new Object[0]));
        }
        RepairRecordDetailVO repairRecordDetailVo = RepairRecordDetailConvert.INSTANCE.convert(repairRecord);
        RepairApply repairApply = (RepairApply) this.repairApplyService.getById(repairRecord.getRepairApplyId());
        if (Func.isNotEmpty(repairApply) && repairRecord.getRecordType().equals(Integer.valueOf(RepairRecordTypeEnum.T2.getType()))) {
            RepairApplyDetailVO repairApplyDetailVo = this.repairApplyService.detailApply(repairRecord.getRepairApplyId());
            repairRecordDetailVo.setRepairApplyDetailVo(repairApplyDetailVo);
        }
        List<RepairRecordMaterialVO> recordByRecord = this.deviceMaterialRecordService.getRecordByRecordId(id);
        if (Func.isNotEmpty(recordByRecord)) {
            repairRecordDetailVo.setMaterialVOList(recordByRecord);
        } else {
            repairRecordDetailVo.setMaterialVOList(new ArrayList<>());
        }
        List<RepairRecordFile> fileList = this.repairRecordFileService.list(Wrappers.<RepairRecordFile>lambdaQuery().eq(RepairRecordFile::getRepairRecordId, id));
        /*
        List<RepairRecordFile> fileList = this.repairRecordFileService.list((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getRepairRecordId();
        }, id));*/
        List<RepairRecordFileAddDTO> fileAddDtoList = fileList.stream().map(RepairRecordFileConvert.INSTANCE::convert).collect(Collectors.toList());
        /*
        Stream<RepairRecordFile> stream = fileList.stream();
        RepairRecordFileConvert repairRecordFileConvert = RepairRecordFileConvert.INSTANCE;
        repairRecordFileConvert.getClass();
        List<RepairRecordFileAddDTO> fileAddDtoList = (List) stream.map(this::convert).collect(Collectors.toList());*/
        if (Func.isNotEmpty(fileAddDtoList)) {
            repairRecordDetailVo.setRecordFileList(fileAddDtoList);
        } else {
            repairRecordDetailVo.setRecordFileList(new ArrayList<>());
        }
        return repairRecordDetailVo;
    }

    @Override // org.springblade.modules.tpm.service.IRepairRecordService
    @Transactional(rollbackFor = {Exception.class})
    public boolean confirmRecord(Long id) {
        RepairRecord repairRecord = (RepairRecord) getById(id);
        if (Func.isNull(repairRecord)) {
            throw new ServiceException(MessageUtils.message("cps.tpm.repair.record.not.exists", new Object[0]));
        }
        if (!repairRecord.getRecordStatus().equals(Integer.valueOf(RepairRecordEnum.R1.getType()))) {
            throw new ServiceException(MessageUtils.message("cps.tpm.repair.record.not.to.be.confirmed", new Object[0]));
        }
        repairRecord.setRecordStatus(Integer.valueOf(RepairRecordEnum.R2.getType()));
        RepairApply repairApply = (RepairApply) this.repairApplyService.getById(repairRecord.getRepairApplyId());
        if (repairRecord.getRecordType().equals(Integer.valueOf(RepairRecordTypeEnum.T2.getType())) && Func.isNull(repairRecord.getRepairApplyId())) {
            throw new ServiceException(MessageUtils.message("cps.tpm.repair.apply.not.exists", new Object[0]));
        }
        if (repairRecord.getRecordType().equals(Integer.valueOf(RepairRecordTypeEnum.T2.getType()))) {
            repairApply.setApplyStatus(Integer.valueOf(RepairApplyStatusEnum.Y4.getType()));
            this.repairApplyService.updateById(repairApply);
        }
        boolean update = updateById(repairRecord);
        List<RepairRecord> toBeConfirmedList = list(Wrappers.<RepairRecord>lambdaQuery().eq(RepairRecord::getDeviceId, repairRecord.getDeviceId()).eq(RepairRecord::getRecordStatus, Integer.valueOf(RepairRecordEnum.R1.getType())));
        List<RepairApply> inMaintenanceList = this.repairApplyService.list(Wrappers.<RepairApply>lambdaQuery().eq(RepairApply::getDeviceId, repairRecord.getDeviceId()).eq(RepairApply::getApplyStatus, Integer.valueOf(RepairApplyStatusEnum.Y2.getType())));
        List<RepairApply> toBeRepairedList = this.repairApplyService.list(Wrappers.<RepairApply>lambdaQuery().eq(RepairApply::getDeviceId, repairRecord.getDeviceId()).eq(RepairApply::getApplyStatus, Integer.valueOf(RepairApplyStatusEnum.Y1.getType())));
        /*
        List<RepairRecord> toBeConfirmedList = list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getDeviceId();
        }, repairRecord.getDeviceId())).eq((v0) -> {
            return v0.getRecordStatus();
        }, Integer.valueOf(RepairRecordEnum.R1.getType())));
        List<RepairApply> inMaintenanceList = this.repairApplyService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getDeviceId();
        }, repairRecord.getDeviceId())).eq((v0) -> {
            return v0.getApplyStatus();
        }, Integer.valueOf(RepairApplyStatusEnum.Y2.getType())));
        List<RepairApply> toBeRepairedList = this.repairApplyService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getDeviceId();
        }, repairRecord.getDeviceId())).eq((v0) -> {
            return v0.getApplyStatus();
        }, Integer.valueOf(RepairApplyStatusEnum.Y1.getType())));*/
        this.machineService.updateMachineRepairPriority(repairRecord.getDeviceId(), toBeConfirmedList, inMaintenanceList, toBeRepairedList);
        this.machineService.renewMachineRepairTime(repairRecord.getDeviceId());
        return update;
    }

    @Override // org.springblade.modules.tpm.service.IRepairRecordService
    public List<RepairRecordVO> getRecordByDeviceId(Long deviceId) {
    	List<RepairRecord> list = list(Wrappers.<RepairRecord>query().lambda().eq(RepairRecord::getDeviceId, deviceId).orderByDesc(RepairRecord::getRepairStartTime));
    	/*
        List<RepairRecord> list = list((Wrapper) ((LambdaQueryWrapper) Wrappers.query().lambda().eq((v0) -> {
            return v0.getDeviceId();
        }, deviceId)).orderByDesc((v0) -> {
            return v0.getRepairStartTime();
        }));*/
        if (Func.isEmpty(list)) {
            throw new ServiceException(MessageUtils.message("cps.tpm.repair.record.not.exists", new Object[0]));
        }
        List<RepairRecordVO> convert = RepairRecordConvert.INSTANCE.convert(list);
        convert.forEach(i -> {
            RepairApply repairApply = (RepairApply) this.repairApplyService.getById(i.getRepairApplyId());
            if (Func.isNotEmpty(repairApply)) {
                i.setApplyCode(repairApply.getApplyCode());
                i.setUrgency(repairApply.getUrgency());
                i.setApplyUserName(repairApply.getApplyUserName());
            }
        });
        
        convert.sort(Comparator.comparing(RepairRecordVO::getRepairStartTime, Comparator.nullsFirst(Date::compareTo)).reversed());
        convert.sort(Comparator.comparing(RepairRecordVO::getUrgency, Comparator.nullsFirst(Integer::compareTo)).reversed());
        convert.sort(Comparator.comparing(RepairRecordVO::getRecordStatus, Comparator.nullsFirst(Integer::compareTo)));
        /*
        convert.sort(Comparator.comparing((v0) -> {
            return v0.getRepairStartTime();
        }, Comparator.nullsFirst((v0, v1) -> {
            return v0.compareTo(v1);
        })).reversed());
        convert.sort(Comparator.comparing((v0) -> {
            return v0.getUrgency();
        }, Comparator.nullsFirst((v0, v1) -> {
            return v0.compareTo(v1);
        })).reversed());
        convert.sort(Comparator.comparing((v0) -> {
            return v0.getRecordStatus();
        }, Comparator.nullsFirst((v0, v1) -> {
            return v0.compareTo(v1);
        })));*/
        return convert;
    }

    @Override // org.springblade.modules.tpm.service.IRepairRecordService
    public ApplyRecordMaterialVO getFiles(Long id) {
        RepairRecord repairRecord = (RepairRecord) getById(id);
        if (Func.isNull(repairRecord)) {
            throw new ServiceException(MessageUtils.message("cps.tpm.repair.record.not.exists", new Object[0]));
        }
        List<RepairApplyFile> applyFileList = this.repairApplyFileService.list(Wrappers.<RepairApplyFile>query().lambda().eq(RepairApplyFile::getRepairApplyId, repairRecord.getRepairApplyId()));
        /*
        List<RepairApplyFile> applyFileList = this.repairApplyFileService.list((Wrapper) Wrappers.query().lambda().eq((v0) -> {
            return v0.getRepairApplyId();
        }, repairRecord.getRepairApplyId()));*/
        ApplyRecordMaterialVO applyRecordMaterialVo = new ApplyRecordMaterialVO();
        if (Func.isNotEmpty(applyFileList)) {
        	List<RepairApplyFileAddDTO> collect = applyFileList.stream().map(RepairApplyFileConvert.INSTANCE::convert).collect(Collectors.toList());
        	/*
            Stream<RepairApplyFile> stream = applyFileList.stream();
            RepairApplyFileConvert repairApplyFileConvert = RepairApplyFileConvert.INSTANCE;
            repairApplyFileConvert.getClass();
            List<RepairApplyFileAddDTO> collect = stream.map(this::convert).collect(Collectors.toList());
            */
            if (Func.isNotEmpty(collect)) {
                applyRecordMaterialVo.setRepairApplyFileAddDTOList(collect);
            }
        } else {
            applyRecordMaterialVo.setRepairApplyFileAddDTOList(new ArrayList<>());
        }
        List<RepairRecordFile> repairRecordFileList = this.repairRecordFileService.list(Wrappers.<RepairRecordFile>query().lambda().eq(RepairRecordFile::getRepairRecordId, id));
        /*
        List<RepairRecordFile> repairRecordFileList = this.repairRecordFileService.list((Wrapper) Wrappers.query().lambda().eq((v0) -> {
            return v0.getRepairRecordId();
        }, id));*/
        if (Func.isNotEmpty(repairRecordFileList)) {
        	List<RepairRecordFileAddDTO> collect2 = repairRecordFileList.stream().map(RepairRecordFileConvert.INSTANCE::convert).collect(Collectors.toList());
        	/*
            Stream<RepairRecordFile> stream2 = repairRecordFileList.stream();
            RepairRecordFileConvert repairRecordFileConvert = RepairRecordFileConvert.INSTANCE;
            repairRecordFileConvert.getClass();
            List<RepairRecordFileAddDTO> collect2 = (List) stream2.map(this::convert).collect(Collectors.toList());
            */
            if (Func.isNotEmpty(collect2)) {
                applyRecordMaterialVo.setRepairRecordFileAddDTOList(collect2);
            }
        } else {
            applyRecordMaterialVo.setRepairRecordFileAddDTOList(new ArrayList<>());
        }
        List<DeviceMaterialRecord> deviceMaterialRecordList = this.deviceMaterialRecordService.list(Wrappers.<DeviceMaterialRecord>query().lambda().eq(DeviceMaterialRecord::getRecordId, id));
        /*
        List<DeviceMaterialRecord> deviceMaterialRecordList = this.deviceMaterialRecordService.list((Wrapper) Wrappers.query().lambda().eq((v0) -> {
            return v0.getRecordId();
        }, id));*/
        if (Func.isNotEmpty(deviceMaterialRecordList)) {
        	List<MaterialVO> collect3 = deviceMaterialRecordList.stream().map(MaterialRecordConvert.INSTANCE::convert).collect(Collectors.toList());
        	/*
            Stream<DeviceMaterialRecord> stream3 = deviceMaterialRecordList.stream();
            MaterialRecordConvert materialRecordConvert = MaterialRecordConvert.INSTANCE;
            materialRecordConvert.getClass();
            List<MaterialVO> collect3 = (List) stream3.map(this::convert).collect(Collectors.toList());*/
            if (Func.isNotEmpty(collect3)) {
                applyRecordMaterialVo.setMaterialVoList(collect3);
            }
        } else {
            applyRecordMaterialVo.setMaterialVoList(new ArrayList<>());
        }
        return applyRecordMaterialVo;
    }

    @Override // org.springblade.modules.tpm.service.IRepairRecordService
    public boolean deleteRecord(List<Long> ids) {
        if (Func.isEmpty(ids) || ids.size() < 1) {
            throw new ServiceException(MessageUtils.message("cps.tpm.repair.delete.id.not.empty.and.least.one", new Object[0]));
        }
        if (!checkRecordConfirm(ids)) {
            throw new ServiceException(MessageUtils.message("cps.tpm.repair.delete.record.status.is.pending.to.be.confirmed", new Object[0]));
        }
        Iterator<Long> it = ids.iterator();
        if (it.hasNext()) {
            Long id = it.next();
            removeById(id);
            RepairRecord repairRecord = (RepairRecord) getById(id);
            if (repairRecord.getRecordType().equals(Integer.valueOf(RepairRecordTypeEnum.T2.getType()))) {
                RepairApply repairApply = (RepairApply) this.repairApplyService.getById(repairRecord.getRepairApplyId());
                if (Func.isNotEmpty(repairApply)) {
                    repairApply.setApplyStatus(Integer.valueOf(RepairApplyStatusEnum.Y2.getType()));
                    this.repairApplyService.updateById(repairApply);
                }
            }
            List<RepairRecord> r1List = list(Wrappers.<RepairRecord>lambdaQuery().eq(RepairRecord::getDeviceId, repairRecord.getDeviceId()).eq(RepairRecord::getRecordStatus, Integer.valueOf(RepairRecordEnum.R1.getType())));
            List<RepairApply> y2List = this.repairApplyService.list(Wrappers.<RepairApply>query().lambda().eq(RepairApply::getDeviceId, repairRecord.getDeviceId()).eq(RepairApply::getApplyStatus, Integer.valueOf(RepairApplyStatusEnum.Y2.getType())));
            List<RepairApply> y1List = this.repairApplyService.list(Wrappers.<RepairApply>query().lambda().eq(RepairApply::getDeviceId, repairRecord.getDeviceId()).eq(RepairApply::getApplyStatus, Integer.valueOf(RepairApplyStatusEnum.Y1.getType())));
            /*
            List<RepairRecord> r1List = list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
                return v0.getDeviceId();
            }, repairRecord.getDeviceId())).eq((v0) -> {
                return v0.getRecordStatus();
            }, Integer.valueOf(RepairRecordEnum.R1.getType())));
            List<RepairApply> y2List = this.repairApplyService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.query().lambda().eq((v0) -> {
                return v0.getDeviceId();
            }, repairRecord.getDeviceId())).eq((v0) -> {
                return v0.getApplyStatus();
            }, Integer.valueOf(RepairApplyStatusEnum.Y2.getType())));
            List<RepairApply> y1List = this.repairApplyService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.query().lambda().eq((v0) -> {
                return v0.getDeviceId();
            }, repairRecord.getDeviceId())).eq((v0) -> {
                return v0.getApplyStatus();
            }, Integer.valueOf(RepairApplyStatusEnum.Y1.getType())));*/
            this.machineService.updateMachineRepairPriority(repairRecord.getDeviceId(), r1List, y2List, y1List);
            return true;
        }
        return false;
    }

    @Override // org.springblade.modules.tpm.service.IRepairRecordService
    public List<RepairRecordVO> queryRecord(RepairRecordLookVO repairRecordLookVO) {
    	List<RepairRecord> recordList = list(Wrappers.<RepairRecord>lambdaQuery()
    	        .and(Func.isNotEmpty(repairRecordLookVO.getDeviceTypeId()), i -> i.eq(RepairRecord::getDeviceTypeId, repairRecordLookVO.getDeviceTypeId()))
    	        .and(Func.isNotEmpty(repairRecordLookVO.getRecordStatus()), i -> i.eq(RepairRecord::getRecordStatus, repairRecordLookVO.getRecordStatus()))
    	        .and(Func.isNotEmpty(repairRecordLookVO.getKeyWords()), i -> i.like(RepairRecord::getRecordCode, repairRecordLookVO.getKeyWords()).or().like(RepairRecord::getDeviceCode, repairRecordLookVO.getKeyWords()).or().like(RepairRecord::getRepairApplyId, getApplyId(repairRecordLookVO.getKeyWords())).or().like(RepairRecord::getDeviceName, repairRecordLookVO.getKeyWords()))
    	        
    	        .orderByDesc(RepairRecord::getRecordCode));
    	/*
        List<RepairRecord> recordList = list((Wrapper) Wrappers.lambdaQuery().and(Func.isNotEmpty(repairRecordLookVO.getDeviceTypeId()), i -> {
            LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) i.eq((v0) -> {
                return v0.getDeviceTypeId();
            }, repairRecordLookVO.getDeviceTypeId());
        }).and(Func.isNotEmpty(repairRecordLookVO.getRecordStatus()), i2 -> {
            LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) i2.eq((v0) -> {
                return v0.getRecordStatus();
            }, repairRecordLookVO.getRecordStatus());
        }).and(Func.isNotEmpty(repairRecordLookVO.getKeyWords()), i3 -> {
            LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) i3.like((v0) -> {
                return v0.getRecordCode();
            }, repairRecordLookVO.getKeyWords())).or()).like((v0) -> {
                return v0.getDeviceCode();
            }, repairRecordLookVO.getKeyWords())).or()).like((v0) -> {
                return v0.getRepairApplyId();
            }, getApplyId(repairRecordLookVO.getKeyWords()))).or()).like((v0) -> {
                return v0.getDeviceName();
            }, repairRecordLookVO.getKeyWords());
        }).orderByDesc((v0) -> {
            return v0.getRecordCode();
        }));*/
        List<RepairRecordVO> convert = RepairRecordConvert.INSTANCE.convert(recordList);
        return convert;
    }

    @Override // org.springblade.modules.tpm.service.IRepairRecordService
    public List<RepairRecord> getRecordByMalId(Long malId) {
    	List<RepairRecord> repairRecordList = list(Wrappers.<RepairRecord>lambdaQuery().eq(RepairRecord::getRecordStatus, Integer.valueOf(RepairRecordEnum.R1.getType())).orderByDesc(RepairRecord::getRecordCode));
    	/*
        List<RepairRecord> repairRecordList = list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getRecordStatus();
        }, Integer.valueOf(RepairRecordEnum.R1.getType()))).orderByDesc((v0) -> {
            return v0.getRecordCode();
        }));*/
        if (Func.isNull(repairRecordList)) {
            throw new ServiceException(MessageUtils.message("cps.tpm.repair.record.malfunction.not.exists", new Object[0]));
        }
        return repairRecordList;
    }

    @Override // org.springblade.modules.tpm.service.IRepairRecordService
    public boolean updateRecordMalfunction(Long malId, String malName, String malCode, Integer action) {
        boolean result = false;
        List<RepairRecord> repairRecordList = getRecordByMalId(malId);
        if (!Func.isNull(repairRecordList)) {
            List<RepairRecord> collect = null;
            if (action.equals(Integer.valueOf(ActionEnum.UPDATE_MAL.getType()))) {
                collect = repairRecordList.stream().peek(i -> {
                    i.setMalfunctionId(malId);
                    i.setMalfunctionName(malName);
                    i.setMalfunctionCode(malCode);
                }).collect(Collectors.toList());
            } else if (action.equals(Integer.valueOf(ActionEnum.DELETE_MAL.getType()))) {
                collect = repairRecordList.stream().peek(i2 -> {
                    i2.setMalfunctionId(null);
                    i2.setMalfunctionName(null);
                    i2.setMalfunctionCode(null);
                }).collect(Collectors.toList());
            }
            updateBatchById(collect);
            result = true;
        }
        return result;
    }

    @Override // org.springblade.modules.tpm.service.IRepairRecordService
    public boolean updateApplyByApply(Long applyId, Long malId, String malName, String malCode) {
        RepairRecord repairRecord = (RepairRecord) getById(applyId);
        if (Func.isNull(repairRecord)) {
            throw new ServiceException(MessageUtils.message("cps.tpm.repair.record.not.exists", new Object[0]));
        }
        repairRecord.setMalfunctionId(malId).setMalfunctionCode(malCode).setMalfunctionName(malName);
        return updateById(repairRecord);
    }

    @Override // org.springblade.modules.tpm.service.IRepairRecordService
    public List<RepairRecordExcelVO> exportRepairRecord(RepairRecordExportVO repairRecordExportVO) {
        List<RepairRecordExcelVO> repairRecordExcelVos = this.baseMapper.exportRecordVo(repairRecordExportVO, AuthUtil.getTenantId());
        if (Func.isNotEmpty(repairRecordExcelVos)) {
            repairRecordExcelVos.forEach(repairRecordExcelVo -> {
                if (Func.isNotBlank(repairRecordExcelVo.getUrgency())) {
                    if (repairRecordExcelVo.getUrgency().equals(String.valueOf(UrgencyEnum.U1.getType()))) {
                        repairRecordExcelVo.setUrgency(UrgencyEnum.U1.getDesc());
                    } else if (repairRecordExcelVo.getUrgency().equals(String.valueOf(UrgencyEnum.U2.getType()))) {
                        repairRecordExcelVo.setUrgency(UrgencyEnum.U2.getDesc());
                    } else {
                        repairRecordExcelVo.setUrgency(UrgencyEnum.U3.getDesc());
                    }
                }
                if (Func.isNotBlank(repairRecordExcelVo.getRecordType())) {
                    if (repairRecordExcelVo.getRecordType().equals(String.valueOf(RepairRecordTypeEnum.T1.getType()))) {
                        repairRecordExcelVo.setRecordType(RepairRecordTypeEnum.T1.getDesc());
                    } else {
                        repairRecordExcelVo.setRecordType(RepairRecordTypeEnum.T2.getDesc());
                    }
                }
                repairRecordExcelVo.setRepairTime(formatTime(Long.valueOf(Func.isNotBlank(repairRecordExcelVo.getRepairTime()) ? repairRecordExcelVo.getRepairTime() : "0")));
            });
            return repairRecordExcelVos;
        }
        return new ArrayList<>();
    }

    @Override // org.springblade.modules.tpm.service.IRepairRecordService
    public IPage<RepairRecordVO> getPageRecordWaring(RepairRecordTodaySearchVO repairRecordTodaySearchVO, Query query) {
        IPage<RepairRecordVO> page = Condition.getPage(query);
        List<RepairRecordVO> repairTodayRecordPages = this.repairRecordMapper.getRepairTodayRecordPages(repairRecordTodaySearchVO, page);
        if (Func.isNotEmpty(repairTodayRecordPages)) {
            return page.setRecords(repairTodayRecordPages);
        }
        return page.setRecords(new ArrayList<>());
    }

    @Override // org.springblade.modules.tpm.service.IRepairRecordService
    public Long countRecord() {
    	Long count = Long.valueOf(count(Wrappers.<RepairRecord>lambdaQuery().eq(RepairRecord::getRecordStatus, Integer.valueOf(RepairRecordEnum.R1.getType()))));
    	/*
        Long count = Long.valueOf(count((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getRecordStatus();
        }, Integer.valueOf(RepairRecordEnum.R1.getType()))));*/
        return (Long) Optional.of(count).orElse(0L);
    }

    @Override // org.springblade.modules.tpm.service.IRepairRecordService
    public RepairRecordVO completeRepair(Long id) {
        RepairApply repairApply = (RepairApply) Optional.ofNullable(this.repairApplyService.getById(id)).orElseThrow(() -> {
            return new ServiceException(MessageUtils.message("cps.tpm.repair.apply.not.exists", new Object[0]));
        });
        RepairRecord repairRecord = new RepairRecord().setRepairApplyId(id).setDeviceId(repairApply.getDeviceId()).setDeviceCode(repairApply.getDeviceCode()).setDeviceName(repairApply.getDeviceName()).setDeviceTypeId(repairApply.getDeviceTypeId()).setDeviceTypeName(repairApply.getDeviceTypeName()).setRepairStartTime(repairApply.getStartTime() == null ? null : DateUtils.localDateTimeToDate(repairApply.getStartTime())).setRepairEndTime(new Date()).setRecordStatus(Integer.valueOf(RepairRecordEnum.R1.getType())).setMalfunctionId(repairApply.getMalfunctionId()).setMalfunctionCode(repairApply.getMalfunctionCode()).setMalfunctionName(repairApply.getMalfunctionName()).setIsAffect(repairApply.getIsAffect()).setRecordType(Integer.valueOf(RepairRecordTypeEnum.T2.getType()));
        if (!checkApplyCode(id)) {
            throw new ServiceException(MessageUtils.message("cps.tpm.repair.apply.num.already.registered", new Object[0]));
        }
        save(repairRecord);
        repairApply.setApplyStatus(Integer.valueOf(RepairApplyStatusEnum.Y3.getType()));
        this.repairApplyService.updateById(repairApply);
        this.machineService.renewMachineRepairStatus(repairRecord.getDeviceId(), Integer.valueOf(DeviceRepairStatusEnum.TO_BE_CONFIRM.getType()));
        return RepairRecordConvert.INSTANCE.convert(repairRecord);
    }

    private boolean checkRecordConfirm(List<Long> ids) {
    	List<RepairRecord> list = list(Wrappers.<RepairRecord>lambdaQuery().ne(RepairRecord::getRecordStatus, Integer.valueOf(RepairRecordEnum.R2.getType())).in(RepairRecord::getId, ids));
    	/*
        List<RepairRecord> list = list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().ne((v0) -> {
            return v0.getRecordStatus();
        }, Integer.valueOf(RepairRecordEnum.R2.getType()))).in((v0) -> {
            return v0.getId();
        }, ids));*/
        return Func.isNull(list);
    }

    private boolean checkRecordStatus(Long id) {
        RepairRecord repairRecord = (RepairRecord) getById(id);
        return repairRecord.getRecordStatus().equals(Integer.valueOf(RepairRecordEnum.R1.getType()));
    }

    private boolean checkApplyCode(Long id) {
    	RepairRecord repairRecord = this.baseMapper.selectOne(Wrappers.<RepairRecord>query().lambda().eq(RepairRecord::getRepairApplyId, id));
    	/*
        RepairRecord repairRecord = (RepairRecord) this.baseMapper.selectOne((Wrapper) Wrappers.query().lambda().eq((v0) -> {
            return v0.getRepairApplyId();
        }, id));*/
        return Func.isNull(repairRecord);
    }

    private boolean checkRecordCode(String recordCode) {
    	RepairRecord repairRecord = this.baseMapper.selectOne(Wrappers.<RepairRecord>query().lambda().eq(Func.isNotEmpty(AuthUtil.getTenantId()), RepairRecord::getTenantId, AuthUtil.getTenantId()).eq(RepairRecord::getRecordCode, recordCode));
    	/*
        RepairRecord repairRecord = (RepairRecord) this.baseMapper.selectOne((Wrapper) Wrappers.query().lambda().eq(Func.isNotEmpty(AuthUtil.getTenantId()), (v0) -> {
            return v0.getTenantId();
        }, AuthUtil.getTenantId()).eq((v0) -> {
            return v0.getRecordCode();
        }, recordCode));*/
        return repairRecord != null;
    }

    private String formatTime(Long minuteStr) {
        String resultStr = "";
        if (!Func.isEmpty(minuteStr)) {
            if (minuteStr.longValue() != 0) {
                if (minuteStr.longValue() / 60 == 0) {
                    resultStr = (minuteStr.longValue() % 60) + "分";
                } else if (minuteStr.longValue() % 60 == 0) {
                    resultStr = (minuteStr.longValue() / 60) + "小时";
                } else if (minuteStr.longValue() % 1440 == 0) {
                    if (minuteStr.longValue() / 1440 > 0) {
                        resultStr = (minuteStr.longValue() / 1440) + "天0小时0分";
                    }
                } else if (minuteStr.longValue() / 1440 > 0) {
                    resultStr = (minuteStr.longValue() / 1440) + "天" + (minuteStr.longValue() / 60) + "小时" + (minuteStr.longValue() % 60) + "分";
                } else {
                    resultStr = (minuteStr.longValue() / 60) + "小时" + (minuteStr.longValue() % 60) + "分";
                }
            } else {
                resultStr = "0分";
            }
        } else {
            resultStr = "0分";
        }
        return resultStr;
    }
}