package com.ruoyi.customer.service.impl;

import java.util.List;
import java.util.Date;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.system.mapper.ChatHistoryMapper;
import com.ruoyi.system.mapper.UserSessionsMapper;
import com.ruoyi.system.mapper.ManualServiceSessionsMapper;
import com.ruoyi.system.domain.ChatHistory;
import com.ruoyi.system.domain.UserSessions;
import com.ruoyi.system.domain.ManualServiceSessions;
import com.ruoyi.customer.service.ICustomerServiceService;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.core.text.Convert;

/**
 * 客服系统Service业务层处理
 * 
 * @author ruoyi
 * @date 2024-01-01
 */
@Service
public class CustomerServiceServiceImpl implements ICustomerServiceService 
{
    @Autowired
    private UserSessionsMapper userSessionsMapper;

    @Autowired
    private ChatHistoryMapper chatHistoryMapper;

    @Autowired
    private ManualServiceSessionsMapper manualServiceSessionsMapper;

    /**
     * 查询用户会话
     * 
     * @param sessionId 用户会话ID
     * @return 用户会话
     */
    @Override
    public UserSessions selectUserSessionsById(String sessionId)
    {
        return userSessionsMapper.selectUserSessionsById(sessionId);
    }

    /**
     * 查询用户会话列表
     * 
     * @param userSessions 用户会话
     * @return 用户会话
     */
    @Override
    public List<UserSessions> selectUserSessionsList(UserSessions userSessions)
    {
        return userSessionsMapper.selectUserSessionsList(userSessions);
    }

    /**
     * 获取活跃会话列表
     * 
     * @return 活跃会话集合
     */
    @Override
    public List<UserSessions> getActiveSessions()
    {
        UserSessions userSessions = new UserSessions();
        userSessions.setStatus("active");
        return userSessionsMapper.selectUserSessionsList(userSessions);
    }

    /**
     * 新增用户会话
     * 
     * @param userSessions 用户会话
     * @return 结果
     */
    @Override
    public int insertUserSessions(UserSessions userSessions)
    {
        userSessions.setCreateTime(DateUtils.getNowDate());
        return userSessionsMapper.insertUserSessions(userSessions);
    }

    /**
     * 修改用户会话
     * 
     * @param userSessions 用户会话
     * @return 结果
     */
    @Override
    public int updateUserSessions(UserSessions userSessions)
    {
        userSessions.setUpdateTime(DateUtils.getNowDate());
        return userSessionsMapper.updateUserSessions(userSessions);
    }

    /**
     * 检查会话ID是否已存在
     * 
     * @param sessionId 会话ID
     * @return 是否存在
     */
    @Override
    public boolean isSessionIdExists(String sessionId)
    {
        UserSessions userSession = userSessionsMapper.selectUserSessionsById(sessionId);
        return userSession != null;
    }

    /**
     * 删除用户会话对象
     * 
     * @param sessionIds 需要删除的数据ID
     * @return 结果
     */
    @Override
    public int deleteUserSessionsByIds(String[] sessionIds)
    {
        return userSessionsMapper.deleteUserSessionsByIds(sessionIds);
    }

    /**
     * 删除用户会话信息
     * 
     * @param sessionId 用户会话ID
     * @return 结果
     */
    @Override
    public int deleteUserSessionsById(String sessionId)
    {
        return userSessionsMapper.deleteUserSessionsById(sessionId);
    }

    /**
     * 根据会话ID获取聊天记录
     * 
     * @param sessionId 会话ID
     * @return 聊天记录列表
     */
    @Override
    public List<ChatHistory> getChatHistoryBySessionId(String sessionId)
    {
        ChatHistory chatHistory = new ChatHistory();
        chatHistory.setSessionId(sessionId);
        return chatHistoryMapper.selectChatHistoryList(chatHistory);
    }

    /**
     * 发送消息
     * 
     * @param chatHistory 聊天记录
     * @return 结果
     */
    @Override
    public int sendMessage(ChatHistory chatHistory)
    {
        chatHistory.setCreateTime(DateUtils.getNowDate());
        return chatHistoryMapper.insertChatHistory(chatHistory);
    }

    /**
     * 创建转人工服务请求
     * 
     * @param manualServiceSessions 转人工服务会话
     * @return 结果
     */
    @Override
    public int createManualServiceRequest(ManualServiceSessions manualServiceSessions)
    {
        System.out.println("[DEBUG] 开始创建转人工服务请求 - sessionId: " + manualServiceSessions.getSessionId() + ", reason: " + manualServiceSessions.getReason());
        
        manualServiceSessions.setCreateTime(DateUtils.getNowDate());
        manualServiceSessions.setStatus("0"); // 0-待处理
        
        System.out.println("[DEBUG] 准备插入数据库 - 数据: " + manualServiceSessions.toString());
        int result = manualServiceSessionsMapper.insertManualServiceSessions(manualServiceSessions);
        System.out.println("[DEBUG] 数据库插入结果: " + result);
        
        // 如果插入成功，通知所有在线客服
        if (result > 0) {
            try {
                System.out.println("[DEBUG] 数据库插入成功，开始发送WebSocket通知");
                
                // 创建WebSocket消息
                com.alibaba.fastjson.JSONObject message = new com.alibaba.fastjson.JSONObject();
                message.put("type", "MANUAL_REQUEST");
                message.put("sessionId", manualServiceSessions.getSessionId());
                message.put("reason", manualServiceSessions.getReason());
                message.put("timestamp", System.currentTimeMillis());
                
                System.out.println("[DEBUG] WebSocket消息内容: " + message.toJSONString());
                
                // 通过反射获取WebSocket类并发送广播消息
                Class<?> webSocketClass = Class.forName("com.ruoyi.web.websocket.CustomerServiceWebSocket");
                java.lang.reflect.Method getWebSocketMapMethod = webSocketClass.getMethod("getWebSocketMap");
                @SuppressWarnings("unchecked")
                java.util.concurrent.ConcurrentHashMap<String, Object> webSocketMap = 
                    (java.util.concurrent.ConcurrentHashMap<String, Object>) getWebSocketMapMethod.invoke(null);
                
                System.out.println("[DEBUG] 当前在线WebSocket连接数: " + webSocketMap.size());
                
                // 向所有在线客服发送通知
                int successCount = 0;
                int failCount = 0;
                for (String key : webSocketMap.keySet()) {
                    Object webSocket = webSocketMap.get(key);
                    try {
                        System.out.println("[DEBUG] 向WebSocket连接发送消息: " + key);
                        java.lang.reflect.Method sendMessageMethod = webSocket.getClass().getMethod("sendMessage", String.class);
                        sendMessageMethod.invoke(webSocket, message.toJSONString());
                        successCount++;
                        System.out.println("[DEBUG] 消息发送成功: " + key);
                    } catch (Exception e) {
                        failCount++;
                        System.err.println("[DEBUG] 向WebSocket连接发送消息失败: " + key + ", 错误: " + e.getMessage());
                    }
                }
                
                System.out.println("[DEBUG] WebSocket通知发送完成 - 成功: " + successCount + ", 失败: " + failCount);
                
            } catch (Exception e) {
                // 记录日志但不影响主要业务流程
                System.err.println("[DEBUG] 发送WebSocket通知失败: " + e.getMessage());
                e.printStackTrace();
            }
        } else {
            System.err.println("[DEBUG] 数据库插入失败，不发送WebSocket通知");
        }
        
        System.out.println("[DEBUG] 创建转人工服务请求完成 - 返回结果: " + result);
        return result;
    }

    /**
     * 更新转人工服务请求
     * 
     * @param manualServiceSessions 转人工服务会话
     * @return 结果
     */
    @Override
    public int updateManualServiceRequest(ManualServiceSessions manualServiceSessions)
    {
        manualServiceSessions.setUpdateTime(DateUtils.getNowDate());
        return manualServiceSessionsMapper.updateManualServiceSessions(manualServiceSessions);
    }

    /**
     * 获取待处理的转人工请求
     * 
     * @return 转人工请求列表
     */
    @Override
    public List<ManualServiceSessions> getPendingManualRequests()
    {
        ManualServiceSessions manualServiceSessions = new ManualServiceSessions();
        manualServiceSessions.setStatus("0"); // 0-待处理
        return manualServiceSessionsMapper.selectManualServiceSessionsList(manualServiceSessions);
    }

    /**
     * 更新客服状态
     * 
     * @param serviceId 客服ID
     * @param status 状态
     * @return 结果
     */
    @Override
    public int updateServiceStatus(Long serviceId, String status)
    {
        // 这里可以扩展为更新sys_user_online表或其他相关表
        return 1;
    }

    /**
     * 获取今日会话数量
     *
     * @return 会话数量
     */
    @Override
    public int getTodaySessionCount()
    {
        return 0;
    }

    /**
     * 获取今日消息数量
     *
     * @return 消息数量
     */
    @Override
    public int getTodayMessageCount()
    {
        return 0;
    }

    /**
     * 获取待处理请求数量
     *
     * @return 请求数量
     */
    @Override
    public int getPendingRequestCount()
    {
        return 0;
    }

    /**
     * 获取在线客服数量
     * 
     * @return 客服数量
     */
    @Override
    public int getOnlineServiceCount()
    {
        // 这里可以查询sys_user_online表获取在线客服数量
        return 5; // 临时返回固定值
    }

    /**
     * 查询聊天记录
     * 
     * @param messageId 聊天记录ID
     * @return 聊天记录
     */
    @Override
    public ChatHistory selectChatHistoryById(Long messageId)
    {
        return chatHistoryMapper.selectChatHistoryById(messageId);
    }

    /**
     * 查询聊天记录列表
     * 
     * @param chatHistory 聊天记录
     * @return 聊天记录
     */
    @Override
    public List<ChatHistory> selectChatHistoryList(ChatHistory chatHistory)
    {
        return chatHistoryMapper.selectChatHistoryList(chatHistory);
    }

    /**
     * 新增聊天记录
     * 
     * @param chatHistory 聊天记录
     * @return 结果
     */
    @Override
    public int insertChatHistory(ChatHistory chatHistory)
    {
        chatHistory.setCreateTime(DateUtils.getNowDate());
        return chatHistoryMapper.insertChatHistory(chatHistory);
    }

    /**
     * 修改聊天记录
     * 
     * @param chatHistory 聊天记录
     * @return 结果
     */
    @Override
    public int updateChatHistory(ChatHistory chatHistory)
    {
        return chatHistoryMapper.updateChatHistory(chatHistory);
    }

    /**
     * 删除聊天记录对象
     * 
     * @param messageIds 需要删除的数据ID
     * @return 结果
     */
    @Override
    public int deleteChatHistoryByIds(Long[] messageIds)
    {
        return chatHistoryMapper.deleteChatHistoryByIds(messageIds);
    }

    /**
     * 删除聊天记录信息
     * 
     * @param messageId 聊天记录ID
     * @return 结果
     */
    @Override
    public int deleteChatHistoryById(Long messageId)
    {
        return chatHistoryMapper.deleteChatHistoryById(messageId);
    }

    /**
     * 查询转人工服务会话
     * 
     * @param id 转人工服务会话ID
     * @return 转人工服务会话
     */
    @Override
    public ManualServiceSessions selectManualServiceSessionsById(Long id)
    {
        return manualServiceSessionsMapper.selectManualServiceSessionsById(id);
    }

    /**
     * 查询转人工服务会话列表
     * 
     * @param manualServiceSessions 转人工服务会话
     * @return 转人工服务会话
     */
    @Override
    public List<ManualServiceSessions> selectManualServiceSessionsList(ManualServiceSessions manualServiceSessions)
    {
        return manualServiceSessionsMapper.selectManualServiceSessionsList(manualServiceSessions);
    }

    /**
     * 新增转人工服务会话
     * 
     * @param manualServiceSessions 转人工服务会话
     * @return 结果
     */
    @Override
    public int insertManualServiceSessions(ManualServiceSessions manualServiceSessions)
    {
        manualServiceSessions.setCreateTime(DateUtils.getNowDate());
        return manualServiceSessionsMapper.insertManualServiceSessions(manualServiceSessions);
    }

    /**
     * 修改转人工服务会话
     * 
     * @param manualServiceSessions 转人工服务会话
     * @return 结果
     */
    @Override
    public int updateManualServiceSessions(ManualServiceSessions manualServiceSessions)
    {
        manualServiceSessions.setUpdateTime(DateUtils.getNowDate());
        return manualServiceSessionsMapper.updateManualServiceSessions(manualServiceSessions);
    }

    /**
     * 删除转人工服务会话对象
     * 
     * @param ids 需要删除的数据ID
     * @return 结果
     */
    @Override
    public int deleteManualServiceSessionsByIds(Long[] ids)
    {
        return manualServiceSessionsMapper.deleteManualServiceSessionsByIds(ids);
    }

    /**
     * 删除转人工服务会话信息
     * 
     * @param id 转人工服务会话ID
     * @return 结果
     */
    @Override
    public int deleteManualServiceSessionsById(Long id)
    {
        return manualServiceSessionsMapper.deleteManualServiceSessionsById(id);
    }
    
    /**
     * 清理用户的待处理转人工记录
     * 
     * @param userId 用户ID
     * @return 清理数量
     */
    @Override
    public int cleanupPendingManualRequests(Long userId)
    {
        ManualServiceSessions condition = new ManualServiceSessions();
        condition.setUserId(userId);
        condition.setStatus("0"); // 待处理状态
        
        List<ManualServiceSessions> pendingRequests = manualServiceSessionsMapper.selectManualServiceSessionsList(condition);
        
        if (pendingRequests != null && !pendingRequests.isEmpty()) {
            System.out.println("[DEBUG] 清理用户 " + userId + " 的待处理转人工记录，数量: " + pendingRequests.size());
            
            // 将状态更新为已关闭
            for (ManualServiceSessions request : pendingRequests) {
                request.setStatus("3"); // 3-已关闭（WebSocket断开）
                request.setEndTime(DateUtils.getNowDate());
                request.setUpdateTime(DateUtils.getNowDate());
                manualServiceSessionsMapper.updateManualServiceSessions(request);
            }
            
            return pendingRequests.size();
        }
        
        return 0;
    }
    
    /**
     * 根据会话ID获取待处理的转人工记录
     * 
     * @param sessionId 会话ID
     * @return 转人工记录列表
     */
    @Override
    public List<ManualServiceSessions> getPendingManualRequestsBySession(String sessionId)
    {
        ManualServiceSessions condition = new ManualServiceSessions();
        condition.setSessionId(sessionId);
        condition.setStatus("0"); // 待处理状态
        return manualServiceSessionsMapper.selectManualServiceSessionsList(condition);
    }
    
    /**
     * 根据ID获取转人工记录
     * 
     * @param requestId 记录ID
     * @return 转人工记录
     */
    @Override
    public ManualServiceSessions getManualRequestById(Long requestId)
    {
        return manualServiceSessionsMapper.selectManualServiceSessionsById(requestId);
    }
    
    /**
     * 根据用户ID获取待处理的转人工记录
     * 
     * @param userId 用户ID
     * @return 转人工记录列表
     */
    @Override
    public List<ManualServiceSessions> getPendingManualRequestsByUserId(Long userId)
    {
        ManualServiceSessions condition = new ManualServiceSessions();
        condition.setUserId(userId);
        condition.setStatus("0"); // 待处理状态
        return manualServiceSessionsMapper.selectManualServiceSessionsList(condition);
    }
    
    /**
     * 根据用户ID查找活跃的会话ID
     * 
     * @param userId 用户ID
     * @return 活跃的会话ID，如果没有则返回null
     */
    @Override
    public String findActiveSessionByUserId(Long userId)
    {
        // 查找该用户最近的活跃会话（状态为0-待处理或1-已接受）
        ManualServiceSessions condition = new ManualServiceSessions();
        condition.setUserId(userId);
        
        List<ManualServiceSessions> sessions = manualServiceSessionsMapper.selectManualServiceSessionsList(condition);
        
        if (sessions != null && !sessions.isEmpty()) {
            // 按创建时间倒序排列，获取最新的活跃会话
            for (ManualServiceSessions session : sessions) {
                if ("0".equals(session.getStatus()) || "1".equals(session.getStatus())) {
                    return session.getSessionId();
                }
            }
        }
        
        return null;
    }
    
    /**
     * 根据用户ID获取已接受状态的转人工记录
     * 
     * @param userId 用户ID
     * @return 已接受的转人工记录，如果没有则返回null
     */
    @Override
    public ManualServiceSessions getAcceptedManualSessionByUserId(Long userId)
    {
        ManualServiceSessions condition = new ManualServiceSessions();
        condition.setUserId(userId);
        condition.setStatus("1"); // 1-已接受状态
        
        List<ManualServiceSessions> sessions = manualServiceSessionsMapper.selectManualServiceSessionsList(condition);
        
        if (sessions != null && !sessions.isEmpty()) {
            // 返回最新的已接受会话
            return sessions.get(0);
        }
        
        return null;
    }
    
    /**
     * 通知用户转人工请求被接受
     * 
     * @param userId 用户ID
     * @param requestId 请求ID
     * @param serviceId 客服ID
     */
    @Override
    public void notifyUserManualRequestAccepted(Long userId, Long requestId, Long serviceId)
    {
        try {
            // 创建WebSocket消息
            com.alibaba.fastjson.JSONObject message = new com.alibaba.fastjson.JSONObject();
            message.put("type", "MANUAL_ACCEPTED");
            message.put("requestId", requestId);
            message.put("serviceId", serviceId);
            message.put("message", "您的转人工请求已被客服接受，即将为您服务");
            message.put("timestamp", System.currentTimeMillis());
            
            System.out.println("[DEBUG] 通知用户转人工请求被接受 - userId: " + userId + ", message: " + message.toJSONString());
            
            // 通过反射调用WebSocket发送消息方法
            Class<?> webSocketClass = Class.forName("com.ruoyi.web.websocket.CustomerServiceWebSocket");
            java.lang.reflect.Method sendMessageToUserMethod = webSocketClass.getMethod("sendMessageToUser", String.class, String.class);
            sendMessageToUserMethod.invoke(null, userId.toString(), message.toJSONString());
            
            System.out.println("[DEBUG] 用户通知发送成功");
            
        } catch (Exception e) {
            System.err.println("[DEBUG] 发送用户通知失败: " + e.getMessage());
            e.printStackTrace();
        }
    }
    
    /**
     * 清理客服的已接受转人工记录
     * 
     * @param serviceId 客服ID
     * @return 清理数量
     */
    @Override
    public int cleanupAcceptedManualRequestsByServiceId(Long serviceId)
    {
        ManualServiceSessions condition = new ManualServiceSessions();
        condition.setServiceId(serviceId);
        condition.setStatus("1"); // 已接受状态
        
        List<ManualServiceSessions> acceptedRequests = manualServiceSessionsMapper.selectManualServiceSessionsList(condition);
        
        if (acceptedRequests != null && !acceptedRequests.isEmpty()) {
            System.out.println("[DEBUG] 清理客服 " + serviceId + " 的已接受转人工记录，数量: " + acceptedRequests.size());
            
            // 将状态更新为已关闭
            for (ManualServiceSessions request : acceptedRequests) {
                request.setStatus("3"); // 3-已关闭（WebSocket断开）
                request.setEndTime(DateUtils.getNowDate());
                request.setUpdateTime(DateUtils.getNowDate());
                manualServiceSessionsMapper.updateManualServiceSessions(request);
            }
            
            return acceptedRequests.size();
        }
        
        return 0;
    }
}