package com.mes.task.service;

import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.mes.device.entity.DeviceConfig;
import com.mes.device.entity.DeviceGroupConfig;
import com.mes.interaction.DeviceInteraction;
import com.mes.interaction.DeviceInteractionRegistry;
import com.mes.interaction.DeviceLogicHandler;
import com.mes.interaction.DeviceLogicHandlerFactory;
import com.mes.interaction.base.InteractionContext;
import com.mes.interaction.base.InteractionResult;
import com.mes.device.service.DeviceCoordinationService;
import com.mes.device.service.DeviceInteractionService;
import com.mes.task.dto.TaskParameters;
import com.mes.task.entity.MultiDeviceTask;
import com.mes.task.entity.TaskStepDetail;
import com.mes.task.mapper.MultiDeviceTaskMapper;
import com.mes.task.mapper.TaskStepDetailMapper;
import com.mes.task.model.RetryPolicy;
import com.mes.task.model.TaskExecutionContext;
import com.mes.task.model.TaskExecutionResult;
import com.mes.task.service.TaskStatusNotificationService;
import com.mes.device.vo.DevicePlcVO;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.util.*;
import java.util.concurrent.*;

/**
 * 多设备任务执行引擎
 * 支持串行和并行两种执行模式
 */
@Slf4j
@Component
@RequiredArgsConstructor
public class TaskExecutionEngine {

    private static final Map<String, String> DEFAULT_OPERATIONS = new HashMap<>();
    private static final TypeReference<Map<String, Object>> MAP_TYPE = new TypeReference<Map<String, Object>>() {};

    // 执行模式常量
    private static final String EXECUTION_MODE_SERIAL = "SERIAL";
    private static final String EXECUTION_MODE_PARALLEL = "PARALLEL";

    static {
        DEFAULT_OPERATIONS.put(DeviceConfig.DeviceType.LOAD_VEHICLE, "feedGlass");
        DEFAULT_OPERATIONS.put(DeviceConfig.DeviceType.LARGE_GLASS, "processGlass");
        DEFAULT_OPERATIONS.put(DeviceConfig.DeviceType.GLASS_STORAGE, "storeGlass");
    }

    private final TaskStepDetailMapper taskStepDetailMapper;
    private final MultiDeviceTaskMapper multiDeviceTaskMapper;
    private final DeviceInteractionService deviceInteractionService;
    private final DeviceInteractionRegistry interactionRegistry;
    private final DeviceLogicHandlerFactory handlerFactory;
    private final DeviceCoordinationService deviceCoordinationService;
    private final TaskStatusNotificationService notificationService;
    private final ObjectMapper objectMapper;

    // 线程池用于并行执行
    private final ExecutorService executorService = Executors.newCachedThreadPool(r -> {
        Thread t = new Thread(r, "TaskExecutionEngine-Parallel");
        t.setDaemon(true);
        return t;
    });

    public TaskExecutionResult execute(MultiDeviceTask task,
                                       DeviceGroupConfig groupConfig,
                                       List<DeviceConfig> devices,
                                       TaskParameters parameters) {

        if (CollectionUtils.isEmpty(devices)) {
            return TaskExecutionResult.failure("设备组未配置设备，无法执行任务", Collections.emptyMap());
        }

        TaskExecutionContext context = new TaskExecutionContext(parameters);
        
        // 设备协调：检查依赖关系和执行条件
        DeviceCoordinationService.CoordinationResult coordinationResult = 
            deviceCoordinationService.coordinateExecution(groupConfig, devices, context);
        if (!coordinationResult.canExecute()) {
            log.warn("设备协调失败: {}", coordinationResult.getMessage());
            return TaskExecutionResult.failure(coordinationResult.getMessage(), Collections.emptyMap());
        }
        log.info("设备协调成功: {}", coordinationResult.getMessage());

        task.setTotalSteps(devices.size());
        task.setStatus(MultiDeviceTask.Status.RUNNING.name());
        multiDeviceTaskMapper.updateById(task);
        
        // 通知任务开始执行
        notificationService.notifyTaskStatus(task);
        
        // 确定执行模式
        String executionMode = determineExecutionMode(groupConfig);
        Integer maxConcurrent = getMaxConcurrentDevices(groupConfig);

        log.info("任务执行模式: {}, 最大并发数: {}, 设备数: {}", executionMode, maxConcurrent, devices.size());

        List<Map<String, Object>> stepSummaries;
        boolean success;
        String failureMessage;

        if (EXECUTION_MODE_PARALLEL.equals(executionMode)) {
            // 并行执行模式
            stepSummaries = new ArrayList<>(Collections.nCopies(devices.size(), null));
            Pair<Boolean, String> result = executeParallel(task, devices, context, stepSummaries, maxConcurrent);
            success = result.getFirst();
            failureMessage = result.getSecond();
        } else {
            // 串行执行模式（默认）
            stepSummaries = new ArrayList<>();
            success = true;
            failureMessage = null;
            for (int i = 0; i < devices.size(); i++) {
                DeviceConfig device = devices.get(i);
                int order = i + 1;
                TaskStepDetail step = createStepRecord(task, device, order);
                StepResult stepResult = executeStep(task, step, device, context);
                stepSummaries.add(stepResult.toSummary());
                if (!stepResult.isSuccess()) {
                    success = false;
                    failureMessage = stepResult.getMessage();
                    break;
                }
            }
        }

        Map<String, Object> payload = new HashMap<>();
        payload.put("steps", stepSummaries);
        payload.put("groupId", groupConfig.getId());
        payload.put("deviceCount", devices.size());
        payload.put("executionMode", executionMode);

        // 更新任务最终状态
        if (success) {
            task.setStatus(MultiDeviceTask.Status.COMPLETED.name());
        } else {
            task.setStatus(MultiDeviceTask.Status.FAILED.name());
            task.setErrorMessage(failureMessage);
        }
        task.setEndTime(new Date());
        multiDeviceTaskMapper.updateById(task);
        
        // 通知任务完成
        notificationService.notifyTaskStatus(task);
        
        if (success) {
            return TaskExecutionResult.success(payload);
        }
        return TaskExecutionResult.failure(failureMessage != null ? failureMessage : "任务执行失败", payload);
    }

    /**
     * 并行执行多个设备操作
     */
    private Pair<Boolean, String> executeParallel(MultiDeviceTask task,
                                                   List<DeviceConfig> devices,
                                                   TaskExecutionContext context,
                                                   List<Map<String, Object>> stepSummaries,
                                                   Integer maxConcurrent) {
        int concurrency = maxConcurrent != null && maxConcurrent > 0 
            ? Math.min(maxConcurrent, devices.size()) 
            : devices.size();

        // 创建所有步骤记录
        List<TaskStepDetail> steps = new ArrayList<>();
        for (int i = 0; i < devices.size(); i++) {
            DeviceConfig device = devices.get(i);
            int order = i + 1;
            TaskStepDetail step = createStepRecord(task, device, order);
            steps.add(step);
        }

        // 使用信号量控制并发数
        Semaphore semaphore = new Semaphore(concurrency);
        List<CompletableFuture<StepResult>> futures = new ArrayList<>();

        for (int i = 0; i < devices.size(); i++) {
            final int index = i;
            final DeviceConfig device = devices.get(index);
            final TaskStepDetail step = steps.get(index);

            CompletableFuture<StepResult> future = CompletableFuture.supplyAsync(() -> {
                try {
                    semaphore.acquire();
                    try {
                        return executeStep(task, step, device, context);
                    } finally {
                        semaphore.release();
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    log.error("并行执行被中断, deviceId={}", device.getId(), e);
                    return StepResult.failure(device.getDeviceName(), "执行被中断");
                } catch (Exception e) {
                    log.error("并行执行异常, deviceId={}", device.getId(), e);
                    return StepResult.failure(device.getDeviceName(), e.getMessage());
                }
            }, executorService);

            final int finalIndex = index;
            future.whenComplete((result, throwable) -> {
                if (throwable != null) {
                    log.error("并行执行完成时异常, deviceId={}", device.getId(), throwable);
                    stepSummaries.set(finalIndex, StepResult.failure(device.getDeviceName(), 
                        throwable.getMessage()).toSummary());
                } else if (result != null) {
                    stepSummaries.set(finalIndex, result.toSummary());
                }
            });

            futures.add(future);
        }

        // 等待所有任务完成
        CompletableFuture<Void> allFutures = CompletableFuture.allOf(
            futures.toArray(new CompletableFuture[0])
        );

        try {
            allFutures.get(30, TimeUnit.MINUTES); // 最多等待30分钟
        } catch (TimeoutException e) {
            log.error("并行执行超时, taskId={}", task.getTaskId(), e);
            return Pair.of(false, "任务执行超时");
        } catch (Exception e) {
            log.error("等待并行执行完成时异常, taskId={}", task.getTaskId(), e);
            return Pair.of(false, "等待执行完成时发生异常: " + e.getMessage());
        }

        // 检查所有步骤的执行结果
        boolean allSuccess = true;
        String firstFailureMessage = null;
        for (int i = 0; i < futures.size(); i++) {
            try {
                StepResult result = futures.get(i).get();
                if (result != null && !result.isSuccess()) {
                    allSuccess = false;
                    if (firstFailureMessage == null) {
                        firstFailureMessage = result.getMessage();
                    }
                }
            } catch (Exception e) {
                log.error("获取步骤执行结果异常, stepIndex={}", i, e);
                allSuccess = false;
                if (firstFailureMessage == null) {
                    firstFailureMessage = "获取执行结果异常: " + e.getMessage();
                }
            }
        }

        return Pair.of(allSuccess, firstFailureMessage);
    }

    /**
     * 确定执行模式
     */
    private String determineExecutionMode(DeviceGroupConfig groupConfig) {
        if (groupConfig == null) {
            return EXECUTION_MODE_SERIAL; // 默认串行
        }

        // 从extraConfig中读取executionMode
        String extraConfig = groupConfig.getExtraConfig();
        if (StringUtils.hasText(extraConfig)) {
            try {
                Map<String, Object> config = objectMapper.readValue(extraConfig, MAP_TYPE);
                Object mode = config.get("executionMode");
                if (mode != null) {
                    String modeStr = String.valueOf(mode).toUpperCase();
                    if (EXECUTION_MODE_PARALLEL.equals(modeStr) || EXECUTION_MODE_SERIAL.equals(modeStr)) {
                        return modeStr;
                    }
                }
            } catch (Exception e) {
                log.warn("解析设备组执行模式失败, groupId={}", groupConfig.getId(), e);
            }
        }

        // 如果有maxConcurrentDevices且大于1，默认使用并行模式
        if (groupConfig.getMaxConcurrentDevices() != null && groupConfig.getMaxConcurrentDevices() > 1) {
            return EXECUTION_MODE_PARALLEL;
        }

        return EXECUTION_MODE_SERIAL; // 默认串行
    }

    /**
     * 获取最大并发设备数
     */
    private Integer getMaxConcurrentDevices(DeviceGroupConfig groupConfig) {
        if (groupConfig == null) {
            return 1;
        }

        // 从extraConfig中读取maxConcurrent
        String extraConfig = groupConfig.getExtraConfig();
        if (StringUtils.hasText(extraConfig)) {
            try {
                Map<String, Object> config = objectMapper.readValue(extraConfig, MAP_TYPE);
                Object maxConcurrent = config.get("maxConcurrent");
                if (maxConcurrent instanceof Number) {
                    return ((Number) maxConcurrent).intValue();
                }
            } catch (Exception e) {
                log.warn("解析设备组最大并发数失败, groupId={}", groupConfig.getId(), e);
            }
        }

        // 使用实体字段
        return groupConfig.getMaxConcurrentDevices() != null && groupConfig.getMaxConcurrentDevices() > 0
            ? groupConfig.getMaxConcurrentDevices()
            : 1;
    }

    /**
     * 简单的Pair类用于返回两个值
     */
    private static class Pair<T, U> {
        private final T first;
        private final U second;

        private Pair(T first, U second) {
            this.first = first;
            this.second = second;
        }

        public static <T, U> Pair<T, U> of(T first, U second) {
            return new Pair<>(first, second);
        }

        public T getFirst() {
            return first;
        }

        public U getSecond() {
            return second;
        }
    }

    private TaskStepDetail createStepRecord(MultiDeviceTask task, DeviceConfig device, int order) {
        TaskStepDetail step = new TaskStepDetail();
        step.setTaskId(task.getTaskId());
        step.setStepOrder(order);
        step.setDeviceId(String.valueOf(device.getId()));
        step.setStepName(device.getDeviceName());
        step.setStatus(TaskStepDetail.Status.PENDING.name());
        step.setRetryCount(0);
        taskStepDetailMapper.insert(step);
        return step;
    }

    private StepResult executeStep(MultiDeviceTask task,
                                   TaskStepDetail step,
                                   DeviceConfig device,
                                   TaskExecutionContext context) {
        return executeStepWithRetry(task, step, device, context, getRetryPolicy(device));
    }

    /**
     * 带重试的步骤执行
     */
    private StepResult executeStepWithRetry(MultiDeviceTask task,
                                            TaskStepDetail step,
                                            DeviceConfig device,
                                            TaskExecutionContext context,
                                            RetryPolicy retryPolicy) {
        Date startTime = new Date();
        step.setStartTime(startTime);
        step.setStatus(TaskStepDetail.Status.RUNNING.name());
        step.setRetryCount(0);

        DeviceInteraction deviceInteraction = interactionRegistry.getInteraction(device.getDeviceType());
        if (deviceInteraction != null) {
            return executeInteractionStepWithRetry(task, step, device, context, deviceInteraction, retryPolicy);
        }

        Map<String, Object> params = buildOperationParams(device, context);
        step.setInputData(toJson(params));
        taskStepDetailMapper.updateById(step);

        String operation = determineOperation(device, params);
        DeviceLogicHandler handler = handlerFactory.getHandler(device.getDeviceType());
        
        int retryAttempt = 0;
        Exception lastException = null;
        
        while (retryAttempt <= retryPolicy.getMaxRetryCount()) {
            try {
                if (retryAttempt > 0) {
                    // 重试前等待
                    long waitTime = retryPolicy.calculateRetryInterval(retryAttempt);
                    log.info("步骤执行重试: deviceId={}, operation={}, retryAttempt={}/{}, waitTime={}ms", 
                        device.getId(), operation, retryAttempt, retryPolicy.getMaxRetryCount(), waitTime);
                    Thread.sleep(waitTime);
                    
                    // 更新步骤状态
                    step.setRetryCount(retryAttempt);
                    step.setStatus(TaskStepDetail.Status.RUNNING.name());
                    step.setStartTime(new Date());
                    taskStepDetailMapper.updateById(step);
                }

                DevicePlcVO.OperationResult result;
                if (handler == null) {
                    result = deviceInteractionService.executeOperation(device.getId(), operation, params);
                } else {
                    result = handler.execute(device, operation, params);
                }

                boolean opSuccess = Boolean.TRUE.equals(result.getSuccess());
                updateStepAfterOperation(step, result, opSuccess);
                updateTaskProgress(task, step.getStepOrder(), opSuccess);
                
                // 通知步骤更新
                notificationService.notifyStepUpdate(task.getTaskId(), step);

                if (opSuccess) {
                    updateContextAfterSuccess(device, context, params);
                    
                    // 同步设备状态
                    deviceCoordinationService.syncDeviceStatus(device, 
                        DeviceCoordinationService.DeviceStatus.COMPLETED, context);
                    
                    return StepResult.success(device.getDeviceName(), result.getMessage());
                } else {
                    // 业务失败，判断是否可重试
                    if (retryAttempt < retryPolicy.getMaxRetryCount() && isRetryableFailure(result)) {
                        retryAttempt++;
                        lastException = new RuntimeException(result.getMessage());
                        log.warn("步骤执行失败，准备重试: deviceId={}, operation={}, retryAttempt={}, message={}", 
                            device.getId(), operation, retryAttempt, result.getMessage());
                        continue;
                    }
                    
                    // 同步失败状态
                    deviceCoordinationService.syncDeviceStatus(device, 
                        DeviceCoordinationService.DeviceStatus.FAILED, context);
                    
                    return StepResult.failure(device.getDeviceName(), result.getMessage());
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                log.error("步骤执行被中断, deviceId={}, operation={}", device.getId(), operation, e);
                step.setStatus(TaskStepDetail.Status.FAILED.name());
                step.setErrorMessage("执行被中断: " + e.getMessage());
                step.setEndTime(new Date());
                step.setDurationMs(step.getEndTime().getTime() - step.getStartTime().getTime());
                step.setRetryCount(retryAttempt);
                taskStepDetailMapper.updateById(step);
                updateTaskProgress(task, step.getStepOrder(), false);
                return StepResult.failure(device.getDeviceName(), "执行被中断");
            } catch (Exception e) {
                lastException = e;
                log.error("设备操作异常, deviceId={}, operation={}, retryAttempt={}", 
                    device.getId(), operation, retryAttempt, e);
                
                // 判断是否可重试
                if (retryAttempt < retryPolicy.getMaxRetryCount() && retryPolicy.isRetryable(e)) {
                    retryAttempt++;
                    log.warn("步骤执行异常，准备重试: deviceId={}, operation={}, retryAttempt={}, exception={}", 
                        device.getId(), operation, retryAttempt, e.getClass().getSimpleName());
                    continue;
                }
                
                // 不可重试或达到最大重试次数
                step.setStatus(TaskStepDetail.Status.FAILED.name());
                step.setErrorMessage(e.getMessage());
                step.setEndTime(new Date());
                step.setDurationMs(step.getEndTime().getTime() - step.getStartTime().getTime());
                step.setRetryCount(retryAttempt);
                taskStepDetailMapper.updateById(step);
                updateTaskProgress(task, step.getStepOrder(), false);
                
                // 通知步骤更新
                notificationService.notifyStepUpdate(task.getTaskId(), step);
                
                // 同步失败状态
                deviceCoordinationService.syncDeviceStatus(device, 
                    DeviceCoordinationService.DeviceStatus.FAILED, context);
                
                String errorMsg = retryAttempt > 0 
                    ? String.format("执行失败（已重试%d次）: %s", retryAttempt, e.getMessage())
                    : e.getMessage();
                return StepResult.failure(device.getDeviceName(), errorMsg);
            }
        }
        
        // 达到最大重试次数
        step.setStatus(TaskStepDetail.Status.FAILED.name());
        step.setErrorMessage(lastException != null ? lastException.getMessage() : "执行失败");
        step.setEndTime(new Date());
        step.setDurationMs(step.getEndTime().getTime() - step.getStartTime().getTime());
        step.setRetryCount(retryAttempt);
        taskStepDetailMapper.updateById(step);
        updateTaskProgress(task, step.getStepOrder(), false);
        
        // 通知步骤更新
        notificationService.notifyStepUpdate(task.getTaskId(), step);
        
        deviceCoordinationService.syncDeviceStatus(device, 
            DeviceCoordinationService.DeviceStatus.FAILED, context);
        
        return StepResult.failure(device.getDeviceName(), 
            String.format("执行失败（已重试%d次）", retryAttempt));
    }

    /**
     * 带重试的交互步骤执行
     */
    private StepResult executeInteractionStepWithRetry(MultiDeviceTask task,
                                                      TaskStepDetail step,
                                                      DeviceConfig device,
                                                      TaskExecutionContext context,
                                                      DeviceInteraction deviceInteraction,
                                                      RetryPolicy retryPolicy) {
        int retryAttempt = 0;
        Exception lastException = null;
        
        while (retryAttempt <= retryPolicy.getMaxRetryCount()) {
            try {
                if (retryAttempt > 0) {
                    long waitTime = retryPolicy.calculateRetryInterval(retryAttempt);
                    log.info("交互步骤执行重试: deviceId={}, retryAttempt={}/{}, waitTime={}ms", 
                        device.getId(), retryAttempt, retryPolicy.getMaxRetryCount(), waitTime);
                    Thread.sleep(waitTime);
                    
                    step.setRetryCount(retryAttempt);
                    step.setStatus(TaskStepDetail.Status.RUNNING.name());
                    step.setStartTime(new Date());
                    taskStepDetailMapper.updateById(step);
                }

                InteractionContext interactionContext = new InteractionContext(device, context);
                step.setInputData(toJson(context.getParameters()));
                InteractionResult interactionResult = deviceInteraction.execute(interactionContext);
                boolean success = interactionResult != null && interactionResult.isSuccess();
                updateStepAfterInteraction(step, interactionResult);
                updateTaskProgress(task, step.getStepOrder(), success);

                if (success) {
                    deviceCoordinationService.syncDeviceStatus(device, 
                        DeviceCoordinationService.DeviceStatus.COMPLETED, context);
                    return StepResult.success(device.getDeviceName(), interactionResult.getMessage());
                } else {
                    if (retryAttempt < retryPolicy.getMaxRetryCount()) {
                        retryAttempt++;
                        continue;
                    }
                    deviceCoordinationService.syncDeviceStatus(device, 
                        DeviceCoordinationService.DeviceStatus.FAILED, context);
                    String message = interactionResult != null ? interactionResult.getMessage() : "交互执行失败";
                    return StepResult.failure(device.getDeviceName(), message);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                log.error("交互步骤执行被中断, deviceId={}", device.getId(), e);
                step.setStatus(TaskStepDetail.Status.FAILED.name());
                step.setErrorMessage("执行被中断: " + e.getMessage());
                step.setEndTime(new Date());
                step.setDurationMs(step.getEndTime().getTime() - step.getStartTime().getTime());
                step.setRetryCount(retryAttempt);
                taskStepDetailMapper.updateById(step);
                updateTaskProgress(task, step.getStepOrder(), false);
                return StepResult.failure(device.getDeviceName(), "执行被中断");
            } catch (Exception e) {
                lastException = e;
                log.error("交互执行异常, deviceId={}, retryAttempt={}", device.getId(), retryAttempt, e);
                
                if (retryAttempt < retryPolicy.getMaxRetryCount() && retryPolicy.isRetryable(e)) {
                    retryAttempt++;
                    continue;
                }
                
                step.setStatus(TaskStepDetail.Status.FAILED.name());
                step.setErrorMessage(e.getMessage());
                step.setEndTime(new Date());
                step.setDurationMs(step.getEndTime().getTime() - step.getStartTime().getTime());
                step.setRetryCount(retryAttempt);
                taskStepDetailMapper.updateById(step);
                updateTaskProgress(task, step.getStepOrder(), false);
                
                // 通知步骤更新
                notificationService.notifyStepUpdate(task.getTaskId(), step);
                
                deviceCoordinationService.syncDeviceStatus(device, 
                    DeviceCoordinationService.DeviceStatus.FAILED, context);
                
                String errorMsg = retryAttempt > 0 
                    ? String.format("执行失败（已重试%d次）: %s", retryAttempt, e.getMessage())
                    : e.getMessage();
                return StepResult.failure(device.getDeviceName(), errorMsg);
            }
        }
        
        step.setStatus(TaskStepDetail.Status.FAILED.name());
        step.setErrorMessage(lastException != null ? lastException.getMessage() : "交互执行失败");
        step.setEndTime(new Date());
        step.setDurationMs(step.getEndTime().getTime() - step.getStartTime().getTime());
        step.setRetryCount(retryAttempt);
        taskStepDetailMapper.updateById(step);
        updateTaskProgress(task, step.getStepOrder(), false);
        
        // 通知步骤更新
        notificationService.notifyStepUpdate(task.getTaskId(), step);
        
        deviceCoordinationService.syncDeviceStatus(device, 
            DeviceCoordinationService.DeviceStatus.FAILED, context);
        
        return StepResult.failure(device.getDeviceName(), 
            String.format("执行失败（已重试%d次）", retryAttempt));
    }

    /**
     * 获取重试策略
     */
    private RetryPolicy getRetryPolicy(DeviceConfig device) {
        // 可以从设备配置中读取重试策略
        // 暂时使用默认策略
        return RetryPolicy.defaultPolicy();
    }

    /**
     * 判断业务失败是否可重试
     */
    private boolean isRetryableFailure(DevicePlcVO.OperationResult result) {
        if (result == null || result.getMessage() == null) {
            return false;
        }
        String message = result.getMessage().toLowerCase();
        // 网络错误、超时错误可重试
        return message.contains("timeout") || 
               message.contains("connection") ||
               message.contains("网络") ||
               message.contains("超时");
    }


    private void updateStepAfterOperation(TaskStepDetail step,
                                          DevicePlcVO.OperationResult result,
                                          boolean success) {
        step.setEndTime(new Date());
        if (step.getStartTime() != null) {
            step.setDurationMs(step.getEndTime().getTime() - step.getStartTime().getTime());
        }
        step.setStatus(success ? TaskStepDetail.Status.COMPLETED.name() : TaskStepDetail.Status.FAILED.name());
        step.setErrorMessage(success ? null : result.getMessage());
        step.setOutputData(toJson(result));
        taskStepDetailMapper.updateById(step);
    }

    private void updateStepAfterInteraction(TaskStepDetail step,
                                            InteractionResult result) {
        step.setEndTime(new Date());
        if (step.getStartTime() != null) {
            step.setDurationMs(step.getEndTime().getTime() - step.getStartTime().getTime());
        }
        boolean success = result != null && result.isSuccess();
        step.setStatus(success ? TaskStepDetail.Status.COMPLETED.name() : TaskStepDetail.Status.FAILED.name());
        step.setErrorMessage(success ? null : (result != null ? result.getMessage() : "交互执行失败"));
        step.setOutputData(result != null ? toJson(result.getData()) : "{}");
        taskStepDetailMapper.updateById(step);
    }

    private void updateTaskProgress(MultiDeviceTask task, int currentStep, boolean success) {
        task.setCurrentStep(currentStep);
        if (!success) {
            task.setStatus(MultiDeviceTask.Status.FAILED.name());
        }
        LambdaUpdateWrapper<MultiDeviceTask> update = Wrappers.<MultiDeviceTask>lambdaUpdate()
                .eq(MultiDeviceTask::getId, task.getId())
                .set(MultiDeviceTask::getCurrentStep, currentStep);
        if (!success) {
            update.set(MultiDeviceTask::getStatus, MultiDeviceTask.Status.FAILED.name());
        }
        multiDeviceTaskMapper.update(null, update);
        
        // 通知任务状态更新
        notificationService.notifyTaskStatus(task);
    }

    private String determineOperation(DeviceConfig device, Map<String, Object> params) {
        if (params != null && params.containsKey("operation")) {
            Object op = params.get("operation");
            if (op != null) {
                return String.valueOf(op);
            }
        }
        return DEFAULT_OPERATIONS.getOrDefault(device.getDeviceType(), "feedGlass");
    }

    private Map<String, Object> buildOperationParams(DeviceConfig device, TaskExecutionContext context) {
        Map<String, Object> params = new HashMap<>();
        TaskParameters taskParams = context.getParameters();

        switch (device.getDeviceType()) {
            case DeviceConfig.DeviceType.LOAD_VEHICLE:
                params.put("glassIds", new ArrayList<>(taskParams.getGlassIds()));
                if (StringUtils.hasText(taskParams.getPositionCode())) {
                    params.put("positionCode", taskParams.getPositionCode());
                }
                if (taskParams.getPositionValue() != null) {
                    params.put("positionValue", taskParams.getPositionValue());
                }
                params.put("triggerRequest", true);
                break;
            case DeviceConfig.DeviceType.LARGE_GLASS:
                List<String> source = context.getSafeLoadedGlassIds();
                if (CollectionUtils.isEmpty(source)) {
                    source = taskParams.getGlassIds();
                }
                if (!CollectionUtils.isEmpty(source)) {
                    params.put("glassId", source.get(0));
                    params.put("glassIds", new ArrayList<>(source));
                }
                params.put("processType", taskParams.getProcessType() != null ? taskParams.getProcessType() : 1);
                params.put("triggerRequest", true);
                break;
            case DeviceConfig.DeviceType.GLASS_STORAGE:
                List<String> processed = context.getSafeProcessedGlassIds();
                if (CollectionUtils.isEmpty(processed)) {
                    processed = context.getSafeLoadedGlassIds();
                }
                if (!CollectionUtils.isEmpty(processed)) {
                    params.put("glassId", processed.get(0));
                    params.put("glassIds", new ArrayList<>(processed));
                }
                if (taskParams.getStoragePosition() != null) {
                    params.put("storagePosition", taskParams.getStoragePosition());
                }
                params.put("triggerRequest", true);
                break;
            default:
                if (!CollectionUtils.isEmpty(taskParams.getExtra())) {
                    params.putAll(taskParams.getExtra());
                }
        }

        mergeOverrides(device, taskParams, params);
        return params;
    }

    private void mergeOverrides(DeviceConfig device, TaskParameters taskParameters, Map<String, Object> params) {
        if (CollectionUtils.isEmpty(taskParameters.getDeviceOverrides())) {
            return;
        }
        Map<String, Object> override = taskParameters.getDeviceOverrides().get(device.getDeviceType());
        if (override == null && StringUtils.hasText(device.getDeviceCode())) {
            override = taskParameters.getDeviceOverrides().get(device.getDeviceCode());
        }
        if (override != null) {
            params.putAll(override);
        }
    }

    private void updateContextAfterSuccess(DeviceConfig device,
                                           TaskExecutionContext context,
                                           Map<String, Object> params) {
        List<String> glassIds = extractGlassIds(params);
        
        switch (device.getDeviceType()) {
            case DeviceConfig.DeviceType.LOAD_VEHICLE:
                context.setLoadedGlassIds(glassIds);
                // 数据传递：大车设备 -> 下一个设备
                if (!CollectionUtils.isEmpty(glassIds)) {
                    Map<String, Object> transferData = new HashMap<>();
                    transferData.put("glassIds", glassIds);
                    transferData.put("sourceDevice", device.getDeviceCode());
                    // 这里简化处理，实际应该找到下一个设备
                    // 在串行模式下，下一个设备会在循环中自动获取
                }
                break;
            case DeviceConfig.DeviceType.LARGE_GLASS:
                context.setProcessedGlassIds(glassIds);
                // 数据传递：大理片 -> 下一个设备
                if (!CollectionUtils.isEmpty(glassIds)) {
                    Map<String, Object> transferData = new HashMap<>();
                    transferData.put("glassIds", glassIds);
                    transferData.put("sourceDevice", device.getDeviceCode());
                }
                break;
            default:
                break;
        }
    }

    private List<String> extractGlassIds(Map<String, Object> params) {
        if (params == null) {
            return Collections.emptyList();
        }
        Object glassIds = params.get("glassIds");
        if (glassIds instanceof List) {
            @SuppressWarnings("unchecked")
            List<String> cast = (List<String>) glassIds;
            return new ArrayList<>(cast);
        }
        Object glassId = params.get("glassId");
        if (glassId != null) {
            return Collections.singletonList(String.valueOf(glassId));
        }
        return Collections.emptyList();
    }

    private String toJson(Object value) {
        try {
            return objectMapper.writeValueAsString(value);
        } catch (JsonProcessingException e) {
            return "{}";
        }
    }

    private static class StepResult {
        private final boolean success;
        private final String message;
        private final String deviceName;

        private StepResult(boolean success, String message, String deviceName) {
            this.success = success;
            this.message = message;
            this.deviceName = deviceName;
        }

        public static StepResult success(String deviceName, String message) {
            return new StepResult(true, message, deviceName);
        }

        public static StepResult failure(String deviceName, String message) {
            return new StepResult(false, message, deviceName);
        }

        public boolean isSuccess() {
            return success;
        }

        public String getMessage() {
            return message;
        }

        public Map<String, Object> toSummary() {
            Map<String, Object> summary = new HashMap<>();
            summary.put("deviceName", deviceName);
            summary.put("success", success);
            summary.put("message", message);
            return summary;
        }
    }
}