package com.fs.app.websocket.service;//package com.fs.app.websocket.service;
//
//
//import com.alibaba.fastjson.JSON;
//import com.alibaba.fastjson.JSONObject;
//import com.fs.app.params.SendSopParam;
//import com.fs.app.params.SendSopParamDetailsB;
//import com.fs.app.params.SopLogsEditParam;
//import com.fs.app.websocket.bean.MsgBean;
//import com.fs.common.core.redis.RedisCache;
//import com.fs.common.utils.StringUtils;
//import com.fs.common.utils.spring.SpringUtils;
//import com.fs.course.domain.FsCourseWatchLog;
//import com.fs.course.service.IFsCourseWatchLogService;
//import com.fs.qw.domain.QwExternalContact;
//import com.fs.qw.domain.QwUser;
//import com.fs.qw.service.IQwExternalContactService;
//import com.fs.qw.service.IQwUserService;
//import com.fs.qw.vo.QwSopTempSetting;
//import com.fs.qwApi.param.QwExternalContactHParam;
//import com.fs.sop.domain.QwSopLogs;
//import com.fs.sop.service.IQwSopLogsService;
//import com.fs.sop.service.IQwSopService;
//import com.fs.sop.vo.QwSopLogsDoSendListTVO;
//import org.springframework.stereotype.Component;
//
//import javax.websocket.*;
//import javax.websocket.server.PathParam;
//import javax.websocket.server.ServerEndpoint;
//import java.io.IOException;
//import java.text.SimpleDateFormat;
//import java.time.Instant;
//import java.time.ZonedDateTime;
//import java.util.*;
//import java.util.concurrent.ConcurrentHashMap;
//import java.util.concurrent.TimeUnit;
//import java.util.stream.Collectors;
//
//@ServerEndpoint("/app/webSocket/{key}")
//@Component
//public class WebSocketServer2 {
//
//    //concurrent包的线程安全Set，用来存放每个客户端对应的WebSocketServer对象。
//    private static ConcurrentHashMap<String, Session> sessionPools = new ConcurrentHashMap<>();
//    RedisCache redisCache=SpringUtils.getBean(RedisCache.class);
//    IQwSopService qwSopService=SpringUtils.getBean(IQwSopService.class);
//    IQwSopLogsService qwSopLogsService=SpringUtils.getBean(IQwSopLogsService.class);
//    IQwUserService qwUserService=SpringUtils.getBean(IQwUserService.class);
//    IFsCourseWatchLogService watchLogService=SpringUtils.getBean(IFsCourseWatchLogService.class);
//    IQwExternalContactService qwExternalContactService=SpringUtils.getBean(IQwExternalContactService.class);
//
//    //发送消息
//    public void sendMessage(Session session, String message,String id,String sopLogId) throws IOException {
//        if(session != null){
//            synchronized (session) {
//
//                session.getBasicRemote().sendText(message);
//
//                if (id != null && sopLogId != null) {
//
//                    //获取时间戳
//                    long timestamp = Instant.now().getEpochSecond();
//                    System.out.println("时间："+new Date()+"-发送消息："+message);
//
//                    // 发送消息并解除占用
//                    redisCache.setCacheObject("QwSopMsg:" + id, timestamp+"/0");
//                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
//                    //更新发送状态
//                    QwSopLogs qwSopLogs=new QwSopLogs();
//                    qwSopLogs.setId(sopLogId);
//                    qwSopLogs.setSendStatus(1L);
//                    qwSopLogs.setRealSendTime(sdf.format(new Date()));
//                    qwSopLogsService.updateQwSopLogs(qwSopLogs);
//
//
//                }
//
//
//
//            }
//        }
//    }
//    public void sendBaseMessage(Session session, String message) throws IOException {
//        if(session != null){
//            synchronized (session) {
//                session.getBasicRemote().sendText(message);
//
//            }
//        }
//    }
//    public void sendBaseInfo(String id, String message){
//        Session session = sessionPools.get(id);
//        try {
//            if(session != null){
//                sendBaseMessage(session, message);
//            }
//
//        }catch (Exception e){
//            e.printStackTrace();
//        }
//    }
//    public void sendBaseSleepInfo(String id, String message){
//        try {
//            Random random = new Random();
//            int randomNumber = random.nextInt(1000);
//            Thread.sleep(1+randomNumber); // 5000 毫秒 = 5 秒
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
//        Session session = sessionPools.get(id);
//        try {
//            if(session != null){
//                sendBaseMessage(session, message);
//            }
//
//        }catch (Exception e){
//            e.printStackTrace();
//        }
//    }
//    //给指定用户发送信息
//    public void sendInfo(String id, String message,String sopLogId){
//        Session session = sessionPools.get(id);
//
//        try {
//            if(session != null){
//
//                sendMessage(session, message,id,sopLogId);
//
//            }else {
//
//                //获取时间戳
//                long timestamp = Instant.now().getEpochSecond();
//                // 解除占用
//                redisCache.setCacheObject("QwSopMsg:" + id, timestamp+"/0");
//
//            }
//
//        }catch (Exception e){
//            e.printStackTrace();
//        }
//    }
//
//    //建立连接成功调用
//    @OnOpen
//    public void onOpen(Session session, @PathParam(value = "key") String key){
//        sessionPools.put(key, session);
//        //获取时间戳
//        long timestamp = Instant.now().getEpochSecond();
//
//        if (!key.equals("null") && !key.isEmpty()){
//            // 发送消息（存入时间和占用状态）
//            redisCache.setCacheObject("QwSopMsg:" + key, timestamp+"/0",2, TimeUnit.HOURS);
//
//            System.out.println(key + "加入webSocket！当前人数为" + sessionPools.size());
//        }
//    }
//
//    //关闭连接时调用
//    @OnClose
//    public void onClose(@PathParam(value = "key") String key){
//
//        sessionPools.remove(key);
//        redisCache.deleteObject("QwSopMsg:" + key);
//
//        System.out.println(key + "断开webSocket连接！当前人数为" + sessionPools.size());
//    }
//
//    //收到客户端信息
//    @OnMessage
//    public void onMessage(String message) throws IOException{
//        MsgBean msg=(MsgBean) JSONObject.parseObject(message, MsgBean.class);
//        Session session;
////        System.out.println( "收到数据：" + msg.getCmd());
//        try {
//            switch (msg.getCmd()){
//                case "heartbeat":
//                    session=sessionPools.get(msg.getKey());
//                    sendMessage(session, JSONObject.toJSONString(msg),null,null);
//                    break;
//                case "sendMsg":
//                    if (msg.getData()!=null&&msg.getData()!=""){
//
//                        System.out.println("收到heartbeat数据" + msg);
//
//                        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
//                        SopLogsEditParam sopLogsEditParam = JSONObject.parseObject(msg.getData(), SopLogsEditParam.class);
//
//                        QwSopLogs sopLogs=new QwSopLogs();
//                        sopLogs.setId(sopLogsEditParam.getId());
//                        sopLogs.setReceivingStatus(sopLogsEditParam.getReceivingStatus());
//                        sopLogs.setRemark(sopLogsEditParam.getRemark());
//                        sopLogs.setRealSendTime(sdf.format(new Date()));
//
//                        qwSopLogsService.updateQwSopLogs(sopLogs);
//
//                    }
//                    break;
//            }
//        }
//        catch (Exception e){
//            System.out.println( "收到数据" + e.getMessage());
//        }
//
//    }
//    //错误时调用
//    @OnError
//    public void onError(Session session, Throwable throwable){
//        System.out.println("发生错误"+throwable.getMessage());
//        throwable.printStackTrace();
//    }
//    public void sendSopMsg() throws InterruptedException {
//        redisCache.setCacheObject("sopFlag","start");
//        while (true){
//            String startSop=redisCache.getCacheObject("sopFlag");
//            if(StringUtils.isEmpty(startSop)){
//                return;
//            }
//            Thread.sleep(30000);
//            try {
//                List<String> keys = sessionPools.keySet().stream()
//                        .map(key -> {
//                            // 保留非空键并去除前后空白
//                            return key != null ? key.trim() : null; // 如果 key 是 null，返回 null
//                        })
//                        .filter(Objects::nonNull) // 过滤掉 null 值
//                        .collect(Collectors.toList()); // 收集结果到 List
//
//                System.out.println("查人开始发送-");
//                for(String key :keys){
//                    //获取每一个人的SOP待发送记录
//                    QwUser user=qwUserService.selectQwUserByAppKey(key);
//
//                    List<QwSopLogsDoSendListTVO> logs=qwSopLogsService.selectQwSopLogsDoSendList(user.getQwUserId(),user.getCorpId());
//
//                    for(QwSopLogsDoSendListTVO log:logs){
//
//                        //客户的信息
//                        QwExternalContactHParam contactHParam=new QwExternalContactHParam();
//                        contactHParam.setUserId(log.getQwUserid());
//                        contactHParam.setExternalUserId(log.getExternalUserId());
//                        contactHParam.setCorpId(user.getCorpId());
//
//                        QwExternalContact contactDetails = qwExternalContactService.getQwExternalContactDetails(contactHParam);
//
//                        QwSopTempSetting.Content content = JSON.parseObject(log.getContentJson(), QwSopTempSetting.Content.class);
//
//                        //过期时间为空,多半删了任务直接作废任务
//                        if (log.getExpiryTime()==null){
//                            qwSopLogsService.updateQwSopLogsByWatchLogType(log.getId(), "SOP任务被删除");
//                        }else {
//
//                            //过期时间
//                            Integer expiryTime = log.getExpiryTime();
//                            //发送时间
//                            Date sendTime = log.getSendTime();
//
//                            //当前时间
//                            Date now = new Date();
//                            // 创建一个Calendar实例，并设置时间为发送时间
//                            Calendar calendar = Calendar.getInstance();
//                            calendar.setTime(sendTime);
//                            calendar.add(Calendar.HOUR_OF_DAY, expiryTime);
//
//                            // 计算发送时间加上expiryTime小时后的时间
//                            Date expiryDate = calendar.getTime();
//
//                            // 判断当前时间是否大于发送时间加上expiryTime小时后的时间
//                            boolean isExpired = now.after(expiryDate);
//
//                            //当前时间大于发送时间，作废消息
//                            if (isExpired) {
//                                //作废消息
//                                qwSopLogsService.updateQwSopLogsByWatchLogType(log.getId(), "已过期，不发送");
//                            }else {
//
//                                //封装消息体
//                                SendSopParamDetailsB sopParamDetailsB=new SendSopParamDetailsB();
//                                sopParamDetailsB.setSopLogId(log.getId());
//                                sopParamDetailsB.setExternalUserId(log.getExternalUserId());
//                                sopParamDetailsB.setExternalUserName(log.getExternalUserName());
//                                sopParamDetailsB.setQwUserid(log.getQwUserid());
//                                sopParamDetailsB.setSetting(content.getSetting());
//
//                                Object appKeyValue = redisCache.getCacheObject("QwSopMsg:" + key);
//                                //key过期了/无key，人还在线 续上 在线
//                                if (appKeyValue == null) {
//                                    //获取时间戳
//                                    long timestamp = Instant.now().getEpochSecond();
//
//                                    //续上在线时间，并锁上
//                                    redisCache.setCacheObject("QwSopMsg:" + key, timestamp + "/1", 2, TimeUnit.HOURS);
//
//                                    //延迟随机2-4秒内发送
//                                    switch (content.getType()) {
//                                        //普通消息
//                                        case 1:
//                                            long l = 2 + (long) (5 * new Random().nextDouble());
//
//                                            Thread.sleep(l * 1000);
//
//                                            //发送消息
//                                            sendGeneralMsg(key, sopParamDetailsB, log.getId());
//
//                                            break;
//                                        //课程消息
//                                        case 2:
//
//
//                                            //查询观看记录状态
//                                            FsCourseWatchLog fsCourseWatchLog = watchLogService.getWatchCourseLogVideoBySop(log.getFsUserId(), Long.valueOf(content.getVideoId()), String.valueOf(user.getId()),contactDetails.getId());
//
//
//                                            //2-4秒
//                                            long l2 = 2 + (long) (5 * new Random().nextDouble());
//
//                                            Thread.sleep(l2 * 1000);
//
//                                            //发送消息
//                                            handleMessage(fsCourseWatchLog, content.getCourseType(), log.getId(), key, sopParamDetailsB);
//
//                                            break;
//                                        //订单消息
//                                        case 3:
//                                            break;
//                                    }
//                                }
//                                //不为空 走正常线
//                                else {
//
//                                    //不为空 则比较时间
//
//                                    String[] keyValue = appKeyValue.toString().split("/");
//                                    String timeValue = keyValue[0];
//                                    String timeStatus = keyValue[1];
//
//                                    //key占用着那么就不发
//                                    if (timeStatus.equals("1")) {
//                                        return;
//                                    } else {
//
//                                        //没被占用 那就用着占着
//                                        redisCache.setCacheObject("QwSopMsg:" + key, timeValue + "/1");
//
//                                        long timestampNow = ZonedDateTime.now().toEpochSecond();
//                                        long timeOld = Long.parseLong(timeValue);
//
//                                        switch (content.getType()) {
//                                            //普通消息
//                                            case 1:
//
//                                                // 判断是否超过 2 秒
//                                                if (timestampNow - timeOld >= 2) {
//
//                                                    //超过2秒再随机2秒内
//                                                    long l = (long) (Math.random() * 4) + 1;
//
//                                                    Thread.sleep(l * 1000);
//
//                                                    //发送消息
//                                                    sendGeneralMsg(key, sopParamDetailsB, log.getId());
//                                                } else {
//
//                                                    // 计算剩余的等待时间
//                                                    long t = 2 - (timestampNow - timeOld);
//
//                                                    // 生成一个大于0且小于等于3的随机数
//                                                    long l = (long) (Math.random() * 5) + 1;
//
//
//                                                    // 延迟执行等待时间+随机数秒
//                                                    Thread.sleep((t + l) * 1000);
//
//                                                    //发送消息
//                                                    sendGeneralMsg(key, sopParamDetailsB, log.getId());
//                                                }
//                                                break;
//                                            //课程消息
//                                            case 2:
//
//
//                                                //查询观看记录状态
//                                                FsCourseWatchLog fsCourseWatchLog = watchLogService.getWatchCourseLogVideoBySop(log.getFsUserId(), Long.valueOf(content.getVideoId()), String.valueOf(user.getId()),contactDetails.getId());
//
//                                                // 判断是否超过 2 秒
//                                                if (timestampNow - timeOld >= 2) {
//
//                                                    // 生成一个大于0且小于等于2的随机数
//                                                    long l = (long) (Math.random() * 4) + 1;
//
//                                                    //超过2秒再随机5秒内
//                                                    Thread.sleep(l * 1000);
//
//                                                    //发送消息
//                                                    handleMessage(fsCourseWatchLog, content.getCourseType(), log.getId(), key, sopParamDetailsB);
//
//                                                } else {
//
//                                                    // 计算剩余的等待时间
//                                                    long t = 2 - (timestampNow - timeOld);
//
//                                                    // 生成一个大于0且小于等于5的随机数
//                                                    long l = (long) (Math.random() * 5) + 1;
//
//                                                    // 延迟执行等待时间+随机数秒
//                                                    Thread.sleep((t + l) * 1000);
//
//                                                    //发送消息
//                                                    handleMessage(fsCourseWatchLog, content.getCourseType(), log.getId(), key, sopParamDetailsB);
//
//
//                                                }
//                                                break;
//                                            //订单消息
//                                            case 3:
//                                                break;
//                                        }
//
//                                        //获取时间戳
//                                        long timestamp = Instant.now().getEpochSecond();
//
//                                        // 解除占用
//                                        redisCache.setCacheObject("QwSopMsg:" + key, timestamp+"/0");
//                                    }
//                                }
//                            }
//                        }
//                    }
//                }
//            }catch (Exception e){
//                System.out.println("发生错误:"+e);
//            }
//
//        }
//    }
//
//    private void handleMessage(FsCourseWatchLog watchLog, int courseType, String logId, String userAppKey, SendSopParamDetailsB sopParamDetailsB) {
//        boolean shouldInvalidate = false;
//
//        SendSopParam sopParam = new SendSopParam();
//        sopParam.setCmd("sendMsg");
//        sopParam.setData(JSON.toJSONString(sopParamDetailsB));
//        sopParam.setKey(userAppKey);
//
//        Integer  courseTypeChange=null;
//
//        switch (courseType){
//            case 0:
//                courseTypeChange=0;
//                break;
//            case 1:
//                courseTypeChange=3;
//                break;
//            case 2:
//                courseTypeChange=1;
//                break;
//            case 3:
//                courseTypeChange=2;
//                break;
//        }
//        if (watchLog!=null){
//
//
//            // 逻辑判断(所有状态均可以发普通消息)
//            if ((watchLog.getLogType().equals(1) && ( courseType == 1)) ||
//                    (watchLog.getLogType().equals(2) && (courseType == 1 || courseType == 2)) ||
//                    (watchLog.getLogType().equals(3) && (courseType == 2 || courseType == 3))) {
//                shouldInvalidate = true;
//            }
//
//            // 更新记录或发送消息
//            if (shouldInvalidate) {
//
//                //作废消息
//                qwSopLogsService.updateQwSopLogsByWatchLogType(logId,"未满足条件，不发送");
//
//                //获取时间戳
//                long timestamp = Instant.now().getEpochSecond();
//
//                // 解除占用
//                redisCache.setCacheObject("QwSopMsg:" + userAppKey, timestamp+"/0");
//
//            } else if (watchLog.getLogType().equals(courseTypeChange) || courseType == 0) {
//
//                // 客户状态与课程状态相等时发送或普通消息
//                sendInfo(userAppKey, JSON.toJSONString(sopParam), logId);
//            }
//        }else {
//
//            //没有观看记录 那就只发 普通消息和待看课的消息 其他的全作废
//            if (courseType==0 || courseType==1){
//
//                //发送消息
//                sendInfo(userAppKey, JSON.toJSONString(sopParam), logId);
//
//            }else {
//
//                //作废消息
//                qwSopLogsService.updateQwSopLogsByWatchLogType(logId,"无观看记录，不发送");
//
//
//                //获取时间戳
//                long timestamp = Instant.now().getEpochSecond();
//
//                // 解除占用
//                redisCache.setCacheObject("QwSopMsg:" + userAppKey, timestamp+"/0");
//            }
//
//        }
//
//        //获取时间戳
//        long timestamp = Instant.now().getEpochSecond();
//        // 解除占用
//        redisCache.setCacheObject("QwSopMsg:" + userAppKey, timestamp+"/0");
//    }
//
//    //发送普通消息
//    private void sendGeneralMsg(String userAppKey, SendSopParamDetailsB sopParamDetailsB,String sopLogId) {
//
//        SendSopParam sopParam = new SendSopParam();
//        sopParam.setCmd("sendMsg");
//        sopParam.setData(JSON.toJSONString(sopParamDetailsB));
//        sopParam.setKey(userAppKey);
//
//        sendInfo(userAppKey, JSON.toJSONString(sopParam), sopLogId);
//
//        //获取时间戳
//        long timestamp = Instant.now().getEpochSecond();
//        // 解除占用
//        redisCache.setCacheObject("QwSopMsg:" + userAppKey, timestamp+"/0");
//
//    }
//}
