package com.mes.device.service;

import com.mes.device.entity.DeviceConfig;
import com.mes.device.entity.DeviceGroupConfig;
import com.mes.task.model.TaskExecutionContext;

import java.util.List;
import java.util.Map;

/**
 * 设备协调服务
 * 负责设备间数据传递、状态同步、依赖管理等协调工作
 * 
 * @author mes
 * @since 2025-01-XX
 */
public interface DeviceCoordinationService {

    /**
     * 协调设备组执行
     * 根据设备依赖关系和执行顺序，协调多个设备的执行
     * 
     * @param groupConfig 设备组配置
     * @param devices 设备列表（已按执行顺序排序）
     * @param context 任务执行上下文
     * @return 协调结果，包含是否可以执行、依赖关系等信息
     */
    CoordinationResult coordinateExecution(DeviceGroupConfig groupConfig, 
                                          List<DeviceConfig> devices, 
                                          TaskExecutionContext context);

    /**
     * 传递数据到下一个设备
     * 将当前设备的数据传递给下一个设备
     * 
     * @param fromDevice 源设备
     * @param toDevice 目标设备
     * @param data 要传递的数据
     * @param context 任务执行上下文
     * @return 是否传递成功
     */
    boolean transferData(DeviceConfig fromDevice, 
                        DeviceConfig toDevice, 
                        Map<String, Object> data, 
                        TaskExecutionContext context);

    /**
     * 同步设备状态
     * 将设备状态同步到共享上下文
     * 
     * @param device 设备配置
     * @param status 设备状态
     * @param context 任务执行上下文
     */
    void syncDeviceStatus(DeviceConfig device, 
                         DeviceStatus status, 
                         TaskExecutionContext context);

    /**
     * 检查设备依赖关系
     * 检查设备是否满足执行的前置条件
     * 
     * @param device 设备配置
     * @param context 任务执行上下文
     * @return 依赖检查结果
     */
    DependencyCheckResult checkDependencies(DeviceConfig device, 
                                            TaskExecutionContext context);

    /**
     * 获取设备依赖的设备列表
     * 
     * @param device 设备配置
     * @param groupConfig 设备组配置
     * @return 依赖的设备列表
     */
    List<DeviceConfig> getDependentDevices(DeviceConfig device, 
                                           DeviceGroupConfig groupConfig);

    /**
     * 协调结果
     */
    class CoordinationResult {
        private final boolean canExecute;
        private final String message;
        private final Map<String, Object> metadata;

        public CoordinationResult(boolean canExecute, String message, Map<String, Object> metadata) {
            this.canExecute = canExecute;
            this.message = message;
            this.metadata = metadata;
        }

        public static CoordinationResult success(String message) {
            return new CoordinationResult(true, message, null);
        }

        public static CoordinationResult success(String message, Map<String, Object> metadata) {
            return new CoordinationResult(true, message, metadata);
        }

        public static CoordinationResult failure(String message) {
            return new CoordinationResult(false, message, null);
        }

        public boolean canExecute() {
            return canExecute;
        }

        public String getMessage() {
            return message;
        }

        public Map<String, Object> getMetadata() {
            return metadata;
        }
    }

    /**
     * 设备状态
     */
    enum DeviceStatus {
        IDLE,           // 空闲
        READY,          // 就绪
        RUNNING,        // 运行中
        COMPLETED,      // 已完成
        FAILED,         // 失败
        WAITING         // 等待中
    }

    /**
     * 依赖检查结果
     */
    class DependencyCheckResult {
        private final boolean satisfied;
        private final String message;
        private final List<String> missingDependencies;

        public DependencyCheckResult(boolean satisfied, String message, List<String> missingDependencies) {
            this.satisfied = satisfied;
            this.message = message;
            this.missingDependencies = missingDependencies;
        }

        public static DependencyCheckResult satisfied() {
            return new DependencyCheckResult(true, "依赖条件满足", null);
        }

        public static DependencyCheckResult unsatisfied(String message, List<String> missingDependencies) {
            return new DependencyCheckResult(false, message, missingDependencies);
        }

        public boolean isSatisfied() {
            return satisfied;
        }

        public String getMessage() {
            return message;
        }

        public List<String> getMissingDependencies() {
            return missingDependencies;
        }
    }
}