package com.ruoyi.system.listener;

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 com.ruoyi.common.utils.DateUtils;
import com.ruoyi.system.domain.SysMessage;
import com.ruoyi.system.event.TaskCreatedEvent;
import com.ruoyi.system.event.TaskAssignedEvent;
import com.ruoyi.system.event.TaskStatusChangedEvent;
import com.ruoyi.system.mapper.SysMessageMapper;
import com.ruoyi.system.mapper.SysUserMapper;
import com.ruoyi.common.core.domain.entity.SysUser;

/**
 * 任务消息监听器
 * 监听任务相关事件并保存消息到消息库
 * 
 * @author ruoyi
 * @date 2025-10-25
 */
@Component
public class TaskMessageListener {
    
    private static final Logger log = LoggerFactory.getLogger(TaskMessageListener.class);
    
    @Autowired
    private SysMessageMapper sysMessageMapper;
    
    @Autowired
    private SysUserMapper sysUserMapper;

    /**
     * 监听任务创建事件
     * 
     * @param event 任务创建事件
     */
    @Async
    @EventListener
    public void handleTaskCreatedEvent(TaskCreatedEvent event) {
        try {
            log.info("收到任务创建事件，任务ID：{}，任务编号：{}", event.getTaskId(), event.getTaskCode());
            
            // 获取创建人信息
            SysUser creator = sysUserMapper.selectUserById(event.getCreatorId());
            if (creator == null) {
                log.warn("找不到创建人信息，用户ID：{}", event.getCreatorId());
                return;
            }
            
            // 创建消息
            SysMessage message = new SysMessage();
            message.setMessageType("CREATE");
            message.setMessageTitle("任务创建成功");
            message.setMessageContent("您创建的任务已成功提交");
            message.setTaskId(event.getTaskId());
            message.setTaskCode(event.getTaskCode());
            message.setReceiverId(event.getCreatorId());
            message.setReceiverName(creator.getNickName());
            message.setSenderId(event.getCreatorId());
            message.setSenderName("系统");
            message.setIsRead("0");
            message.setCreateTime(DateUtils.getNowDate());
            message.setDelFlag("0");
            
            // 保存消息
            sysMessageMapper.insertSysMessage(message);
            log.info("任务创建消息已保存，消息ID：{}", message.getMessageId());
            
        } catch (Exception e) {
            log.error("处理任务创建事件失败", e);
        }
    }

    /**
     * 监听任务分配事件
     * 
     * @param event 任务分配事件
     */
    @Async
    @EventListener
    public void handleTaskAssignedEvent(TaskAssignedEvent event) {
        try {
            log.info("收到任务分配事件，任务ID：{}，任务编号：{}，执行人数量：{}", 
                    event.getTaskId(), event.getTaskCode(), 
                    event.getAssigneeIds() != null ? event.getAssigneeIds().size() : 0);
            
            if (event.getAssigneeIds() == null || event.getAssigneeIds().isEmpty()) {
                log.warn("执行人ID列表为空，无法推送消息");
                return;
            }
            
            // 给每个执行人发送消息
            for (int i = 0; i < event.getAssigneeIds().size(); i++) {
                Long assigneeId = event.getAssigneeIds().get(i);
                
                // 获取执行人信息
                SysUser assignee = sysUserMapper.selectUserById(assigneeId);
                if (assignee == null) {
                    log.warn("找不到执行人信息，用户ID：{}", assigneeId);
                    continue;
                }
                
                // 创建消息
                SysMessage message = new SysMessage();
                message.setMessageType("PUSH");
                message.setMessageTitle("任务推送");
                message.setMessageContent("您有新的任务，请及时处理");
                message.setTaskId(event.getTaskId());
                message.setTaskCode(event.getTaskCode());
                message.setReceiverId(assigneeId);
                message.setReceiverName(assignee.getNickName());
                message.setSenderId(event.getAssignerId());
                message.setSenderName(event.getAssignerName() != null ? event.getAssignerName() : "系统");
                message.setIsRead("0");
                message.setCreateTime(DateUtils.getNowDate());
                message.setDelFlag("0");
                
                // 保存消息
                sysMessageMapper.insertSysMessage(message);
                log.info("任务分配消息已保存，消息ID：{}，接收人：{}", message.getMessageId(), assignee.getNickName());
            }
            
        } catch (Exception e) {
            log.error("处理任务分配事件失败", e);
        }
    }

    /**
     * 监听任务状态变更事件
     * 
     * @param event 任务状态变更事件
     */
    @Async
    @EventListener
    public void handleTaskStatusChangedEvent(TaskStatusChangedEvent event) {
        try {
            log.info("收到任务状态变更事件，任务ID：{}，旧状态：{}，新状态：{}", 
                    event.getTaskId(), event.getOldStatus(), event.getNewStatus());
            
            // 构建状态变更内容
            String statusContent = getStatusChangeContent(event.getNewStatus(), event.getNewStatusDesc());
            
            // 收集所有需要通知的用户ID（执行人+创建人，去重）
            java.util.Set<Long> receiverIds = new java.util.HashSet<>();
            
            // 添加执行人
            if (event.getAssigneeIds() != null) {
                receiverIds.addAll(event.getAssigneeIds());
            }
            
            // 添加创建人（如果不是执行人）
            if (event.getCreatorId() != null) {
                receiverIds.add(event.getCreatorId());
            }
            
            // 给每个用户发送消息
            for (Long receiverId : receiverIds) {
                SysUser user = sysUserMapper.selectUserById(receiverId);
                if (user == null) {
                    log.warn("找不到用户信息，用户ID：{}", receiverId);
                    continue;
                }
                
                // 创建消息
                SysMessage message = new SysMessage();
                message.setMessageType("STATUS");
                message.setMessageTitle("任务状态变更");
                message.setMessageContent(statusContent);
                message.setTaskId(event.getTaskId());
                message.setTaskCode(event.getTaskCode());
                message.setReceiverId(receiverId);
                message.setReceiverName(user.getNickName());
                message.setSenderId(event.getCreatorId());
                message.setSenderName("系统");
                message.setIsRead("0");
                message.setCreateTime(DateUtils.getNowDate());
                message.setDelFlag("0");
                
                // 保存消息
                sysMessageMapper.insertSysMessage(message);
                log.info("任务状态变更消息已保存，消息ID：{}，新状态：{}，接收人：{}", 
                        message.getMessageId(), event.getNewStatus(), user.getNickName());
            }
            
        } catch (Exception e) {
            log.error("处理任务状态变更事件失败", e);
        }
    }

    /**
     * 根据状态获取状态变更内容
     * 
     * @param status 任务状态
     * @param statusDesc 状态描述
     * @return 状态变更内容
     */
    private String getStatusChangeContent(String status, String statusDesc) {
        if (statusDesc != null && !statusDesc.isEmpty()) {
            return "任务状态变更为：" + statusDesc;
        }
        
        switch (status) {
            case "PENDING":
                return "任务状态变更为：待处理";
            case "DEPARTING":
            case "DEPARTED":
                return "任务状态变更为：已出发";
            case "ARRIVED":
                return "任务状态变更为：已到达";
            case "RETURNING":
                return "任务状态变更为：返程中";
            case "COMPLETED":
                return "任务状态变更为：已完成";
            case "CANCELLED":
                return "任务状态变更为：已取消";
            default:
                return "任务状态已更新";
        }
    }
}