package com.ruoyi.system.service.impl;

import java.util.Date;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.mapper.SysMessageMapper;
import com.ruoyi.system.mapper.SysUserMapper;
import com.ruoyi.system.mapper.SysTaskAssigneeMapper;
import com.ruoyi.system.domain.SysMessage;
import com.ruoyi.system.domain.SysTask;
import com.ruoyi.system.domain.SysTaskAssignee;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.system.service.ISysMessageService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 系统消息Service业务层处理
 * 
 * @author ruoyi
 * @date 2025-10-25
 */
@Service
public class SysMessageServiceImpl implements ISysMessageService {
    
    private static final Logger log = LoggerFactory.getLogger(SysMessageServiceImpl.class);
    
    @Autowired
    private SysMessageMapper sysMessageMapper;
    
    @Autowired
    private SysUserMapper sysUserMapper;
    
    @Autowired
    private SysTaskAssigneeMapper sysTaskAssigneeMapper;

    /**
     * 查询系统消息
     * 
     * @param messageId 系统消息主键
     * @return 系统消息
     */
    @Override
    public SysMessage selectSysMessageByMessageId(Long messageId) {
        return sysMessageMapper.selectSysMessageByMessageId(messageId);
    }

    /**
     * 查询系统消息列表
     * 
     * @param sysMessage 系统消息
     * @return 系统消息
     */
    @Override
    public List<SysMessage> selectSysMessageList(SysMessage sysMessage) {
        return sysMessageMapper.selectSysMessageList(sysMessage);
    }

    /**
     * 查询用户的消息列表
     * 
     * @param receiverId 接收人ID
     * @return 系统消息集合
     */
    @Override
    public List<SysMessage> selectSysMessageListByReceiverId(Long receiverId) {
        return sysMessageMapper.selectSysMessageListByReceiverId(receiverId);
    }

    /**
     * 查询用户未读消息数量
     * 
     * @param receiverId 接收人ID
     * @return 未读消息数量
     */
    @Override
    public int countUnreadMessageByReceiverId(Long receiverId) {
        return sysMessageMapper.countUnreadMessageByReceiverId(receiverId);
    }

    /**
     * 新增系统消息
     * 
     * @param sysMessage 系统消息
     * @return 结果
     */
    @Override
    public int insertSysMessage(SysMessage sysMessage) {
        if (sysMessage.getCreateTime() == null) {
            sysMessage.setCreateTime(DateUtils.getNowDate());
        }
        if (sysMessage.getIsRead() == null) {
            sysMessage.setIsRead("0");
        }
        if (sysMessage.getDelFlag() == null) {
            sysMessage.setDelFlag("0");
        }
        return sysMessageMapper.insertSysMessage(sysMessage);
    }

    /**
     * 修改系统消息
     * 
     * @param sysMessage 系统消息
     * @return 结果
     */
    @Override
    public int updateSysMessage(SysMessage sysMessage) {
        sysMessage.setUpdateTime(DateUtils.getNowDate());
        return sysMessageMapper.updateSysMessage(sysMessage);
    }

    /**
     * 批量删除系统消息
     * 
     * @param messageIds 需要删除的系统消息主键
     * @return 结果
     */
    @Override
    public int deleteSysMessageByMessageIds(Long[] messageIds) {
        return sysMessageMapper.deleteSysMessageByMessageIds(messageIds);
    }

    /**
     * 删除系统消息信息
     * 
     * @param messageId 系统消息主键
     * @return 结果
     */
    @Override
    public int deleteSysMessageByMessageId(Long messageId) {
        return sysMessageMapper.deleteSysMessageByMessageId(messageId);
    }

    /**
     * 标记消息为已读
     * 
     * @param messageId 消息ID
     * @return 结果
     */
    @Override
    public int markMessageAsRead(Long messageId) {
        return sysMessageMapper.markMessageAsRead(messageId);
    }

    /**
     * 标记用户所有消息为已读
     * 
     * @param receiverId 接收人ID
     * @return 结果
     */
    @Override
    public int markAllMessagesAsRead(Long receiverId) {
        return sysMessageMapper.markAllMessagesAsRead(receiverId);
    }

    // ========== 消息推送业务方法 ==========

    /**
     * 推送任务创建成功消息（给创建人）
     * 
     * @param task 任务对象
     */
    @Override
    public void pushTaskCreateMessage(SysTask task) {
        try {
            if (task == null || task.getCreatorId() == null) {
                log.warn("任务对象或创建人ID为空，无法推送创建成功消息");
                return;
            }
            
            // 获取创建人信息
            SysUser creator = sysUserMapper.selectUserById(task.getCreatorId());
            if (creator == null) {
                log.warn("找不到创建人信息，用户ID：{}", task.getCreatorId());
                return;
            }
            
            SysMessage message = new SysMessage();
            message.setMessageType("CREATE");
            message.setMessageTitle("任务创建成功");
            message.setMessageContent("您创建的任务已成功提交");
            message.setTaskId(task.getTaskId());
            message.setTaskCode(task.getTaskCode());
            message.setReceiverId(task.getCreatorId());
            message.setReceiverName(creator.getNickName());
            message.setSenderId(task.getCreatorId());
            message.setSenderName("系统");
            
            insertSysMessage(message);
            log.info("推送任务创建成功消息，任务编号：{}，接收人：{}", task.getTaskCode(), creator.getNickName());
        } catch (Exception e) {
            log.error("推送任务创建成功消息失败", e);
        }
    }

    /**
     * 推送任务分配消息（给执行人）
     * 
     * @param task 任务对象
     * @param assigneeIds 执行人ID列表
     */
    @Override
    public void pushTaskAssignMessage(SysTask task, List<Long> assigneeIds) {
        try {
            if (task == null || assigneeIds == null || assigneeIds.isEmpty()) {
                log.warn("任务对象或执行人ID列表为空，无法推送任务分配消息");
                return;
            }
            
            // 获取创建人信息
            SysUser creator = null;
            if (task.getCreatorId() != null) {
                creator = sysUserMapper.selectUserById(task.getCreatorId());
            }
            
            String senderName = (creator != null && StringUtils.isNotEmpty(creator.getNickName())) 
                ? creator.getNickName() : "系统";
            
            // 给每个执行人发送消息
            for (Long assigneeId : assigneeIds) {
                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(task.getTaskId());
                message.setTaskCode(task.getTaskCode());
                message.setReceiverId(assigneeId);
                message.setReceiverName(assignee.getNickName());
                message.setSenderId(task.getCreatorId());
                message.setSenderName(senderName);
                
                insertSysMessage(message);
                log.info("推送任务分配消息，任务编号：{}，接收人：{}", task.getTaskCode(), assignee.getNickName());
            }
        } catch (Exception e) {
            log.error("推送任务分配消息失败", e);
        }
    }

    /**
     * 推送任务状态变更消息（给相关人员）
     * 
     * @param task 任务对象
     * @param oldStatus 旧状态
     * @param newStatus 新状态
     */
    @Override
    public void pushTaskStatusChangeMessage(SysTask task, String oldStatus, String newStatus) {
        try {
            if (task == null || StringUtils.isEmpty(newStatus)) {
                log.warn("任务对象或新状态为空，无法推送状态变更消息");
                return;
            }
            
            // 构建状态变更内容
            String statusContent = getStatusChangeContent(newStatus);
            
            // 查询任务的所有执行人
            List<SysTaskAssignee> assignees = sysTaskAssigneeMapper.selectSysTaskAssigneeByTaskId(task.getTaskId());
            
            if (assignees != null && !assignees.isEmpty()) {
                // 给每个执行人发送消息
                for (SysTaskAssignee assignee : assignees) {
                    SysUser user = sysUserMapper.selectUserById(assignee.getUserId());
                    if (user == null) {
                        log.warn("找不到执行人信息，用户ID：{}", assignee.getUserId());
                        continue;
                    }
                    
                    SysMessage message = new SysMessage();
                    message.setMessageType("STATUS");
                    message.setMessageTitle("任务状态变更");
                    message.setMessageContent(statusContent);
                    message.setTaskId(task.getTaskId());
                    message.setTaskCode(task.getTaskCode());
                    message.setReceiverId(assignee.getUserId());
                    message.setReceiverName(user.getNickName());
                    message.setSenderId(task.getCreatorId());
                    message.setSenderName("系统");
                    
                    insertSysMessage(message);
                    log.info("推送任务状态变更消息，任务编号：{}，新状态：{}，接收人：{}", 
                            task.getTaskCode(), newStatus, user.getNickName());
                }
            }
            
            // 同时给创建人发送消息（如果创建人不是执行人）
            if (task.getCreatorId() != null) {
                boolean isCreatorAlsoAssignee = assignees != null && assignees.stream()
                    .anyMatch(a -> a.getUserId().equals(task.getCreatorId()));
                
                if (!isCreatorAlsoAssignee) {
                    SysUser creator = sysUserMapper.selectUserById(task.getCreatorId());
                    if (creator != null) {
                        SysMessage message = new SysMessage();
                        message.setMessageType("STATUS");
                        message.setMessageTitle("任务状态变更");
                        message.setMessageContent(statusContent);
                        message.setTaskId(task.getTaskId());
                        message.setTaskCode(task.getTaskCode());
                        message.setReceiverId(task.getCreatorId());
                        message.setReceiverName(creator.getNickName());
                        message.setSenderId(task.getCreatorId());
                        message.setSenderName("系统");
                        
                        insertSysMessage(message);
                        log.info("推送任务状态变更消息给创建人，任务编号：{}，新状态：{}，接收人：{}", 
                                task.getTaskCode(), newStatus, creator.getNickName());
                    }
                }
            }
        } catch (Exception e) {
            log.error("推送任务状态变更消息失败", e);
        }
    }

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