package com.example.caseData.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.example.caseData.common.Response;
import com.example.caseData.dao.*;
import com.example.caseData.exception.BusinessException;
import com.example.caseData.model.*;
import com.example.caseData.request.caseExchangeRequest.addCaseExchange;
import com.example.caseData.request.caseExchangeRequest.addCaseExchangeComment;
import com.example.caseData.request.caseExchangeRequest.updateCaseExchange;
import com.example.caseData.utils.JwtUtil;
import com.example.caseData.utils.RegularUtil;
import com.example.caseData.utils.Replace;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.*;

@Service
public class CaseExchangeService {

    @Resource
    private UserCollectExchangeDao userCollectExchangeDao;

    @Resource
    private BasicSensitiveWordService basicSensitiveWordService;

    @Resource
    private CaseExchangeDao caseExchangeDao;

    @Resource
    private CaseExchangeVoteDao caseExchangeVoteDao;

    @Resource
    private CaseExchangeVoteOptionDao caseExchangeVoteOptionDao;

    @Resource
    private StatsCaseExchangeDao statsCaseExchangeDao;

    @Resource
    private CaseExchangeLabelDao caseExchangeLabelDao;

    @Resource
    private StatsCaseExchangeUserDao statsCaseExchangeUserDao;

    @Resource
    private UserCommentExchangeDao userCommentExchangeDao;

    @Resource
    private UserDao userDao;

    @Resource
    private UserService userService;

    @Resource
    private RegularUtil regularUtil;

    @Resource
    private UserVoteExchangeDao userVoteExchangeDao;

    @Resource
    private StatsCaseClinicalLabelDao statsCaseClinicalLabelDao;

    /**
     * 新增-病例交流
     * @param userId 用户id
     * @return bool
     */
    @Transactional
    public boolean AddCaseExchange(String userId, addCaseExchange r){
        // 验证入参数据
        if (r.getCaseExchangeVote() != null){
            if (r.getCaseExchangeVote().getCaseExchangeVoteOption() == null){
                throw new BusinessException("缺少选项");
            }

            if (r.getCaseExchangeVote().getCaseExchangeVoteOption().size() > 5){
                throw new BusinessException("选项不可多余5项");
            }

            if (r.getCaseExchangeVote().getCaseExchangeVoteOption().size() < 2){
                throw new BusinessException("选项不可少于2项");
            }

            if (r.getCaseExchangeVote().getVoteTitle() == null){
                throw new BusinessException("请输入投票标题");
            }

            if (r.getCaseExchangeVote().getValidDay() < 1 || r.getCaseExchangeVote().getValidDay() > 20){
                throw new BusinessException("投票有效期在1-20天内");
            }
        }

        if (r.getCaseExchangeLabel() != null && !r.getCaseExchangeLabel().isEmpty()){
            for (addCaseExchange.CaseExchangeLabelRequest caseExchangeLabelRequest : r.getCaseExchangeLabel()){
                if (caseExchangeLabelRequest.getAppIden() == null){
                    throw new BusinessException("操作失败");
                }

                if (caseExchangeLabelRequest.getLabelName() == null){
                    throw new BusinessException("操作失败");
                }
            }
        }

        // 处理违法内容
        BasicSensitiveWordService.FilterResult result = basicSensitiveWordService.filter(r.getExchangeContent());
        if (result.hasSensitive == 1){
            throw new BusinessException("内容中存在敏感词，请修改后提交");
        }

        if (r.getExchangeSummary() != null){
            result = basicSensitiveWordService.filter(r.getExchangeSummary());
            if (result.hasSensitive == 1){
                throw new BusinessException("总结中存在敏感词，请修改后提交");
            }
        }

        // 匹配预览视频
        List<String> videoUrls = regularUtil.extractOssVideosUrls(r.getExchangeContent());
        videoUrls.replaceAll(Replace::removeOssDomain);
        String exchangeContentVideo = String.join(",", videoUrls);

        String exchangeContentImage = "";
        if (exchangeContentVideo.isEmpty()){
            // 匹配预览图片
            List<String> imageUrls = regularUtil.extractOssImageUrls(r.getExchangeContent());
            imageUrls.replaceAll(Replace::removeOssDomain);
            exchangeContentImage = String.join(",", imageUrls);
        }else{
            exchangeContentImage = "";
        }

        // 新增病例交流
        CaseExchangeModel caseExchangeData = new CaseExchangeModel();
        caseExchangeData.setUserId(Long.valueOf(userId));
        caseExchangeData.setExchangeTitle(r.getExchangeTitle());
        caseExchangeData.setExchangeStatus(1);
        caseExchangeData.setPushDate(LocalDateTime.now(ZoneId.of("Asia/Shanghai")));
        caseExchangeData.setExchangeContent(r.getExchangeContent());
        caseExchangeData.setExchangeSummary(r.getExchangeSummary());
        caseExchangeData.setExchangeContentVideo(exchangeContentVideo);
        caseExchangeData.setExchangeContentImage(exchangeContentImage);
        int res = caseExchangeDao.insert(caseExchangeData);
        if (res <= 0){
            throw new BusinessException("操作失败");
        }

        // 新增投票
        if (r.getCaseExchangeVote() != null){
            // 投票结束时间
            LocalDateTime endTime = LocalDateTime.now().plusDays(r.getCaseExchangeVote().getValidDay());

            CaseExchangeVoteModel caseExchangeVoteData = new CaseExchangeVoteModel();
            caseExchangeVoteData.setExchangeId(caseExchangeData.getExchangeId());
            caseExchangeVoteData.setVoteTitle(r.getCaseExchangeVote().getVoteTitle());
            caseExchangeVoteData.setEndTime(endTime);
            res = caseExchangeVoteDao.insert(caseExchangeVoteData);
            if (res <= 0){
                throw new BusinessException("操作失败");
            }

            List<addCaseExchange.CaseExchangeVoteOptionRequest> caseExchangeVoteOption = r.getCaseExchangeVote().getCaseExchangeVoteOption();
            for (addCaseExchange.CaseExchangeVoteOptionRequest option : caseExchangeVoteOption ){
                CaseExchangeVoteOptionModel caseExchangeVoteOptionData = new CaseExchangeVoteOptionModel();
                caseExchangeVoteOptionData.setVoteId(caseExchangeVoteData.getVoteId());
                caseExchangeVoteOptionData.setOptionValue(option.getOptionValue());
                caseExchangeVoteOptionData.setVoteNum(0);
                res = caseExchangeVoteOptionDao.insert(caseExchangeVoteOptionData);
                if (res <= 0){
                    throw new BusinessException("操作失败");
                }
            }
        }

        // 新增标签
        if (r.getCaseExchangeLabel() != null && !r.getCaseExchangeLabel().isEmpty()){
            // 验证标签数据-暂时无法验证，病例库不存标签库
            List<addCaseExchange.CaseExchangeLabelRequest> caseExchangeLabel = r.getCaseExchangeLabel();
            for (addCaseExchange.CaseExchangeLabelRequest label : caseExchangeLabel ){
                CaseExchangeLabelModel caseExchangeLabelData = new CaseExchangeLabelModel();
                caseExchangeLabelData.setExchangeId(caseExchangeData.getExchangeId());
                caseExchangeLabelData.setAppIden(label.getAppIden());
                caseExchangeLabelData.setLabelName(label.getLabelName());
                res = caseExchangeLabelDao.insert(caseExchangeLabelData);
                if (res <= 0){
                    throw new BusinessException("操作失败");
                }
            }
        }

        // 病例交流统计
        if (!handleStatsCaseExchange()){
            throw new BusinessException("操作失败");
        }

        // 新增病例交流统计-用户
        if (!handleStatsCaseExchangeUser(userId,"exchange_num")){
            throw new BusinessException("操作失败");
        }

        // 发放积分
//        userService.ReportUserScore(String.valueOf(caseExchangeData.getExchangeId()),3,userId,50);

        return true;
    }

    /**
     * 修改-病例交流
     * @param userId 用户id
     * @param exchangeId 病例交流id
     * @return bool
     */
    @Transactional
    public boolean UpdateCaseExchange(String userId,String exchangeId, updateCaseExchange r){
        // 获取病例交流数据
        CaseExchangeModel caseExchange = caseExchangeDao.selectById(exchangeId);
        if (caseExchange == null){
            throw new BusinessException("非法操作");
        }

        if (!Objects.equals(caseExchange.getUserId(), Long.valueOf(userId))){
            throw new BusinessException("非法操作");
        }

        // 检测作品状态
        if (!checkCaseExchangeStatus(caseExchange)){
            throw new BusinessException("非法操作");
        }

        // 标签
        if (r.getCaseExchangeLabel() != null && !r.getCaseExchangeLabel().isEmpty()){
            for (updateCaseExchange.CaseExchangeLabelRequest caseExchangeLabelRequest : r.getCaseExchangeLabel()){
                if (caseExchangeLabelRequest.getAppIden() == null){
                    throw new BusinessException("操作失败");
                }

                if (caseExchangeLabelRequest.getLabelName() == null){
                    throw new BusinessException("操作失败");
                }
            }
        }

        // 处理违法内容
        BasicSensitiveWordService.FilterResult result = basicSensitiveWordService.filter(r.getExchangeContent());
        if (result.hasSensitive == 1){
            throw new BusinessException("内容中存在敏感词，请修改后提交");
        }

        if (r.getExchangeSummary() != null){
            result = basicSensitiveWordService.filter(r.getExchangeSummary());
            if (result.hasSensitive == 1){
                throw new BusinessException("总结中存在敏感词，请修改后提交");
            }
        }

        // 匹配预览视频
        List<String> videoUrls = regularUtil.extractOssVideosUrls(r.getExchangeContent());
        videoUrls.replaceAll(Replace::removeOssDomain);
        String exchangeContentVideo = String.join(",", videoUrls);

        String exchangeContentImage = "";
        if (exchangeContentVideo.isEmpty()){
            // 匹配预览图片
            List<String> imageUrls = regularUtil.extractOssImageUrls(r.getExchangeContent());
            imageUrls.replaceAll(Replace::removeOssDomain);
            exchangeContentImage = String.join(",", imageUrls);
        }else{
            exchangeContentImage = "";
        }

        // 修改病例交流
        caseExchange.setExchangeTitle(r.getExchangeTitle());
        caseExchange.setExchangeContent(r.getExchangeContent());
        caseExchange.setExchangeSummary(r.getExchangeSummary());
        caseExchange.setExchangeContentVideo(exchangeContentVideo);
        caseExchange.setExchangeContentImage(exchangeContentImage);
        caseExchangeDao.updateById(caseExchange);

        // 删除标签
        LambdaQueryWrapper<CaseExchangeLabelModel> labelQueryWrapper = new LambdaQueryWrapper<>();
        labelQueryWrapper.eq(CaseExchangeLabelModel::getExchangeId, exchangeId);
        caseExchangeLabelDao.delete(labelQueryWrapper);

        // 新增标签
        if (r.getCaseExchangeLabel() != null && !r.getCaseExchangeLabel().isEmpty()){
            // 验证标签数据-暂时无法验证，病例库不存标签库
            List<updateCaseExchange.CaseExchangeLabelRequest> caseExchangeLabel = r.getCaseExchangeLabel();
            for (updateCaseExchange.CaseExchangeLabelRequest label : caseExchangeLabel ){
                CaseExchangeLabelModel caseExchangeLabelData = new CaseExchangeLabelModel();
                caseExchangeLabelData.setExchangeId(caseExchange.getExchangeId());
                caseExchangeLabelData.setAppIden(label.getAppIden());
                caseExchangeLabelData.setLabelName(label.getLabelName());
                int res = caseExchangeLabelDao.insert(caseExchangeLabelData);
                if (res <= 0){
                    throw new BusinessException("操作失败");
                }
            }
        }

        return true;
    }

    /**
     * 删除-病例交流
     * @param exchangeId 病例交流id
     * @param userId 用户id
     * @return bool
     */
    @Transactional
    public boolean DeleteCaseExchange(String exchangeId, String userId){
        // 获取病例交流数据
        CaseExchangeModel caseExchange = caseExchangeDao.selectById(exchangeId);
        if (caseExchange == null) {
            return false;
        }

        if (!Objects.equals(caseExchange.getUserId(), Long.valueOf(userId))){
            throw new BusinessException("非法操作");
        }

        if (caseExchange.getDeleteStatus() == 1){
            return true;
        }

        // 修改病例交流删除状态
        caseExchange.setDeleteStatus(1);
        caseExchangeDao.updateById(caseExchange);

        // 处理统计数据
        boolean r = DecCaseExchangeStats(exchangeId,4,1);
        if (!r){
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return false;
        }

        r = DecCaseExchangeStats(exchangeId,1,caseExchange.getReadNum());
        if (!r){
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return false;
        }

        r = DecCaseExchangeStats(exchangeId,2,caseExchange.getCollectNum());
        if (!r){
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return false;
        }

        r = DecCaseExchangeStats(exchangeId,3,caseExchange.getCommentNum());
        if (!r){
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return false;
        }

        return  true;
    }

    /**
     * 新增收藏-病例交流
     * @param exchangeId 病例交流id
     * @param userId 用户id
     * @return bool
     */
    @Transactional
    public boolean AddCaseExchangeCollect(String exchangeId,String userId){
        // 获取病例交流数据
        CaseExchangeModel article = caseExchangeDao.selectById(exchangeId);
        if (article == null) {
            return false;
        }

        // 检测用户是否已收藏过
        UserCollectExchangeModel userCollectExchange = getUserCollectExchangeStatus(exchangeId,userId);
        if (userCollectExchange != null) {
            return true;
        }

        // 新增收藏
        UserCollectExchangeModel userCollectExchangeData = new UserCollectExchangeModel();
        userCollectExchangeData.setUserId(Long.valueOf(userId));
        userCollectExchangeData.setExchangeId(Long.valueOf(exchangeId));
        int res = userCollectExchangeDao.insert(userCollectExchangeData);
        if (res <= 0){
            return false;
        }

        // 新增统计字段
        boolean r = IncCaseExchangeStats(exchangeId,2);
        if (!r){
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return false;
        }

        return true;
    }

    /**
     * 取消收藏-病例交流
     * @param exchangeId 病例交流id
     * @param userId 用户id
     * @return bool
     */
    @Transactional
    public boolean DeleteCaseExchangeCollect(String exchangeId,String userId){
        // 检测用户是否已收藏过
        UserCollectExchangeModel userCollectExchange = getUserCollectExchangeStatus(exchangeId,userId);
        if (userCollectExchange == null) {
            return true;
        }

        // 删除收藏
        int res = userCollectExchangeDao.deleteById(userCollectExchange.getCollectId());
        if (res <= 0){
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return false;
        }

        // 减少文章的统计字段
        boolean r = DecCaseExchangeStats(exchangeId,2,1);
        if (!r){
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return false;
        }

        return true;
    }

    /**
     * 新增评论-病例交流
     * @param exchangeId 病例交流id
     * @param userId 用户id
     * @return bool
     */
    @Transactional
    public Map<String, Object> AddCaseExchangeComment(String exchangeId, String userId, addCaseExchangeComment request){
        Map<String, Object> resultData = new HashMap<>();
        resultData.put("status", 1);
        resultData.put("message", "成功");

        // 获取病例交流数据
        CaseExchangeModel article = caseExchangeDao.selectById(exchangeId);
        if (article == null) {
            throw new BusinessException("非法病例交流");
        }

        if (article.getExchangeStatus() != 1){
            throw new BusinessException("非法病例交流");
        }

        // 处理评论内容
        BasicSensitiveWordService.FilterResult result = basicSensitiveWordService.filter(request.getContent());
        if (result.hasSensitive == 1){
            throw new BusinessException("存在敏感词，请修改后提交");
        }

        // 新增评论
        UserCommentExchangeModel userCommentExchangeData = new UserCommentExchangeModel();
        userCommentExchangeData.setUserId(Long.valueOf(userId));
        userCommentExchangeData.setExchangeId(Long.valueOf(exchangeId));
        userCommentExchangeData.setStatus(1);
        userCommentExchangeData.setIsSensitive(0);
        userCommentExchangeData.setContent(request.getContent());
        userCommentExchangeData.setCommentImage(Replace.removeOssDomain(request.getCommentImage()));

        // 评论根id
        if (request.getRootId() != null) {
            userCommentExchangeData.setRootId(Long.valueOf(request.getRootId()));
        }

        // 评论父级id
        if (request.getParentId() != null) {
            userCommentExchangeData.setParentId(Long.valueOf(request.getParentId()));
        }

        int res = userCommentExchangeDao.insert(userCommentExchangeData);
        if (res <= 0){
            throw new BusinessException("操作失败");
        }

        // 新增统计字段
        boolean r = IncCaseExchangeStats(exchangeId,3);
        if (!r){
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            throw new BusinessException("操作失败");
        }

        // 获取发放积分次数
        Integer num = userService.GetReportUserScore(userId);
        if (num < 3){
            // 发放积分
            resultData.put("status", 2);
            userService.ReportUserScore(exchangeId,3,userId,5);
        }

        return resultData;
    }

    /**
     * 删除评论-病例交流
     * @param commentId 评论id
     * @param userId 用户id
     * @return bool
     */
    @Transactional
    public boolean DeleteCaseExchangeComment(String commentId, String userId){
        // 获取评论数据
        UserCommentExchangeModel comment = userCommentExchangeDao.selectById(commentId);
        if (comment == null) {
            return false;
        }

        // 获取病例交流数据
        CaseExchangeModel article = caseExchangeDao.selectById(comment.getExchangeId());
        if (article == null) {
            return false;
        }

        if (article.getExchangeStatus() != 1){
            return false;
        }

        // 检测用户是否病例交流作者
        if (!Objects.equals(comment.getUserId(), Long.valueOf(userId))){
            return false;
        }

        // 获取下级评论
        LambdaQueryWrapper<UserCommentExchangeModel> exchangeQueryWrapper = new LambdaQueryWrapper<>();
        exchangeQueryWrapper.eq(UserCommentExchangeModel::getRootId, comment.getCommentId());
        List<UserCommentExchangeModel> userCommentExchanges = userCommentExchangeDao.selectList(exchangeQueryWrapper);
        for (UserCommentExchangeModel m : userCommentExchanges){
            // 删除评论
            int res = userCommentExchangeDao.deleteById(m.getCommentId());
            if (res <= 0){
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return false;
            }

            // 减少文章的统计字段
            boolean r = DecCaseExchangeStats(String.valueOf(comment.getCommentId()),2,1);
            if (!r){
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return false;
            }
        }

        // 删除评论
        int res = userCommentExchangeDao.deleteById(comment.getCommentId());
        if (res <= 0){
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return false;
        }

        // 减少统计字段
        boolean r = DecCaseExchangeStats(String.valueOf(comment.getExchangeId()),3,1);
        if (!r){
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return false;
        }

        return  true;
    }

    /**
     * 置顶评论-病例交流
     * @param commentId 评论id
     * @param userId 用户id
     * @return bool
     */
    @Transactional
    public boolean AddTopCaseExchangeComment(String commentId, String userId){
        // 获取评论数据
        UserCommentExchangeModel comment = userCommentExchangeDao.selectById(commentId);
        if (comment == null) {
            return false;
        }

        // 获取病例交流数据
        CaseExchangeModel article = caseExchangeDao.selectById(comment.getExchangeId());
        if (article == null) {
            return false;
        }

        if (article.getExchangeStatus() != 1){
            return false;
        }

        // 检测用户是否病例交流作者
        if (!Objects.equals(comment.getUserId(), Long.valueOf(userId))){
            return false;
        }

        if (comment.getIsTop() == 1){
            return true;
        }

        // 置顶评论
        comment.setIsTop(1);
        userCommentExchangeDao.updateById(comment);

        return  true;
    }

    /**
     * 取消置顶评论-病例交流
     * @param commentId 评论id
     * @param userId 用户id
     * @return bool
     */
    @Transactional
    public boolean deleteTopCaseExchangeComment(String commentId, String userId){
        // 获取评论数据
        UserCommentExchangeModel comment = userCommentExchangeDao.selectById(commentId);
        if (comment == null) {
            return false;
        }

        // 获取病例交流数据
        CaseExchangeModel article = caseExchangeDao.selectById(comment.getExchangeId());
        if (article == null) {
            return false;
        }

        if (article.getExchangeStatus() != 1){
            return false;
        }

        // 检测用户是否病例交流作者
        if (!Objects.equals(comment.getUserId(), Long.valueOf(userId))){
            return false;
        }

        // 取消置顶评论
        if (comment.getIsTop() == 0){
            return true;
        }

        // 置顶评论
        comment.setIsTop(0);
        userCommentExchangeDao.updateById(comment);

        return  true;
    }

    /**
     * 获取用户收藏数据
     * @param exchangeId 病例交流id
     * @param userId 用户id
     * @return bool false:未收藏 true：已收藏
     */
    public UserCollectExchangeModel getUserCollectExchangeStatus(String exchangeId, String userId){
        // 检测用户是否已收藏过
        LambdaQueryWrapper<UserCollectExchangeModel> mapQueryWrapper = new LambdaQueryWrapper<>();
        mapQueryWrapper.eq(UserCollectExchangeModel::getUserId, userId);
        mapQueryWrapper.eq(UserCollectExchangeModel::getExchangeId, exchangeId);

        return userCollectExchangeDao.selectOne(mapQueryWrapper);
    }

    /**
     * 新增病例交流统计
     * @return bool
     */
    public boolean handleStatsCaseExchange(){
        LambdaQueryWrapper<StatsCaseExchangeModel> mapQueryWrapper = new LambdaQueryWrapper<>();
        StatsCaseExchangeModel statsCaseExchange = statsCaseExchangeDao.selectOne(mapQueryWrapper);
        if (statsCaseExchange == null){
            // 新增
            StatsCaseExchangeModel statsCaseExchangeData = new StatsCaseExchangeModel();
            statsCaseExchangeData.setExchangeNum(1);
            int res = statsCaseExchangeDao.insert(statsCaseExchangeData);
            return res > 0;
        }else{
            // 增加数量
            statsCaseExchangeDao.inc(statsCaseExchange.getStatsId(),"exchange_num",1);
        }

        return true;
    }

    /**
     * 新增病例交流统计-用户
     * @return bool
     */
    public boolean handleStatsCaseExchangeUser(String userId,String field){
        LambdaQueryWrapper<StatsCaseExchangeUserModel> mapQueryWrapper = new LambdaQueryWrapper<>();
        mapQueryWrapper.eq(StatsCaseExchangeUserModel::getUserId, userId);
        StatsCaseExchangeUserModel statsCaseExchangeUser = statsCaseExchangeUserDao.selectOne(mapQueryWrapper);
        if (statsCaseExchangeUser == null){
            // 新增
            StatsCaseExchangeUserModel statsCaseExchangeUserData = new StatsCaseExchangeUserModel();
            statsCaseExchangeUserData.setUserId(Long.valueOf(userId));
            statsCaseExchangeUserData.setExchangeNum(1);
            int res = statsCaseExchangeUserDao.insert(statsCaseExchangeUserData);
            return res > 0;
        }else{
            // 增加数量
            statsCaseExchangeUserDao.inc(statsCaseExchangeUser.getStatsId(),field,1);
        }

        return true;
    }


    /**
     * 新增病例交流统计字段
     * @param exchangeId 病例id
     * @param type 类型：1:阅读量 2：收藏量 3:评论数
     */
    @Transactional
    public boolean IncCaseExchangeStats(String exchangeId,Integer type){
        try {
            // 获取病例数据
            CaseExchangeModel caseExchange = caseExchangeDao.selectById(exchangeId);
            if (caseExchange == null){
                throw new BusinessException("操作失败");
            }

            LambdaQueryWrapper<StatsCaseExchangeUserModel> mapQueryWrapper = new LambdaQueryWrapper<>();
            mapQueryWrapper.eq(StatsCaseExchangeUserModel::getUserId, caseExchange.getUserId());
            StatsCaseExchangeUserModel statsCaseExchangeUser = statsCaseExchangeUserDao.selectOne(mapQueryWrapper);
            if (statsCaseExchangeUser == null){
                throw new BusinessException("操作失败");
            }

            // 阅读量
            if (type == 1){
                // 总
                statsCaseExchangeDao.inc(1L,"exchange_read_num",1);

                // 单
                caseExchangeDao.inc(Long.valueOf(exchangeId),"read_num",1);

                // 用户-此处无需担心stats_case_exchange_user无数据，发布病例时会新增
                statsCaseExchangeUserDao.inc(statsCaseExchangeUser.getUserId(),"exchange_read_num",1);
            }

            // 收藏量
            if (type == 2){
                // 总
                statsCaseExchangeDao.inc(1L,"exchange_collect_num",1);

                // 单
                caseExchangeDao.inc(Long.valueOf(exchangeId),"collect_num",1);

                // 用户-此处无需担心stats_case_exchange_user无数据，发布病例时会新增
                statsCaseExchangeUserDao.inc(statsCaseExchangeUser.getUserId(),"exchange_collect_num",1);
            }

            // 评论数
            if (type == 3){
                // 总
                statsCaseExchangeDao.inc(1L,"exchange_comment_num",1);

                // 单
                caseExchangeDao.inc(Long.valueOf(exchangeId),"comment_num",1);

                // 用户-此处无需担心stats_case_exchange_user无数据，发布病例时会新增
                statsCaseExchangeUserDao.inc(statsCaseExchangeUser.getUserId(),"exchange_comment_num",1);
            }

            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 减少病例交流统计字段
     * @param exchangeId 病例id
     * @param type 类型：1:阅读量 2：收藏量 3:评论数 4:数量
     */
    @Transactional
    public boolean DecCaseExchangeStats(String exchangeId,Integer type,Integer num){
        try {
            // 获取病例数据
            CaseExchangeModel caseExchange = caseExchangeDao.selectById(exchangeId);
            if (caseExchange == null){
                throw new BusinessException("操作失败");
            }

            LambdaQueryWrapper<StatsCaseExchangeUserModel> mapQueryWrapper = new LambdaQueryWrapper<>();
            mapQueryWrapper.eq(StatsCaseExchangeUserModel::getUserId, caseExchange.getUserId());
            StatsCaseExchangeUserModel statsCaseExchangeUser = statsCaseExchangeUserDao.selectOne(mapQueryWrapper);
            if (statsCaseExchangeUser == null){
                throw new BusinessException("操作失败");
            }

            // 阅读量
            if (type == 1){
                // 总
                statsCaseExchangeDao.dec(1L,"exchange_read_num",num);

                // 单
                caseExchangeDao.dec(Long.valueOf(exchangeId),"read_num",num);

                // 用户
                statsCaseExchangeUserDao.dec(statsCaseExchangeUser.getUserId(),"exchange_read_num",num);
            }

            // 收藏量
            if (type == 2){
                // 总
                statsCaseExchangeDao.dec(1L,"exchange_collect_num",num);

                // 单
                caseExchangeDao.dec(Long.valueOf(exchangeId),"collect_num",num);

                // 用户
                statsCaseExchangeUserDao.dec(statsCaseExchangeUser.getUserId(),"exchange_collect_num",num);
            }

            // 评论数
            if (type == 3){
                // 总
                statsCaseExchangeDao.dec(1L,"exchange_comment_num",num);

                // 单
                caseExchangeDao.dec(Long.valueOf(exchangeId),"comment_num",num);

                // 用户
                statsCaseExchangeUserDao.dec(statsCaseExchangeUser.getUserId(),"exchange_comment_num",num);
            }

            // 数量
            if (type == 4){
                // 总
                statsCaseExchangeDao.dec(1L,"exchange_num",num);

                // 用户
                statsCaseExchangeUserDao.dec(statsCaseExchangeUser.getUserId(),"exchange_num",num);
            }

            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 新增投票-病例交流
     * @param exchangeId 病例交流id
     * @param userId 用户id
     * @return bool
     */
    @Transactional
    public boolean AddCaseExchangeVote(String exchangeId,String userId,String optionId){
        // 获取病例交流数据
        CaseExchangeModel article = caseExchangeDao.selectById(exchangeId);
        if (article == null) {
            return false;
        }

        // 检测用户是否已投票
        LambdaQueryWrapper<UserVoteExchangeModel> userVoteExchangeQueryWrapper = new LambdaQueryWrapper<>();
        userVoteExchangeQueryWrapper.eq(UserVoteExchangeModel::getUserId, userId);
        userVoteExchangeQueryWrapper.eq(UserVoteExchangeModel::getExchangeId, exchangeId);
        UserVoteExchangeModel userVoteExchange = userVoteExchangeDao.selectOne(userVoteExchangeQueryWrapper);
        if (userVoteExchange != null) {
            return true;
        }

        // 获取病例交流对应投票数据
        LambdaQueryWrapper<CaseExchangeVoteModel> caseExchangeVoteQueryWrapper = new LambdaQueryWrapper<>();
        caseExchangeVoteQueryWrapper.eq(CaseExchangeVoteModel::getExchangeId, exchangeId);
        CaseExchangeVoteModel caseExchangeVote = caseExchangeVoteDao.selectOne(caseExchangeVoteQueryWrapper);
        if (caseExchangeVote == null) {
            return true;
        }

        // 获取对应投票选项
        LambdaQueryWrapper<CaseExchangeVoteOptionModel> caseExchangeVoteOptionQueryWrapper = new LambdaQueryWrapper<>();
        caseExchangeVoteOptionQueryWrapper.eq(CaseExchangeVoteOptionModel::getOptionId, optionId);
        caseExchangeVoteOptionQueryWrapper.eq(CaseExchangeVoteOptionModel::getVoteId, caseExchangeVote.getVoteId());
        CaseExchangeVoteOptionModel caseExchangeVoteOption = caseExchangeVoteOptionDao.selectOne(caseExchangeVoteOptionQueryWrapper);
        if (caseExchangeVoteOption == null) {
            return false;
        }

        // 新增投票
        UserVoteExchangeModel userVoteExchangedata = new UserVoteExchangeModel();
        userVoteExchangedata.setUserId(Long.valueOf(userId));
        userVoteExchangedata.setExchangeId(Long.valueOf(exchangeId));
        userVoteExchangedata.setVoteId(caseExchangeVote.getVoteId());
        userVoteExchangedata.setOptionId(Long.valueOf(optionId));
        userVoteExchangedata.setVoteTime(LocalDateTime.now());
        int res = userVoteExchangeDao.insert(userVoteExchangedata);
        if (res <= 0){
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return false;
        }

        // 处理投票数
        caseExchangeVoteOptionDao.inc(Long.valueOf(optionId),"vote_num",1);

        return true;
    }
//
//    /**
//     * 新增病例交流的统计字段
//     * @param exchangeId id
//     * @param type 类型：1:阅读量 2：收藏量 3:评论数
//     */
//    @Transactional
//    public boolean IncCaseExchangeStats(String exchangeId,String userId,Integer type){
//        try {
//            // 阅读量
//            if (type == 1){
//                // 单
//                caseExchangeDao.inc(Long.valueOf(exchangeId),"read_num",1);
//
//                // 总
//                statsCaseExchangeDao.inc(1L,"exchange_read_num",1);
//
//                // 此处无需担心stats_case_exchange_user无数据，发布病例时会新增
//                statsCaseExchangeUserDao.inc(Long.valueOf(userId),"exchange_read_num",1);
//            }
//
//            // 收藏量
//            if (type == 2){
//                // 单
//                caseExchangeDao.inc(Long.valueOf(exchangeId),"collect_num",1);
//
//                // 总
//                statsCaseExchangeDao.inc(1L,"exchange_collect_num",1);
//
//                // 此处无需担心stats_case_exchange_user无数据，发布病例时会新增
//                statsCaseExchangeUserDao.inc(Long.valueOf(userId),"exchange_collect_num",1);
//            }
//
//            // 评论数
//            if (type == 3){
//                // 单
//                caseExchangeDao.inc(Long.valueOf(exchangeId),"comment_num",1);
//
//                // 总
//                statsCaseExchangeDao.inc(1L,"exchange_comment_num",1);
//
//                // 此处无需担心stats_case_exchange_user无数据，发布病例时会新增
//                statsCaseExchangeUserDao.inc(Long.valueOf(userId),"exchange_comment_num",1);
//            }
//
//            return true;
//        } catch (Exception e) {
//            return false;
//        }
//    }
//
//    /**
//     * 减少文章的统计字段
//     * @param exchangeId id
//     * @param type 类型：1:阅读量 2：收藏量 3:评论数
//     */
//    @Transactional
//    public boolean DecCaseExchangeStats(String exchangeId,String userId,Integer type){
//        try {
//            // 阅读量
//            if (type == 1){
//                caseExchangeDao.dec(Long.valueOf(exchangeId),"read_num",1);
//                statsCaseExchangeDao.dec(1L,"exchange_read_num",1);
//
//                // 此处无需担心stats_case_exchange_user无数据，发布病例时会新增
//                statsCaseExchangeUserDao.dec(Long.valueOf(userId),"exchange_read_num",1);
//            }
//
//            // 收藏量
//            if (type == 2){
//                caseExchangeDao.inc(Long.valueOf(exchangeId),"collect_num",1);
//                statsCaseExchangeDao.dec(1L,"exchange_collect_num",1);
//
//                // 此处无需担心stats_case_exchange_user无数据，发布病例时会新增
//                statsCaseExchangeUserDao.dec(Long.valueOf(userId),"exchange_collect_num",1);
//            }
//
//            // 评论数
//            if (type == 3){
//                caseExchangeDao.inc(Long.valueOf(exchangeId),"comment_num",1);
//                statsCaseExchangeDao.dec(1L,"exchange_comment_num",1);
//
//                // 此处无需担心stats_case_exchange_user无数据，发布病例时会新增
//                statsCaseExchangeUserDao.dec(Long.valueOf(userId),"exchange_comment_num",1);
//            }
//
//            return true;
//        } catch (Exception e) {
//            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//            return false;
//        }
//    }

    /**
     * 检测作品状态
     */
    public boolean checkCaseExchangeStatus(CaseExchangeModel caseExchange){
        // 删除状态
        if (caseExchange.getDeleteStatus() == 1){
            return false;
        }

        // 状态（1:正常 2:禁用）
        if (caseExchange.getExchangeStatus() == 2){
            return false;
        }

        return true;
    }
}