import { isEmpty } from '../../@core/base/shared/src/utils';

// ========== IOT - 依赖注入 ==========
/** IoT 依赖注入 KEY */
export const IOT_PROVIDE_KEY = {
  PRODUCT: 'IOT_PRODUCT',
} as const;

// ========== IOT - 设备模块 ==========
/** 设备状态枚举 */
export const DeviceStateEnum = {
  INACTIVE: 0, // 未激活
  ONLINE: 1, // 在线
  OFFLINE: 2, // 离线
} as const;

/** 设备状态选择器特殊选项 */
export const DEVICE_SELECTOR_OPTIONS = {
  ALL_DEVICES: {
    id: 0,
    deviceName: '全部设备',
  },
};

/**
 * 设备状态汇总；label / value 给业务用，tagType 给 UI 层做颜色映射（不同框架可能各取所需）
 */
export const IoTDeviceStatusEnum = {
  // 在线状态
  ONLINE: {
    label: '在线',
    value: 'online',
    tagType: 'success',
  },
  OFFLINE: {
    label: '离线',
    value: 'offline',
    tagType: 'danger',
  },
  // 启用状态
  ENABLED: {
    label: '正常',
    value: 0,
    value2: 'enabled',
    tagType: 'success',
  },
  DISABLED: {
    label: '禁用',
    value: 1,
    value2: 'disabled',
    tagType: 'danger',
  },
  // 激活状态
  ACTIVATED: {
    label: '已激活',
    value2: 'activated',
    tagType: 'success',
  },
  NOT_ACTIVATED: {
    label: '未激活',
    value2: 'not_activated',
    tagType: 'info',
  },
};

// ========== IOT - 产品模块 ==========
/** 产品设备类型枚举 */
export const DeviceTypeEnum = {
  DEVICE: 0, // 直连设备
  GATEWAY: 2, // 网关设备
  GATEWAY_SUB: 1, // 网关子设备
} as const;

/** 产品设备类型枚举（与 DeviceTypeEnum 同义，保留旧名兼容旧代码） */
export const IoTProductDeviceTypeEnum = DeviceTypeEnum;

/** 产品状态枚举 */
export const ProductStatusEnum = {
  UNPUBLISHED: 0, // 开发中
  PUBLISHED: 1, // 已发布
} as const;

/** 数据格式（编解码器类型）枚举 */
export const CodecTypeEnum = {
  ALINK: 'Alink', // 阿里云 Alink 协议
} as const;

// ========== IOT - 告警模块 ==========
/** IoT 告警接收方式枚举，与后端 IotAlertReceiveTypeEnum 保持一致 */
export const IotAlertReceiveTypeEnum = {
  SMS: 1, // 短信
  MAIL: 2, // 邮箱
  NOTIFY: 3, // 站内信
} as const;

// ========== IOT - 物模型 ==========
/** IoT 产品物模型类型枚举类 */
export const IoTThingModelTypeEnum = {
  PROPERTY: 1, // 属性
  SERVICE: 2, // 服务
  EVENT: 3, // 事件
};

/** 物模型组标签常量 */
export const THING_MODEL_GROUP_LABELS = {
  PROPERTY: '设备属性',
  EVENT: '设备事件',
  SERVICE: '设备服务',
};

/** IoT 产品物模型服务调用方式枚举 */
export const IoTThingModelServiceCallTypeEnum = {
  ASYNC: { label: '异步', value: 'async' },
  SYNC: { label: '同步', value: 'sync' },
};

/** 获取服务调用方式标签 */
export const getThingModelServiceCallTypeLabel = (
  value: string,
): string | undefined =>
  Object.values(IoTThingModelServiceCallTypeEnum).find(
    (type) => type.value === value,
  )?.label;

/** IoT 产品物模型事件类型枚举 */
export const IoTThingModelEventTypeEnum = {
  INFO: { label: '信息', value: 'info' },
  ALERT: { label: '告警', value: 'alert' },
  ERROR: { label: '故障', value: 'error' },
};

/** 获取事件类型标签 */
export const getEventTypeLabel = (value: string): string | undefined =>
  Object.values(IoTThingModelEventTypeEnum).find((type) => type.value === value)
    ?.label;

/** IoT 产品物模型参数方向：输入参数 / 输出参数 */
export const IoTThingModelParamDirectionEnum = {
  INPUT: 'input', // 输入参数
  OUTPUT: 'output', // 输出参数
};

/** IoT 产品物模型访问模式枚举 */
export const IoTThingModelAccessModeEnum = {
  READ_WRITE: { label: '读写', value: 'rw' },
  READ_ONLY: { label: '只读', value: 'r' },
  WRITE_ONLY: { label: '只写', value: 'w' },
};

/** 获取访问模式标签 */
export const getAccessModeLabel = (value: string): string => {
  const mode = Object.values(IoTThingModelAccessModeEnum).find(
    (item) => item.value === value,
  );
  return mode?.label || value;
};

/** 属性值的数据类型 */
export const IoTDataSpecsDataTypeEnum = {
  INT: 'int',
  FLOAT: 'float',
  DOUBLE: 'double',
  ENUM: 'enum',
  BOOL: 'bool',
  TEXT: 'text',
  DATE: 'date',
  STRUCT: 'struct',
  ARRAY: 'array',
};

const DATA_TYPE_OPTIONS = Object.freeze([
  { value: IoTDataSpecsDataTypeEnum.INT, label: '整数型' },
  { value: IoTDataSpecsDataTypeEnum.FLOAT, label: '单精度浮点型' },
  { value: IoTDataSpecsDataTypeEnum.DOUBLE, label: '双精度浮点型' },
  { value: IoTDataSpecsDataTypeEnum.ENUM, label: '枚举型' },
  { value: IoTDataSpecsDataTypeEnum.BOOL, label: '布尔型' },
  { value: IoTDataSpecsDataTypeEnum.TEXT, label: '文本型' },
  { value: IoTDataSpecsDataTypeEnum.DATE, label: '时间型' },
  { value: IoTDataSpecsDataTypeEnum.STRUCT, label: '结构体' },
  { value: IoTDataSpecsDataTypeEnum.ARRAY, label: '数组' },
]);

/** 获取物模型数据类型选项 */
export const getDataTypeOptions = () => DATA_TYPE_OPTIONS;

/** 获取数据类型选项展示标签（value 含括号说明） */
export const getDataTypeOptionsLabel = (value: string) => {
  if (isEmpty(value)) {
    return value;
  }
  const dataType = getDataTypeOptions().find(
    (option) => option.value === value,
  );
  return dataType && `${dataType.value}(${dataType.label})`;
};

/** 获取数据类型显示名称（用于属性选择器） */
export const getDataTypeName = (dataType: string): string => {
  const typeMap: Record<string, string> = {
    [IoTDataSpecsDataTypeEnum.INT]: '整数',
    [IoTDataSpecsDataTypeEnum.FLOAT]: '浮点数',
    [IoTDataSpecsDataTypeEnum.DOUBLE]: '双精度',
    [IoTDataSpecsDataTypeEnum.TEXT]: '字符串',
    [IoTDataSpecsDataTypeEnum.BOOL]: '布尔值',
    [IoTDataSpecsDataTypeEnum.ENUM]: '枚举',
    [IoTDataSpecsDataTypeEnum.DATE]: '日期',
    [IoTDataSpecsDataTypeEnum.STRUCT]: '结构体',
    [IoTDataSpecsDataTypeEnum.ARRAY]: '数组',
  };
  return typeMap[dataType] || dataType;
};

/** 获取数据类型标签类型（用于 tag 的 type 属性） */
export const getDataTypeTagType = (
  dataType: string,
): 'danger' | 'info' | 'primary' | 'success' | 'warning' => {
  const tagMap: Record<
    string,
    'danger' | 'info' | 'primary' | 'success' | 'warning'
  > = {
    [IoTDataSpecsDataTypeEnum.INT]: 'primary',
    [IoTDataSpecsDataTypeEnum.FLOAT]: 'success',
    [IoTDataSpecsDataTypeEnum.DOUBLE]: 'success',
    [IoTDataSpecsDataTypeEnum.TEXT]: 'info',
    [IoTDataSpecsDataTypeEnum.BOOL]: 'warning',
    [IoTDataSpecsDataTypeEnum.ENUM]: 'danger',
    [IoTDataSpecsDataTypeEnum.DATE]: 'primary',
    [IoTDataSpecsDataTypeEnum.STRUCT]: 'info',
    [IoTDataSpecsDataTypeEnum.ARRAY]: 'warning',
  };
  return tagMap[dataType] || 'info';
};

// ========== IOT - 设备消息 ==========
/** IoT 设备消息的方法枚举 */
export const IotDeviceMessageMethodEnum = {
  // ========== 设备状态 ==========
  STATE_UPDATE: {
    method: 'thing.state.update',
    name: '设备状态更新',
    upstream: true,
  },

  // ========== 拓扑管理 ==========
  TOPO_ADD: {
    method: 'thing.topo.add',
    name: '添加拓扑关系',
    upstream: true,
  },
  TOPO_DELETE: {
    method: 'thing.topo.delete',
    name: '删除拓扑关系',
    upstream: true,
  },
  TOPO_GET: {
    method: 'thing.topo.get',
    name: '获取拓扑关系',
    upstream: true,
  },
  TOPO_CHANGE: {
    method: 'thing.topo.change',
    name: '拓扑关系变更通知',
    upstream: false,
  },

  // ========== 设备注册 ==========
  DEVICE_REGISTER: {
    method: 'thing.auth.register',
    name: '设备动态注册',
    upstream: true,
  },
  SUB_DEVICE_REGISTER: {
    method: 'thing.auth.register.sub',
    name: '子设备动态注册',
    upstream: true,
  },

  // ========== 设备属性 ==========
  PROPERTY_POST: {
    method: 'thing.property.post',
    name: '属性上报',
    upstream: true,
  },
  PROPERTY_SET: {
    method: 'thing.property.set',
    name: '属性设置',
    upstream: false,
  },
  PROPERTY_PACK_POST: {
    method: 'thing.event.property.pack.post',
    name: '批量上报（属性 + 事件 + 子设备）',
    upstream: true,
  },

  // ========== 设备事件 ==========
  EVENT_POST: {
    method: 'thing.event.post',
    name: '事件上报',
    upstream: true,
  },

  // ========== 服务调用 ==========
  SERVICE_INVOKE: {
    method: 'thing.service.invoke',
    name: '服务调用',
    upstream: false,
  },

  // ========== 设备配置 ==========
  CONFIG_PUSH: {
    method: 'thing.config.push',
    name: '配置推送',
    upstream: false,
  },

  // ========== OTA 固件 ==========
  OTA_UPGRADE: {
    method: 'thing.ota.upgrade',
    name: 'OTA 固件信息推送',
    upstream: false,
  },
  OTA_PROGRESS: {
    method: 'thing.ota.progress',
    name: 'OTA 升级进度上报',
    upstream: true,
  },
} as const;

// ========== IOT - OTA ==========
/** IoT OTA 任务设备范围枚举 */
export const IoTOtaTaskDeviceScopeEnum = {
  ALL: { label: '全部设备', value: 1 },
  SELECT: { label: '指定设备', value: 2 },
};

/** IoT OTA 任务状态枚举 */
export const IoTOtaTaskStatusEnum = {
  IN_PROGRESS: { label: '进行中', value: 10 },
  END: { label: '已结束', value: 20 },
  CANCELED: { label: '已取消', value: 30 },
};

/** IoT OTA 升级记录状态枚举 */
export const IoTOtaTaskRecordStatusEnum = {
  PENDING: { label: '待推送', value: 0 },
  PUSHED: { label: '已推送', value: 10 },
  UPGRADING: { label: '升级中', value: 20 },
  SUCCESS: { label: '升级成功', value: 30 },
  FAILURE: { label: '升级失败', value: 40 },
  CANCELED: { label: '升级取消', value: 50 },
};

// ========== IOT - 场景联动 ==========
/** IoT 场景联动触发器类型枚举 */
export const IotRuleSceneTriggerTypeEnum = {
  DEVICE_STATE_UPDATE: 1, // 设备上下线变更
  DEVICE_PROPERTY_POST: 2, // 物模型属性上报
  DEVICE_EVENT_POST: 3, // 设备事件上报
  DEVICE_SERVICE_INVOKE: 4, // 设备服务调用
  TIMER: 100, // 定时触发
};

/** 触发器类型选项配置 */
export const triggerTypeOptions = [
  {
    value: IotRuleSceneTriggerTypeEnum.DEVICE_STATE_UPDATE,
    label: '设备状态变更',
  },
  {
    value: IotRuleSceneTriggerTypeEnum.DEVICE_PROPERTY_POST,
    label: '设备属性上报',
  },
  {
    value: IotRuleSceneTriggerTypeEnum.DEVICE_EVENT_POST,
    label: '设备事件上报',
  },
  {
    value: IotRuleSceneTriggerTypeEnum.DEVICE_SERVICE_INVOKE,
    label: '设备服务调用',
  },
  {
    value: IotRuleSceneTriggerTypeEnum.TIMER,
    label: '定时触发',
  },
];

/** 判断是否为设备触发器类型 */
export function isDeviceTrigger(type: number): boolean {
  const deviceTriggerTypes = [
    IotRuleSceneTriggerTypeEnum.DEVICE_STATE_UPDATE,
    IotRuleSceneTriggerTypeEnum.DEVICE_PROPERTY_POST,
    IotRuleSceneTriggerTypeEnum.DEVICE_EVENT_POST,
    IotRuleSceneTriggerTypeEnum.DEVICE_SERVICE_INVOKE,
  ] as number[];
  return deviceTriggerTypes.includes(type);
}

/** 获取触发器类型标签 */
export const getTriggerTypeLabel = (type: number): string => {
  const option = triggerTypeOptions.find((item) => item.value === type);
  return option?.label || '未知类型';
};

/** IoT 场景联动执行器类型枚举 */
export const IotRuleSceneActionTypeEnum = {
  DEVICE_PROPERTY_SET: 1, // 设备属性设置
  DEVICE_SERVICE_INVOKE: 2, // 设备服务调用
  ALERT_TRIGGER: 100, // 告警触发
  ALERT_RECOVER: 101, // 告警恢复
};

/** 执行器类型选项配置 */
export const actionTypeOptions = [
  {
    value: IotRuleSceneActionTypeEnum.DEVICE_PROPERTY_SET,
    label: '设备属性设置',
  },
  {
    value: IotRuleSceneActionTypeEnum.DEVICE_SERVICE_INVOKE,
    label: '设备服务调用',
  },
  { value: IotRuleSceneActionTypeEnum.ALERT_TRIGGER, label: '触发告警' },
  { value: IotRuleSceneActionTypeEnum.ALERT_RECOVER, label: '恢复告警' },
];

/** 兼容旧调用：保留函数形态 */
export const getActionTypeOptions = () => actionTypeOptions;

/** 获取执行器类型标签 */
export const getActionTypeLabel = (type: number): string => {
  const option = actionTypeOptions.find((opt) => opt.value === type);
  return option?.label || '未知类型';
};

/** IoT 场景联动触发条件参数操作符枚举 */
export const IotRuleSceneTriggerConditionParameterOperatorEnum = {
  EQUALS: { name: '等于', value: '=' },
  NOT_EQUALS: { name: '不等于', value: '!=' },
  GREATER_THAN: { name: '大于', value: '>' },
  GREATER_THAN_OR_EQUALS: { name: '大于等于', value: '>=' },
  LESS_THAN: { name: '小于', value: '<' },
  LESS_THAN_OR_EQUALS: { name: '小于等于', value: '<=' },
  IN: { name: '在...之中', value: 'in' },
  NOT_IN: { name: '不在...之中', value: 'not in' },
  BETWEEN: { name: '在...之间', value: 'between' },
  NOT_BETWEEN: { name: '不在...之间', value: 'not between' },
  LIKE: { name: '字符串匹配', value: 'like' },
  NOT_NULL: { name: '非空', value: 'not null' },
};

/** IoT 场景联动触发条件类型枚举 */
export const IotRuleSceneTriggerConditionTypeEnum = {
  DEVICE_STATUS: 1, // 设备状态
  DEVICE_PROPERTY: 2, // 设备属性
  CURRENT_TIME: 3, // 当前时间
};

/** 条件类型选项配置 */
export const conditionTypeOptions = [
  {
    value: IotRuleSceneTriggerConditionTypeEnum.DEVICE_STATUS,
    label: '设备状态',
  },
  {
    value: IotRuleSceneTriggerConditionTypeEnum.DEVICE_PROPERTY,
    label: '设备属性',
  },
  {
    value: IotRuleSceneTriggerConditionTypeEnum.CURRENT_TIME,
    label: '当前时间',
  },
];

/** 兼容旧调用：保留函数形态 */
export const getConditionTypeOptions = () => conditionTypeOptions;

/** IoT 场景联动触发时间操作符枚举 */
export const IotRuleSceneTriggerTimeOperatorEnum = {
  BEFORE_TIME: { name: '在时间之前', value: 'before_time' },
  AFTER_TIME: { name: '在时间之后', value: 'after_time' },
  BETWEEN_TIME: { name: '在时间之间', value: 'between_time' },
  AT_TIME: { name: '在指定时间', value: 'at_time' },
  BEFORE_TODAY: { name: '在今日之前', value: 'before_today' },
  AFTER_TODAY: { name: '在今日之后', value: 'after_today' },
  TODAY: { name: '在今日之间', value: 'today' },
};

// ========== IOT - JSON 参数输入 ==========
/** JSON 参数输入组件类型枚举 */
export const JsonParamsInputTypeEnum = {
  SERVICE: 'service',
  EVENT: 'event',
  PROPERTY: 'property',
  CUSTOM: 'custom',
};

/** JSON 参数输入组件类型 */
export type JsonParamsInputType =
  (typeof JsonParamsInputTypeEnum)[keyof typeof JsonParamsInputTypeEnum];

/** JSON 参数输入组件文本常量 */
export const JSON_PARAMS_INPUT_CONSTANTS = {
  // 基础文本
  PLACEHOLDER: '请输入JSON格式的参数',
  JSON_FORMAT_CORRECT: 'JSON 格式正确',
  QUICK_FILL_LABEL: '快速填充：',
  EXAMPLE_DATA_BUTTON: '示例数据',
  CLEAR_BUTTON: '清空',
  VIEW_EXAMPLE_TITLE: '查看参数示例',
  COMPLETE_JSON_FORMAT: '完整 JSON 格式：',
  REQUIRED_TAG: '必填',

  // 错误信息
  PARAMS_MUST_BE_OBJECT: '参数必须是一个有效的 JSON 对象',
  PARAM_REQUIRED_ERROR: (paramName: string) => `参数 ${paramName} 为必填项`,
  JSON_FORMAT_ERROR: (error: string) => `JSON格式错误: ${error}`,
  UNKNOWN_ERROR: '未知错误',

  // 类型相关标题
  TITLES: {
    SERVICE: (name?: string) => `${name || '服务'} - 输入参数示例`,
    EVENT: (name?: string) => `${name || '事件'} - 输出参数示例`,
    PROPERTY: '属性设置 - 参数示例',
    CUSTOM: (name?: string) => `${name || '自定义'} - 参数示例`,
    DEFAULT: '参数示例',
  },

  // 参数标签
  PARAMS_LABELS: {
    SERVICE: '输入参数',
    EVENT: '输出参数',
    PROPERTY: '属性参数',
    CUSTOM: '参数列表',
    DEFAULT: '参数',
  },

  // 空状态消息
  EMPTY_MESSAGES: {
    SERVICE: '此服务无需输入参数',
    EVENT: '此事件无输出参数',
    PROPERTY: '无可设置的属性',
    CUSTOM: '无参数配置',
    DEFAULT: '无参数',
  },

  // 无配置消息
  NO_CONFIG_MESSAGES: {
    SERVICE: '请先选择服务',
    EVENT: '请先选择事件',
    PROPERTY: '请先选择产品',
    CUSTOM: '请先进行配置',
    DEFAULT: '请先进行配置',
  },
};

/** JSON 参数输入组件图标常量 */
export const JSON_PARAMS_INPUT_ICONS = {
  // 标题图标
  TITLE_ICONS: {
    SERVICE: 'ep:service',
    EVENT: 'ep:bell',
    PROPERTY: 'ep:edit',
    CUSTOM: 'ep:document',
    DEFAULT: 'ep:document',
  },

  // 参数图标
  PARAMS_ICONS: {
    SERVICE: 'ep:edit',
    EVENT: 'ep:upload',
    PROPERTY: 'ep:setting',
    CUSTOM: 'ep:list',
    DEFAULT: 'ep:edit',
  },

  // 状态图标
  STATUS_ICONS: {
    ERROR: 'ep:warning',
    SUCCESS: 'ep:circle-check',
  },
};

/** JSON 参数输入组件示例值常量 */
export const JSON_PARAMS_EXAMPLE_VALUES: Record<string, any> = {
  [IoTDataSpecsDataTypeEnum.INT]: { display: '25', value: 25 },
  [IoTDataSpecsDataTypeEnum.FLOAT]: { display: '25.5', value: 25.5 },
  [IoTDataSpecsDataTypeEnum.DOUBLE]: { display: '25.5', value: 25.5 },
  [IoTDataSpecsDataTypeEnum.BOOL]: { display: 'false', value: false },
  [IoTDataSpecsDataTypeEnum.TEXT]: { display: '"auto"', value: 'auto' },
  [IoTDataSpecsDataTypeEnum.ENUM]: { display: '"option1"', value: 'option1' },
  [IoTDataSpecsDataTypeEnum.STRUCT]: { display: '{}', value: {} },
  [IoTDataSpecsDataTypeEnum.ARRAY]: { display: '[]', value: [] },
  DEFAULT: { display: '""', value: '' },
};

// ========== IOT - Modbus ==========
/** Modbus 模式枚举 */
export const ModbusModeEnum = {
  POLLING: 1, // 云端轮询
  ACTIVE_REPORT: 2, // 主动上报
} as const;

/** Modbus 帧格式枚举 */
export const ModbusFrameFormatEnum = {
  MODBUS_TCP: 1, // Modbus TCP
  MODBUS_RTU: 2, // Modbus RTU
} as const;

/** Modbus 功能码枚举 */
export const ModbusFunctionCodeEnum = {
  READ_COILS: 1, // 读线圈
  READ_DISCRETE_INPUTS: 2, // 读离散输入
  READ_HOLDING_REGISTERS: 3, // 读保持寄存器
  READ_INPUT_REGISTERS: 4, // 读输入寄存器
} as const;

/** Modbus 功能码选项 */
export const ModbusFunctionCodeOptions = [
  { value: 1, label: '01 - 读线圈 (Coils)', description: '可读写布尔值' },
  {
    value: 2,
    label: '02 - 读离散输入 (Discrete Inputs)',
    description: '只读布尔值',
  },
  {
    value: 3,
    label: '03 - 读保持寄存器 (Holding Registers)',
    description: '可读写 16 位数据',
  },
  {
    value: 4,
    label: '04 - 读输入寄存器 (Input Registers)',
    description: '只读 16 位数据',
  },
];

/** Modbus 原始数据类型枚举 */
export const ModbusRawDataTypeEnum = {
  INT16: 'INT16',
  UINT16: 'UINT16',
  INT32: 'INT32',
  UINT32: 'UINT32',
  FLOAT: 'FLOAT',
  DOUBLE: 'DOUBLE',
  BOOLEAN: 'BOOLEAN',
  STRING: 'STRING',
} as const;

/** Modbus 原始数据类型选项 */
export const ModbusRawDataTypeOptions = [
  {
    value: 'INT16',
    label: 'INT16',
    description: '有符号16位整数',
    registerCount: 1,
  },
  {
    value: 'UINT16',
    label: 'UINT16',
    description: '无符号16位整数',
    registerCount: 1,
  },
  {
    value: 'INT32',
    label: 'INT32',
    description: '有符号32位整数',
    registerCount: 2,
  },
  {
    value: 'UINT32',
    label: 'UINT32',
    description: '无符号32位整数',
    registerCount: 2,
  },
  {
    value: 'FLOAT',
    label: 'FLOAT',
    description: '32位浮点数',
    registerCount: 2,
  },
  {
    value: 'DOUBLE',
    label: 'DOUBLE',
    description: '64位浮点数',
    registerCount: 4,
  },
  {
    value: 'BOOLEAN',
    label: 'BOOLEAN',
    description: '布尔值',
    registerCount: 1,
  },
  { value: 'STRING', label: 'STRING', description: '字符串', registerCount: 0 },
];

/** Modbus 字节序选项 - 16 位 */
export const ModbusByteOrder16Options = [
  { value: 'AB', label: 'AB', description: '大端序' },
  { value: 'BA', label: 'BA', description: '小端序' },
];

/** Modbus 字节序选项 - 32 位 */
export const ModbusByteOrder32Options = [
  { value: 'ABCD', label: 'ABCD', description: '大端序' },
  { value: 'CDAB', label: 'CDAB', description: '大端字交换' },
  { value: 'DCBA', label: 'DCBA', description: '小端序' },
  { value: 'BADC', label: 'BADC', description: '小端字交换' },
];

/** 根据数据类型获取字节序选项 */
export const getByteOrderOptions = (rawDataType: string) => {
  if (['FLOAT', 'INT32', 'UINT32'].includes(rawDataType)) {
    return ModbusByteOrder32Options;
  }
  if (rawDataType === 'DOUBLE') {
    // 64 位复用 32 位字节序
    return ModbusByteOrder32Options;
  }
  return ModbusByteOrder16Options;
};