package com.ruoyi.system.service.impl;

import com.ruoyi.common.config.LegacySystemConfig;
import com.ruoyi.system.domain.DispatchOrd;
import com.ruoyi.system.domain.SysTask;
import com.ruoyi.system.domain.SysTaskEmergency;
import com.ruoyi.system.domain.enums.TaskStatus;
import com.ruoyi.system.mapper.SysTaskMapper;
import com.ruoyi.system.service.IDispatchOrdService;
import com.ruoyi.system.service.ISysTaskEmergencyService;
import com.ruoyi.system.service.ITaskStatusSyncService;
import com.ruoyi.system.utils.TaskStatusConverter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;

/**
 * 任务状态同步Service业务层处理
 * 负责从旧系统同步任务状态到新系统
 * 
 * @author ruoyi
 * @date 2024-01-16
 */
@Service
public class TaskStatusSyncServiceImpl implements ITaskStatusSyncService {
    
    private static final Logger log = LoggerFactory.getLogger(TaskStatusSyncServiceImpl.class);
    
    @Autowired
    private LegacySystemConfig legacyConfig;
    
    @Autowired
    private SysTaskMapper sysTaskMapper;
    
    @Autowired
    private ISysTaskEmergencyService sysTaskEmergencyService;
    
    @Autowired
    private IDispatchOrdService dispatchOrdService;
    
    /**
     * 从旧系统同步单个任务状态到新系统
     * 
     * @param taskId 任务ID
     * @return 是否同步成功
     */
    @Override
    @Transactional
    public boolean syncTaskStatusFromLegacy(Long taskId) {
        if (!legacyConfig.isEnabled()) {
            log.info("旧系统同步已禁用，跳过状态同步，任务ID: {}", taskId);
            return false;
        }
        
        try {
            // 查询任务信息
            SysTask task = sysTaskMapper.selectSysTaskByTaskId(taskId);
            if (task == null) {
                log.error("任务不存在，任务ID: {}", taskId);
                return false;
            }
            
            // 只同步急救转运任务
            if (!"EMERGENCY_TRANSFER".equals(task.getTaskType())) {
                log.info("非急救转运任务，跳过状态同步，任务ID: {}", taskId);
                return false;
            }
            
            // 查询急救转运扩展信息
            SysTaskEmergency emergency = sysTaskEmergencyService.selectSysTaskEmergencyByTaskId(taskId);
            if (emergency == null) {
                log.error("急救转运扩展信息不存在，任务ID: {}", taskId);
                return false;
            }
            
            // 必须已经同步过调度单
            if (emergency.getLegacyDispatchOrdId() == null || emergency.getLegacyDispatchOrdId() <= 0) {
                log.warn("调度单未同步，无法同步状态，任务ID: {}", taskId);
                return false;
            }
            
            // 查询旧系统状态（直接查询SQL Server数据库）
            Integer legacyStatus = dispatchOrdService.selectDispatchOrdStateByID(emergency.getLegacyDispatchOrdId());
            if (legacyStatus == null) {
                log.error("查询旧系统状态失败，任务ID: {}, DispatchOrdID: {}", taskId, emergency.getLegacyDispatchOrdId());
                return false;
            }
            
            // 调用内部方法同步状态
            return syncTaskStatusWithLegacyState(taskId, legacyStatus);
            
        } catch (Exception e) {
            log.error("同步任务状态异常，任务ID: {}", taskId, e);
            return false;
        }
    }
    
    /**
     * 批量同步已同步调度单的任务状态（从旧系统到新系统）
     * 使用分页查询，批量查询SQL Server数据库，减少网络请求次数
     * 
     * @return 成功同步的任务数量
     */
    @Override
    public int batchSyncTaskStatusFromLegacy() {
        if (!legacyConfig.isEnabled()) {
            log.info("旧系统同步已禁用");
            return 0;
        }
        
        try {
            int totalSuccessCount = 0;
            int pageSize = 200; // 每页200条
            int offset = 0;
            
            while (true) {
                // 1. 分页查询新系统中需要同步状态的任务（已同步调度单且状态未完成）
                List<SysTaskEmergency> syncedTasks = sysTaskEmergencyService.selectSyncedTasksForStatusUpdate(offset, pageSize);
                
                if (syncedTasks == null || syncedTasks.isEmpty()) {
                    log.info("没有更多需要同步状态的任务，offset: {}", offset);
                    break; // 没有更多数据，退出循环
                }
                
                log.info("开始同步状态第 {} 页，任务数量: {}", (offset / pageSize) + 1, syncedTasks.size());
                
                // 2. 提取调度单ID列表
                List<Long> dispatchOrdIDs = new ArrayList<>();
                Map<Long, SysTaskEmergency> dispatchIdToTaskMap = new HashMap<>();
                
                for (SysTaskEmergency emergency : syncedTasks) {
                    Long dispatchOrdId = emergency.getLegacyDispatchOrdId();
                    if (dispatchOrdId != null && dispatchOrdId > 0) {
                        dispatchOrdIDs.add(dispatchOrdId);
                        dispatchIdToTaskMap.put(dispatchOrdId, emergency);
                    }
                }
                
                if (dispatchOrdIDs.isEmpty()) {
                    log.warn("本页没有有效的调度单ID");
                    offset += pageSize;
                    continue;
                }
                
                // 3. 批量查询旧系统调度单状态（直接查询SQL Server数据库）
                List<DispatchOrd> dispatchOrds = dispatchOrdService.selectDispatchOrdStatesByIDs(dispatchOrdIDs);
                
                if (dispatchOrds == null || dispatchOrds.isEmpty()) {
                    log.warn("未查询到旧系统调度单状态");
                    offset += pageSize;
                    continue;
                }
                
                // 4. 构建调度单ID到状态的映射
                Map<Long, Integer> dispatchIdToStateMap = new HashMap<>();
                for (DispatchOrd dispatchOrd : dispatchOrds) {
                    try {
                        Long dispatchOrdId = Long.parseLong(dispatchOrd.getDispatchOrdID());
                        Integer dispatchOrdState = Integer.parseInt(dispatchOrd.getDispatchOrdState());
                        if (dispatchOrdState != null) {
                            dispatchIdToStateMap.put(dispatchOrdId, dispatchOrdState);
                        }
                    } catch (NumberFormatException e) {
                        log.error("解析调度单ID失败: {}", dispatchOrd.getDispatchOrdID(), e);
                    }
                }
                
                // 5. 遍历任务，同步状态
                int pageSuccessCount = 0;
                for (Map.Entry<Long, SysTaskEmergency> entry : dispatchIdToTaskMap.entrySet()) {
                    Long dispatchOrdId = entry.getKey();
                    SysTaskEmergency emergency = entry.getValue();
                    
                    // 获取旧系统状态
                    Integer legacyStatus = dispatchIdToStateMap.get(dispatchOrdId);
                    if (legacyStatus == null) {
                        log.warn("未找到调度单状态，DispatchOrdID: {}", dispatchOrdId);
                        continue;
                    }
                    
                    // 同步单个任务状态
                    boolean result = syncTaskStatusWithLegacyState(emergency.getTaskId(), legacyStatus);
                    if (result) {
                        pageSuccessCount++;
                    }
                }
                
                totalSuccessCount += pageSuccessCount;
                log.info("状态第 {} 页同步完成，总数: {}, 成功: {}", 
                    (offset / pageSize) + 1, syncedTasks.size(), pageSuccessCount);
                
                // 如果本页数据少于每页大小，说明已经是最后一页
                if (syncedTasks.size() < pageSize) {
                    log.info("已到达最后一页，状态同步结束");
                    break;
                }
                
                offset += pageSize; // 下一页
            }
            
            log.info("批量同步任务状态完成，总成功数: {}", totalSuccessCount);
            return totalSuccessCount;
            
        } catch (Exception e) {
            log.error("批量同步任务状态异常", e);
            return 0;
        }
    }
    
    /**
     * 同步单个任务状态（已知旧系统状态码）
     * 增加状态对比逻辑：当旧系统状态落后于新系统状态时，不进行同步
     * 
     * @param taskId 任务ID
     * @param legacyStatus 旧系统状态码
     * @return 是否成功
     */
    @Transactional
    private boolean syncTaskStatusWithLegacyState(Long taskId, Integer legacyStatus) {
        try {
            // 查询任务信息
            SysTask task = sysTaskMapper.selectSysTaskByTaskId(taskId);
            if (task == null) {
                log.error("任务不存在，任务ID: {}", taskId);
                return false;
            }
            
            // 转换为新系统状态
            TaskStatus newStatus = TaskStatusConverter.convertFromLegacyStatus(legacyStatus);
            if (newStatus == null) {
                log.debug("旧系统状态码 > 10 或无法转换，跳过同步，任务ID: {}, 状态码: {} ({})",
                    taskId, legacyStatus, TaskStatusConverter.getLegacyStatusDescription(legacyStatus));
                return false;
            }
            
            // 检查状态是否变化
            if (newStatus.getCode().equals(task.getTaskStatus())) {
                log.debug("任务状态未变化，任务ID: {}, 当前状态: {}", taskId, newStatus.getInfo());
                return true;
            }
            
            // 比较新旧系统状态的优先级，防止状态倒退
            TaskStatus currentStatus = TaskStatus.getByCode(task.getTaskStatus());
            if (currentStatus != null && !shouldSyncStatus(currentStatus, newStatus, legacyStatus)) {
                log.info("【旧系统更新到新系统】 旧系统状态落后于新系统状态，跳过同步，任务ID: {}, 新系统状态: {} ({}), 旧系统状态: {} ({})",
                    taskId, task.getTaskStatus(), currentStatus.getInfo(), 
                    newStatus.getCode(), TaskStatusConverter.getLegacyStatusDescription(legacyStatus));
                return false;
            }
            
            // 更新任务状态
            String oldStatus = task.getTaskStatus();
            task.setTaskStatus(newStatus.getCode());
            
            // 根据状态设置时间
            Date now = new Date();
            switch (newStatus) {
                case DEPARTING:
                case ARRIVED:
                case IN_PROGRESS:
                    // 如果实际开始时间为空，设置实际开始时间
                    if (task.getActualStartTime() == null) {
                        task.setActualStartTime(now);
                    }
                    break;
                case COMPLETED:
                case CANCELLED:
                    // 设置实际结束时间
                    if (task.getActualEndTime() == null) {
                        task.setActualEndTime(now);
                    }
                    // 如果实际开始时间为空，也设置一下
                    if (task.getActualStartTime() == null) {
                        task.setActualStartTime(now);
                    }
                    break;
                default:
                    break;
            }
            
            sysTaskMapper.updateSysTask(task);
            
            log.info("任务状态同步成功，任务ID: {}, 旧状态: {}, 新状态: {}, 旧系统状态码: {} ({})", 
                taskId, oldStatus, newStatus.getCode(), legacyStatus, 
                TaskStatusConverter.getLegacyStatusDescription(legacyStatus));
            
            return true;
            
        } catch (Exception e) {
            log.error("同步任务状态异常，任务ID: {}", taskId, e);
            return false;
        }
    }
    
    /**
     * 判断是否应该同步状态
     * 规则：旧系统状态码需要大于等于新系统当前状态对应的旧系统状态码
     * 防止因为时间差导致新系统状态比旧系统更新，而被旧系统的旧状态覆盖
     * 
     * @param currentStatus 新系统当前状态
     * @param targetStatus 旧系统转换后的目标状态
     * @param legacyStatusCode 旧系统状态码
     * @return true-应该同步，false-不应该同步
     */
    private boolean shouldSyncStatus(TaskStatus currentStatus, TaskStatus targetStatus, Integer legacyStatusCode) {
        // 获取新系统当前状态对应的旧系统状态码
        Integer currentLegacyCode = TaskStatusConverter.convertToLegacyStatus(currentStatus);
        
        if (currentLegacyCode == null) {
            // 如果当前状态无法转换为旧系统状态码，允许同步
            log.warn("新系统当前状态无法转换为旧系统状态码，允许同步，当前状态: {}", currentStatus.getCode());
            return true;
        }
        
        // 比较状态码大小
        // 旧系统状态码 >= 新系统当前状态对应的旧系统状态码，才允许同步
        // 例如：新系统已经是"出发中"(4)，旧系统还是"待处理"(3)，则不同步
        //      新系统是"出发中"(4)，旧系统是"已到达"(5)或"出发中"(4)，则同步
        boolean shouldSync = legacyStatusCode >= currentLegacyCode;
        
        if (!shouldSync) {
            log.debug("状态对比：旧系统状态码({}) < 新系统当前状态对应码({})",
                legacyStatusCode, currentLegacyCode);
        }
        
        return shouldSync;
    }
}