package org.dromara.ems.record.service.impl;

import cn.hutool.http.HttpStatus;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.common.core.exception.ServiceException;
import org.springframework.beans.BeanUtils;
import org.dromara.ems.base.domain.EmsBaseMonitorInfo;
import org.dromara.ems.base.mapper.EmsBaseMonitorInfoMapper;
import org.dromara.ems.record.domain.RecordIotenvInstant;
import org.dromara.ems.record.mapper.RecordIotenvInstantMapper;
import org.dromara.ems.record.service.IRecordIotenvInstantService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * 物联网数据Service业务层处理
 * 
 * @author zch
 * @date 2025-04-28
 */
@Service
@RequiredArgsConstructor
public class RecordIotenvInstantServiceImpl implements IRecordIotenvInstantService
{
    
    private final RecordIotenvInstantMapper recordIotenvInstantMapper;

    
    private final EmsBaseMonitorInfoMapper emsBaseMonitorInfoMapper;

    /** 表名格式校验正则表达式（record_iotenv_instant_yyyyMMdd） */
    private static final Pattern TABLE_NAME_PATTERN = Pattern.compile("^record_iotenv_instant_\\d{8}$");

    /**
     * 查询物联网数据
     * 
     * @param objid 物联网数据主键
     * @return 物联网数据
     */
    @Override
    public RecordIotenvInstant selectRecordIotenvInstantByObjid(Long objid)
    {
        return recordIotenvInstantMapper.selectRecordIotenvInstantByObjid(objid);
    }

    /**
     * 查询物联网数据列表
     *
     * @param recordIotenvInstant 物联网数据
     * @return 物联网数据
     */
    @Override
    public List<RecordIotenvInstant> selectRecordIotenvInstantList(RecordIotenvInstant recordIotenvInstant) throws ParseException {
            Map<String, Object> params = recordIotenvInstant.getParams();
            // 检查是否有时间范围参数
                // 获取开始和结束时间
                String beginTimeStr = params.get("beginRecordTime").toString();
                String endTimeStr = params.get("endRecordTime").toString();
                // 解析日期
                SimpleDateFormat fullFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                Date beginDate = fullFormat.parse(beginTimeStr);
                Date endDate = fullFormat.parse(endTimeStr);

                // 获取需要查询的表名列表
                List<String> tableNames = getTableNamesByDateRange(beginDate, endDate);
                if (tableNames.isEmpty()) {
                    return new ArrayList<>();
                }
                
                // 检查是否需要采样
                if (recordIotenvInstant.getSamplingInterval() != null && recordIotenvInstant.getSamplingInterval() > 1) {
                    // 使用采样查询
                    return recordIotenvInstantMapper.selectRecordIotenvInstantListFromTablesWithSampling(tableNames, recordIotenvInstant);
                } else {
                    // 使用普通查询
                    return recordIotenvInstantMapper.selectRecordIotenvInstantListFromTables(tableNames, recordIotenvInstant);
                }
    }

    /**
     * 新增物联网数据
     * 
     * @param recordIotenvInstant 物联网数据
     * @return 结果
     */
    @Override
    public int insertRecordIotenvInstant(RecordIotenvInstant recordIotenvInstant)
    {
        return recordIotenvInstantMapper.insertRecordIotenvInstant(recordIotenvInstant);
    }

    /**
     * 修改物联网数据
     * 
     * @param recordIotenvInstant 物联网数据
     * @return 结果
     */
    @Override
    public int updateRecordIotenvInstant(RecordIotenvInstant recordIotenvInstant)
    {
        return recordIotenvInstantMapper.updateRecordIotenvInstant(recordIotenvInstant);
    }

    /**
     * 批量删除物联网数据
     * 
     * @param objids 需要删除的物联网数据主键
     * @return 结果
     */
    @Override
    public int deleteRecordIotenvInstantByObjids(Long[] objids)
    {
        return recordIotenvInstantMapper.deleteRecordIotenvInstantByObjids(objids);
    }

    /**
     * 删除物联网数据信息
     * 
     * @param objid 物联网数据主键
     * @return 结果
     */
    @Override
    public int deleteRecordIotenvInstantByObjid(Long objid)
    {
        return recordIotenvInstantMapper.deleteRecordIotenvInstantByObjid(objid);
    }


    /**
     * 根据日期范围获取需要查询的表名列表
     *
     * @param beginDate 开始日期
     * @param endDate 结束日期
     * @return 表名列表
     */
    private List<String> getTableNamesByDateRange(Date beginDate, Date endDate) throws ParseException {
        List<String> tableNames = new ArrayList<>();
        // 如果开始日期晚于结束日期，则返回空列表
        if (beginDate.after(endDate)) {
            return tableNames;
        }
        // 设置日期格式
        SimpleDateFormat tableFormat = new SimpleDateFormat("yyyyMMdd");
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
            // 获取开始日期和结束日期（不含时间部分）
            String beginDateStr = dateFormat.format(beginDate);
            String endDateStr = dateFormat.format(endDate);

            Date currentDate = dateFormat.parse(beginDateStr);
            Date endDateOnly = dateFormat.parse(endDateStr);
            // 循环添加每一天对应的表名
            Calendar calendar = Calendar.getInstance();
            while (!currentDate.after(endDateOnly)) {
                String tableSuffix = tableFormat.format(currentDate);
                String tableName = "record_iotenv_instant_" + tableSuffix;

                // 添加表名格式校验，防止SQL注入
                if (!TABLE_NAME_PATTERN.matcher(tableName).matches()) {
                    throw new ServiceException("非法的表名格式: " + tableName);
                }

                if (isTableExists(tableName)){
                    tableNames.add(tableName);
                }
                // 日期加1天
                calendar.setTime(currentDate);
                calendar.add(Calendar.DAY_OF_MONTH, 1);
                currentDate = calendar.getTime();
            }

        return tableNames;
    }


    /**
     * 分页查询物联网数据列表
     *
     * @param recordIotenvInstant 物联网数据
     * @return 物联网数据
     */
    @Override
    public TableDataInfo selectRecordIotenvInstantListWithPage(RecordIotenvInstant recordIotenvInstant, int pageNum, int pageSize) throws ParseException {

        Map<String, Object> params = recordIotenvInstant.getParams();
        // 检查是否有时间范围参数
        // 获取开始和结束时间
        String beginTimeStr = params.get("beginRecordTime").toString();
        String endTimeStr = params.get("endRecordTime").toString();
        // 解析日期
        SimpleDateFormat fullFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date beginDate = fullFormat.parse(beginTimeStr);
        Date endDate = fullFormat.parse(endTimeStr);

        // 获取需要查询的表名列表
        List<String> tableNames = getTableNamesByDateRange(beginDate, endDate);
        // 如果没有需要查询的表，则返回空结果
        if (tableNames.isEmpty()) {
            TableDataInfo rspData = new TableDataInfo();
            rspData.setCode(0);
            rspData.setRows(new ArrayList<>());
            rspData.setTotal(0);
            return rspData;
        }

        // 先查询总记录数
        int total = recordIotenvInstantMapper.countFromTables(tableNames, recordIotenvInstant);
        // 计算分页偏移量
        int offset = (pageNum - 1) * pageSize;
        // 执行分页查询
        List<RecordIotenvInstant> list = recordIotenvInstantMapper.selectFromTablesWithPage(tableNames, recordIotenvInstant, offset, pageSize);
            //获取设备列表，根据monitorId查询设备名称
//        EmsBaseMonitorInfo baseMonitorInfo = new EmsBaseMonitorInfo();
//        List<EmsBaseMonitorInfo> baseMonitorInfruoyi = emsBaseMonitorInfoMapper.selectEmsBaseMonitorInfoList(baseMonitorInfo);
//        // 将baseMonitorInfruoyi中的monitorName字段添加到list中
//        for (RecordIotenvInstant iotenvInstant : list) {
//            for (EmsBaseMonitorInfo monitorInfo : baseMonitorInfruoyi) {
//                if (iotenvInstant.getMonitorId().equals(monitorInfo.getMonitorCode())){
//                    iotenvInstant.setMonitorName(monitorInfo.getMonitorName());
//                }
//            }
//        }
        

        TableDataInfo rspData = new TableDataInfo();
        rspData.setCode(HttpStatus.HTTP_OK);
        rspData.setMsg("查询成功");
        rspData.setRows(list);
        rspData.setTotal(total);
        return rspData;
    }


    /**
     * 验证表是否存在
     *
     * @param tableName 表名
     * @return 是否存在
     */
    private boolean isTableExists(String tableName) {
        // 查询数据库中是否存在该表
        Map<String, Object> params = new HashMap<>();
        params.put("tableName", tableName);
        Integer count = recordIotenvInstantMapper.checkTableExists(params);
        return count != null && count > 0;
    }



    /**
     * 多线程并行查询多个设备的数据
     * @param tableNames 表名列表
     * @param recordIotenvInstant 查询参数
     * @param monitorIds 设备ID数组
     * @return 合并后的查询结果
     */
    private List<RecordIotenvInstant> selectMultipleMonitorData(List<String> tableNames, RecordIotenvInstant recordIotenvInstant,String[] monitorIds) {
            // 创建线程池
            int threadCount = Math.min(monitorIds.length,20);
            ExecutorService executorService = Executors.newFixedThreadPool(threadCount);

            //创建任务列表
            List<Future<List<RecordIotenvInstant>>> futures = new ArrayList<>();

            // 为每个设备创建查询任务
            for(String monitorId : monitorIds){
                Future<List<RecordIotenvInstant>> future
                 = executorService.submit(() -> {
                     // 创建新的查询对象，避免并发修改
                    RecordIotenvInstant query = new RecordIotenvInstant();
                    BeanUtils.copyProperties(recordIotenvInstant, query);
                    query.setMonitorId(monitorId);
                    query.setMonitorIds(null); // 清空数组，使用单个ID查询

                    // 执行查询
                    return recordIotenvInstantMapper
                    .selectRecordIotenvInstantListFromTables(tableNames, query);
                    });
                    futures.add(future);
                 }

                 // 收集所有查询结果
                 List<RecordIotenvInstant> result = new ArrayList<>();
                 for (Future<List<RecordIotenvInstant>> future : futures) {
                     try {
                         List<RecordIotenvInstant> partialResult = future.get();
                         if (partialResult != null && !partialResult.isEmpty()) {
                             result.addAll(partialResult);
                         }
                     } catch (Exception e) {
                         // 记录异常但继续处理其他结果
                         e.printStackTrace();
                     }
                 }
                     // 关闭线程池
                    executorService.shutdown();

                    return result;
    }

    @Override
    public List<RecordIotenvInstant> selectRecordList(RecordIotenvInstant recordIotenvInstant)
    {
        List<RecordIotenvInstant> result = new ArrayList<>();
        
        // 获取当天日期对应的分表名
        String todayTableName = getTodayTableName();
        
        // 检查当天分表是否存在
        boolean tableExists = isTableExists(todayTableName);
        
        // 获取所有设备信息
        List<EmsBaseMonitorInfo> baseMonitorInfruoyi = emsBaseMonitorInfoMapper.selectEmsBaseMonitorInfoList(new EmsBaseMonitorInfo());
        //获取所有能源类型

        if (tableExists) {
            // 如果分表存在，批量查询所有设备的最新数据
            List<String> monitorCodes = new ArrayList<>();
            for (EmsBaseMonitorInfo baseMonitorInfo : baseMonitorInfruoyi) {
                monitorCodes.add(baseMonitorInfo.getMonitorCode());
            }
            
            // 批量查询最新记录
            List<RecordIotenvInstant> latestRecords = recordIotenvInstantMapper
                .selectLatestRecordsByMonitorIdsFromTable(todayTableName, monitorCodes);
            
            // 创建设备编号到最新记录的映射
            Map<String, RecordIotenvInstant> recordMap = new HashMap<>();
            for (RecordIotenvInstant record : latestRecords) {
                recordMap.put(record.getMonitorId(), record);
            }
            
            // 遍历所有设备，构建返回结果
            for (EmsBaseMonitorInfo baseMonitorInfo : baseMonitorInfruoyi) {
                String monitorCode = baseMonitorInfo.getMonitorCode();
                String monitorName = baseMonitorInfo.getMonitorName();
                Long monitorType = baseMonitorInfo.getMonitorType();
                String energyName = baseMonitorInfo.getEnergyName();
                
                RecordIotenvInstant iotenvInstant = recordMap.get(monitorCode);
                if (iotenvInstant == null) {
                    // 如果没有找到记录，创建一个空记录
                    iotenvInstant = new RecordIotenvInstant();
                    iotenvInstant.setMonitorId(monitorCode);
                }
                
                // 设置设备基本信息
                iotenvInstant.setMonitorName(monitorName);
                iotenvInstant.setMonitorCode(monitorCode);
                iotenvInstant.setEnergyName(energyName);
                iotenvInstant.setMonitorType(monitorType);
                
                result.add(iotenvInstant);
            }
        } else {
            // 如果分表不存在，返回所有设备的空记录
            for (EmsBaseMonitorInfo baseMonitorInfo : baseMonitorInfruoyi) {
                RecordIotenvInstant iotenvInstant = new RecordIotenvInstant();
                iotenvInstant.setMonitorId(baseMonitorInfo.getMonitorCode());
                iotenvInstant.setMonitorName(baseMonitorInfo.getMonitorName());
                iotenvInstant.setMonitorCode(baseMonitorInfo.getMonitorCode());
                iotenvInstant.setEnergyName(baseMonitorInfo.getEnergyName());
                iotenvInstant.setMonitorType(baseMonitorInfo.getMonitorType());
                // 数据值字段保持null，前端会显示"无最新数据"
                result.add(iotenvInstant);
            }
        }

        return result;
    }

    /**
     * 根据父节点ID查询子设备的最新数据
     * 
     * @param parentId 父节点ID
     * @return 子设备最新数据列表
     */
    @Override
    public List<RecordIotenvInstant> selectRecordListByParentId(Long parentId)
    {
        List<RecordIotenvInstant> result = new ArrayList<>();
        
        // 获取当天日期对应的分表名
        String todayTableName = getTodayTableName();
        
        // 检查当天分表是否存在
        boolean tableExists = isTableExists(todayTableName);
        
        // 根据父节点ID查询子设备信息
        EmsBaseMonitorInfo queryParam = new EmsBaseMonitorInfo();
        queryParam.setParentId(parentId);
        List<EmsBaseMonitorInfo> childDevices = emsBaseMonitorInfoMapper.selectEmsBaseMonitorInfoList(queryParam);
        
        if (childDevices.isEmpty()) {
            return result;
        }

        if (tableExists) {
            // 如果分表存在，批量查询子设备的最新数据
            List<String> monitorCodes = new ArrayList<>();
            for (EmsBaseMonitorInfo device : childDevices) {
                monitorCodes.add(device.getMonitorCode());
            }
            
            // 批量查询最新记录
            List<RecordIotenvInstant> latestRecords = recordIotenvInstantMapper
                .selectLatestRecordsByMonitorIdsFromTable(todayTableName, monitorCodes);
            
            // 创建设备编号到最新记录的映射
            Map<String, RecordIotenvInstant> recordMap = new HashMap<>();
            for (RecordIotenvInstant record : latestRecords) {
                recordMap.put(record.getMonitorId(), record);
            }
            
            // 遍历子设备，构建返回结果
            for (EmsBaseMonitorInfo device : childDevices) {
                String monitorCode = device.getMonitorCode();
                String monitorName = device.getMonitorName();
                Long monitorType = device.getMonitorType();
                String energyName = device.getEnergyName();
                
                RecordIotenvInstant iotenvInstant = recordMap.get(monitorCode);
                if (iotenvInstant == null) {
                    // 如果没有找到记录，创建一个空记录
                    iotenvInstant = new RecordIotenvInstant();
                    iotenvInstant.setMonitorId(monitorCode);
                }
                
                // 设置设备基本信息
                iotenvInstant.setMonitorName(monitorName);
                iotenvInstant.setMonitorCode(monitorCode);
                iotenvInstant.setEnergyName(energyName);
                iotenvInstant.setMonitorType(monitorType);
                
                result.add(iotenvInstant);
            }
        } else {
            // 如果分表不存在，返回子设备的空记录
            for (EmsBaseMonitorInfo device : childDevices) {
                RecordIotenvInstant iotenvInstant = new RecordIotenvInstant();
                iotenvInstant.setMonitorId(device.getMonitorCode());
                iotenvInstant.setMonitorName(device.getMonitorName());
                iotenvInstant.setMonitorCode(device.getMonitorCode());
                iotenvInstant.setEnergyName(device.getEnergyName());
                iotenvInstant.setMonitorType(device.getMonitorType());
                // 数据值字段保持null，前端会显示"无最新数据"
                result.add(iotenvInstant);
            }
        }

        return result;
    }

    /**
     * 获取当天日期对应的分表名
     *
     * @return 分表名
     */
    private String getTodayTableName() {
        LocalDate today = LocalDate.now();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMdd");
        String dateSuffix = today.format(formatter);
        return "record_iotenv_instant_" + dateSuffix;
    }

    /**
     * 查询物联网数据列表（专用导出）
     * 与普通查询的区别：
     * 1. 使用专用的导出Mapper方法，移除ORDER BY提升性能
     * 2. 支持多设备批量导出
     * 3. 自动过滤虚拟设备
     *
     * @param recordIotenvInstant 物联网数据
     * @return 物联网数据集合
     */
    @Override
    public List<RecordIotenvInstant> selectRecordIotenvInstantListForExport(RecordIotenvInstant recordIotenvInstant) throws ParseException {
        Map<String, Object> params = recordIotenvInstant.getParams();

        // 添加null检查，防止空指针异常
        if (params == null) {
            throw new ServiceException("导出参数不能为空");
        }

        Object beginTimeObj = params.get("beginRecordTime");
        Object endTimeObj = params.get("endRecordTime");

        if (beginTimeObj == null || endTimeObj == null) {
            throw new ServiceException("导出时间范围不能为空");
        }

        String beginTimeStr = beginTimeObj.toString();
        String endTimeStr = endTimeObj.toString();

        // 解析日期
        SimpleDateFormat fullFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date beginDate = fullFormat.parse(beginTimeStr);
        Date endDate = fullFormat.parse(endTimeStr);

        // 获取需要查询的表名列表
        List<String> tableNames = getTableNamesByDateRange(beginDate, endDate);
        if (tableNames.isEmpty()) {
            return new ArrayList<>();
        }

        // 使用专用导出查询（无ORDER BY，性能优化）
        return recordIotenvInstantMapper.selectRecordIotenvInstantListForExport(tableNames, recordIotenvInstant);
    }

    /**
     * 查询物联网数据列表（专用导出，含数据过滤）
     * 根据设备类型过滤无效数据并返回
     *
     * @param recordIotenvInstant 物联网数据
     * @param monitorTypes 设备类型集合
     * @param vibrationParam 振动参数（振动设备可选择单个参数导出）
     * @return 过滤后的物联网数据集合
     */
    @Override
    public List<RecordIotenvInstant> selectRecordIotenvInstantListForExportWithFilter(RecordIotenvInstant recordIotenvInstant, Set<Integer> monitorTypes, String vibrationParam) throws ParseException {
        // 先查询原始数据
        List<RecordIotenvInstant> list = selectRecordIotenvInstantListForExport(recordIotenvInstant);
        // 根据设备类型过滤无效数据
        return filterInvalidData(list, monitorTypes, vibrationParam);
    }

    /**
     * 根据设备类型获取导出列
     * 列顺序：设备编号、设备名称、能源类型数据列、记录时间
     * type=5: 温度设备 -> 设备编号、设备名称、温度、记录时间
     * type=6: 温湿度设备 -> 设备编号、设备名称、温度、湿度、记录时间
     * type=7: 噪声设备 -> 设备编号、设备名称、噪声、记录时间
     * type=10: 振动设备 -> 若指定vibrationParam则只导出该参数，否则导出全部振动参数
     * 混合类型: 导出所有列
     *
     * @param monitorTypes 设备类型集合
     * @param vibrationParam 振动参数（振动设备可选择单个参数导出：vibrationSpeed/vibrationDisplacement/vibrationAcceleration/vibrationTemp）
     */
    @Override
    public String[] getExportColumnsByType(Set<Integer> monitorTypes, String vibrationParam) {
        List<String> columns = new ArrayList<>();
        // 固定列：设备编号、设备名称
        columns.add("monitorCode");
        columns.add("monitorName");

        if (monitorTypes.isEmpty() || monitorTypes.size() > 1) {
            // 混合类型或未指定：导出所有数据列
            columns.add("temperature");
            columns.add("humidity");
            columns.add("noise");
/*            columns.add("vibrationSpeed");
            columns.add("vibrationDisplacement");
            columns.add("vibrationAcceleration");
            columns.add("vibrationTemp");*/
        } else {
            // 单一类型：只导出对应的列
            Integer type = monitorTypes.iterator().next();
            switch (type) {
                case 5: // 温度设备
                    columns.add("temperature");
                    break;
                case 6: // 温湿度设备
                    columns.add("temperature");
                    columns.add("humidity");
                    break;
                case 7: // 噪声设备
                    columns.add("noise");
                    break;
                case 10: // 振动设备：若指定vibrationParam则只导出该参数
                    if (vibrationParam != null && !vibrationParam.isEmpty()) {
                        columns.add(vibrationParam);
                    } else {
                        columns.add("vibrationSpeed");
                        columns.add("vibrationDisplacement");
                        columns.add("vibrationAcceleration");
                        columns.add("vibrationTemp");
                    }
                    break;
                default:
                    // 其他类型：导出所有列
                    columns.add("temperature");
                    columns.add("humidity");
                    columns.add("noise");
/*                    columns.add("vibrationSpeed");
                    columns.add("vibrationDisplacement");
                    columns.add("vibrationAcceleration");
                    columns.add("vibrationTemp");*/
                    break;
            }
        }

        // 固定列：记录时间
        columns.add("recodeTime");
        return columns.toArray(new String[0]);
    }

    /**
     * 根据设备类型过滤无效数据
     * 过滤规则（使用OR关系，满足任一类型的有效性即保留）：
     * 1. 温度设备(type=5)：温度>0且<80
     * 2. 温湿度设备(type=6)：温度或湿度任一>0且<80
     * 3. 噪声设备(type=7)：噪声>0且<80
     * 4. 振动设备(type=10)：若指定vibrationParam则只过滤该参数，否则振动相关字段任一>0且<80
     *
     * @param vibrationParam 振动参数（振动设备可选择单个参数过滤）
     */
    private List<RecordIotenvInstant> filterInvalidData(List<RecordIotenvInstant> list, Set<Integer> monitorTypes, String vibrationParam) {
        if (monitorTypes.isEmpty()) {
            // 未指定类型时，保留有任何有效数据的记录
            return list.stream().filter(this::hasValidData).collect(Collectors.toList());
        }

        // 单一类型：严格按该类型过滤
        if (monitorTypes.size() == 1) {
            Integer type = monitorTypes.iterator().next();
            // 振动设备且指定了单个参数时，只过滤该参数
            if (type == 10 && vibrationParam != null && !vibrationParam.isEmpty()) {
                return list.stream().filter(record -> isValidVibrationParam(record, vibrationParam)).collect(Collectors.toList());
            }
            return list.stream().filter(record -> isValidForType(record, type)).collect(Collectors.toList());
        }

        // 多类型：使用OR关系，满足任一选中类型的有效性即保留
        return list.stream().filter(record -> {
            for (Integer type : monitorTypes) {
                if (isValidForType(record, type)) {
                    return true;
                }
            }
            return false;
        }).collect(Collectors.toList());
    }

    /** 判断指定振动参数是否有效：>0且<80 */
    private boolean isValidVibrationParam(RecordIotenvInstant record, String vibrationParam) {
        BigDecimal value = null;
        switch (vibrationParam) {
            case "vibrationSpeed":
                value = record.getVibrationSpeed();
                break;
            case "vibrationDisplacement":
                value = record.getVibrationDisplacement();
                break;
            case "vibrationAcceleration":
                value = record.getVibrationAcceleration();
                break;
            case "vibrationTemp":
                value = record.getVibrationTemp();
                break;
            default:
                return false;
        }
        return value != null && value.compareTo(BigDecimal.ZERO) > 0 && value.compareTo(new BigDecimal("80")) < 0;
    }

    /** 判断记录对于指定类型是否有效 */
    private boolean isValidForType(RecordIotenvInstant record, Integer type) {
        switch (type) {
            case 5: // 温度设备
                return isValidTemperature(record.getTemperature());
            case 6: // 温湿度设备
                return isValidTemperature(record.getTemperature()) || isValidHumidity(record.getHumidity());
            case 7: // 噪声设备
                return isValidNoise(record.getNoise());
            case 10: // 振动设备
                return hasValidVibrationData(record);
            default:
                return hasValidData(record);
        }
    }

    /** 判断温度是否有效：>0且<=79 */
    private boolean isValidTemperature(BigDecimal temperature) {
        return temperature != null && temperature.compareTo(BigDecimal.ZERO) > 0 && temperature.compareTo(new BigDecimal("79")) <= 0;
    }

    /** 判断湿度是否有效：>0且<=79 */
    private boolean isValidHumidity(BigDecimal humidity) {
        return humidity != null && humidity.compareTo(BigDecimal.ZERO) > 0 && humidity.compareTo(new BigDecimal("79")) <= 0;
    }

    /** 判断噪声是否有效：>0且<=79 */
    private boolean isValidNoise(BigDecimal noise) {
        return noise != null && noise.compareTo(BigDecimal.ZERO) > 0 && noise.compareTo(new BigDecimal("79")) <= 0;
    }

    /** 判断是否有有效的振动数据：>0且<80 */
    private boolean hasValidVibrationData(RecordIotenvInstant record) {
        BigDecimal upperLimit = new BigDecimal("80");
        return isValidVibrationValue(record.getVibrationSpeed(), upperLimit) ||
               isValidVibrationValue(record.getVibrationDisplacement(), upperLimit) ||
               isValidVibrationValue(record.getVibrationAcceleration(), upperLimit) ||
               isValidVibrationValue(record.getVibrationTemp(), upperLimit);
    }

    /** 判断振动值是否有效：>0且<80 */
    private boolean isValidVibrationValue(BigDecimal value, BigDecimal upperLimit) {
        return value != null && value.compareTo(BigDecimal.ZERO) > 0 && value.compareTo(upperLimit) < 0;
    }

    /** 判断记录是否有任何有效数据 */
    private boolean hasValidData(RecordIotenvInstant record) {
        return isValidTemperature(record.getTemperature()) ||
               isValidHumidity(record.getHumidity()) ||
               isValidNoise(record.getNoise()) ||
               hasValidVibrationData(record);
    }

}
