package com.example.caseData.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.caseData.common.Response;
import com.example.caseData.dao.*;
import com.example.caseData.dto.T;
import com.example.caseData.dto.caseExchange.CaseExchangeDto;
import com.example.caseData.dto.caseExchangeLabel.CaseExchangeLabelDto;
import com.example.caseData.dto.caseExchangeVote.CaseExchangeVoteDto;
import com.example.caseData.dto.caseExchangeVoteOption.CaseExchangeVoteOptionDto;
import com.example.caseData.dto.userCommentCaseExchange.GetUserCaseExchangeCommentPageDto;
import com.example.caseData.dto.userCommentCaseExchange.UserCommentCaseExchangeDto;
import com.example.caseData.exception.BusinessException;
import com.example.caseData.model.*;
import com.example.caseData.request.caseExchangeRequest.*;
import com.example.caseData.service.CaseExchangeService;
import com.example.caseData.utils.IntToString;
import com.example.caseData.utils.Replace;
import jakarta.annotation.Resource;
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;

@RestController
@RequestMapping("/api")
public class CaseExchangeController {
    @Resource
    private HttpServletRequest httpServletRequest;

    @Resource
    private CaseExchangeDao caseExchangeDao;

    @Resource
    private UserDao userDao;

    @Resource
    private BasicHospitalDao basicHospitalDao;

    @Resource
    private CaseExchangeService caseExchangeService;

    @Resource
    private CaseExchangeVoteDao caseExchangeVoteDao;

    @Resource
    private CaseExchangeLabelDao caseExchangeLabelDao;

    @Resource
    private CaseExchangeVoteOptionDao caseExchangeVoteOptionDao;

    @Resource
    private UserVoteExchangeDao userVoteExchangeDao;

    @Resource
    private UserCommentExchangeDao userCommentExchangeDao;

    /**
     * 临床病例库-病例交流-搜索
     */
    @PostMapping("/exchange/search")
    public Response<Map<String, Object>> getCaseExchangeSearchPage(
            @Validated()
            @RequestBody getCaseExchangeSearchPage request
    ) {
        UserModel user = new UserModel();
        BasicHospitalModel basicHospital = new BasicHospitalModel();

        // 此步骤是为了在我的病例交流列表页面少查询
        String userId = (String) httpServletRequest.getAttribute("userId");

        request.validateForPage();

        Map<String, Object> resultMap = new HashMap<>();

        Page<CaseExchangeDto> page = new Page<>(request.getPage(), request.getPageSize());

        // 获取数据
        IPage<CaseExchangeDto> resultPage = caseExchangeDao.getCaseExchangeSearchPage(
                page,
                request.getKeyword(),
                request.getUserId(),
                request.getIsSelected(),
                request.getLabelIden(),
                request.handleOrder()
        );

        for (CaseExchangeDto dto : resultPage.getRecords()) {
            // 处理预览视频
            dto.setExchangeContentVideoString(dto.getExchangeContentVideoString());

            // 处理预览图片
            if (dto.getExchangeContentVideo() == null){
                dto.setExchangeContentImageString(dto.getExchangeContentImageString());
            }

            dto.setExchangeContentImageString("");
            dto.setExchangeContentVideoString("");

            user = userDao.selectById(dto.getUserId());
            if (user == null) {
                return Response.error();
            }

            // 获取当前用户所属医院
            basicHospital = basicHospitalDao.selectById(user.getHospitalId());
            if (basicHospital == null) {
                return Response.error();
            }

            dto.setAvatar(Replace.addOssDomain(user.getAvatar()));
            dto.setUserName(user.getUserName());
            dto.setHospitalName(basicHospital.getHospitalName());

            // 获取用户收藏状态
            UserCollectExchangeModel userCollectExchangeModel = caseExchangeService.getUserCollectExchangeStatus(dto.getExchangeId(),userId);
            if (userCollectExchangeModel != null) {
                dto.setCollect(true);
            }

            // 查找标签
            LambdaQueryWrapper<CaseExchangeLabelModel> labelQueryWrapper = new LambdaQueryWrapper<>();
            labelQueryWrapper.eq(CaseExchangeLabelModel::getExchangeId, dto.getExchangeId());
            List<CaseExchangeLabelModel> caseExchangeLabels = caseExchangeLabelDao.selectList(labelQueryWrapper);
            if (caseExchangeLabels != null && !caseExchangeLabels.isEmpty()) {
                List<CaseExchangeLabelDto> caseExchangeLabelDto = CaseExchangeLabelDto.GetListDto(caseExchangeLabels);
                dto.setLabel(caseExchangeLabelDto);
            }
        }

        resultMap.put("page", resultPage.getCurrent());
        resultMap.put("pageSize", resultPage.getSize());
        resultMap.put("total", resultPage.getTotal());
        resultMap.put("data", resultPage.getRecords());
        return Response.success(resultMap);
    }

    /**
     * 病例交流-详情
     */
    @GetMapping("/exchange/{exchange_id}")
    public Response<CaseExchangeDto> getExchange(
            @PathVariable("exchange_id") String exchangeId
    ) {
        String userId = (String) httpServletRequest.getAttribute("userId");

        // 获取文章数据
        CaseExchangeModel caseExchange = caseExchangeDao.selectById(exchangeId);
        if (caseExchange == null) {
            return Response.error();
        }

        // 查找用户
        UserModel user = userDao.selectById(caseExchange.getUserId());
        if (user == null) {
            return Response.error();
        }

        // 获取当前用户所属医院
        BasicHospitalModel basicHospital = basicHospitalDao.selectById(user.getHospitalId());
        if (basicHospital == null) {
            return Response.error();
        }

        // 获取投票数据
        LambdaQueryWrapper<CaseExchangeVoteModel> caseExchangeVoteQueryWrapper = new LambdaQueryWrapper<>();
        caseExchangeVoteQueryWrapper.eq(CaseExchangeVoteModel::getExchangeId, caseExchange.getExchangeId());
        CaseExchangeVoteModel caseExchangeVote = caseExchangeVoteDao.selectOne(caseExchangeVoteQueryWrapper);
        if (caseExchangeVote != null) {
            // 检测是否过期
            if (caseExchangeVote.getEndTime() == null) {
                return Response.error();
            }

            // 获取选项
            LambdaQueryWrapper<CaseExchangeVoteOptionModel> caseExchangeVoteOptionQueryWrapper = new LambdaQueryWrapper<>();
            caseExchangeVoteOptionQueryWrapper.eq(CaseExchangeVoteOptionModel::getVoteId, caseExchangeVote.getVoteId());
            List<CaseExchangeVoteOptionModel> caseExchangeVoteOptions = caseExchangeVoteOptionDao.selectList(caseExchangeVoteOptionQueryWrapper);
            if (caseExchangeVoteOptions.isEmpty()) {
                return Response.error();
            }
            caseExchangeVote.setCaseExchangeVoteOption(caseExchangeVoteOptions);

            caseExchange.setCaseExchangeVote(caseExchangeVote);
        }

        // 获取标签数据
        LambdaQueryWrapper<CaseExchangeLabelModel> caseExchangeLabelQueryWrapper = new LambdaQueryWrapper<>();
        caseExchangeLabelQueryWrapper.eq(CaseExchangeLabelModel::getExchangeId, caseExchange.getExchangeId());
        List<CaseExchangeLabelModel> caseExchangeLabels = caseExchangeLabelDao.selectList(caseExchangeLabelQueryWrapper);
        if (caseExchangeLabels != null && !caseExchangeLabels.isEmpty()) {
            caseExchange.setCaseExchangeLabel(caseExchangeLabels);
        }

        // 处理返回值
        CaseExchangeDto g = CaseExchangeDto.GetDto(caseExchange);

        g.setAvatar(Replace.addOssDomain(user.getAvatar()));
        g.setUserName(user.getUserName());
        g.setHospitalName(basicHospital.getHospitalName());

        // 获取用户收藏状态
        if (userId != null) {
            // 检测用户是否已收藏过
            UserCollectExchangeModel userCollectExchangeModel = caseExchangeService.getUserCollectExchangeStatus(String.valueOf(caseExchange.getExchangeId()),userId);
            if (userCollectExchangeModel != null) {
                g.setCollect(true);
            }
        }

        // 处理投票数据
        if (g.getCaseExchangeVote() != null){
            if (g.getCaseExchangeVote().getEndTime().isAfter(LocalDateTime.now())) {
                g.getCaseExchangeVote().setIsEnabled(1);
            }else{
                g.getCaseExchangeVote().setIsEnabled(0);
            }

            // 用户投票状态
            if (userId != null) {
                LambdaQueryWrapper<UserVoteExchangeModel> queryWrapper = new LambdaQueryWrapper<>();
                queryWrapper.eq(UserVoteExchangeModel::getUserId, userId);
                queryWrapper.eq(UserVoteExchangeModel::getExchangeId, exchangeId);
                queryWrapper.eq(UserVoteExchangeModel::getVoteId, g.getCaseExchangeVote().getVoteId());
                UserVoteExchangeModel userVoteExchange = userVoteExchangeDao.selectOne(queryWrapper);
                if (userVoteExchange != null) {
                    // 已投过票
                    g.getCaseExchangeVote().setIsHaveVoted(1);
                }
            }

            // 处理投票数据
            Integer voteNum = 0;
            for (CaseExchangeVoteOptionDto dto : g.getCaseExchangeVote().getCaseExchangeVoteOption()){
                voteNum += dto.getVoteNum();
            }

            for (CaseExchangeVoteOptionDto dto : g.getCaseExchangeVote().getCaseExchangeVoteOption()){
                Integer proportion = (int) (Math.round((double) dto.getVoteNum() / voteNum * 10000) / 100.0);
                dto.setProportion(proportion);
            }
        }


        return Response.success(g);
    }

    /**
     * 临床病例库-病例交流-列表
     */
    @PostMapping("/exchange/list")
    public Response<List<CaseExchangeDto>> getCaseExchangeSearchList(
            @Validated()
            @RequestBody getCaseExchangeSearchList request
    ) {
        request.validateForLimit();

        // 获取数据
        List<CaseExchangeDto> caseExchanges = caseExchangeDao.getCaseExchangeSearchList(
                request.getLimit(),
                request.getKeyword(),
                request.getIsSelected(),
                request.handleOrder()
        );

        return Response.success(caseExchanges);
    }

    /**
     * 病例交流-详情-投票数据
     */
    @GetMapping("/exchange/vote/{exchange_id}")
    public Response<CaseExchangeVoteDto> getExchangeVote(
            @PathVariable("exchange_id") String exchangeId
    ) {
        String userId = (String) httpServletRequest.getAttribute("userId");

        // 获取投票数据
        LambdaQueryWrapper<CaseExchangeVoteModel> caseExchangeVoteQueryWrapper = new LambdaQueryWrapper<>();
        caseExchangeVoteQueryWrapper.eq(CaseExchangeVoteModel::getExchangeId, exchangeId);
        CaseExchangeVoteModel caseExchangeVote = caseExchangeVoteDao.selectOne(caseExchangeVoteQueryWrapper);
        if (caseExchangeVote == null) {
            return Response.success();
        }

        // 检测是否过期
        if (caseExchangeVote.getEndTime() == null) {
            return Response.error();
        }

        // 获取选项
        LambdaQueryWrapper<CaseExchangeVoteOptionModel> caseExchangeVoteOptionQueryWrapper = new LambdaQueryWrapper<>();
        caseExchangeVoteOptionQueryWrapper.eq(CaseExchangeVoteOptionModel::getVoteId, caseExchangeVote.getVoteId());
        List<CaseExchangeVoteOptionModel> caseExchangeVoteOptions = caseExchangeVoteOptionDao.selectList(caseExchangeVoteOptionQueryWrapper);
        if (caseExchangeVoteOptions.isEmpty()) {
            return Response.error();
        }
        caseExchangeVote.setCaseExchangeVoteOption(caseExchangeVoteOptions);

        // 处理返回值
        CaseExchangeVoteDto g = CaseExchangeVoteDto.GetDto(caseExchangeVote);

        // 过期状态
        if (g.getEndTime().isAfter(LocalDateTime.now())) {
            g.setIsEnabled(1);
        }else{
            g.setIsEnabled(0);
        }

        // 用户投票状态
        if (userId != null) {
            LambdaQueryWrapper<UserVoteExchangeModel> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(UserVoteExchangeModel::getUserId, userId);
            queryWrapper.eq(UserVoteExchangeModel::getExchangeId, exchangeId);
            queryWrapper.eq(UserVoteExchangeModel::getVoteId, g.getVoteId());
            UserVoteExchangeModel userVoteExchange = userVoteExchangeDao.selectOne(queryWrapper);
            if (userVoteExchange != null) {
                // 已投过票
                g.setIsHaveVoted(1);
            }
        }

        // 处理投票数据
        Integer voteNum = 0;
        for (CaseExchangeVoteOptionDto dto : g.getCaseExchangeVoteOption()){
            voteNum += dto.getVoteNum();
        }

        for (CaseExchangeVoteOptionDto dto : g.getCaseExchangeVoteOption()){
            Integer proportion = (int) (Math.round((double) dto.getVoteNum() / voteNum * 10000) / 100.0);
            dto.setProportion(proportion);
        }

        return Response.success(g);
    }

    /**
     * 病例交流-新增
     */
    @PostMapping("/exchange")
    public Response<T> AddCaseExchange(
            @Validated()
            @RequestBody addCaseExchange request
    ) {
        String userId = (String) httpServletRequest.getAttribute("userId");

        if (userId == null) {
            return Response.error("操作失败");
        }

        try {
            boolean res = caseExchangeService.AddCaseExchange(userId,request);
            if (!res){
                return Response.error("操作失败");
            }
        } catch (BusinessException e) {
            return Response.error(e.getMessage());
        }

        return Response.success();
    }

    /**
     * 病例交流-收藏
     */
    @PostMapping("/exchange/collect/{exchange_id}")
    public Response<T> AddCaseExchangeCollect(
            @PathVariable("exchange_id") String exchangeId
    ) {

        String userId = (String) httpServletRequest.getAttribute("userId");

        if (userId == null) {
            return Response.error("操作失败");
        }

        boolean res = caseExchangeService.AddCaseExchangeCollect(exchangeId,userId);
        if (!res){
            return Response.error("操作失败");
        }

        return Response.success();
    }

    /**
     * 病例交流-取消收藏
     */
    @DeleteMapping("/exchange/collect/{exchange_id}")
    public Response<T> DeleteCaseExchangeCollect(
            @PathVariable("exchange_id") String exchangeId
    ) {

        String userId = (String) httpServletRequest.getAttribute("userId");

        if (userId == null) {
            return Response.error("操作失败");
        }

        boolean res = caseExchangeService.DeleteCaseExchangeCollect(exchangeId,userId);
        if (!res){
            return Response.error("操作失败");
        }

        return Response.success();
    }

    /**
     * 病例交流-新增评论
     */
    @PostMapping("/exchange/comment/{exchange_id}")
    public Response<T> AddCaseExchangeComment(
            @PathVariable("exchange_id") String exchangeId,
            @Validated()
            @RequestBody addCaseExchangeComment request
    ) {

        String userId = (String) httpServletRequest.getAttribute("userId");

        if (userId == null) {
            return Response.error("操作失败");
        }

        try {
            boolean res = caseExchangeService.AddCaseExchangeComment(exchangeId,userId,request);
            if (!res){
                return Response.error("操作失败");
            }
        } catch (BusinessException e) {
            return Response.error(e.getMessage());
        }

        return Response.success();
    }

    /**
     * 病例交流-评论-删除
     */
    @DeleteMapping("/exchange/comment/{comment_id}")
    public Response<T> DeleteCaseExchangeComment(
            @PathVariable("comment_id") String commentId
    ) {

        String userId = (String) httpServletRequest.getAttribute("userId");

        if (userId == null) {
            return Response.error("操作失败");
        }

        try {
            boolean res = caseExchangeService.DeleteCaseExchangeComment(commentId,userId);
            if (!res){
                return Response.error("操作失败");
            }
        } catch (BusinessException e) {
            return Response.error(e.getMessage());
        }

        return Response.success();
    }

    /**
     * 病例交流-评论-置顶
     */
    @PutMapping("/exchange/comment/top/{comment_id}")
    public Response<T> AddTopCaseExchangeComment(
            @PathVariable("comment_id") String commentId
    ) {

        String userId = (String) httpServletRequest.getAttribute("userId");

        if (userId == null) {
            return Response.error("操作失败");
        }

        try {
            boolean res = caseExchangeService.AddTopCaseExchangeComment(commentId,userId);
            if (!res){
                return Response.error("操作失败");
            }
        } catch (BusinessException e) {
            return Response.error(e.getMessage());
        }

        return Response.success();
    }

    /**
     * 病例交流-评论-取消置顶
     */
    @DeleteMapping("/exchange/comment/top/{comment_id}")
    public Response<T> deleteTopCaseExchangeComment(
            @PathVariable("comment_id") String commentId
    ) {

        String userId = (String) httpServletRequest.getAttribute("userId");

        if (userId == null) {
            return Response.error("操作失败");
        }

        try {
            boolean res = caseExchangeService.deleteTopCaseExchangeComment(commentId,userId);
            if (!res){
                return Response.error("操作失败");
            }
        } catch (BusinessException e) {
            return Response.error(e.getMessage());
        }

        return Response.success();
    }

    /**
     * 病例交流-评论-分页
     */
    @PostMapping("/exchange/comment/page")
    public Response<Map<String, Object>> getCaseExchangeCommentPage(
            @Validated()
            @RequestBody getCaseExchangeCommentPage request
    ) {
        String userId = (String) httpServletRequest.getAttribute("userId");

        // 获取当前登录用户数据
        UserModel user = userDao.selectById(Long.valueOf(userId));
        if (user == null) {
            return Response.error();
        }

        request.validateForPage();

        Map<String, Object> resultMap = new HashMap<>();

        Page<UserCommentCaseExchangeDto> page = new Page<>(request.getPage(), request.getPageSize());

        // 获取评论数据
        IPage<UserCommentCaseExchangeDto> resultPage = userCommentExchangeDao.getCaseExchangeCommentPage(
                page,
                request.getExchangeId(),
                request.getRootId()
        );

        // 处理是否本人评论
        for (UserCommentCaseExchangeDto dto : resultPage.getRecords()) {
            if (Objects.equals(dto.getUserId(), userId)){
                dto.setIsAuthor(1);
            }
        }

        // 处理返回值
        for (UserCommentCaseExchangeDto dto : resultPage.getRecords()) {
            // 去除用户唯一标识
            dto.setUserIden(null);

            // 图片
            dto.setCommentImage(Replace.addOssDomain(dto.getCommentImage()));

            // 获取次级评论
            if (request.getIsHaveSubComment() == 1){
                if (dto.getRootId() == null){
                    List<UserCommentCaseExchangeDto> subComments = userCommentExchangeDao.getCaseExchangeCommentList(
                            dto.getExchangeId(),
                            dto.getCommentId(),
                            5
                    );

                    dto.setSubComment(subComments);
                }
            }
        }

        resultMap.put("page", resultPage.getCurrent());
        resultMap.put("pageSize", resultPage.getSize());
        resultMap.put("total", resultPage.getTotal());
        resultMap.put("data", resultPage.getRecords());
        return Response.success(resultMap);
    }

    /**
     * 病例交流-评论-分页-用户
     */
    @PostMapping("/exchange/user/comment/page")
    public Response<Map<String, Object>> getUserCaseExchangeCommentPage(
            @Validated()
            @RequestBody getUserCaseExchangeCommentPage request
    ) {
        String userId = (String) httpServletRequest.getAttribute("userId");

        // 获取当前登录用户数据
        UserModel user = userDao.selectById(Long.valueOf(userId));
        if (user == null) {
            return Response.error();
        }

        request.validateForPage();

        Map<String, Object> resultMap = new HashMap<>();

        Page<UserCommentCaseExchangeDto> page = new Page<>(request.getPage(), request.getPageSize());

        // 获取评论数据
        IPage<GetUserCaseExchangeCommentPageDto> resultPage = userCommentExchangeDao.getUserCaseExchangeCommentPage(
                page,
                userId
        );

        // 处理返回值
        for (GetUserCaseExchangeCommentPageDto dto : resultPage.getRecords()) {
            if (dto.getAuthorTitleInt() != null) {
                dto.setAuthorTitle(IntToString.DoctorTitleToString(dto.getAuthorTitleInt()));
            }
        }

        resultMap.put("page", resultPage.getCurrent());
        resultMap.put("pageSize", resultPage.getSize());
        resultMap.put("total", resultPage.getTotal());
        resultMap.put("data", resultPage.getRecords());
        return Response.success(resultMap);
    }

    /**
     * 病例交流-投票
     */
    @PostMapping("/exchange/vote/{exchange_id}")
    public Response<T> AddCaseExchangeVote(
            @Validated()
            @PathVariable("exchange_id") String exchangeId,
            @RequestBody addCaseExchangeVote r
    ) {

        String userId = (String) httpServletRequest.getAttribute("userId");

        if (userId == null) {
            return Response.error("操作失败");
        }

        boolean res = caseExchangeService.AddCaseExchangeVote(exchangeId,userId,r.getOptionId());
        if (!res){
            return Response.error("操作失败");
        }

        return Response.success();
    }
}