package com.mes.interaction.vehicle.coordination;

import com.mes.device.entity.DeviceConfig;
import com.mes.device.service.DeviceConfigService;
import com.mes.device.service.DeviceGroupRelationService;
import com.mes.device.vo.DeviceGroupVO;
import com.mes.interaction.vehicle.model.VehiclePath;
import com.mes.interaction.vehicle.model.VehicleStatus;
import com.mes.interaction.vehicle.model.VehicleState;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 车辆协调服务
 * 负责在多个大车实例中选择和分配任务
 * 
 * @author mes
 * @since 2025-01-XX
 */
@Slf4j
@Service
public class VehicleCoordinationService {
    
    @Autowired
    private VehicleStatusManager statusManager;
    
    @Autowired
    private DeviceConfigService deviceConfigService;
    
    @Autowired
    private DeviceGroupRelationService deviceGroupRelationService;
    
    /**
     * 从设备组中选择一个可用的大车实例
     * 
     * @param groupId 设备组ID
     * @return 可用的设备配置，如果没有可用车辆则返回null
     */
    public DeviceConfig selectAvailableVehicle(Long groupId) {
        if (groupId == null) {
            log.warn("设备组ID为空，无法选择车辆");
            return null;
        }
        
        // 1. 获取设备组中的所有设备
        List<DeviceGroupVO.DeviceInfo> groupDevices = deviceGroupRelationService.getGroupDevices(groupId);
        if (groupDevices == null || groupDevices.isEmpty()) {
            log.warn("设备组 {} 中没有设备", groupId);
            return null;
        }
        
        // 2. 过滤出大车类型的设备
        List<DeviceGroupVO.DeviceInfo> vehicles = groupDevices.stream()
            .filter(d -> DeviceConfig.DeviceType.LOAD_VEHICLE.equals(d.getDeviceType()))
            .collect(Collectors.toList());
        
        if (vehicles.isEmpty()) {
            log.warn("设备组 {} 中没有大车设备", groupId);
            return null;
        }
        
        // 3. 过滤出可用的车辆
        List<DeviceGroupVO.DeviceInfo> availableVehicles = vehicles.stream()
            .filter(v -> {
                String deviceId = v.getId() != null ? v.getId().toString() : null;
                if (deviceId == null) {
                    deviceId = v.getDeviceCode();
                }
                return statusManager.isVehicleAvailable(deviceId);
            })
            .collect(Collectors.toList());
        
        if (availableVehicles.isEmpty()) {
            log.warn("设备组 {} 中没有可用的大车设备", groupId);
            return null;
        }
        
        // 4. 选择策略（简单策略：选择第一个可用的，可以扩展为按优先级、负载等选择）
        DeviceGroupVO.DeviceInfo selected = availableVehicles.get(0);
        
        // 5. 获取完整的设备配置
        DeviceConfig deviceConfig = null;
        if (selected.getId() != null) {
            deviceConfig = deviceConfigService.getDeviceById(selected.getId());
        } else if (selected.getDeviceCode() != null) {
            deviceConfig = deviceConfigService.getDeviceByCode(selected.getDeviceCode());
        }
        
        if (deviceConfig != null) {
            log.info("选择可用车辆: deviceId={}, deviceName={}", 
                deviceConfig.getDeviceId(), deviceConfig.getDeviceName());
        }
        
        return deviceConfig;
    }
    
    /**
     * 检查路径冲突
     * 
     * @param deviceId 设备ID
     * @param plannedPath 计划路径
     * @return true表示有冲突，false表示无冲突
     */
    public boolean hasPathConflict(String deviceId, VehiclePath plannedPath) {
        if (deviceId == null || plannedPath == null) {
            return false;
        }
        
        // 获取所有执行中的车辆
        List<VehicleStatus> executingVehicles = statusManager.getExecutingVehicles();
        
        // 排除自己
        executingVehicles = executingVehicles.stream()
            .filter(v -> !v.getDeviceId().equals(deviceId))
            .collect(Collectors.toList());
        
        // 检查路径是否冲突
        for (VehicleStatus vehicle : executingVehicles) {
            if (vehicle.getCurrentTask() != null) {
                VehiclePath existingPath = vehicle.getCurrentTask().getPlannedPath();
                if (existingPath != null && plannedPath.conflictsWith(existingPath)) {
                    log.warn("检测到路径冲突: deviceId={}, 与 deviceId={} 的路径冲突", 
                        deviceId, vehicle.getDeviceId());
                    return true;
                }
            }
        }
        
        return false;
    }
    
    /**
     * 获取设备组中所有大车设备
     * 
     * @param groupId 设备组ID
     * @return 大车设备列表
     */
    public List<DeviceConfig> getVehiclesInGroup(Long groupId) {
        if (groupId == null) {
            return Collections.emptyList();
        }
        
        List<DeviceGroupVO.DeviceInfo> groupDevices = deviceGroupRelationService.getGroupDevices(groupId);
        if (groupDevices == null || groupDevices.isEmpty()) {
            return Collections.emptyList();
        }
        
        return groupDevices.stream()
            .filter(d -> DeviceConfig.DeviceType.LOAD_VEHICLE.equals(d.getDeviceType()))
            .map(d -> {
                if (d.getId() != null) {
                    return deviceConfigService.getDeviceById(d.getId());
                } else if (d.getDeviceCode() != null) {
                    return deviceConfigService.getDeviceByCode(d.getDeviceCode());
                }
                return null;
            })
            .filter(d -> d != null)
            .collect(Collectors.toList());
    }
    
    /**
     * 获取设备组中所有可用的大车设备
     * 
     * @param groupId 设备组ID
     * @return 可用的大车设备列表
     */
    public List<DeviceConfig> getAvailableVehiclesInGroup(Long groupId) {
        return getVehiclesInGroup(groupId).stream()
            .filter(v -> statusManager.isVehicleAvailable(v.getDeviceId()))
            .collect(Collectors.toList());
    }
    
    /**
     * 检查设备组中是否有可用的大车
     * 
     * @param groupId 设备组ID
     * @return true表示有可用车辆，false表示没有
     */
    public boolean hasAvailableVehicle(Long groupId) {
        return selectAvailableVehicle(groupId) != null;
    }
}