package com.ruoyi.system.service.impl;

import com.ruoyi.common.config.LegacySystemConfig;
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.ITaskStatusPushService;
import com.ruoyi.system.utils.TaskStatusPushConverter;
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 TaskStatusPushServiceImpl implements ITaskStatusPushService {
    
    private static final Logger log = LoggerFactory.getLogger(TaskStatusPushServiceImpl.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 pushTaskStatusToLegacy(Long taskId) {
        if (!legacyConfig.isEnabled()) {
            log.info("旧系统同步已禁用，跳过状态推送，任务ID: {}", taskId);
            return false;
        }
        
        try {
            // 查询任务信息
            log.debug("【新推旧】查询任务ID: {}", taskId);
            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;
            }
            
            // 获取新系统状态
            TaskStatus newTaskStatus = TaskStatus.getByCode(task.getTaskStatus());
            if (newTaskStatus == null) {
                log.error("无效的任务状态，任务ID: {}, 状态码: {}", taskId, task.getTaskStatus());
                return false;
            }
            
            // 转换为旧系统状态码
            Integer targetStatusCode = TaskStatusPushConverter.convertToLegacyStatus(newTaskStatus);
            if (targetStatusCode == null) {
                log.debug("【新推旧】任务状态不需要推送到旧系统，任务ID: {}, 状态: {}",
                    taskId, newTaskStatus.getInfo());
                return false;
            }
            
            // 查询旧系统当前状态
            Integer currentLegacyStatus = dispatchOrdService.selectDispatchOrdStateByID(
                emergency.getLegacyDispatchOrdId());
            if (currentLegacyStatus == null) {
                log.error("【新推旧】查询旧系统状态失败，任务ID: {}, DispatchOrdID: {}",
                    taskId, emergency.getLegacyDispatchOrdId());
                return false;
            }
            
            // 判断是否需要更新（包含防止状态倒退的检查）
            // 如果旧系统状态已经 >= 新系统要推送的状态，说明旧系统状态更新，新系统落后，不应该推送
            if (!TaskStatusPushConverter.shouldUpdateLegacyStatus(targetStatusCode, currentLegacyStatus)) {
                log.info("【新推旧】新系统状态落后或等于旧系统状态，跳过推送，任务ID: {}, 新系统状态: {} ({}→{}), 旧系统状态: {} ({})",
                    taskId, 
                    task.getTaskStatus(), newTaskStatus.getInfo(), targetStatusCode,
                    currentLegacyStatus, TaskStatusPushConverter.getLegacyStatusDescription(currentLegacyStatus));
                return true; // 返回true，因为这不算失败，只是不需要推送
            }
            
            // 推送状态到旧系统
            boolean result = updateLegacyTaskStatus(emergency.getLegacyDispatchOrdId(), targetStatusCode);
            
            if (result) {
                log.info("【新推旧】任务状态推送成功，任务ID: {}, DispatchOrdID: {}, 旧状态: {} ({}), 新状态: {} ({})",
                    taskId, emergency.getLegacyDispatchOrdId(),
                    currentLegacyStatus, TaskStatusPushConverter.getLegacyStatusDescription(currentLegacyStatus),
                    targetStatusCode, TaskStatusPushConverter.getLegacyStatusDescription(targetStatusCode));
            } else {
                log.error("【新推旧】任务状态推送失败，任务ID: {}, DispatchOrdID: {}",
                    taskId, emergency.getLegacyDispatchOrdId());
            }
            
            return result;
            
        } catch (Exception e) {
            log.error("【新推旧】推送任务状态异常，任务ID: {}", taskId, e);
            return false;
        }
    }
    
    /**
     * 批量推送任务状态到旧系统
     * 使用分页查询，确保所有符合条件的任务都能被推送
     * 
     * @return 成功推送的任务数量
     */
    @Override
    public int batchPushTaskStatusToLegacy() {
        if (!legacyConfig.isEnabled()) {
            log.info("旧系统同步已禁用");
            return 0;
        }
        
        try {
            int totalSuccessCount = 0;
            int pageSize = 200; // 每页200条
            int offset = 0;
            
            while (true) {
                // 分页查询已同步调度单且状态未完成的任务
                List<SysTaskEmergency> syncedTasks = sysTaskEmergencyService.selectSyncedTasksForStatusUpdate(offset, pageSize);
                
                if (syncedTasks == null || syncedTasks.isEmpty()) {
                    log.info("【新推旧】没有更多需要推送状态的任务，offset: {}", offset);
                    break; // 没有更多数据，退出循环
                }
                
                log.info("【新推旧】开始推送状态第 {} 页，任务数量: {}", (offset / pageSize) + 1, syncedTasks.size());
                
                int pageSuccessCount = 0;
                for (SysTaskEmergency emergency : syncedTasks) {
                    boolean result = pushTaskStatusToLegacy(emergency.getTaskId());
                    if (result) {
                        pageSuccessCount++;
                    }
                    
                    // 避免过于频繁的请求
                    try {
                        Thread.sleep(200); // 每个请求间隔0.2秒
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        log.warn("【新推旧】推送状态被中断");
                        return totalSuccessCount + 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;
        }
    }
    
    /**
     * 更新旧系统调度单状态（直接操作SQL Server数据库）
     * 
     * @param dispatchOrdId 调度单ID
     * @param statusCode 目标状态码
     * @return 是否成功
     */
    private boolean updateLegacyTaskStatus(Long dispatchOrdId, Integer statusCode) {
        try {
            // 直接通过Service调用Mapper更新SQL Server数据库
            int rows = dispatchOrdService.updateDispatchOrdState(dispatchOrdId, statusCode);
            log.debug("更新旧系统状态，DispatchOrdID: {}, StateInt: {}", dispatchOrdId, statusCode);
            if (rows > 0) {
                log.debug("更新旧系统状态成功，DispatchOrdID: {}, StateInt: {}", 
                    dispatchOrdId, statusCode);
                return true;
            } else {
                log.warn("更新旧系统状态失败，未找到对应调度单，DispatchOrdID: {}", dispatchOrdId);
                return false;
            }
            
        } catch (Exception e) {
            log.error("更新旧系统状态异常，DispatchOrdID: {}", dispatchOrdId, e);
            return false;
        }
    }
}