package org.jeecg.modules.mdc.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.google.common.base.CaseFormat;
import org.apache.commons.lang3.StringUtils;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.mdc.dto.EquipmentTemperatureDto;
import org.jeecg.modules.mdc.dto.MdcEquDepDto;
import org.jeecg.modules.mdc.dto.MdcEquProDto;
import org.jeecg.modules.mdc.dto.MdcEquipmentDto;
import org.jeecg.modules.mdc.entity.*;
import org.jeecg.modules.mdc.mapper.MdcEquipmentMapper;
import org.jeecg.modules.mdc.mapper.XYZAliasesMapper;
import org.jeecg.modules.mdc.model.MdcEquipmentTree;
import org.jeecg.modules.mdc.service.*;
import org.jeecg.modules.mdc.util.DateUtils;
import org.jeecg.modules.mdc.util.FindsEquipmentDepartUtil;
import org.jeecg.modules.mdc.util.FindsEquipmentProductionUtil;
import org.jeecg.modules.mdc.vo.MdcEquipmentDepVo;
import org.jeecg.modules.mdc.vo.MdcEquipmentProVo;
import org.jeecg.modules.mdc.vo.MdcEquipmentVo;
import org.jeecg.modules.system.entity.MdcEquipmentDepart;
import org.jeecg.modules.system.entity.MdcProduction;
import org.jeecg.modules.system.entity.MdcProductionEquipment;
import org.jeecg.modules.system.entity.SysDepart;
import org.jeecg.modules.system.mapper.MdcEquipmentDepartMapper;
import org.jeecg.modules.system.mapper.MdcProductionEquipmentMapper;
import org.jeecg.modules.system.service.IMdcProductionService;
import org.jeecg.modules.system.service.IMdcUserProductionService;
import org.jeecg.modules.system.service.ISysDepartService;
import org.jeecg.modules.system.service.ISysUserDepartService;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @Description: 设备表
 * @Author: liuS
 * @Date: 2023-03-22
 * @Version: V1.0
 */
@Service
public class MdcEquipmentServiceImpl extends ServiceImpl<MdcEquipmentMapper, MdcEquipment> implements IMdcEquipmentService {

    @Resource
    private MdcEquipmentDepartMapper mdcEquipmentDepartMapper;
    @Resource
    private MdcProductionEquipmentMapper mdcProductionEquipmentMapper;
    @Resource
    private ISysUserDepartService sysUserDepartService;
    @Resource
    private IMdcUserProductionService mdcUserProductionService;
    @Resource
    private ISysDepartService sysDepartService;
    @Resource
    private IMdcProductionService mdcProductionService;
    @Resource
    private IControlSystemService controlSystemService;
    @Resource
    private IEquipmentWorkLineService equipmentWorkLineService;
    @Resource
    private IMdcDriveTypeParamConfigService mdcDriveTypeParamConfigService;
    @Resource
    private XYZAliasesMapper xyzAliasesMapper;
    @Resource
    private IEquipmentXYZService equipmentXYZService;
    @Resource
    private IEquipmentBaseInfoService equipmentBaseInfoService;
    @Resource
    private IEquipmentTemperatureService equipmentTemperatureService;

    @Override
    public Map<String, String> getDepNamesByEquipmentIds(List<String> equipmentIds) {
        List<MdcEquipmentDepVo> list = this.baseMapper.getDepNamesByEquipmentIds(equipmentIds);
        Map<String, String> res = new HashMap(5);
        list.forEach(item -> res.merge(item.getEquipmentId(), item.getDepartName(), (a, b) -> a + "," + b));
        return res;
    }

    @Override
    public Map<String, String> getProNamesByEquipmentIds(List<String> equipmentIds) {
        List<MdcEquipmentProVo> list = this.baseMapper.getProNamesByEquipmentIds(equipmentIds);
        Map<String, String> res = new HashMap(5);
        list.forEach(item -> res.merge(item.getEquipmentId(), item.getProductionName(), (a, b) -> a + "," + b));
        return res;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void saveMdcEquipment(MdcEquipment mdcEquipment, String selectedDeparts, String selectedProduction) {
        //step.1 保存设备
        this.save(mdcEquipment);
        //step.2 保存所属部门
        if (oConvertUtils.isNotEmpty(selectedDeparts)) {
            String[] arr = selectedDeparts.split(",");
            for (String departId : arr) {
                MdcEquipmentDepart equipmentDepart = new MdcEquipmentDepart(mdcEquipment.getId(), departId);
                mdcEquipmentDepartMapper.insert(equipmentDepart);
            }
        }
        //step.3 保存所属产线
        if (oConvertUtils.isNotEmpty(selectedProduction)) {
            String[] arr = selectedProduction.split(",");
            for (String productionId : arr) {
                MdcProductionEquipment mdcProductionEquipment = new MdcProductionEquipment(mdcEquipment.getId(), productionId);
                mdcProductionEquipmentMapper.insert(mdcProductionEquipment);
            }
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    @CacheEvict(value = {"mdc:cache:encrypt:equipment"}, allEntries = true)
    public void editMdcEquipment(MdcEquipment mdcEquipment) {
        //step.1 修改设备基础信息
        this.updateById(mdcEquipment);
        //step.2 修改部门
        String departs = mdcEquipment.getSelectedDeparts();
        String[] arr = {};
        if (oConvertUtils.isNotEmpty(departs)) {
            arr = departs.split(",");
        }
        //先删后加
        mdcEquipmentDepartMapper.delete(new LambdaQueryWrapper<MdcEquipmentDepart>().eq(MdcEquipmentDepart::getEquipmentId, mdcEquipment.getId()));
        if (oConvertUtils.isNotEmpty(departs)) {
            for (String departId : arr) {
                MdcEquipmentDepart equipmentDepart = new MdcEquipmentDepart(mdcEquipment.getId(), departId);
                mdcEquipmentDepartMapper.insert(equipmentDepart);
            }
        }
        //step.3 修改产线
        String productions = mdcEquipment.getSelectedProduction();
        String[] array = {};
        if (oConvertUtils.isNotEmpty(productions)) {
            array = productions.split(",");
        }
        //先删后加
        mdcProductionEquipmentMapper.delete(new LambdaQueryWrapper<MdcProductionEquipment>().eq(MdcProductionEquipment::getEquipmentId, mdcEquipment.getId()));
        if (oConvertUtils.isNotEmpty(productions)) {
            for (String productionId : array) {
                MdcProductionEquipment productionEquipment = new MdcProductionEquipment(mdcEquipment.getId(), productionId);
                mdcProductionEquipmentMapper.insert(productionEquipment);
            }
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    @CacheEvict(value = {"mdc:cache:encrypt:equipment"}, allEntries = true)
    public boolean deleteById(String id) {
        // 1. 删除设备
        int line = this.baseMapper.deleteById(id);
        // 2. 删除设备部门关系
        line += mdcEquipmentDepartMapper.delete(new LambdaQueryWrapper<MdcEquipmentDepart>().eq(MdcEquipmentDepart::getEquipmentId, id));
        // 3. 删除设备产线关系
        line += mdcProductionEquipmentMapper.delete(new LambdaQueryWrapper<MdcProductionEquipment>().eq(MdcProductionEquipment::getEquipmentId, id));

        return line != 0;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    @CacheEvict(value = {"mdc:cache:encrypt:equipment"}, allEntries = true)
    public boolean deleteByIds(List<String> equipmentIds) {
        // 1. 删除设备
        int line = this.baseMapper.deleteBatchIds(equipmentIds);
        // 2. 删除设备部门关系
        line += mdcEquipmentDepartMapper.delete(new LambdaQueryWrapper<MdcEquipmentDepart>().in(MdcEquipmentDepart::getEquipmentId, equipmentIds));
        // 3. 删除设备产线关系
        line += mdcProductionEquipmentMapper.delete(new LambdaQueryWrapper<MdcProductionEquipment>().in(MdcProductionEquipment::getEquipmentId, equipmentIds));

        return line != 0;
    }

    @Override
    public IPage<MdcEquipment> pageListByDepId(Page<MdcEquipment> page, String departId, String equipmentId) {
        return this.baseMapper.pageListByDepId(page, departId, equipmentId);
    }

    @Override
    public IPage<MdcEquipment> pageListByProId(Page<MdcEquipment> page, String productionId, String equipmentId) {
        return this.baseMapper.pageListByProId(page, productionId, equipmentId);
    }

    @Override
    public void removeEquipmentForDepart(String departId, String equipmentId) {
        mdcEquipmentDepartMapper.delete(new LambdaQueryWrapper<MdcEquipmentDepart>().eq(MdcEquipmentDepart::getDepId, departId).eq(MdcEquipmentDepart::getEquipmentId, equipmentId));
    }

    @Override
    public void removeEquipmentsForDepart(String departId, List<String> equipmentIdList) {
        mdcEquipmentDepartMapper.delete(new LambdaQueryWrapper<MdcEquipmentDepart>().eq(MdcEquipmentDepart::getDepId, departId).in(MdcEquipmentDepart::getEquipmentId, equipmentIdList));
    }

    @Override
    public void removeEquipmentForProduction(String productionId, String equipmentId) {
        mdcProductionEquipmentMapper.delete(new LambdaQueryWrapper<MdcProductionEquipment>().eq(MdcProductionEquipment::getProductionId, productionId).eq(MdcProductionEquipment::getEquipmentId, equipmentId));
    }

    @Override
    public void removeEquipmentsForProduction(String productionId, List<String> equipmentIdList) {
        mdcProductionEquipmentMapper.delete(new LambdaQueryWrapper<MdcProductionEquipment>().eq(MdcProductionEquipment::getProductionId, productionId).in(MdcProductionEquipment::getEquipmentId, equipmentIdList));
    }

    @Override
    public List<MdcEquipmentTree> loadTreeListByDepart(String userId) {
        //获取所有部门数据
        List<SysDepart> departList = sysDepartService.list(new LambdaQueryWrapper<SysDepart>().eq(SysDepart::getDelFlag, CommonConstant.DEL_FLAG_0.toString()).orderByAsc(SysDepart::getDepartOrder));
        //根据用户ID获取拥有的部门id集合
        List<String> departIds = sysUserDepartService.queryDepartIdsByUserId(userId);
        List<String> allDepartIds = new ArrayList<>();
        //找到所有部门id的上级id
        if (departIds != null && !departIds.isEmpty()) {
            for (String departId : departIds) {
                this.getAllDepartIds(departList, departId, allDepartIds);
            }
        }
        //过滤部门数据
        List<SysDepart> list = departList.stream().filter((SysDepart sysDepart) -> allDepartIds.contains(sysDepart.getId())).collect(Collectors.toList());
        //组装部门设备树
        List<MdcEquipmentTree> treeList = FindsEquipmentDepartUtil.wrapEquipmentDepartTreeList(list);
        //填充设备数据
        FillEquipmentByDepart(treeList);
        return treeList;
    }

    /**
     * 部门设备树填充设备数据
     *
     * @param treeList
     */
    private void FillEquipmentByDepart(List<MdcEquipmentTree> treeList) {
        for (MdcEquipmentTree mdcEquipmentTree : treeList) {
            List<MdcEquipment> equipmentList = this.baseMapper.queryByDepartId(mdcEquipmentTree.getKey());
            if (equipmentList != null && !equipmentList.isEmpty()) {
                for (MdcEquipment mdcEquipment : equipmentList) {
                    MdcEquipmentTree tree = new MdcEquipmentTree().convert(mdcEquipment);
                    tree.setParentId(mdcEquipmentTree.getKey());
                    mdcEquipmentTree.getChildren().add(tree);
                }
                mdcEquipmentTree.setLeaf(false);
            }
            if (!mdcEquipmentTree.getChildren().isEmpty()) {
                FillEquipmentByDepart(mdcEquipmentTree.getChildren());
            }
        }
    }

    /**
     * 获取所有的部门id（包含所有上级）
     */
    private void getAllDepartIds(List<SysDepart> departList, String departId, List<String> allDepartIds) {
        if (!allDepartIds.contains(departId)) {
            allDepartIds.add(departId);
        }
        for (SysDepart sysDepart : departList) {
            if (StringUtils.isEmpty(sysDepart.getParentId())) {
                continue;
            }
            if (departId.equals(sysDepart.getId())) {
                if (!allDepartIds.contains(sysDepart.getParentId())) {
                    allDepartIds.add(sysDepart.getParentId());
                    getAllDepartIds(departList, sysDepart.getParentId(), allDepartIds);
                }
            }
        }
    }


    @Override
    public List<MdcEquipmentTree> loadTreeListByProduction(String userId) {
        //获取所有产线数据
        List<MdcProduction> productionList = mdcProductionService.list(new LambdaQueryWrapper<MdcProduction>().eq(MdcProduction::getDelFlag, CommonConstant.DEL_FLAG_0.toString()).orderByAsc(MdcProduction::getProductionOrder));
        //根据用户id获取拥有的产线信息集合
        List<String> productionIds = mdcUserProductionService.queryProductionIdsByUserId(userId);
        List<String> allProductionIds = new ArrayList<>();
        //找到所有产线id的上级id
        if (productionIds != null && !productionIds.isEmpty()) {
            for (String productionId : productionIds) {
                this.getAllProductionIds(productionList, productionId, allProductionIds);
            }
        }
        //过滤产线数据
        List<MdcProduction> list = productionList.stream().filter((MdcProduction mdcProduction) -> allProductionIds.contains(mdcProduction.getId())).collect(Collectors.toList());
        //组装产线设备树
        List<MdcEquipmentTree> treeList = FindsEquipmentProductionUtil.wrapEquipmentProductionTreeList(list);
        //填充设备数据
        FillEquipmentByProduction(treeList);
        return treeList;
    }

    /**
     * 设备监控列表
     */
    @Override
    public List<MdcEquipmentMonitor> queryEquipmentMonitorList(String userId, String key) {
        List<String> equipmentIds = this.getEquipmentIdsProduction(userId, key);
        if (equipmentIds == null || equipmentIds.isEmpty()) {
            return Collections.emptyList();
        }
        List<MdcEquipmentMonitor> result = this.baseMapper.checkStatusFromEquipmentIds(equipmentIds);
        if (result != null && !result.isEmpty()) {
            for (MdcEquipmentMonitor mdcEquipmentMonitor : result) {
                if (mdcEquipmentMonitor.getOporation() != null) {
                    switch (mdcEquipmentMonitor.getOporation()) {
                        case 1:
                        case 2:
                            mdcEquipmentMonitor.setOporationDict("待机");
                            break;
                        case 3:
                            mdcEquipmentMonitor.setOporationDict("运行");
                            break;
                        case 22:
                            mdcEquipmentMonitor.setOporationDict("报警");
                            break;
                        default:
                            mdcEquipmentMonitor.setOporationDict("关机");
                            break;
                    }
                } else {
                    mdcEquipmentMonitor.setOporationDict("关机");
                    mdcEquipmentMonitor.setOporation(0);
                }
            }
        }
        return result;
    }

    /**
     * 设备监控 - 设备详细信息
     */
    @Override
    public MdcEquipmentDto mdcEquipmentDetailedInfo(String id) {
        MdcEquipmentDto mdcEquipmentDto = new MdcEquipmentDto();
        MdcEquipment mdcEquipment = this.baseMapper.selectById(id);
        //封装基础信息
        mdcEquipmentDto.setSystemVersion(mdcEquipment.getSystemVersion());
        mdcEquipmentDto.setSystemType(mdcEquipment.getControlSystem());
        mdcEquipmentDto.setDevicePower(mdcEquipment.getDevicePower());
        mdcEquipmentDto.setDeviceType(mdcEquipment.getDriveType());
        mdcEquipmentDto.setRemark(mdcEquipment.getRemark());
        mdcEquipmentDto.setEquipmentID(mdcEquipment.getEquipmentId());//设备编号
        mdcEquipmentDto.setEquipmentName(mdcEquipment.getEquipmentName());
        mdcEquipmentDto.setEquipmentIP(mdcEquipment.getEquipmentIp());
        mdcEquipmentDto.setEquipmentModel(mdcEquipment.getEquipmentModel());//设备型号
        mdcEquipmentDto.setDriveType(mdcEquipment.getDriveType());
        mdcEquipmentDto.setDataPort(mdcEquipment.getDataPort());
        mdcEquipmentDto.setDataFlag(Integer.parseInt(CommonConstant.STATUS_1));
        ControlSystem controlSystem = controlSystemService.getByDriveType(mdcEquipmentDto.getDriveType());
        if (controlSystem != null) {
            //获取工作数据并初始化
            String saveTableName = mdcEquipment.getSaveTableName();
            MdcEquipmentDto dto = equipmentWorkLineService.getMacingDataList(saveTableName);
            if (dto != null) {
                mdcEquipmentDto.setCollectTime(dto.getCollectTime());
                mdcEquipmentDto.setSpindlespeed(dto.getSpindlespeed());
                mdcEquipmentDto.setSpindleload(dto.getSpindleload());
                mdcEquipmentDto.setSpindlebeilv(dto.getSpindlebeilv());
                mdcEquipmentDto.setFeedrate(dto.getFeedrate());
                mdcEquipmentDto.setFeedbeilv(dto.getFeedbeilv());
                mdcEquipmentDto.setProgramnumber(dto.getProgramnumber());
                mdcEquipmentDto.setSequencenumber(dto.getSequencenumber());
                mdcEquipmentDto.setExecutingcode(dto.getExecutingcode());
                mdcEquipmentDto.setProductName(dto.getProductName());

                //获取 MDC 驱动对应的展示参数   并根据key 拼装从 workData  查询的数据
                List<MdcDriveTypeParamConfig> mdcDriveTypeParamList = mdcDriveTypeParamConfigService.getShowDriveParam(mdcEquipment.getDriveType());
                if (mdcDriveTypeParamList != null && !mdcDriveTypeParamList.isEmpty()) {
                    for (MdcDriveTypeParamConfig mdcDriveTypeParamConfig : mdcDriveTypeParamList) {
                        String englishName = mdcDriveTypeParamConfig.getEnglishName();
                        JSONObject jsonObject = (JSONObject) JSONObject.toJSON(dto);
                        Object result = jsonObject.get(englishName);
                        String value = "";
                        if ("CollectTime".equals(englishName)) {
                            Date date = result == null ? null : (Date) result;
                            value = DateUtils.format(date, DateUtils.STR_DATE_TIME_SMALL);
                        } else {
                            value = result == null ? null : result.toString();
                        }
                        mdcDriveTypeParamConfig.setValue(value);
                    }
                    mdcEquipmentDto.setMdcDriveTypeParamConfigList(mdcDriveTypeParamList);
                }
            }
//            // 设备坐标数 获取设备需要采集的坐标信息
//            List<XYZAliases> equipmentCoordinateList = xyzAliasesMapper.getCoordinateByEquipmentId(mdcEquipment.getEquipmentId());
//            // 设备采集的坐标信息
//            EquipmentXYZ equipmentXYZ = equipmentXYZService.getByEquipmentId(mdcEquipment.getEquipmentId());
//            JSONObject jsonEquipmentXYZ = (JSONObject) JSONObject.toJSON(equipmentXYZ);
//            if (equipmentCoordinateList != null && !equipmentCoordinateList.isEmpty()) {
//                for (XYZAliases xyzAliases : equipmentCoordinateList) {
//                    String englishName = xyzAliases.getXYZFieldName().toLowerCase();
//                    englishName = englishName.substring(0, 1) + "_" + englishName.substring(1, englishName.length());
//                    englishName = CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, englishName);
//                    Object orgValue = jsonEquipmentXYZ.get(englishName);
//                    String value = orgValue != null ? orgValue.toString() : null;
//                    //  坐标数据的title 来自 xyzAliases 表, 根据 是否包含 absolute 和  machine  判断是绝对坐标还是机床坐标
//                    String title = englishName.substring(0, 1).toUpperCase();
//                    title = englishName.contains("absolute") ? "绝对坐标" + title : "机床坐标" + title;
//                    xyzAliases.setTitle(title);
//                    xyzAliases.setValue(value);
//                }
//                mdcEquipmentDto.setXyzAliasesList(equipmentCoordinateList);
//            }

//            if (equipmentXYZ != null) {
//                mdcEquipmentDto.setXmachine(equipmentXYZ.getXMachine());
//                mdcEquipmentDto.setYmachine(equipmentXYZ.getYMachine());
//                mdcEquipmentDto.setZmachine(equipmentXYZ.getZMachine());
//                mdcEquipmentDto.setAmachine(equipmentXYZ.getAMachine());
//                mdcEquipmentDto.setBmachine(equipmentXYZ.getBMachine());
//                mdcEquipmentDto.setXabsolute(equipmentXYZ.getXAbsolute());
//                mdcEquipmentDto.setYabsolute(equipmentXYZ.getYAbsolute());
//                mdcEquipmentDto.setZabsolute(equipmentXYZ.getZAbsolute());
//                mdcEquipmentDto.setAabsolute(equipmentXYZ.getAAbsolute());
//                mdcEquipmentDto.setBabsolute(equipmentXYZ.getBAbsolute());
//            }
//            EquipmentBaseInfo equipmentBaseInfo = equipmentBaseInfoService.getByEquipmentId(mdcEquipment.getEquipmentId());
//            if (equipmentBaseInfo != null) {
//                mdcEquipmentDto.setMaxAxis(equipmentBaseInfo.getMaxAxis());
//                mdcEquipmentDto.setValidAxis(equipmentBaseInfo.getValidAxis());
//            }
//            if (controlSystem.getDriveType().equals("SIEMENS840DSL")) {
//                EquipmentTemperatureDto equipmentTemperature = equipmentTemperatureService.getEquipmentTemperature(mdcEquipment.getEquipmentId());
//                if (equipmentTemperature != null) {
//                    mdcEquipmentDto.setTemperatureX(equipmentTemperature.getX());
//                    mdcEquipmentDto.setTemperatureY(equipmentTemperature.getY());
//                    mdcEquipmentDto.setTemperatureZ(equipmentTemperature.getZ());
//                    mdcEquipmentDto.setTemperatureA(equipmentTemperature.getA());
//                    mdcEquipmentDto.setTemperatureB(equipmentTemperature.getB());
//                }
//                EquipmentTemperatureDto equipmentLagError = equipmentTemperatureService.getEquipmentLagError(mdcEquipment.getEquipmentId());
//                if (equipmentLagError != null) {
//                    mdcEquipmentDto.setEquipmentLagErrorX(equipmentLagError.getX());
//                    mdcEquipmentDto.setEquipmentLagErrorY(equipmentLagError.getY());
//                    mdcEquipmentDto.setEquipmentLagErrorZ(equipmentLagError.getZ());
//                    mdcEquipmentDto.setEquipmentLagErrorA(equipmentLagError.getA());
//                    mdcEquipmentDto.setEquipmentLagErrorB(equipmentLagError.getB());
//                }
//            }
//            EquipmentTemperatureDto equipmentCurrent = equipmentTemperatureService.getEquipmentCurrent(mdcEquipment.getEquipmentId());
//            if (equipmentCurrent != null) {
//                mdcEquipmentDto.setEquipmentCurrentX(equipmentCurrent.getX());
//                mdcEquipmentDto.setEquipmentCurrentY(equipmentCurrent.getY());
//                mdcEquipmentDto.setEquipmentCurrentZ(equipmentCurrent.getZ());
//                mdcEquipmentDto.setEquipmentCurrentA(equipmentCurrent.getA());
//                mdcEquipmentDto.setEquipmentCurrentB(equipmentCurrent.getB());
//            }
        }
        return mdcEquipmentDto;
    }

    /**
     * 通过用户部门关系获取设备id集合
     */
    @Override
    public List<String> getEquipmentIdsByDepart(String userId, String key) {
        //获取所有部门数据
        List<SysDepart> departList = sysDepartService.list(new LambdaQueryWrapper<SysDepart>().eq(SysDepart::getDelFlag, CommonConstant.DEL_FLAG_0.toString()).orderByAsc(SysDepart::getDepartOrder));
        //根据用户id获取拥有的部门信息集合
        List<String> departIds = sysUserDepartService.queryDepartIdsByUserId(userId);
        List<String> allDepartIds = new ArrayList<>();
        if (departIds != null && !departIds.isEmpty()) {
            for (String departId : departIds) {
                this.getAllDepartIds(departList, departId, allDepartIds);
            }
        }
        //根据产线集合查找所有设备id
        if (allDepartIds.isEmpty()) {
            return null;
        }
        List<String> equipmentIds = this.baseMapper.queryIdsByDeparts(allDepartIds);
        if (StringUtils.isNotEmpty(key)) {
            //key不为空，查询所有下级部门id
            List<String> partDepart = this.findAllDeparts(key);
            partDepart.add(key);
            //过滤无权限部门id
            List<String> allDepartIdsByKey = partDepart.stream().filter(allDepartIds::contains).collect(Collectors.toList());
            equipmentIds = this.baseMapper.queryIdsByDeparts(allDepartIdsByKey);
        }
        return equipmentIds;
    }

    /**
     * 根据父级id递归查询所有下级id集合
     */
    private List<String> findAllDeparts(String key) {
        List<String> departs = new ArrayList<>();
        List<SysDepart> sysDeparts = sysDepartService.queryDeptByPid(key);
        if (sysDeparts != null && !sysDeparts.isEmpty()) {
            List<String> ids = sysDeparts.stream().map(SysDepart::getId).collect(Collectors.toList());
            departs.addAll(ids);
            for (SysDepart sysDepart : sysDeparts) {
                List<String> allDeparts = findAllDeparts(sysDepart.getId());
                departs.addAll(allDeparts);
            }
        }
        return departs;
    }

    /**
     * 通过用户产线关系获取设备id集合
     */
    @Override
    public List<String> getEquipmentIdsProduction(String userId, String key) {
        //获取所有产线数据
        List<MdcProduction> productionList = mdcProductionService.list(new LambdaQueryWrapper<MdcProduction>().eq(MdcProduction::getDelFlag, CommonConstant.DEL_FLAG_0.toString()).orderByAsc(MdcProduction::getProductionOrder));
        //根据用户id获取拥有的产线信息集合
        List<String> productionIds = mdcUserProductionService.queryProductionIdsByUserId(userId);
        List<String> allProductionIds = new ArrayList<>();
        //找到所有产线id的上级id
        if (productionIds != null && !productionIds.isEmpty()) {
            for (String productionId : productionIds) {
                this.getAllProductionIds(productionList, productionId, allProductionIds);
            }
        }
        //根据产线集合查找所有设备id
        if (allProductionIds.isEmpty()) {
            return null;
        }
        List<String> equipmentIds = this.baseMapper.queryIdsByProductions(allProductionIds);
        if (StringUtils.isNotEmpty(key)) {
            //key不为空，查询所有下级产线id
            List<String> partProduction = this.findAllProductions(key);
            partProduction.add(key);
            //过滤无权限产线id
            List<String> allProductionIdsByKey = partProduction.stream().filter(allProductionIds::contains).collect(Collectors.toList());
            equipmentIds = this.baseMapper.queryIdsByProductions(allProductionIdsByKey);
        }
        return equipmentIds;
    }

    /**
     * 根据设备id查询设备名称
     */
    @Override
    public MdcEquipment findEquipmentNameByEquipmentId(String equipmentId) {
        return this.getOne(new LambdaQueryWrapper<MdcEquipment>().eq(MdcEquipment::getEquipmentId, equipmentId));
    }

    /**
     * 选择设备分页列表
     */
    @Override
    public IPage<MdcEquipment> findEquipmentList(Page<MdcEquipment> page, String userId, MdcEquipmentVo mdcEquipment) {
        List<String> equipmentIdsByDepart = new ArrayList<>();
        if (StringUtils.isNotEmpty(mdcEquipment.getDepartId())) {
            equipmentIdsByDepart = getEquipmentIdsByDepart(userId, mdcEquipment.getDepartId());
        }
        List<String> equipmentIdsProduction = new ArrayList<>();
        if (StringUtils.isNotEmpty(mdcEquipment.getProductionId())) {
            equipmentIdsProduction = getEquipmentIdsProduction(userId, mdcEquipment.getProductionId());
        }
        List<String> allEquipments = new ArrayList<>();
        if (StringUtils.isEmpty(mdcEquipment.getDepartId()) && StringUtils.isEmpty(mdcEquipment.getProductionId())) {
            List<String> idsByDepart = getEquipmentIdsByDepart(userId, null);
            List<String> idsProduction = getEquipmentIdsProduction(userId, null);
            // 去重并集
            allEquipments = Stream.of(idsByDepart, idsProduction).flatMap(Collection::stream).distinct().collect(Collectors.toList());
        }
        if (StringUtils.isNotEmpty(mdcEquipment.getDepartId()) && StringUtils.isNotEmpty(mdcEquipment.getProductionId())) {
            // 交集
            allEquipments = equipmentIdsByDepart.stream().filter(equipmentIdsProduction::contains).collect(Collectors.toList());
        }
        LambdaQueryWrapper<MdcEquipment> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.isNotNull(MdcEquipment::getEquipmentId);
        if (StringUtils.isNotEmpty(mdcEquipment.getEquipmentId())) {
            queryWrapper.like(MdcEquipment::getEquipmentId, mdcEquipment.getEquipmentId());
        }
        if (StringUtils.isNotEmpty(mdcEquipment.getEquipmentName())) {
            queryWrapper.like(MdcEquipment::getEquipmentName, mdcEquipment.getEquipmentName());
        }
        if (!allEquipments.isEmpty()) {
            queryWrapper.in(MdcEquipment::getEquipmentId, allEquipments);
        } else if (!equipmentIdsByDepart.isEmpty() && equipmentIdsProduction.isEmpty()) {
            queryWrapper.in(MdcEquipment::getEquipmentId, equipmentIdsByDepart);
        } else if (equipmentIdsByDepart.isEmpty() && !equipmentIdsProduction.isEmpty()) {
            queryWrapper.in(MdcEquipment::getEquipmentId, equipmentIdsProduction);
        }
        queryWrapper.orderByAsc(MdcEquipment::getEquipmentName);
        return this.baseMapper.selectPage(page, queryWrapper);
    }

    /**
     * 根据父级id递归查询所有下级id集合
     */
    private List<String> findAllProductions(String key) {
        List<String> productions = new ArrayList<>();
        List<MdcProduction> mdcProductions = mdcProductionService.queryProdByPid(key);
        if (mdcProductions != null && !mdcProductions.isEmpty()) {
            List<String> ids = mdcProductions.stream().map(MdcProduction::getId).collect(Collectors.toList());
            productions.addAll(ids);
            for (MdcProduction mdcProduction : mdcProductions) {
                List<String> allProductions = findAllProductions(mdcProduction.getId());
                productions.addAll(allProductions);
            }
        }
        return productions;
    }

    /**
     * 产线设备树填充设备数据
     */
    private void FillEquipmentByProduction(List<MdcEquipmentTree> treeList) {
        for (MdcEquipmentTree mdcEquipmentTree : treeList) {
            List<MdcEquipment> equipmentList = this.baseMapper.queryByProductionId(mdcEquipmentTree.getKey());
            if (equipmentList != null && !equipmentList.isEmpty()) {
                for (MdcEquipment mdcEquipment : equipmentList) {
                    MdcEquipmentTree tree = new MdcEquipmentTree().convert(mdcEquipment);
                    tree.setParentId(mdcEquipmentTree.getKey());
                    mdcEquipmentTree.getChildren().add(tree);
                }
                mdcEquipmentTree.setLeaf(false);
            }
            if (!mdcEquipmentTree.getChildren().isEmpty()) {
                FillEquipmentByProduction(mdcEquipmentTree.getChildren());
            }
        }
    }

    /**
     * 获取所有的产线id（包含所有上级）
     */
    private void getAllProductionIds(List<MdcProduction> productionList, String productionId, List<String> allProductionIds) {
        if (!allProductionIds.contains(productionId)) {
            allProductionIds.add(productionId);
        }
        for (MdcProduction mdcProduction : productionList) {
            if (StringUtils.isEmpty(mdcProduction.getParentId())) {
                continue;
            }
            if (productionId.equals(mdcProduction.getId())) {
                if (!allProductionIds.contains(mdcProduction.getParentId())) {
                    allProductionIds.add(mdcProduction.getParentId());
                    getAllProductionIds(productionList, mdcProduction.getParentId(), allProductionIds);
                }
            }
        }
    }

    /**
     * 根据产线层级查询设备单个
     */
    @Override
    public MdcEquipment getEquipmentByPid(String pid, String userId) {
        List<String> idsProduction = this.getEquipmentIdsProduction(userId, pid);
        if (idsProduction != null && !idsProduction.isEmpty()) {
            return super.getOne(new LambdaQueryWrapper<MdcEquipment>().eq(MdcEquipment::getEquipmentId, idsProduction.get(0)));
        }
        return null;
    }

    /**
     * 根据设备编号查询设备信息和部门信息
     *
     * @param equipmentIdList
     * @return
     */
    @Override
    public List<MdcEquDepDto> findEquDepList(List<String> equipmentIdList) {
        return this.baseMapper.findEquDepList(equipmentIdList);
    }

    /**
     * 根据设备编号查询设备信息和产线信息
     *
     * @param equipmentIdList
     * @return
     */
    @Override
    public List<MdcEquProDto> findEquProList(List<String> equipmentIdList) {
        return this.baseMapper.findEquProList(equipmentIdList);
    }

    /**
     * 根据部门层级查询设备单个
     */
    @Override
    public MdcEquipment getEquipmentByDepPid(String pid, String userId) {
        List<String> idsByDepart = this.getEquipmentIdsByDepart(userId, pid);
        if (idsByDepart != null && !idsByDepart.isEmpty()) {
            return super.getOne(new LambdaQueryWrapper<MdcEquipment>().eq(MdcEquipment::getEquipmentId, idsByDepart.get(0)));
        }
        return null;
    }

}