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

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

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.alibaba.excel.write.merge.AbstractMergeStrategy;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.google.common.collect.Lists;
import com.qianwen.core.cache.utils.CacheUtil;
import com.qianwen.core.excel.util.ExcelUtil;
import com.qianwen.core.log.exception.ServiceException;
import com.qianwen.core.mp.base.BaseServiceImpl;
import com.qianwen.core.mp.support.Condition;
import com.qianwen.core.mp.support.Query;
import com.qianwen.core.oss.model.BladeFile;
import com.qianwen.core.secure.utils.AuthUtil;
import com.qianwen.core.tool.utils.DateUtil;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.smartman.common.cache.DictCache;
import com.qianwen.smartman.common.cache.cps.WorkstationCache;
import com.qianwen.smartman.common.cache.cps.WorkstationOfMachineCache;
import com.qianwen.smartman.common.constant.CommonConstant;
import com.qianwen.smartman.common.constant.CommonGroupConstant;
import com.qianwen.smartman.common.constant.DateConstant;
import com.qianwen.smartman.common.constant.ExcelConstant;
import com.qianwen.smartman.common.constant.ExtCacheConstant;
import com.qianwen.smartman.common.enums.CommonGroupTypeEnum;
import com.qianwen.smartman.common.enums.DictEnum;
import com.qianwen.smartman.common.enums.StatusType;
import com.qianwen.smartman.common.enums.WcsDataTypeEnums;
import com.qianwen.smartman.common.utils.ListUtils;
import com.qianwen.smartman.common.utils.MessageUtils;
import com.qianwen.smartman.modules.smis.convert.MachineConvert;
import com.qianwen.smartman.modules.smis.convert.WorkstationWcsConvert;
import com.qianwen.smartman.modules.smis.dto.DeviceMaintainInDTO;
import com.qianwen.smartman.modules.smis.dto.DeviceSimpleDTO;
import com.qianwen.smartman.modules.smis.dto.EmployeeNameDTO;
import com.qianwen.smartman.modules.smis.dto.MachineExtDTO;
import com.qianwen.smartman.modules.smis.dto.WorkstationWcsDTO;
import com.qianwen.smartman.modules.smis.entity.CommonGroupOfItem;
import com.qianwen.smartman.modules.smis.entity.DeviceType;
import com.qianwen.smartman.modules.smis.entity.Machine;
import com.qianwen.smartman.modules.smis.entity.Workstation;
import com.qianwen.smartman.modules.smis.entity.WorkstationOfMachine;
import com.qianwen.smartman.modules.smis.entity.WorkstationWcs;
import com.qianwen.smartman.modules.smis.excel.MachineExcel;
import com.qianwen.smartman.modules.smis.excel.MachineImport;
import com.qianwen.smartman.modules.smis.mapper.MachineMapper;
import com.qianwen.smartman.modules.smis.mapper.WorkstationWcsMapper;
import com.qianwen.smartman.modules.smis.service.ICommonGroupOfItemService;
import com.qianwen.smartman.modules.smis.service.ICommonGroupService;
import com.qianwen.smartman.modules.smis.service.IDeviceTypeService;
import com.qianwen.smartman.modules.smis.service.IEmployeeService;
import com.qianwen.smartman.modules.smis.service.IMachineService;
import com.qianwen.smartman.modules.smis.service.IWorkstationOfMachineService;
import com.qianwen.smartman.modules.smis.service.IWorkstationService;
import com.qianwen.smartman.modules.smis.utils.ThrowFun;
import com.qianwen.smartman.modules.smis.vo.IdsVO;
import com.qianwen.smartman.modules.smis.vo.MachineDetailVO;
import com.qianwen.smartman.modules.smis.vo.MachineListVO;
import com.qianwen.smartman.modules.smis.vo.MachineSelectVO;
import com.qianwen.smartman.modules.smis.vo.MachineSubmitVO;
import com.qianwen.smartman.modules.smis.vo.MachineUpdateVO;
import com.qianwen.smartman.modules.smis.vo.MachineVO;
import com.qianwen.smartman.modules.smis.vo.WorkstationSubmitVO;
//import com.qianwen.smartman.modules.dnc.enums.DncEnums;
//import com.qianwen.smartman.modules.dnc.vo.HmiDeviceVO;
import com.qianwen.smartman.modules.resource.builder.oss.OssBuilder;
import com.qianwen.smartman.modules.system.service.ICodeGeneratorService;
import com.qianwen.smartman.modules.tpm.entity.MaintainPlan;
import com.qianwen.smartman.modules.tpm.entity.RepairApply;
import com.qianwen.smartman.modules.tpm.entity.RepairRecord;
import com.qianwen.smartman.modules.tpm.enums.DeviceRepairStatusEnum;
import com.qianwen.smartman.modules.tpm.enums.MaintainPlanStatusEnum;
import com.qianwen.smartman.modules.tpm.enums.MaintainStatusEnum;
import com.qianwen.smartman.modules.tpm.enums.MetaTypeEnum;
import com.qianwen.smartman.modules.tpm.enums.RepairRecordEnum;
import com.qianwen.smartman.modules.tpm.service.IMaintainPlanService;

import cn.hutool.core.util.StrUtil;

@Service
public class MachineServiceImpl extends BaseServiceImpl<MachineMapper, Machine> implements IMachineService {
    private static final Logger log = LoggerFactory.getLogger(MachineServiceImpl.class);
    private static final Pattern NUMBER = Pattern.compile("[1-9]\\d*.\\d*|0\\.\\d*[1-9]\\d*");
    private static final Pattern CHINESE = Pattern.compile("^[A-Za-z0-9]+$");
    @Autowired
    private IWorkstationOfMachineService workstationOfMachineService;
    @Autowired
    @Lazy
    private IMaintainPlanService maintainPlanService;
    @Autowired
    private ICommonGroupService commonGroupService;
    @Autowired
    private OssBuilder ossBuilder;
    @Autowired
    @Lazy
    private IDeviceTypeService typeService;
    @Autowired
    private ICommonGroupOfItemService itemService;
    @Autowired
    @Lazy
    private IWorkstationService workstationService;
    @Autowired
    private WorkstationWcsMapper workstationWcsMapper;
    @Autowired
    private ICodeGeneratorService codeGeneratorService;
    @Autowired
    private IEmployeeService employeeService;


    @Override
    @Transactional(rollbackFor = {Exception.class})
    public MachineVO insert(MachineVO machineVO) {
        checkMachine(machineVO.id, machineVO.getMachineCode());
        checkStopMachineByCode(machineVO.getMachineCode());
        Machine machine = MachineConvert.INSTANCE.convert(machineVO);
        machine.setMaintenanceStatus(Integer.valueOf(MaintainStatusEnum.T1.getType()));
        machine.setRepairStatus(Integer.valueOf(RepairRecordEnum.R1.getType()));
        save(machine);
        saveCommonGroupItem(Lists.newArrayList(new Machine[]{machine}));
        return MachineConvert.INSTANCE.convert(machine);
    }

    @Override
    public Boolean changeCollectSwitch(Long workstationId, Integer collectSwitch) {
        ((MachineMapper) this.baseMapper).changeCollectSwitch(workstationId, collectSwitch, AuthUtil.getTenantId());
        if (0 == collectSwitch.intValue()) {
            WorkstationOfMachine workstationOfMachineServiceOne = this.workstationOfMachineService.getWorkstationOfMachineByWorkstationId(workstationId);
            if (Func.isNotEmpty(workstationOfMachineServiceOne)) {
                WorkstationCache.clearWorkstationParamTypeCache(String.valueOf(workstationOfMachineServiceOne.getMachineId()));
            }
        }
        return true;
    }

    @Override
    public List<WorkstationWcsDTO> getWorkstationWcsByMachineId(Long machineId, String paramName) {
    	List<WorkstationOfMachine> workstationOfMachineList = this.workstationOfMachineService.list(Wrappers.<WorkstationOfMachine>lambdaQuery().eq(WorkstationOfMachine::getMachineId, machineId));
    	
        List<Long> workstationIdList =workstationOfMachineList.stream().map((v0) -> {
            return v0.getWorkstationId();
        }).collect(Collectors.toList());
        List<WorkstationWcs> workstationWcsList = this.workstationWcsMapper.getWorkstationWcsByName(workstationIdList, paramName);
        return WorkstationWcsConvert.INSTANCE.convertToDTOList(workstationWcsList);
    }

    @Override
    public Boolean updateBrand(Long id, String brand) {
        Machine machine = (Machine) getById(id);
        machine.setBrand(brand);
        boolean updateById = updateById(machine);
        if (updateById) {
            CacheUtil.clear(ExtCacheConstant.POSTING_MACHINE, Boolean.FALSE);
            CacheUtil.clear(ExtCacheConstant.WORKSTATION_MACHINE, Boolean.FALSE);
        }
        return Boolean.valueOf(updateById);
    }

    @Override
    public MachineDetailVO detailMachine(Long id) {
        MachineDetailVO machineDetailVO = ((MachineMapper) this.baseMapper).selectMachineDetail(id);
        if (Func.isNotEmpty(machineDetailVO)) {
            machineDetailVO.setMachineLifeStatusName(DictCache.getValue(DictEnum.MACHINE_LIFE_STATUS.getName(), machineDetailVO.getMachineLifeStatus()));
            machineDetailVO.setManagementClassName(DictCache.getValue(DictEnum.MACHINE_MANAGEMENT_CLASS, machineDetailVO.getManagementClass()));
            machineDetailVO.setMachineUseStatusName(DictCache.getValue(DictEnum.MACHINE_USE_STATUS.getName(), machineDetailVO.getMachineUseStatus()));
            List<WorkstationOfMachine> workstationOfMachineList = this.workstationOfMachineService.list(Wrappers.<WorkstationOfMachine>lambdaQuery().eq(WorkstationOfMachine::getMachineId, machineDetailVO.getId()));
            if (Func.isNotEmpty(workstationOfMachineList)) {
                List<Workstation> workstationList = this.workstationService.listByIds(workstationOfMachineList.stream().map((v0) -> {
                    return v0.getWorkstationId();
                }).collect(Collectors.toList()));
                Optional.ofNullable(workstationList).ifPresent(workstations -> {
                    List<String> workstationCodeList = workstations.stream().map((v0) -> {
                        return v0.getCode();
                    }).collect(Collectors.toList());
                    List<String> workstationNameList = workstations.stream().map((v0) -> {
                        return v0.getName();
                    }).collect(Collectors.toList());
                    String code = workstationCodeList.stream().reduce((a, b) -> {
                        return a.concat(";").concat(b);
                    }).orElse("");
                    String name = workstationNameList.stream().reduce((a2, b2) -> {
                        return a2.concat(";").concat(b2);
                    }).orElse("");
                    machineDetailVO.setWorkstationCode(code);
                    machineDetailVO.setWorkstationName(name);
                });
            }
        }
        return machineDetailVO;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public Machine createMachine(MachineSubmitVO machineSubmitVO) {
        String pinCode = machineSubmitVO.getPinCode();
        if (Func.isNotBlank(pinCode)) {
            checkPinCode(pinCode, null);
            boolean matches = CHINESE.matcher(pinCode).matches();
            if (!matches) {
                throw new ServiceException(MessageUtils.message("machine.ping.code.chinese.characters.exist", new Object[0]));
            }
        }
        String shortCode = machineSubmitVO.getShortCode();
        if (Func.isNotBlank(shortCode)) {
            validShortCode(shortCode, null);
            boolean matches2 = CHINESE.matcher(shortCode).matches();
            if (!matches2) {
                throw new ServiceException(MessageUtils.message("machine.short.code.chinese.characters.exist", new Object[0]));
            }
        }
        if (Func.isBlank(machineSubmitVO.getMachineCode())) {
            String code = this.codeGeneratorService.getGeneratorCode(machineSubmitVO, MetaTypeEnum.MACHINE.getCode());
            log.info("机器编码规则生成的code:{}", code + " ," + code.length());
            machineSubmitVO.setMachineCode(code);
        }
        checkMachine(null, machineSubmitVO.getMachineCode());
        checkStopMachine(machineSubmitVO.getMachineCode());
        Machine machine = MachineConvert.INSTANCE.convert(machineSubmitVO);
        machine.setMaintenanceStatus(Integer.valueOf(MaintainStatusEnum.T1.getType()));
        machine.setRepairStatus(Integer.valueOf(DeviceRepairStatusEnum.NORMAL.getType()));
        machine.setExtendId(UUID.randomUUID().toString());
        machine.setExternalKey(machineSubmitVO.getMachineCode());
        save(machine);
        saveWorkstation(machineSubmitVO, machine);
        CommonGroupOfItem commonGroupOfItem = CommonGroupOfItem.builder().groupId(machine.getGroupId()).itemId(machine.getId()).extendId(machine.getExtendId()).groupType(CommonGroupTypeEnum.MACHINE.getName()).groupCategory(CommonGroupConstant.DEFAULT_CATEGORY).build();
        this.itemService.save(commonGroupOfItem);
        CacheUtil.clear(ExtCacheConstant.POSTING_MACHINE, Boolean.FALSE);
        CacheUtil.clear(ExtCacheConstant.WORKSTATION_MACHINE, Boolean.FALSE);
        return machine;
    }

    @Transactional(rollbackFor = {Exception.class})
    public void saveWorkstation(MachineSubmitVO machineSubmitVO, Machine machine) {
        if (machineSubmitVO.getLinkWay() != null && 1 == machineSubmitVO.getLinkWay()) {
            WorkstationSubmitVO workstationSaveVO = new WorkstationSubmitVO();
            workstationSaveVO.setCode(machineSubmitVO.getMachineCode());
            workstationSaveVO.setName(machineSubmitVO.getMachineName());
            workstationSaveVO.setGroupId(CommonGroupConstant.DEFAULT_WORKSTATION_ID);
            workstationSaveVO.setLinkWay(0);
            workstationSaveVO.setMachineId(machine.getId());
            workstationSaveVO.setType(0);
            this.workstationService.submit(workstationSaveVO);
        }
    }

    private void validShortCode(String shortCode, Long id) {
        int len = shortCode.length();
        if (len < 4 || len > 8) {
            throw new ServiceException(String.format(MessageUtils.message("cps.tpm.machine.short.code.length", new Object[0]), 4, 8));
        }

        Long count = Long.valueOf(count(Wrappers.<Machine>lambdaQuery().eq(Machine::getShortCode, shortCode).ne(Func.isNotEmpty(id), Machine::getId, id)));
        if (count.longValue() > 0) {
            throw new ServiceException(MessageUtils.message("cps.tpm.machine.short.code.exists", new Object[0]));
        }
    }

    @Override
    public IPage<MachineListVO> pageMachine(MachineSelectVO machineSelectVO, Query query) {
        String machineName = machineSelectVO.getMachineName();
        String machineCode = machineSelectVO.getMachineCode();
        Long machineTypeId = machineSelectVO.getMachineTypeId();
        Long groupId = machineSelectVO.getGroupId();
        Integer status = machineSelectVO.getStatus();
        IPage<MachineListVO> page = this.baseMapper.pageMachine(Condition.getPage(query), machineName, machineCode, machineTypeId, groupId, CommonGroupConstant.ALL_MACHINE_ID, status == null ? CommonConstant.ENABLE : status);
        List<MachineListVO> records = page.getRecords();
        List<MachineListVO> collect = records.stream().peek(c -> {
            c.setMachineUseStatusName(DictCache.getValue(DictEnum.MACHINE_USE_STATUS.getName(), c.getMachineUseStatus()));
        }).collect(Collectors.toList());
        page.setRecords(collect);
        return page;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public Boolean updateMachine(MachineUpdateVO vo) {
        Long id = vo.getId();
        int nums = ((MachineMapper) this.baseMapper).typeAndonRecord(Lists.newArrayList(new Long[]{id})).intValue();
        if (nums > 0) {
            throw new ServiceException(MessageUtils.message("machine.andon.not.update", new Object[0]));
        }
        String machineCode = vo.getMachineCode();
        checkMachine(id, machineCode);
        String pinCode = vo.getPinCode();
        if (Func.isNotBlank(pinCode)) {
            checkPinCode(pinCode, id);
        }
        String shortCode = vo.getShortCode();
        if (Func.isNotBlank(shortCode)) {
            validShortCode(shortCode, id);
        }
        Machine machine = MachineConvert.INSTANCE.convert(vo);
        boolean updateById = updateById(machine);
        Long groupId = machine.getGroupId();
        if (!Func.isNull(groupId)) {
        	this.itemService.update(Wrappers.<CommonGroupOfItem>lambdaUpdate()
        	          .set(CommonGroupOfItem::getGroupId, groupId)
        	          .set(CommonGroupOfItem::getExtendId, machine.getExtendId())
        	          .eq(CommonGroupOfItem::getItemId, machine.getId())); 
        	/*
            this.itemService.update((Wrapper) ((LambdaUpdateWrapper) ((LambdaUpdateWrapper) Wrappers.lambdaUpdate().set((v0) -> {
                return v0.getGroupId();
            }, groupId)).set((v0) -> {
                return v0.getExtendId();
            }, machine.getExtendId())).eq((v0) -> {
                return v0.getItemId();
            }, machine.getId()));*/
        }
        if (updateById) {
            CacheUtil.clear(ExtCacheConstant.POSTING_MACHINE, Boolean.FALSE);
            CacheUtil.clear(ExtCacheConstant.WORKSTATION_MACHINE, Boolean.FALSE);
        }
        return Boolean.valueOf(updateById);
    }

    @Override
    public void renewMachineRepairStatus(Long machineId, Integer maintenanceStatus) {
    	Machine machine = (Machine)getOne(new QueryWrapper<Machine>().lambda().eq(Machine::getId, machineId));
     
        if (machine != null) {
            machine.setRepairStatus(maintenanceStatus);
            updateById(machine);
        }
    }

    @Override
    public void updateMachineRepairPriority(Long deviceId, List<RepairRecord> toBeConfirmedRecordList, List<RepairApply> inMaintenanceApplyList, List<RepairApply> toBeRepairedApplyList) {
        if (Func.isNotEmpty(toBeConfirmedRecordList)) {
            renewMachineRepairStatus(deviceId, Integer.valueOf(DeviceRepairStatusEnum.TO_BE_CONFIRM.getType()));
        } else if (Func.isNotEmpty(inMaintenanceApplyList)) {
            renewMachineRepairStatus(deviceId, Integer.valueOf(DeviceRepairStatusEnum.IN_MAINTENANCE.getType()));
        } else if (Func.isNotEmpty(toBeRepairedApplyList)) {
            renewMachineRepairStatus(deviceId, Integer.valueOf(DeviceRepairStatusEnum.TO_BE_REPAIRED.getType()));
        } else {
            renewMachineRepairStatus(deviceId, Integer.valueOf(DeviceRepairStatusEnum.NORMAL.getType()));
        }
    }

    @Override
    public void renewMachineRepairTime(Long deviceId) {
        Machine machine = (Machine) getById(deviceId);
        if (machine != null) {
            machine.setLastRepairTime(LocalDateTime.now());
            updateById(machine);
        }
    }

    @Override
    public void createRepairApplyUpdateMachine(Long deviceId, Integer maintenanceStatus) {
        Machine machine = (Machine) getById(deviceId);
        if (machine != null) {
            if (Func.isNull(machine.getRepairStatus())) {
                throw new ServiceException(MessageUtils.message("cps.tpm.machine.repair.status.is.not.empty", new Object[0]));
            }
            if (machine.getRepairStatus().equals(Integer.valueOf(DeviceRepairStatusEnum.NORMAL.getType()))) {
                renewMachineRepairStatus(deviceId, maintenanceStatus);
            }
        }
    }

    @Override
    public void implementRepairApply(Long deviceId, Integer maintenanceStatus) {
        Machine machine = (Machine) getById(deviceId);
        if (Func.isNull(machine.getRepairStatus())) {
            throw new ServiceException(MessageUtils.message("cps.tpm.machine.repair.status.is.not.empty", new Object[0]));
        }
        if (!machine.getRepairStatus().equals(Integer.valueOf(DeviceRepairStatusEnum.IN_MAINTENANCE.getType())) || !machine.getRepairStatus().equals(Integer.valueOf(DeviceRepairStatusEnum.IN_MAINTENANCE.getType()))) {
            renewMachineRepairStatus(deviceId, maintenanceStatus);
        }
    }

    @Override
    public void updateDeviceMaintainStatus(Long deviceId, Integer status, Long planId, LocalDateTime nextMaintainTime) {
        List<MaintainPlan> checkList = checkExistPlanStatus(deviceId, null);
        List<MaintainPlan> checkTimeList = checkList.stream().sorted(Comparator.comparing((v0) -> {
            return v0.getMaintainDate();
        })).collect(Collectors.toList());
        DeviceMaintainInDTO deviceMaintainInDTO = new DeviceMaintainInDTO();
        deviceMaintainInDTO.setDeviceId(deviceId);
        if (checkList.isEmpty()) {
            deviceMaintainInDTO.setMaintainStatus(Integer.valueOf(MaintainPlanStatusEnum.T1.getType()));
        } else {
            deviceMaintainInDTO.setMaintainStatus(Integer.valueOf(MaintainPlanStatusEnum.of(checkList.get(0).getPlanStatus()).getType()));
        }
        if (checkTimeList.isEmpty()) {
            deviceMaintainInDTO.setNextMaintainTime(null);
        } else {
            deviceMaintainInDTO.setNextMaintainTime(checkTimeList.get(0).getMaintainDate());
        }
        updateDeviceMaintain(deviceMaintainInDTO);
    }

    @Override
    public void updateDeviceMaintain(DeviceMaintainInDTO deviceMaintainInDTO) {
        Machine one = (Machine) getById(deviceMaintainInDTO.getDeviceId());
        if (one == null) {
            throw new ServiceException(MessageUtils.message("machine.not.exists", new Object[0]));
        }
        one.setLastMaintainTime(deviceMaintainInDTO.getLastMaintainTime());
        one.setMaintenanceStatus(deviceMaintainInDTO.getMaintainStatus());
        one.setNextMaintainTime(deviceMaintainInDTO.getNextMaintainTime());
        updateById(one);
    }

    @Override
    public void updateDeviceMaintainStatus(Long deviceId, Long planId, LocalDateTime lastMaintainTime) {
        List<MaintainPlan> checkList = checkExistPlanStatus(deviceId, null);
        List<MaintainPlan> checkTimeList =  checkList.stream().sorted(Comparator.comparing((v0) -> {
            return v0.getMaintainDate();
        })).collect(Collectors.toList());
        DeviceMaintainInDTO deviceMaintainInDTO = new DeviceMaintainInDTO();
        deviceMaintainInDTO.setDeviceId(deviceId);
        if (checkList.isEmpty()) {
            deviceMaintainInDTO.setMaintainStatus(Integer.valueOf(MaintainStatusEnum.T1.getType()));
        } else {
            deviceMaintainInDTO.setMaintainStatus(checkList.get(0).getPlanStatus());
        }
        if (checkTimeList.isEmpty()) {
            deviceMaintainInDTO.setNextMaintainTime(null);
        } else {
            deviceMaintainInDTO.setNextMaintainTime(checkTimeList.get(0).getMaintainDate());
        }
        if (lastMaintainTime != null) {
            deviceMaintainInDTO.setLastMaintainTime(lastMaintainTime);
        }
        updateDeviceMaintain(deviceMaintainInDTO);
    }

    @Override
    public List<DeviceSimpleDTO> deviceListByDeviceTypeId(Long deviceTypeId) {
        return ((MachineMapper) this.baseMapper).deviceListByDeviceTypeId(deviceTypeId);
    }

    @Override
    public List<DeviceSimpleDTO> deviceListByDeviceIdList(List<Long> deviceIdList) {
        return ((MachineMapper) this.baseMapper).deviceListByDeviceIdList(deviceIdList);
    }

    @Override
    public BladeFile exportMachine(MachineSelectVO vo) {
        List<MachineDetailVO> vos = ((MachineMapper) this.baseMapper).listMachineDetail(vo.getMachineName(), vo.getMachineCode(), vo.getMachineTypeId(), vo.getGroupId(), CommonGroupConstant.ALL_MACHINE_ID, vo.getStatus());
        List<MachineDetailVO> list = vos.stream().peek(c -> {
            c.setMachineLifeStatusName(DictCache.getValue(DictEnum.MACHINE_LIFE_STATUS.getName(), c.getMachineLifeStatus()));
            c.setManagementClassName(DictCache.getValue(DictEnum.MACHINE_MANAGEMENT_CLASS, c.getManagementClass()));
            c.setMachineUseStatusName(DictCache.getValue(DictEnum.MACHINE_USE_STATUS.getName(), c.getMachineUseStatus()));
        }).collect(Collectors.toList());
        List<MachineExcel> excels = MachineConvert.INSTANCE.convertVO(list);
        String fileName = String.format("%s-%s.xlsx", "机器管理", DateUtil.time());
        MultipartFile multipartFile = ExcelUtil.exportToMultipartFile(fileName, "机器管理数据表", excels, MachineExcel.class);
        return this.ossBuilder.tempTemplate().putFile(multipartFile.getOriginalFilename(), multipartFile);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public BladeFile importMachine(MultipartFile file) {
        List<MachineImport> rawData = ExcelUtil.read(file, 0, 2, MachineImport.class);
        ThrowFun.isTrue(Func.isEmpty(rawData)).throwMessage(MessageUtils.message("excel.import.data.can.not.be.null", new Object[0]));
        ThrowFun.isTrue(rawData.size() > 200).throwMessage(MessageUtils.message("excel.import.size.failed", new Object[0]));
        Map<String, Integer> machineCodeMap = new HashMap<>(rawData.size());
        Set<String> machineCodes = new HashSet<>(rawData.size());
        Map<String, Integer> pinMap = new HashMap<>(rawData.size());
        Set<String> pinCodes = new HashSet<>(rawData.size());
        Map<String, Integer> shortMap = new HashMap<>(rawData.size());
        Set<String> shortCodes = new HashSet<>(rawData.size());
        buildMap(rawData, machineCodeMap, machineCodes, pinMap, pinCodes, shortMap, shortCodes);
        List<MachineImport> failExcel = Lists.newArrayList();
        List<DeviceType> deviceTypeList = Lists.newArrayList();
        List<Workstation> workstationList = this.workstationService.list(Wrappers.<Workstation>lambdaQuery().eq(Workstation::getStatus, CommonConstant.ENABLE));
        Map<String, Workstation> workstationMap = workstationList.stream().collect(Collectors.toMap((v0) -> {
            return v0.getCode();
        }, v -> {
            return v;
        }));
        HashMap<String, Long> commonGroupNameMap = this.commonGroupService.getCommonGroupNameMap(CommonGroupTypeEnum.MACHINE.getName(), CommonGroupConstant.DEFAULT_CATEGORY);
        HashMap<String, Long> organizationNameMap = this.commonGroupService.getCommonGroupNameMap(CommonGroupTypeEnum.ORGANIZATION.getName(), CommonGroupConstant.DEFAULT_CATEGORY);
        HashMap<String, Long> commonGroupNameStatusMap = this.commonGroupService.getCommonGroupNameMap(CommonGroupTypeEnum.ORGANIZATION.getName(), CommonGroupConstant.DEFAULT_CATEGORY, CommonConstant.ENABLE);
        Map<String, Long> commonGroupNameDisableMap = this.commonGroupService.getCommonGroupNameMap(CommonGroupTypeEnum.ORGANIZATION.getName(), CommonGroupConstant.DEFAULT_CATEGORY, CommonConstant.DEACTIVATE);
        EmployeeNameDTO employeeNameMap = this.employeeService.getEmployeeNameMap();
        for (MachineImport data : rawData) {
            boolean validImport = validImport(data, machineCodeMap, machineCodes, pinCodes, pinMap, shortCodes, shortMap, failExcel, deviceTypeList, commonGroupNameMap, organizationNameMap, workstationMap, commonGroupNameStatusMap, commonGroupNameDisableMap, employeeNameMap);
            if (validImport) {
                break;
            }
        }
        if (Func.isNotEmpty(failExcel)) {
            return exportFailFile(failExcel);
        }
        Map<String, Long> typeMap = deviceTypeList.stream().collect(Collectors.toMap((v0) -> {
            return v0.getCode();
        }, (v0) -> {
            return v0.getId();
        },(v1, v2) -> {
            return v1;
        }));
        saveExportMachine(rawData, typeMap, commonGroupNameMap, organizationNameMap, employeeNameMap);
        return null;
    }

    public void saveExportMachine(List<MachineImport> rawData, Map<String, Long> typeMap, HashMap<String, Long> commonGroupNameMap, HashMap<String, Long> organizationNameMap, EmployeeNameDTO employeeNameMap) {
        List<Machine> collect = rawData.stream().map(c -> {
            Machine machine = MachineConvert.INSTANCE.convert(c);
            String machineTypeName = c.getMachineTypeName();
            String machineTypeCode = c.getMachineTypeCode();
            if (Func.isNotBlank(machineTypeName) && Func.isNotBlank(machineTypeCode)) {
                Long machineTypeId = (Long) typeMap.get(machineTypeCode);
                machine.setMachineTypeId(machineTypeId);
            }
            String groupName = c.getGroupName();
            if (Func.isNotBlank(groupName) && !CommonGroupConstant.ALL_NAME.equals(groupName)) {
                Long groupId = (Long) commonGroupNameMap.get(groupName);
                machine.setGroupId(groupId);
            } else if (CommonGroupConstant.ALL_NAME.equals(groupName)) {
                machine.setGroupId(CommonGroupConstant.DEFAULT_MACHINE_ID);
            } else {
                machine.setGroupId(CommonGroupConstant.DEFAULT_MACHINE_ID);
            }
            String organizationName = c.getOrganizationName();
            if (Func.isNotBlank(organizationName)) {
                Long organizationId = (Long) organizationNameMap.get(organizationName);
                machine.setOrganizationId(organizationId);
            }
            String lifeStatusName = c.getMachineLifeStatusName();
            if (Func.isNotBlank(lifeStatusName)) {
                String lifeStatus = DictCache.getKey(DictEnum.MACHINE_LIFE_STATUS, lifeStatusName);
                machine.setMachineLifeStatus(Integer.valueOf(Integer.parseInt(lifeStatus)));
            }
            String managementClassName = c.getManagementClassName();
            if (Func.isNotBlank(managementClassName)) {
                String managementClass = DictCache.getKey(DictEnum.MACHINE_MANAGEMENT_CLASS, managementClassName);
                machine.setManagementClass(Integer.valueOf(Integer.parseInt(managementClass)));
            }
            String useStatusName = c.getMachineUseStatusName();
            if (Func.isNotBlank(useStatusName)) {
                String useStatus = DictCache.getKey(DictEnum.MACHINE_USE_STATUS, useStatusName);
                machine.setMachineUseStatus(Integer.valueOf(Integer.parseInt(useStatus)));
            }
            String employeeName = c.getEmployeeName();
            if (Func.isNotEmpty(employeeName)) {
                machine.setEmployeeId(employeeNameMap.getEmployeeNameMap().get(employeeName));
            }
            machine.setMaintenanceStatus(Integer.valueOf(MaintainStatusEnum.T1.getType()));
            machine.setRepairStatus(Integer.valueOf(RepairRecordEnum.R1.getType()));
            machine.setExtendId(UUID.randomUUID().toString());
            return machine;
        }).collect(Collectors.toList());
        saveBatch(collect);
        saveCommonGroupItem(collect);
        saveWorkstationOfMachine(collect);
        CacheUtil.clear(ExtCacheConstant.POSTING_MACHINE, Boolean.FALSE);
    }

    private BladeFile exportFailFile(List<MachineImport> failExcel) {
        MultipartFile multipartFile = ExcelUtil.exportFillTemplateToMultipartFile(ExcelConstant.DIRECTORY + "machineFailTemplate" + ExcelConstant.SUFFIX, MessageUtils.message("excel.import.failed.report.name", new Object[0]) + ExcelConstant.SUFFIX, "机器表", failExcel, (Object) null, (AbstractMergeStrategy) null);
        return this.ossBuilder.tempTemplate().putFile(multipartFile.getOriginalFilename(), multipartFile);
    }

    private void buildMap(List<MachineImport> rawData, Map<String, Integer> machineCodeMap, Set<String> machineCodes, Map<String, Integer> pinMap, Set<String> pinCodes, Map<String, Integer> shortMap, Set<String> shortCodes) {
        QueryWrapper<Machine> machineCodeQuery = Wrappers.<Machine>query().select(new String[]{"machine_code"});
        QueryWrapper<Machine> pinCodeQuery = Wrappers.<Machine>query().select(new String[]{"pin_code"});
        QueryWrapper<Machine> shortCodeQuery = Wrappers.<Machine>query().select(new String[]{"short_code"});
        boolean flag1 = false;
        boolean flag2 = false;
        boolean flag3 = false;
        for (MachineImport data : rawData) {
            String machineCode = data.getMachineCode();
            if (Func.isNotBlank(machineCode)) {
                if (machineCodeMap.containsKey(machineCode)) {
                    machineCodeMap.put(machineCode, Integer.valueOf(machineCodeMap.get(machineCode).intValue() + 1));
                } else {
                    machineCodeMap.put(machineCode, 1);
                }
                if (flag1) {
                    machineCodeQuery.or();
                }
                flag1 = true;
                machineCodeQuery.nested(i -> {
                	 i.eq("machine_code", machineCode);
                    //QueryWrapper queryWrapper = (QueryWrapper) i.eq("machine_code", machineCode);
                });
                machineCodeQuery.apply("status =1", new Object[0]);
            }
            String pinCode = data.getPinCode();
            if (Func.isNotBlank(pinCode)) {
                if (pinMap.containsKey(pinCode)) {
                    pinMap.put(pinCode, Integer.valueOf(pinMap.get(pinCode).intValue() + 1));
                } else {
                    pinMap.put(pinCode, 1);
                }
                if (flag2) {
                    pinCodeQuery.or();
                }
                flag2 = true;
                pinCodeQuery.nested(i2 -> {
                    i2.eq("pin_code", pinCode);
                });
                pinCodeQuery.apply("status =1", new Object[0]);
            }
            String shortCode = data.getShortCode();
            if (Func.isNotBlank(shortCode)) {
                if (shortMap.containsKey(shortCode)) {
                    shortMap.put(shortCode, Integer.valueOf(shortMap.get(shortCode).intValue() + 1));
                } else {
                    shortMap.put(shortCode, 1);
                }
                if (flag3) {
                    shortCodeQuery.or();
                }
                flag3 = true;
                shortCodeQuery.nested(i3 -> {
                    i3.eq("short_code", shortCode);
                });
                shortCodeQuery.apply("status =1", new Object[0]);
            }
        }
        String sqlSegment1 = machineCodeQuery.getSqlSegment();
        if (Func.isNotBlank(sqlSegment1)) {
            List<String> machineCodeList = listObjs(machineCodeQuery, String::valueOf);
            if (Func.isNotEmpty(machineCodeList)) {
                machineCodes.addAll(machineCodeList);
            }
        }
        String sqlSegment2 = pinCodeQuery.getSqlSegment();
        if (Func.isNotBlank(sqlSegment2)) {
            List<String> pinCodeList = listObjs(pinCodeQuery, String::valueOf);
            if (Func.isNotEmpty(pinCodeList)) {
                pinCodes.addAll(pinCodeList);
            }
        }
        String sqlSegment3 = shortCodeQuery.getSqlSegment();
        if (Func.isNotBlank(sqlSegment3)) {
            List<String> shortCodeList = listObjs(shortCodeQuery, String::valueOf);
            if (Func.isNotEmpty(shortCodeList)) {
                shortCodes.addAll(shortCodeList);
            }
        }
    }

    public void saveWorkstationOfMachine(List<Machine> collect) {
        collect.forEach(machine -> {
            if ("是".equals(machine.getLinkWay())) {
                WorkstationSubmitVO workstationSaveVO = new WorkstationSubmitVO();
                workstationSaveVO.setCode(machine.getMachineCode());
                workstationSaveVO.setName(machine.getMachineName());
                workstationSaveVO.setMachineCode(machine.getMachineCode());
                workstationSaveVO.setMachineName(machine.getMachineName());
                workstationSaveVO.setGroupId(CommonGroupConstant.DEFAULT_WORKSTATION_ID);
                workstationSaveVO.setLinkWay(0);
                workstationSaveVO.setType(0);
                workstationSaveVO.setMachineId(machine.getId());
                this.workstationService.submit(workstationSaveVO);
            }
        });
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public Boolean delete(IdsVO vo, Integer type) {
        if (StatusType.REMOVE.getType().equals(type)) {
            WorkstationOfMachineCache.clearWorkStationMachineCache(vo.getIds());
            Integer nums = ((MachineMapper) this.baseMapper).typeAndonRecord(Func.toLongList(vo.getIds()));
            if (nums.intValue() > 0) {
                throw new ServiceException(MessageUtils.message("machine.andon.not.remove", new Object[0]));
            }
            removeByIds(Func.toLongList(vo.getIds()));
            this.workstationOfMachineService.remove(Wrappers.<WorkstationOfMachine>lambdaQuery().in(WorkstationOfMachine::getMachineId, vo.getIds()));
            this.itemService.remove( Wrappers.<CommonGroupOfItem>lambdaQuery().in(CommonGroupOfItem::getItemId, vo.getIds()));
            CacheUtil.clear(ExtCacheConstant.POSTING_MACHINE, Boolean.FALSE);
            CacheUtil.clear(ExtCacheConstant.WORKSTATION_MACHINE, Boolean.FALSE);
        }
        return Boolean.valueOf(changeStatus(Func.toLongList(vo.getIds()), CommonConstant.DEACTIVATE));
    }
    /*
    @Override
    public List<HmiDeviceVO> getHmiWorkstation(String machineId) {
        List<HmiDeviceVO> hmiDeviceVOList = new ArrayList<>();
        Machine machine = (Machine) getById(machineId);
        if (machine == null) {
            throw new ServiceException("机器不存在");
        }
        List<WorkstationOfMachine> list = this.workstationOfMachineService.list(Wrappers.<WorkstationOfMachine>lambdaQuery().eq(WorkstationOfMachine::getMachineId, machineId));
        
        if (Func.isNotEmpty(list)) {
            List<Long> workstationIds =  list.stream().map((v0) -> {
                return v0.getWorkstationId();
            }).collect(Collectors.toList());
            if (Func.isNotEmpty(workstationIds)) {
                List<Workstation> workstations = this.workstationService.listByIds(workstationIds);
                for (Workstation workstation : workstations) {
                    HmiDeviceVO hmiDeviceVO = new HmiDeviceVO();
                    hmiDeviceVO.setWorkstationId(String.valueOf(workstation.getId()));
                    hmiDeviceVO.setWorkstationName(workstation.getName());
                    Integer supportCncRw = workstation.getSupportCncRw();
                    if (DncEnums.SupportCncRw.Support.getCode().equals(supportCncRw)) {
                        hmiDeviceVO.setFileLocations(Arrays.asList(1, 2));
                    } else {
                        hmiDeviceVO.setFileLocations(Collections.singletonList(2));
                    }
                    hmiDeviceVOList.add(hmiDeviceVO);
                }
            }
        }
        return hmiDeviceVOList;
    }
    */

    @Override
    public List<MachineExtDTO> getMachineByWorkStation(List<Long> workstationIds) {
        return ((MachineMapper) this.baseMapper).getMachineByWorkStation(workstationIds);
    }

    @Override
    public String queryDateTypeState(Long workstationId) {
        return ((MachineMapper) this.baseMapper).queryDateTypeState(WcsDataTypeEnums.WcsDataType.STATE.getCode(), workstationId);
    }

    private boolean validImport(MachineImport data, Map<String, Integer> machineCodeMap, Set<String> machineCodes, Set<String> pinCodes, Map<String, Integer> pinMap, Set<String> shortCodes, Map<String, Integer> shortMap, List<MachineImport> failExcel, List<DeviceType> deviceTypeList, HashMap<String, Long> commonGroupNameMap, HashMap<String, Long> organizationNameMap, Map<String, Workstation> workstationMap, HashMap<String, Long> commonGroupNameStatusMap, Map<String, Long> commonGroupNameDisableMap, EmployeeNameDTO employeeNameMap) {
        boolean validMachineCode = validMachineCode(data, machineCodeMap, machineCodes, failExcel);
        if (validMachineCode) {
            return true;
        }
        boolean validMachineName = validMachineName(data, failExcel);
        if (validMachineName) {
            return true;
        }
        boolean validLinkWay = validLinkWay(data, workstationMap, failExcel);
        if (validLinkWay) {
            return true;
        }
        boolean validWorkstationBind = validWorkstationBind(data, workstationMap, failExcel);
        if (validWorkstationBind) {
            return true;
        }
        String pinCode = data.getPinCode();
        if (Func.isNotBlank(pinCode)) {
            boolean valid = validPinCodeImport(pinCode, data, failExcel, pinCodes, pinMap);
            if (valid) {
                return true;
            }
        }
        String shortCode = data.getShortCode();
        if (Func.isNotBlank(shortCode)) {
            boolean valid2 = validShortCodeImport(shortCode, data, failExcel, shortCodes, shortMap);
            if (valid2) {
                return true;
            }
        }
        String typeCode = data.getMachineTypeCode();
        String typeName = data.getMachineTypeName();
        if (Func.isNotBlank(typeName) && Func.isBlank(typeCode)) {
            data.setFailReason(MessageUtils.message("excel.import.machine.type.code.error", new Object[0]));
            failExcel.add(data);
            return true;
        }
        if (Func.isNotBlank(typeName) && Func.isNotBlank(typeCode)) {
            DeviceType type = this.typeService.getOne(Wrappers.<DeviceType>lambdaQuery().eq(DeviceType::getName, typeName)
            		.eq(DeviceType::getCode, typeCode));
            if (Func.isEmpty(type)) {
                data.setFailReason(MessageUtils.message("cps.tpm.machine.type.not.exists", new Object[0]));
                failExcel.add(data);
                return true;
            }
            deviceTypeList.add(type);
        }
        String groupName = data.getGroupName();
        if (Func.isNotBlank(groupName) && !commonGroupNameMap.containsKey(groupName)) {
            data.setFailReason(MessageUtils.message("cps.tpm.machine.group.not.exists", new Object[0]));
            failExcel.add(data);
            return true;
        }
        String voltage = data.getVoltage();
        if (Func.isNotBlank(voltage)) {
            boolean valid3 = checkNumberFormat(voltage, data, failExcel);
            if (valid3) {
                return true;
            }
        }
        String dimensions = data.getDimensions();
        if (Func.isNotBlank(dimensions)) {
            boolean valid4 = checkNumberFormat(dimensions, data, failExcel);
            if (valid4) {
                return true;
            }
        }
        String netWeight = data.getNetWeight();
        if (Func.isNotBlank(netWeight)) {
            boolean valid5 = checkNumberFormat(netWeight, data, failExcel);
            if (valid5) {
                return true;
            }
        }
        String power = data.getPower();
        if (Func.isNotBlank(power)) {
            boolean valid6 = checkNumberFormat(power, data, failExcel);
            if (valid6) {
                return true;
            }
        }
        String invoiceValue = data.getInvoiceValue();
        if (Func.isNotBlank(invoiceValue)) {
            boolean valid7 = checkNumberFormat(invoiceValue, data, failExcel);
            if (valid7) {
                return true;
            }
        }
        String ovfa = data.getOvfa();
        if (Func.isNotBlank(ovfa)) {
            boolean valid8 = checkNumberFormat(ovfa, data, failExcel);
            if (valid8) {
                return true;
            }
        }
        String netAssetValue = data.getNetAssetValue();
        if (Func.isNotBlank(netAssetValue)) {
            boolean valid9 = checkNumberFormat(netAssetValue, data, failExcel);
            if (valid9) {
                return true;
            }
        }
        String productionTime = data.getProductionTime();
        if (Func.isNotBlank(productionTime)) {
            boolean valid10 = checkTimeFormat(productionTime, data, failExcel);
            if (valid10) {
                return true;
            }
        }
        String deliveryTime = data.getDeliveryTime();
        if (Func.isNotBlank(deliveryTime)) {
            boolean valid11 = checkTimeFormat(deliveryTime, data, failExcel);
            if (valid11) {
                return true;
            }
        }
        String turnToFixedAssetsTime = data.getTurnToFixedAssetsTime();
        if (Func.isNotBlank(turnToFixedAssetsTime)) {
            boolean valid12 = checkTimeFormat(turnToFixedAssetsTime, data, failExcel);
            if (valid12) {
                return true;
            }
        }
        String lifeStatusName = data.getMachineLifeStatusName();
        if (Func.isNotBlank(lifeStatusName)) {
            String lifeStatus = DictCache.getKey(DictEnum.MACHINE_LIFE_STATUS, lifeStatusName);
            if (Func.isBlank(lifeStatus)) {
                data.setFailReason(MessageUtils.message("cps.tpm.machine.life.status.exists", new Object[0]));
                failExcel.add(data);
                return true;
            }
        }
        String managementClassName = data.getManagementClassName();
        if (Func.isNotBlank(managementClassName)) {
            String managementClass = DictCache.getKey(DictEnum.MACHINE_MANAGEMENT_CLASS, managementClassName);
            if (Func.isBlank(managementClass)) {
                data.setFailReason(MessageUtils.message("cps.tpm.machine.management.class.exists", new Object[0]));
                failExcel.add(data);
                return true;
            }
        }
        String organizationName = data.getOrganizationName();
        if (Func.isNotBlank(organizationName)) {
            if (!commonGroupNameStatusMap.containsKey(organizationName)) {
                data.setFailReason(MessageUtils.message("cps.tpm.machine.organization.not.exists", new Object[0]));
                failExcel.add(data);
                return true;
            } else if (commonGroupNameDisableMap.containsKey(data.getOrganizationName())) {
                data.setFailReason(MessageUtils.message("cps.organization.already.exist.stop.status", new Object[0]));
                failExcel.add(data);
                return true;
            }
        }
        String useStatusName = data.getMachineUseStatusName();
        if (Func.isNotBlank(useStatusName)) {
            String useStatus = DictCache.getKey(DictEnum.MACHINE_USE_STATUS, useStatusName);
            if (Func.isBlank(useStatus)) {
                data.setFailReason(MessageUtils.message("cps.tpm.use.status.exists", new Object[0]));
                failExcel.add(data);
                return true;
            }
        }
        String employeeName = data.getEmployeeName();
        if (Func.isNotEmpty(employeeName)) {
            if (!employeeNameMap.getEmployeeNameMap().containsKey(employeeName)) {
                data.setFailReason(MessageUtils.message("cps.employee.name.is.not.exist", new Object[0]));
                failExcel.add(data);
                return true;
            } else if (employeeNameMap.getRepeatEmployeeNameMap().containsKey(employeeName)) {
                data.setFailReason(StrUtil.format(MessageUtils.message("cps.employee.name.already.exists", new Object[0]), new Object[]{employeeName}));
                failExcel.add(data);
                return true;
            } else {
                return false;
            }
        }
        return false;
    }

    @Override
    public MachineDetailVO detailByCode(String machineCode) {
        MachineDetailVO machineDetailVO = ((MachineMapper) this.baseMapper).selectMachineDetailByCode(machineCode);
        if (Func.isNotEmpty(machineDetailVO)) {
            machineDetailVO.setMachineLifeStatusName(DictCache.getValue(DictEnum.MACHINE_LIFE_STATUS.getName(), machineDetailVO.getMachineLifeStatus()));
            machineDetailVO.setManagementClassName(DictCache.getValue(DictEnum.MACHINE_MANAGEMENT_CLASS, machineDetailVO.getManagementClass()));
            machineDetailVO.setMachineUseStatusName(DictCache.getValue(DictEnum.MACHINE_USE_STATUS.getName(), machineDetailVO.getMachineUseStatus()));
            List<WorkstationOfMachine> workstationOfMachineList = this.workstationOfMachineService.list(Wrappers.<WorkstationOfMachine>lambdaQuery()
            		.eq(WorkstationOfMachine::getMachineId, machineDetailVO.getId()));
            if (Func.isNotEmpty(workstationOfMachineList)) {
                List<Workstation> workstationList = this.workstationService.listByIds(workstationOfMachineList.stream().map(WorkstationOfMachine::getWorkstationId).collect(Collectors.toList()));
                Optional.ofNullable(workstationList).ifPresent(workstations -> {
                    String code = ((Workstation) ListUtils.getFirst(workstations)).getCode();
                    String name = ((Workstation) ListUtils.getFirst(workstations)).getName();
                    Long workstationId = ((Workstation) ListUtils.getFirst(workstations)).getId();
                    machineDetailVO.setWorkstationCode(code);
                    machineDetailVO.setWorkstationName(name);
                    machineDetailVO.setWorkstationId(workstationId);
                });
            }
        }
        return machineDetailVO;
    }

    @Override
    public IPage<MachineListVO> pageMachineByParam(MachineSelectVO machineSelectVO, Query query) {
        IPage<MachineListVO> page = ((MachineMapper) this.baseMapper).pageMachineByParam(Condition.getPage(query), machineSelectVO);
        List<MachineListVO> records = page.getRecords();
        List<MachineListVO> collect = (List) records.stream().peek(c -> {
            c.setMachineUseStatusName(DictCache.getValue(DictEnum.MACHINE_USE_STATUS.getName(), c.getMachineUseStatus()));
        }).collect(Collectors.toList());
        page.setRecords(collect);
        return page;
    }

    @Override
    public List<MachineVO> listNoBand() {
        return ((MachineMapper) this.baseMapper).listNoBand();
    }

    @Override
    public List<MachineVO> listHaveBand() {
        return ((MachineMapper) this.baseMapper).listHaveBand();
    }

    private boolean validMachineCode(MachineImport data, Map<String, Integer> machineCodeMap, Set<String> machineCodes, List<MachineImport> failExcel) {
        String machineCode = data.getMachineCode();
        if (Func.isBlank(machineCode)) {
            data.setFailReason(MessageUtils.message("excel.import.machine.code.exists", new Object[0]));
            failExcel.add(data);
            return true;
        } else if (machineCodes.contains(machineCode)) {
            data.setFailReason(MessageUtils.message("excel.import.machine.code.code.same", new Object[0]));
            failExcel.add(data);
            return true;
        } else {
            Integer nums = machineCodeMap.getOrDefault(machineCode, 1);
            if (nums.intValue() > 1) {
                data.setFailReason(MessageUtils.message("excel.import.machine.code.code.same", new Object[0]));
                failExcel.add(data);
                return true;
            } else if (checkStopImportMachine(machineCode)) {
                data.setFailReason(MessageUtils.message("machine.code.already.exist.stop.status", new Object[0]));
                failExcel.add(data);
                return true;
            } else {
                return false;
            }
        }
    }

    private boolean validMachineName(MachineImport data, List<MachineImport> failExcel) {
        String machineName = data.getMachineName();
        if (Func.isBlank(machineName)) {
            data.setFailReason(MessageUtils.message("excel.import.machine.name.exists", new Object[0]));
            failExcel.add(data);
            return true;
        }
        return false;
    }

    private boolean validLinkWay(MachineImport data, Map<String, Workstation> workstationMap, List<MachineImport> failExcel) {
        String linkWay = data.getLinkWay();
        if (Func.isNotEmpty(linkWay)) {
            if (!"是".equals(linkWay) && !"否".equals(linkWay)) {
                data.setFailReason(MessageUtils.message("excel.import.machine.linkWay.not.correct", new Object[0]));
                failExcel.add(data);
                return true;
            } else if ("是".equals(linkWay)) {
                String machineCode = data.getMachineCode();
                if (workstationMap.containsKey(machineCode)) {
                    data.setFailReason(MessageUtils.message("cps.workstation.code.already.exists", new Object[0]));
                    failExcel.add(data);
                    return true;
                }
                return false;
            } else {
                return false;
            }
        }
        return false;
    }

    private boolean validWorkstationBind(MachineImport data, Map<String, Workstation> workstationMap, List<MachineImport> failExcel) {
        Workstation workstation = workstationMap.get(data.getMachineCode());
        if (Func.isNotEmpty(workstation)) {
        	long count = this.workstationOfMachineService.count(Wrappers.<WorkstationOfMachine>lambdaQuery()
        	          .eq(WorkstationOfMachine::getWorkstationId, workstation.getId()));
        	/*
            long count = this.workstationOfMachineService.count((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
                return v0.getWorkstationId();
            }, workstation.getId()));*/
            if (count > 0) {
                data.setFailReason(MessageUtils.message("excel.import.machine.workstation.already.bound", new Object[0]));
                failExcel.add(data);
                return true;
            }
            return false;
        }
        return false;
    }

    private boolean validPinCodeImport(String pinCode, MachineImport data, List<MachineImport> failExcel, Set<String> pinCodes, Map<String, Integer> pinMap) {
        int len = pinCode.length();
        if (len < 4 || len > 6) {
            data.setFailReason(String.format(MessageUtils.message("cps.tpm.machine.pin.code.length", new Object[0]), 4, 6));
            failExcel.add(data);
            return true;
        }
        boolean matches = CHINESE.matcher(pinCode).matches();
        if (!matches) {
            data.setFailReason(MessageUtils.message("excel.import.machine.ping.code.have.chinese", new Object[0]));
            failExcel.add(data);
            return true;
        }
        return false;
    }

    private boolean validShortCodeImport(String shortCode, MachineImport data, List<MachineImport> failExcel, Set<String> shortCodes, Map<String, Integer> shortMap) {
        int len = shortCode.length();
        if (len < 4 || len > 8) {
            data.setFailReason(String.format(MessageUtils.message("cps.tpm.machine.short.code.length", new Object[0]), 4, 8));
            failExcel.add(data);
            return true;
        } else if (Func.isNotEmpty(shortCodes) && shortCodes.contains(shortCode)) {
            data.setFailReason(MessageUtils.message("cps.tpm.machine.short.code.exists", new Object[0]));
            failExcel.add(data);
            return true;
        } else if (Func.isNotEmpty(shortMap) && shortMap.getOrDefault(shortCode, 1).intValue() > 1) {
            data.setFailReason(MessageUtils.message("cps.tpm.machine.short.code.excel.exists", new Object[0]));
            failExcel.add(data);
            return true;
        } else {
            boolean matches = CHINESE.matcher(shortCode).matches();
            if (!matches) {
                data.setFailReason(MessageUtils.message("excel.import.machine.short.code.have.chinese", new Object[0]));
                failExcel.add(data);
                return true;
            }
            return false;
        }
    }

    private boolean checkTimeFormat(String time, MachineImport data, List<MachineImport> failExcel) {
        if (Func.isNotBlank(time)) {
            try {
                DateUtil.parse(time, DateConstant.PATTERN_DATE);
                return false;
            } catch (Exception e) {
                data.setFailReason(MessageUtils.message("excel.import.machine.time.error", new Object[0]));
                failExcel.add(data);
                return true;
            }
        }
        return false;
    }

    private boolean checkNumberFormat(String number, MachineImport data, List<MachineImport> failExcel) {
        if (Func.isNotBlank(number)) {
            boolean matches = NUMBER.matcher(number).matches();
            if (!matches) {
                data.setFailReason(MessageUtils.message("excel.import.machine.number.error", new Object[0]));
                failExcel.add(data);
                return true;
            }
            return false;
        }
        return false;
    }

    private boolean checkStopImportMachine(String machineCode) {
    	Machine machine = getOne(Wrappers.<Machine>lambdaQuery().eq(Machine::getMachineCode, machineCode).eq(Machine::getStatus, CommonConstant.DEACTIVATE));
       
        if (machine != null) {
            return Boolean.TRUE.booleanValue();
        }
        return Boolean.FALSE.booleanValue();
    }

    private void checkStopMachine(String machineCode) {
    	Machine machine = getOne(Wrappers.<Machine>lambdaQuery().eq(Machine::getMachineCode, machineCode).eq(Machine::getStatus, CommonConstant.DEACTIVATE));
    	/*
        Machine machine = (Machine) getOne((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getMachineCode();
        }, machineCode)).eq((v0) -> {
            return v0.getStatus();
        }, CommonConstant.DEACTIVATE));*/
        if (machine != null) {
            throw new ServiceException(MessageUtils.message("machine.code.already.exist.stop.status", new Object[0]));
        }
    }

    private void checkStopMachineByCode(String workstationCode) {
        Machine machine = getOne(Wrappers.<Machine>lambdaQuery().eq(Machine::getMachineCode, workstationCode).eq(Machine::getStatus, CommonConstant.DEACTIVATE));
        if (machine != null) {
            throw new ServiceException(MessageUtils.message("machine.machine.workstation.already.exist.stop.status", new Object[0]));
        }
    }

    private void checkMachine(Long id, String machineCode) {
    	Long count = Long.valueOf(count(Wrappers.<Machine>lambdaQuery().ne(Func.isNotEmpty(id), Machine::getId, id)
    			.eq(Machine::getMachineCode, machineCode)
    			.eq(Machine::getStatus, CommonConstant.ENABLE)));
    	/*
        Long count = Long.valueOf(count((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().ne(Func.isNotEmpty(id), (v0) -> {
            return v0.getId();
        }, id).eq((v0) -> {
            return v0.getMachineCode();
        }, machineCode)).eq((v0) -> {
            return v0.getStatus();
        }, CommonConstant.ENABLE)));*/
        if (count.longValue() > 0) {
            throw new ServiceException(MessageUtils.message("machine.code.already.exists", new Object[0]));
        }
    }

    private void checkPinCode(String pinCode, Long id) {
        int len = pinCode.length();
        if (len < 4 || len > 6) {
            throw new ServiceException(String.format(MessageUtils.message("cps.tpm.machine.pin.code.length", new Object[0]), 4, 6));
        }
    }

    private void saveCommonGroupItem(List<Machine> machines) {
        if (Func.isNotEmpty(machines)) {
            List<CommonGroupOfItem> collect = (List) machines.stream().map(c -> {
                return CommonGroupOfItem.builder().groupId(c.getGroupId()).itemId(c.getId()).extendId(c.getExtendId()).groupType(CommonGroupTypeEnum.MACHINE.getName()).groupCategory(CommonGroupConstant.DEFAULT_CATEGORY).build();
            }).collect(Collectors.toList());
            this.itemService.saveBatch(collect);
        }
    }

    private List<MaintainPlan> checkExistPlanStatus(Long deviceId, Long id) {
    	List<MaintainPlan> maintainPlanList = this.maintainPlanService.list(Wrappers.<MaintainPlan>query().lambda()
    			.eq(Func.isNotEmpty(AuthUtil.getTenantId()), MaintainPlan::getTenantId, AuthUtil.getTenantId())
    			.eq(MaintainPlan::getDeviceId, deviceId)
    			.notIn(
    	          Func.isNotEmpty(id), MaintainPlan::getId, new Object[] { id })
    			.notIn(MaintainPlan::getPlanStatus, new Object[] { Integer.valueOf(MaintainPlanStatusEnum.T5.getType()) })
    			.orderByDesc(MaintainPlan::getPlanStatus));
    	/*
        List<MaintainPlan> maintainPlanList = this.maintainPlanService.list((Wrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) Wrappers.query().lambda().eq(Func.isNotEmpty(AuthUtil.getTenantId()), (v0) -> {
            return v0.getTenantId();
        }, AuthUtil.getTenantId()).eq((v0) -> {
            return v0.getDeviceId();
        }, deviceId)).notIn(Func.isNotEmpty(id), (v0) -> {
            return v0.getId();
        }, new Object[]{id}).notIn((v0) -> {
            return v0.getPlanStatus();
        }, new Object[]{Integer.valueOf(MaintainPlanStatusEnum.T5.getType())})).orderByDesc((v0) -> {
            return v0.getPlanStatus();
        }));*/
        return maintainPlanList;
    }
}