/// <reference lib="deno.worker" />  

import {
  MasterController,
  AgvId,
  ClientOptions,
  Topic,
  Order,
  State,
  Headerless,
  InstantActions,
  BlockingType,
  Connection,
  Factsheet,
} from "vda-5050-lib";
import { v4 as uuidv4 } from "npm:uuid";
import { createWorkerEventHelper } from "./worker_event_helper.ts";

// 创建事件助手
const eventHelper = createWorkerEventHelper("vdaWorker");

console.log("VDA 5050 Worker initialized");

// 预注册设备列表（后续主程序可动态更新）  
const preRegisteredDevices: AgvId[] = [
];

// 用于保存所有设备状态及动态更新设备列表  
const currentDevices: Map<
  string,
  { agvId: AgvId; lastSeen: number; isOnline: boolean; state?: State }
> = new Map();

// 内部方法：生成设备唯一 key  
function getDeviceKey(agvId: AgvId) {
  return `${agvId.manufacturer}-${agvId.serialNumber}`;
}

// 先将预注册设备保存到 currentDevices（初始状态为离线）  
preRegisteredDevices.forEach((device) => {
  const key = getDeviceKey(device);
  currentDevices.set(key, {
    agvId: device,
    lastSeen: 0,
    isOnline: false,
  });
});

// 用于保存已经订阅状态的设备，避免重复订阅  
const subscribedDevices: Set<string> = new Set();

// 全局保存 MasterController 实例  
let masterController: MasterController | null = null;

// 从初始化参数读取的接口名和制造商  
let interfaceNameValue = "oagv";
let manufacturerValue = "gateway";
// 标记 Master Controller 是否启动完成  
let clientStarted = false;

/**  
 * 当收到 init 消息后，从启动参数中提取 MQTT broker 地址，从而构造客户端选项并启动控制器  
 */
function initializeControllerWithOptions(brokerUrl: string, iValue: string) {
  // Validate input parameters
  if (!brokerUrl || !iValue) {
    console.error("❌ Invalid initialization parameters:");
    console.error("brokerUrl:", brokerUrl);
    console.error("interfaceName:", iValue);
    return;
  }
  
  // Reset previous state
  clientStarted = false;
  if (masterController) {
    try {
      masterController.stop().catch(() => {});
    } catch (e) {
      // Ignore stop errors
    }
    masterController = null;
  }
  
  const clientOptions: ClientOptions = {
    interfaceName: iValue,
    transport: {
      // 使用启动参数传入的 MQTT server 地址  
      brokerUrl: brokerUrl,
      heartbeat:5,
      reconnectPeriod:1000,
      connectTimeout:5000,
    },
    vdaVersion: "2.0.0",
  };

  console.log(`🚀 正在初始化VDA 5050 Master Controller...`);
  console.log(`📡 MQTT Broker: ${brokerUrl}`);
  console.log(`🏷️ Interface: ${iValue}`);
  console.log(`🏭 Manufacturer: ${manufacturerValue}`);

  // Test MQTT broker connectivity
  console.log(`🔍 Testing MQTT broker connectivity...`);
  try {
    const url = new URL(brokerUrl);
    console.log(`📍 Broker host: ${url.hostname}, port: ${url.port || 1883}`);
  } catch (urlError) {
    console.error("❌ Invalid broker URL format:", urlError);
    return;
  }

  try {
    masterController = new MasterController(clientOptions, {});
    console.log("📦 MasterController instance created successfully");
  } catch (error) {
    console.error("❌ Failed to create MasterController instance:", error);
    return;
  }

  // Add timeout to prevent hanging
  Promise.race([
    masterController.start(),
    new Promise((_, reject) => 
      setTimeout(() => reject(new Error("Master controller start timeout after 30 seconds")), 30000)
    )
  ])
    .then(() => {
      clientStarted = true;
      console.log("✅ VDA 5050 master controller started successfully");
      self.postMessage({ type: "started" });

      // 跟踪所有AGV连接状态  
      masterController!.trackAgvs((trackAgvId, connectionState, timestamp) => {
        const key = getDeviceKey(trackAgvId);
        // 如果设备不在设备列表中，则不予上线  
        // console.log("->", key, connectionState);
        // if (!currentDevices.has(key)) {  
        //   console.warn(  
        //     `收到未知设备 ${trackAgvId.manufacturer}/${trackAgvId.serialNumber} 的状态消息，忽略上线。`  
        //   );  
        //   return;  
        // }  
        const ts = Number(timestamp);
        const lastSeen = isNaN(ts) ? Date.now() : ts;
        // 自动添加新设备到currentDevices，无需预先配置
        let record = currentDevices.get(key);
        if (!record) {
          // 动态添加新发现的设备
          record = { agvId: trackAgvId, lastSeen: 0, isOnline: false };
          currentDevices.set(key, record);
          console.log(`🆕 自动添加新设备: ${trackAgvId.manufacturer}/${trackAgvId.serialNumber}`);
        }
        const wasOffline = !record.isOnline;
        // 无条件置为 ONLINE 并更新最后更新时间  
        currentDevices.set(key, { ...record, lastSeen, isOnline: true });
        // 发送上线状态更新信息  
        self.postMessage({
          type: "connectionState",
          data: { agvId: trackAgvId, state: "ONLINE", timestamp: lastSeen },
        });
        if (wasOffline) {
          // console.log(  
          //   `设备 ${trackAgvId.manufacturer}/${trackAgvId.serialNumber} 新上线`  
          // );  
          // 额外通知一次"新上线"  
          self.postMessage({
            type: "connectionState",
            data: { agvId: trackAgvId, state: "ONLINE", timestamp: lastSeen },
          });
        }
        // 若设备首次出现，则订阅其状态更新  
        if (!subscribedDevices.has(key)) {
          subscribedDevices.add(key);
          try {
            // 使用 trackAgvId 本身作为 AgvId 订阅  
            masterController!.subscribe(
              Topic.State,
              { manufacturer: manufacturerValue, serialNumber: trackAgvId.serialNumber },
              (state: State) => {
                const subKey = getDeviceKey(trackAgvId);
                // 自动添加新设备，无需预先配置
                let existing = currentDevices.get(subKey);
                if (!existing) {
                  existing = { agvId: trackAgvId, lastSeen: 0, isOnline: false };
                  currentDevices.set(subKey, existing);
                  console.log(`🆕 状态订阅中自动添加新设备: ${trackAgvId.manufacturer}/${trackAgvId.serialNumber}`);
                }
                const wasOfflineInSub = !existing.isOnline;
                currentDevices.set(subKey, {
                  ...existing,
                  lastSeen: Date.now(),
                  state,
                  isOnline: true,
                });
                if (wasOfflineInSub) {
                  // console.log(  
                  //   `设备 ${trackAgvId.manufacturer}/${trackAgvId.serialNumber} 新上线（订阅）`  
                  // );  
                  self.postMessage({
                    type: "connectionState",
                    data: {
                      agvId: trackAgvId,
                      state: "ONLINE",
                      timestamp: Date.now(),
                    },
                  });
                }
                self.postMessage({
                  type: "stateUpdate",
                  data: {
                    agvId: trackAgvId,
                    state: state,
                    timestamp: Date.now(),
                  },
                });
              }
            );
            // Subscribe to Factsheet topic
            masterController!.subscribe(
              Topic.Factsheet,
              { manufacturer: manufacturerValue, serialNumber: trackAgvId.serialNumber },
              (factsheet: Factsheet) => {
                // console.log("收到 factsheet 消息", factsheet);
                self.postMessage({
                  type: "factsheet",
                  data: { agvId: trackAgvId, factsheet, timestamp: Date.now() },
                });
              }
            );
            // Subscribe to Connection topic
            masterController!.subscribe(
              Topic.Connection,
              { manufacturer: manufacturerValue, serialNumber: trackAgvId.serialNumber },
              (connection: Connection) => {
                self.postMessage({
                  type: "deviceDiscovered",
                  data: { agvId: trackAgvId, connection, timestamp: Date.now() },
                });
              }
            );
          } catch (error) {
            console.error(`Failed to subscribe to tracked device ${trackAgvId.manufacturer}/${trackAgvId.serialNumber}:`, error);
            // 移除已添加的订阅标记，以便重试
            subscribedDevices.delete(key);
          }
        }
      });

      // 定时检测设备状态，超时则标记为离线  
      const stateUpdateCycle = 5000;
      const offlineThreshold = stateUpdateCycle * 3;
      setInterval(() => {
        const now = Date.now();
        currentDevices.forEach((device, key) => {
          // console.log(  
          //   `设备 ${device.agvId.manufacturer}/${device.agvId.serialNumber} - lastSeen: ${device.lastSeen}, isOnline: ${device.isOnline}`  
          // );  
          if (now - device.lastSeen > offlineThreshold && device.isOnline) {
            device.isOnline = false;
            currentDevices.set(key, device);
            // console.log(  
            //   `设备 ${device.agvId.manufacturer}/${device.agvId.serialNumber} 超过 ${offlineThreshold} 毫秒未更新，标记为下线`  
            // );  
          }
          self.postMessage({
            type: "connectionState",
            data: { agvId: device.agvId, state: device.isOnline ? "ONLINE" : "OFFLINE", timestamp: now },
          });
        });
      }, stateUpdateCycle);
    })
    .catch((error) => {
      console.error("❌ Failed to start VDA 5050 master controller:");
      console.error("Error details:", error);
      console.error("Error message:", error?.message || "Unknown error");
      console.error("Error stack:", error?.stack || "No stack trace");
      
      // Reset client state
      clientStarted = false;
      masterController = null;
      
      // Schedule retry after delay
      console.log("🔄 Scheduling retry in 10 seconds...");
      setTimeout(() => {
        console.log("🔄 Retrying VDA 5050 master controller initialization...");
        initializeControllerWithOptions(brokerUrl, iValue);
        eventHelper.dispatchEvent("reconnect-all", {
          reason: "grpc-stream-failed",
          retryCount: 5,
          timestamp: Date.now()
        });
        self.postMessage({ type: "reconnect-all" });
      }, 10000);
    });
}

/**  
 * 辅助函数：  
 * 当客户端尚未启动时，延迟一段时间后重试订阅  
 */
function subscribeWithRetry(device: AgvId, retryCount = 0) {
  const key = getDeviceKey(device);
  // console.log("订阅设备->", key);
  // 自动添加新设备，无需预先配置
  if (!currentDevices.has(key)) {
    currentDevices.set(key, { agvId: device, lastSeen: 0, isOnline: false });
    console.log(`🆕 订阅时自动添加新设备: ${device.manufacturer}/${device.serialNumber}`);
  }
  if (!clientStarted) {
    if (retryCount < 50000) {
      // console.warn("Client not started, retry subscribing after delay...", device);
      setTimeout(() => {
        subscribeWithRetry(device, retryCount + 1);
      }, 3000);
    } else {
      console.error("订阅失败：超过最大重试次数", device);
    }
    return;
  }
  if (!subscribedDevices.has(key)) {
    subscribedDevices.add(key);
    try {
      // 双重检查客户端状态
      if (!clientStarted || !masterController) {
        subscribedDevices.delete(key);
        setTimeout(() => {
          subscribeWithRetry(device, retryCount + 1);
        }, 3000);
        return;
      }
      // Subscribe to State topic
      masterController!.subscribe(
        Topic.State,
        { manufacturer: manufacturerValue, serialNumber: device.serialNumber },
        (state: State) => {
        const subKey = getDeviceKey(device);
        // 自动添加新设备，无需预先配置
        let existing = currentDevices.get(subKey);
        if (!existing) {
          existing = { agvId: device, lastSeen: 0, isOnline: false };
          currentDevices.set(subKey, existing);
          console.log(`🆕 状态更新中自动添加新设备: ${device.manufacturer}/${device.serialNumber}`);
        }
        const wasOfflineInSub = !existing.isOnline;
        currentDevices.set(subKey, {
          ...existing,
          lastSeen: Date.now(),
          state,
          isOnline: true,
        });
        if (wasOfflineInSub) {
          self.postMessage({
            type: "connectionState",
            data: { agvId: device, state: "ONLINE", timestamp: Date.now() },
          });
        }
        self.postMessage({
          type: "stateUpdate",
          data: { agvId: device, state, timestamp: Date.now() },
        });
      }
      );
      // Subscribe to Factsheet topic
      masterController!.subscribe(
        Topic.Factsheet,
        { manufacturer: manufacturerValue, serialNumber: device.serialNumber },
        (factsheet: Factsheet) => {
          // console.log("收到 factsheet 消息", factsheet);
          self.postMessage({
            type: "factsheet",
            data: { agvId: device, factsheet, timestamp: Date.now() },
          });
        }
      );
      // Subscribe to Connection topic
      masterController!.subscribe(
        Topic.Connection,
        { manufacturer: manufacturerValue, serialNumber: device.serialNumber },
        (connection: Connection) => {
          self.postMessage({
            type: "deviceDiscovered",
            data: { agvId: device, connection, timestamp: Date.now() },
          });
        }
      );
    } catch (error) {
      console.error(`Failed to subscribe to device ${device.manufacturer}/${device.serialNumber}:`, error);
      // 移除已添加的订阅标记，以便重试
      subscribedDevices.delete(key);
      // 如果客户端未启动，重新调度重试
      if (!clientStarted) {
        setTimeout(() => {
          subscribeWithRetry(device, 0);
        }, 5000);
      }
    }
  }
}

// 处理来自主线程的消息  
self.onmessage = async (event) => {
  const message = event.data;
  // console.log("Received message from main thread:", message);  

  // 如果收到 init 消息，从启动参数中传入 MQTT server 地址  
  if (message.type === "init") {
    // 从主线程传入初始化参数  
    // data: {
    //   brokerUrl: config.mqtt.brokerUrl,
    //   interfaceName: config.interfaceName,
    //   manufacturer: config.manufacturer,
    //   instanceId: config.instanceId
    // },
      console.log("event", message);
    const { brokerUrl, interfaceName, manufacturer, instanceId } = message.data;
    console.log(`init params → brokerUrl: ${brokerUrl}, interfaceName: ${interfaceName}, manufacturer: ${manufacturer}, instanceId: ${instanceId}`);
    manufacturerValue = instanceId;
    interfaceNameValue = interfaceName;
    initializeControllerWithOptions(brokerUrl, interfaceNameValue);
  }

  // 处理单个设备移除
  if (message.type === "removeDevice") {
    const { manufacturer, serialNumber } = message.data;
    const deviceKey = getDeviceKey({ manufacturer, serialNumber });
    
    if (currentDevices.has(deviceKey)) {
      // 移除设备
      currentDevices.delete(deviceKey);
      subscribedDevices.delete(deviceKey);
      
      console.log(`🗑️ 已移除设备: ${manufacturer}/${serialNumber}`);
      
      // 通知主线程设备已移除
      self.postMessage({
        type: "deviceRemoved",
        data: {
          manufacturer,
          serialNumber,
          deviceKey,
          remainingDevices: currentDevices.size
        }
      });
    } else {
      console.log(`⚠️ 设备 ${manufacturer}/${serialNumber} 不存在，无法移除`);
    }
  }

  // 动态更新设备列表（主程序从配置文件发送更新消息）  
  if (message.type === "updateDeviceList") {
    const newDeviceList: AgvId[] = message.data;
    console.log(`🔄 VDA Worker 收到设备列表更新，包含 ${newDeviceList.length} 个设备`);
    
    // 构造新设备的 Key 集合  
    const newKeys = new Set(newDeviceList.map(getDeviceKey));
    let addedCount = 0;
    let updatedCount = 0;

    // 遍历新设备列表，新增或更新记录，并进行状态订阅  
    newDeviceList.forEach((device) => {
      const key = getDeviceKey(device);
      if (!currentDevices.has(key)) {
        currentDevices.set(key, { agvId: device, lastSeen: 0, isOnline: false });
        console.log(`➕ 新增设备: ${device.manufacturer}/${device.serialNumber}`);
        addedCount++;
      } else {
        // 更新 agvId 信息（如果有必要）  
        const record = currentDevices.get(key)!;
        record.agvId = device;
        currentDevices.set(key, record);
        console.log(`🔄 更新设备: ${device.manufacturer}/${device.serialNumber}`);
        updatedCount++;
      }
      // 根据设备列表订阅对应的状态更新（重试订阅，直到客户端启动）  
      subscribeWithRetry(device);
    });

    // 对于 currentDevices 中存在但不在最新列表中的设备，置为离线  
    let removedCount = 0;
    currentDevices.forEach((device, key) => {
      if (!newKeys.has(key)) {
        device.isOnline = false;
        currentDevices.set(key, device);
        console.log(`⏸️ 设备离线: ${device.agvId.manufacturer}/${device.agvId.serialNumber}`);
        removedCount++;
      }
    });
    
    console.log(`✅ 设备列表更新完成: 新增 ${addedCount}, 更新 ${updatedCount}, 离线 ${removedCount}`);
    console.log(`📊 当前管理设备总数: ${currentDevices.size}`);
    
    // 通知主线程最新设备列表情况
    self.postMessage({
      type: "deviceListUpdated",
      data: {
        total: currentDevices.size,
        added: addedCount,
        updated: updatedCount,
        removed: removedCount,
        devices: Array.from(currentDevices.values()).map(d => ({
          manufacturer: d.agvId.manufacturer,
          serialNumber: d.agvId.serialNumber,
          isOnline: d.isOnline
        }))
      }
    });
  }
  if (message.type === "orderForwarded") {
    // Check if client is started before processing orders
    if (!clientStarted || !masterController) {
      console.warn("❌ VDA client not started yet, ignoring order request");
      return;
    }
    
    // console.log("收到 AGV 订单消息1", message);  
    // 解构出 agvId 串号和 order 对象
    const { agvId: agvSerial, order: msg } = message.data as { agvId: string; order: any };
    // Rebuild order payload as Headerless<Order>
    const order: Headerless<Order> = {
      orderId: msg.orderId,
      orderUpdateId: msg.orderUpdateId || 0,
      nodes: msg.nodes.map((node: any, idx: number) => ({
        nodeId: node.nodeId,
        sequenceId: idx * 2,
        released: node.released ?? true,
        nodePosition: node.nodePosition,
        actions: node.actions || []
      })),
      edges: []
    };
    if (msg.nodes.length > 1) {
      for (let i = 0; i < msg.nodes.length - 1; i++) {
        order.edges.push({
          edgeId: msg.edges?.[i]?.edgeId || `edge${i}to${i + 1}`,
          sequenceId: i * 2 + 1,
          startNodeId: msg.nodes[i].nodeId,
          endNodeId: msg.nodes[i + 1].nodeId,
          released: msg.edges?.[i]?.released ?? true,
          actions: msg.edges?.[i]?.actions || []
        });
      }
    }
    let devId: any = undefined;
    // console.log("检查设备", currentDevices, msg.agvId);
    currentDevices.forEach((device, key) => {
      // console.log("检查设备", device, key, device.agvId.serialNumber, agvSerial);
      if (device.agvId.serialNumber === agvSerial) {
        devId = device.agvId;
      }
    });
    if (devId) {
      // console.log("收到 AGV 订单消息2", devId);
      try {
        // console.log("---->",{ manufacturer: manufacturerValue, serialNumber: devId.serialNumber }, order);
        await masterController!.assignOrder({ manufacturer: manufacturerValue, serialNumber: devId.serialNumber }, order, {
          onOrderProcessed: (err, canceled, active, ctx) => {
            if (err) {
              console.error("Order 被拒绝", err);
            } else if (canceled) {
              console.log("Order 被取消", ctx.order);
            } else if (active) {
              console.log("Order 正在执行", ctx.order);
            } else {
              console.log("Order 完成", ctx.order);
            }
          },
          onNodeTraversed: (node, nextEdge, nextNode, ctx) => {
            console.log("节点遍历完成", node);
          },
          onEdgeTraversing: (edge, start, end, stateChanges, count, ctx) => {
            console.log("开始路径", edge);
          },
          onEdgeTraversed: (edge, start, end, ctx) => {
            console.log("路径遍历完成", edge);
          },
          onActionStateChanged: (actionState, error) => {
            console.log("Action 状态变化", actionState, error || "");
          }
        });
      } catch (err) {
        console.error("assignOrder 异常", err);
      }
    }  // end if(agvId)
  }    // end if(message.type === "orderForwarded")
  // 2) 收到 InstantActions 转发  
  if (message.type === "instantActionsForwarded") {
    // Check if client is started before processing instant actions
    if (!clientStarted || !masterController) {
      console.warn("❌ VDA client not started yet, ignoring instant actions request");
      return;
    }
    
    // console.log("收到 AGV 即时动作消息", message);  
    const msg: any = message.data;
    // const actions: InstantActions = msg.actions;  
    const { agvId, actions } = msg as {
      agvId: string;
      actions: Array<{
        actionType: string; /* …其它可能的字段… */
        actionParameters: Array<{ key: string; value: string }>;
        actionDescription: string;
        actionId: string;
        blockingType: string;
      }>;
    };
    // console.log("收到 AGV 即时动作消息", agvId, actions);

    let devId: any = undefined;
    currentDevices.forEach((device, key) => {
      if (device.agvId.serialNumber === msg.agvId) {
        devId = device.agvId;
      }
    });

    if (devId) {
      // console.log("收到 AGV 即时动作消息", msg);
      try {
        const headerless: Headerless<InstantActions> = {
          actions: actions.map(a => ({
            actionType: a.actionType,                         // 必填  
            actionId: a.actionId,         // 必填  
            blockingType: a.blockingType === "HARD" ? BlockingType.Hard : BlockingType.None,                 // 必填，使用枚举  
            actionParameters: a.actionParameters || [],       // 使用原始的actionParameters或空数组
            actionDescription: "action parameters",          // 可选  
          }))
        };
        // console.log("=====>",headerless);
        await masterController!.initiateInstantActions({ manufacturer: manufacturerValue, serialNumber: devId.serialNumber }, headerless, {
          onActionStateChanged: (actionState, withError, action, agvId, state) => console.log("Instant action state changed: %o %o %o", actionState, withError, action),
          onActionError: (error, action, agvId, state) => console.log("Instant action error: %o %o %o", error, action, state),
        });
      } catch (err) {
        console.error("initiateInstantActions 异常", err);
      }
    }  // end if(agvId)
  }  // end if(message.type === "instantActionsForwarded")

  // 处理发送订单请求  
  if (message.type === "sendOrder") {
    // Check if client is started before processing orders
    if (!clientStarted || !masterController) {
      console.warn("❌ VDA client not started yet, ignoring send order request");
      return;
    }
    
    try {
      const order: Headerless<Order> = {
        orderId: message.orderId || masterController!.createUuid(),
        orderUpdateId: 0,
        nodes: message.nodes.map((node: any, index: number) => ({
          nodeId: node.nodeId,
          sequenceId: index * 2,
          released: true,
          nodePosition: node.nodePosition,
          actions: node.actions || [],
        })),
        edges: [],
      };

      if (message.nodes.length > 1) {
        for (let i = 0; i < message.nodes.length - 1; i++) {
          order.edges.push({
            edgeId: `edge${i}to${i + 1}`,
            sequenceId: i * 2 + 1,
            startNodeId: message.nodes[i].nodeId,
            endNodeId: message.nodes[i + 1].nodeId,
            released: true,
            actions: [],
          });
        }
      }

      // 使用预注册列表中的第一个设备发送订单  
      let devId: any = undefined;
      // currentDevices.forEach((device, key) => {  
      //   if ( device.agvId.serialNumber === 'ZKG-0') {
      //     devId = device.agvId;
      //   } 
      // });
      if (devId) {
        await masterController!.assignOrder({ manufacturer: manufacturerValue, serialNumber: devId.serialNumber }, order, {
          onOrderProcessed: (withError, byCancelation, active, ctx) => {
            console.log("Order processed", { withError, byCancelation, active });
            self.postMessage({
              type: "orderCompleted",
              orderId: order.orderId,
              withError,
              byCancelation,
              active,
            });
          },
          onNodeTraversed: (node, nextEdge, nextNode, ctx) => {
            console.log("Order node traversed:", node);
            self.postMessage({
              type: "nodeTraversed",
              node,
              nextEdge,
              nextNode,
            });
          },
          onEdgeTraversing: (
            edge,
            startNode,
            endNode,
            stateChanges,
            invocationCount,
            ctx
          ) => {
            console.log("Order edge traversing:", edge);
            self.postMessage({
              type: "edgeTraversing",
              edge,
              startNode,
              endNode,
            });
          },
          onEdgeTraversed: (edge, startNode, endNode, ctx) => {
            console.log("Order edge traversed:", edge);
            self.postMessage({ type: "edgeTraversed", edge, startNode, endNode });
          },
        });
      }

      console.log("Order assigned successfully");
      self.postMessage({ type: "orderSent", orderId: order.orderId });
    } catch (error) {
      console.error("Failed to send order:", error);
      self.postMessage({ type: "error", error: (error as Error).message });
    }
  }

  // 处理取消订单请求  
  if (message.type === "cancelOrder") {
    // 此处添加取消订单逻辑……  
  }

  // 处理主动请求设备列表的消息  
  if (message.type === "discoverDevices") {
    const devicesList = Array.from(currentDevices.values())
      .filter(d => d.isOnline)
      .map(d => ({
        agvId: d.agvId,
        isOnline: d.isOnline,
        x: d.state?.agvPosition?.x,
        y: d.state?.agvPosition?.y,
        theta: d.state?.agvPosition?.theta,
        actionStatus: d.state?.actionStates,
        lastNodeId: d.state?.lastNodeId,
        lastNodeSequenceId: d.state?.lastNodeSequenceId,
        nodeStates: d.state?.nodeStates,
        edgeStates: d.state?.edgeStates,
        driving: d.state?.driving,
        errors: d.state?.errors?.map(err => ({
          errorType: err.errorType,
          errorLevel: err.errorLevel,
          errorDescription: err.errorDescription,
          errorReferences: err.errorReferences?.map((ref: any) => ({
            referenceKey: ref.referenceKey,
            referenceValue: ref.referenceValue
          }))
        })),
        information: d.state?.information || []
      }));
    console.log("currentDevices", JSON.stringify(Array.from(currentDevices.values()), null, 2));
    self.postMessage({ type: "devicesList", data: devicesList });
  }

  // 处理factsheet请求
  if (message.type === "factsheetRequest") {
    // Check if client is started before processing factsheet requests
    if (!clientStarted || !masterController) {
      console.warn("❌ VDA client not started yet, ignoring factsheet request");
      return;
    }
    
    const { agvId } = message.data || {};
    if (!agvId) {
      console.warn("❌ No agvId provided for factsheet request");
      return;
    }
    
    console.log(`📋 Processing factsheet request for AGV: ${agvId}`);
    
    // Find the device in currentDevices
    let targetDevice: any = undefined;
    currentDevices.forEach((device, key) => {
      if (device.agvId.serialNumber === agvId) {
        targetDevice = device.agvId;
      }
    });
    
    if (targetDevice) {
      try {
        // Request factsheet using instant action
        const factsheetAction: Headerless<InstantActions> = {
          actions: [{
            actionType: "factsheetRequest",
            actionId: `factsheet_${Date.now()}`,
            blockingType: BlockingType.None,
            actionParameters: [],
            actionDescription: "Request device factsheet"
          }]
        };
        
        await masterController!.initiateInstantActions(
          { manufacturer: manufacturerValue, serialNumber: targetDevice.serialNumber }, 
          factsheetAction, 
          {
            onActionStateChanged: (actionState, withError, action, agvId, state) => {
              console.log("Factsheet action state changed:", actionState, withError ? "with error" : "success");
            },
            onActionError: (error, action, agvId, state) => {
              console.error("Factsheet action error:", error);
            },
          }
        );
        
        console.log(`✅ Factsheet request sent for AGV: ${agvId}`);
      } catch (err) {
        console.error("❌ Failed to send factsheet request:", err);
      }
    } else {
      console.warn(`⚠️ AGV ${agvId} not found in current devices`);
    }
  }

  // 处理 shutdown 消息  
  if (message === "shutdown" || message.type === "shutdown") {
    console.log("收到 shutdown 消息，退出 Worker");
    // 此处可添加关闭逻辑  
  }
};

// 在 worker 退出时关闭 Master Controller  
addEventListener("unload", () => {
  console.log("Closing VDA 5050 Worker");
  masterController?.stop().catch((err: Error) => console.log(err));
});