package com.ruoyi.system.listener;

import com.ruoyi.common.config.LegacySystemConfig;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.system.domain.SysTask;
import com.ruoyi.system.domain.SysTaskEmergency;
import com.ruoyi.system.domain.enums.TaskStatus;
import com.ruoyi.system.event.TaskStatusChangedEvent;
import com.ruoyi.system.mapper.LegacyTransferSyncMapper;
import com.ruoyi.system.mapper.SysTaskEmergencyMapper;
import com.ruoyi.system.mapper.SysTaskMapper;
import com.ruoyi.system.mapper.SysUserMapper;
import com.ruoyi.system.utils.TaskStatusPushConverter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.event.EventListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

import java.util.Date;

/**
 * 调度单状态变更记录监听器
 * 监听任务状态变更事件，并将状态变更记录同步到SQL Server的DispatchOrd_Running表
 * 
 * @author ruoyi
 * @date 2025-12-05
 */
@Component
public class DispatchOrdRunningListener {
    
    private static final Logger log = LoggerFactory.getLogger(DispatchOrdRunningListener.class);
    
    @Autowired
    private LegacySystemConfig legacyConfig;
    
    @Autowired
    private SysTaskMapper sysTaskMapper;
    
    @Autowired
    private SysTaskEmergencyMapper sysTaskEmergencyMapper;
    
    @Autowired
    private LegacyTransferSyncMapper legacyTransferSyncMapper;

    @Autowired
    private SysUserMapper sysUserMapper;
    
    /**
     * 监听任务状态变更事件
     * 
     * @param event 任务状态变更事件
     */
    @Async
    @EventListener
    public void handleTaskStatusChangedEvent(TaskStatusChangedEvent event) {
        try {
            log.info("收到任务状态变更事件，准备同步到DispatchOrd_Running，任务ID：{}，旧状态：{}，新状态：{}", 
                    event.getTaskId(), event.getOldStatus(), event.getNewStatus());
            
            // 检查旧系统同步是否启用
            if (!legacyConfig.isEnabled()) {
                log.debug("旧系统同步已禁用，跳过DispatchOrd_Running同步，任务ID: {}", event.getTaskId());
                return;
            }
            
            // 查询任务信息
            SysTask task = sysTaskMapper.selectSysTaskByTaskId(event.getTaskId());
            if (task == null) {
                log.error("任务不存在，任务ID: {}", event.getTaskId());
                return;
            }
            
            // 只处理急救转运任务
            if (!"EMERGENCY_TRANSFER".equals(task.getTaskType())) {
                log.debug("非急救转运任务，跳过DispatchOrd_Running同步，任务ID: {}", event.getTaskId());
                return;
            }
            
            // 查询急救转运扩展信息
            SysTaskEmergency emergency = sysTaskEmergencyMapper.selectSysTaskEmergencyByTaskId(event.getTaskId());
            if (emergency == null) {
                log.error("急救转运扩展信息不存在，任务ID: {}", event.getTaskId());
                return;
            }
            
            // 必须已经同步过调度单
            if (emergency.getLegacyDispatchOrdId() == null || emergency.getLegacyDispatchOrdId() <= 0) {
                log.debug("调度单未同步到旧系统，跳过DispatchOrd_Running同步，任务ID: {}", event.getTaskId());
                return;
            }
            
            // 获取新系统状态
            TaskStatus newTaskStatus = TaskStatus.getByCode(event.getNewStatus());
            if (newTaskStatus == null) {
                log.error("无效的任务状态，任务ID: {}, 状态码: {}", event.getTaskId(), event.getNewStatus());
                return;
            }

            SysUser user= sysUserMapper.selectUserById(event.getOperatorId());
            if(user==null){
                log.error("操作人不存在，任务ID: {}, 操作人ID: {}", event.getTaskId(), event.getOperatorId());
                return;
            }
            Integer oaUserId=user.getOaUserId();
            
            // 转换为旧系统状态码
            Integer legacyStatusCode = TaskStatusPushConverter.convertToLegacyStatus(newTaskStatus);
            if (legacyStatusCode == null) {
                log.debug("任务状态不需要同步到旧系统，任务ID: {}, 状态: {}",
                    event.getTaskId(), newTaskStatus.getInfo());
                return;
            }
            
            // 插入状态变更记录到DispatchOrd_Running表
            syncDispatchOrdRunning(
                emergency.getLegacyDispatchOrdId(),
                legacyStatusCode,
                new Date(), // 使用当前时间作为状态变更时
                    oaUserId.longValue(),
                event.getLatitude(),
                event.getLongitude(),
                event.getAddress()
            );
            
        } catch (Exception e) {
            log.error("处理任务状态变更事件并同步到DispatchOrd_Running失败，任务ID: {}", event.getTaskId(), e);
            // 不抛出异常，避免影响主流程
        }
    }
    
    /**
     * 同步状态变更记录到DispatchOrd_Running表
     * 
     * @param dispatchOrdId 调度单ID
     * @param statusCode 状态码
     * @param statusTime 状态时间
     * @param operatorId 操作人ID
     * @param latitude 纬度
     * @param longitude 经度
     * @param address 地址
     */
    private void syncDispatchOrdRunning(Long dispatchOrdId, Integer statusCode, 
                                        Date statusTime, Long operatorId,
                                        Double latitude, Double longitude, String address) {
        try {
            // 判断是否有GPS信息
            boolean hasGps = (latitude != null && longitude != null);
            if (hasGps) {
                log.info("开始同步状态变更记录到DispatchOrd_Running，DispatchOrdID: {}, 状态码: {} ({}), GPS: [{}, {}]", 
                    dispatchOrdId, statusCode, TaskStatusPushConverter.getLegacyStatusDescription(statusCode),
                    latitude, longitude);
            } else {
                log.info("开始同步状态变更记录到DispatchOrd_Running，DispatchOrdID: {}, 状态码: {} ({}), 无GPS信息", 
                    dispatchOrdId, statusCode, TaskStatusPushConverter.getLegacyStatusDescription(statusCode));
            }
            
            // 调用Mapper插入记录
            int rows = legacyTransferSyncMapper.insertDispatchOrdRunning(
                dispatchOrdId,
                statusCode,
                statusTime,
                operatorId,
                latitude,
                longitude,
                address
            );
            
            if (rows > 0) {
                if (hasGps) {
                    log.info("状态变更记录已同步到DispatchOrd_Running，DispatchOrdID: {}, 状态码: {} ({}), GPS: [{}, {}], 地址: {}", 
                        dispatchOrdId, 
                        statusCode, 
                        TaskStatusPushConverter.getLegacyStatusDescription(statusCode),
                        latitude, 
                        longitude,
                        address != null ? address : "无");
                } else {
                    log.info("状态变更记录已同步到DispatchOrd_Running，DispatchOrdID: {}, 状态码: {} ({}), 无GPS信息", 
                        dispatchOrdId, 
                        statusCode, 
                        TaskStatusPushConverter.getLegacyStatusDescription(statusCode));
                }
            } else {
                log.warn("同步状态变更记录失败，未插入数据，DispatchOrdID: {}", dispatchOrdId);
            }
            
        } catch (Exception e) {
            log.error("同步状态变更记录到DispatchOrd_Running异常，DispatchOrdID: {}, 状态码: {}", 
                dispatchOrdId, statusCode, e);
            // 不抛出异常，避免影响主流程
        }
    }
}