package com.ruoyi.study.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.core.constant.Constants;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.exception.GlobalException;
import com.ruoyi.common.core.web.domain.BaseModel;
import com.ruoyi.study.domain.*;
import com.ruoyi.study.dto.StudyWeekDTO;
import com.ruoyi.study.mapper.TStudyMapper;
import com.ruoyi.study.service.*;
import com.ruoyi.study.vo.*;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
import java.util.stream.Collectors;

/**
 * <p>
 * 学习类型 听 周目配置 服务实现类
 * </p>
 *
 * @author 无关风月
 * @since 2024-04-26
 */
@Service
public class TStudyServiceImpl extends ServiceImpl<TStudyMapper, TStudy> implements ITStudyService {

    @Resource
    private ITUserStudyService userStudyService;
    @Resource
    private ITSubjectService subjectService;
    @Resource
    private ITGameRecordService gameRecordService;
    @Resource
    private ITStudyAnswerService studyAnswerService;
    @Resource
    private ITStudyInductionService studyInductionService;
    @Resource
    private ITStudyLookService studyLookService;
    @Resource
    private ITStudyListenService studyListenService;
    @Resource
    private ITStudyPairService studyPairService;
    @Resource
    private ITGameService gameService;
    @Resource
    private ITStoryListenService storyListenService;
    @Resource
    private ITSubjectRecordDetailService subjectRecordDetailService;

    private final static Map<Integer, Integer> GAME_DIFFICULTY_MAP = new HashMap<>();

    static {
        GAME_DIFFICULTY_MAP.put(1, 0);
        GAME_DIFFICULTY_MAP.put(2, 1);
    }

    @Override
    public List<StudyWeekDTO> weekList(Integer type, Integer quarter, Integer userId) {
        List<StudyWeekDTO> result = new ArrayList<>();
        // 根据季度和type查询学习配置
        List<TStudy> study = lambdaQuery().eq(TStudy::getQuarter, quarter).eq(TStudy::getType, type)
                .eq(TStudy::getDisabled, 0).orderByAsc(TStudy::getWeek).list();
        for (TStudy item : study) {
            Integer week = item.getWeek();
            String title = item.getTitle();
            Integer id = item.getId();
            // 计算总积分
            int total = 0;
            List<Integer> dayList = new ArrayList<>();
            // 有问有答
            List<TStudyAnswer> answerList = studyAnswerService.lambdaQuery()
                    .eq(TStudyAnswer::getStudyId, id)
                    .eq(TStudyAnswer::getWeek, week)
                    .eq(TStudyAnswer::getDisabled, 0).list();
            for (TStudyAnswer data : answerList) {
                Integer day = data.getDay();
                if (!dayList.contains(day)) {
                    total += data.getIntegral();
                    dayList.add(day);
                }
            }
            dayList.clear();
            // 归纳判断
            List<TStudyInduction> inductionList = studyInductionService.lambdaQuery()
                    .eq(TStudyInduction::getStudyId, id)
                    .eq(TStudyInduction::getWeek, week)
                    .eq(TStudyInduction::getDisabled, 0).list();
            for (TStudyInduction data : inductionList) {
                Integer day = data.getDay();
                if (!dayList.contains(day)) {
                    total += data.getIntegral();
                    dayList.add(day);
                }
            }
            dayList.clear();
            // 看图选音
            List<TStudyLook> lookList = studyLookService.lambdaQuery()
                    .eq(TStudyLook::getStudyId, id)
                    .eq(TStudyLook::getWeek, week)
                    .eq(TStudyLook::getDisabled, 0).list();
            for (TStudyLook data : lookList) {
                Integer day = data.getDay();
                if (!dayList.contains(day)) {
                    total += data.getIntegral();
                    dayList.add(day);
                }
            }
            dayList.clear();
            // 听音选图
            List<TStudyListen> listenList = studyListenService.lambdaQuery()
                    .eq(TStudyListen::getStudyId, id)
                    .eq(TStudyListen::getWeek, week)
                    .eq(TStudyListen::getDisabled, 0).list();
            for (TStudyListen data : listenList) {
                Integer day = data.getDay();
                if (!dayList.contains(day)) {
                    total += data.getIntegral();
                    dayList.add(day);
                }
            }
            dayList.clear();
            // 音图相配
            List<TStudyPair> pairList = studyPairService.lambdaQuery()
                    .eq(TStudyPair::getStudyId, id)
                    .eq(TStudyPair::getWeek, week)
                    .eq(TStudyPair::getDisabled, 0).list();
            for (TStudyPair data : pairList) {
                Integer day = data.getDay();
                if (!dayList.contains(day)) {
                    total += data.getIntegral();
                    dayList.add(day);
                }
            }
            dayList.clear();
            // 自主游戏
            List<TGame> gameList = gameService.lambdaQuery().eq(TGame::getStudyId, id)
                    .eq(TGame::getDisabled, 0)
                    .eq(TGame::getWeek, week).list();
            // 自主游戏-超级听力
            List<String> gameIntegral = gameList.stream().map(TGame::getIntegral).collect(Collectors.toList());
            for (String s : gameIntegral) {
                List<String> list = Arrays.stream(s.split(",")).collect(Collectors.toList());
                total += list.stream().mapToInt(Integer::parseInt).sum();
            }
            // 自主游戏-框架记忆
            List<Integer> gameAnswerIntegral = gameList.stream().map(TGame::getAnswerIntegral).collect(Collectors.toList());
            for (Integer integral : gameAnswerIntegral) {
                if (null != integral) {
                    total += integral;
                }
            }
            // 自主故事
            List<TStoryListen> storyListenList = storyListenService.lambdaQuery()
                    .eq(TStoryListen::getStudyId, id)
                    .eq(TStoryListen::getWeek, week)
                    .eq(TStoryListen::getDisabled, 0).list();
            // 自主故事 - 框架记忆
            total += storyListenList.stream().map(TStoryListen::getIntegral).mapToInt(Integer::intValue).sum();
            // 自主故事 - 看图配音
            total += storyListenList.stream().map(TStoryListen::getLookIntegral).mapToInt(Integer::intValue).sum();
            // 判断周目是否可以进入学习
            Boolean canStudy = checkWeekCanStudy(userId, item, week);
            result.add(new StudyWeekDTO(week, type, quarter, title, total, canStudy));
        }
        return result;
    }

    @Override
    public TUserStudy studySchedule(TUserStudy studyRecord, Integer week) {
        // 剩余周目
        List<TStudy> studyList = this.lambdaQuery().eq(TStudy::getDisabled, 0)
                .eq(TStudy::getType, Constants.ONE)
                .orderByAsc(TStudy::getWeek).list();
        // 已学习到的周目
        Integer studyWeek = studyRecord.getWeek();
        // 学习到的季度
        Integer studyQuarter = 1;
        // 当前所点击进入的周目所属季度
        Integer currentQuarter = 1;
        // 根据季度分组封装
        Map<Integer, List<TStudy>> integerListMap = getIntegerListMap(studyList);
        for (Map.Entry<Integer, List<TStudy>> map : integerListMap.entrySet()) {
            List<TStudy> list = map.getValue();
            for (TStudy study : list) {
                Integer itemWeek = study.getWeek();
                if (studyWeek.equals(itemWeek)) {
                    studyQuarter = map.getKey();
                    break;
                }
            }
            for (TStudy study : list) {
                Integer itemWeek = study.getWeek();
                if (week.equals(itemWeek)) {
                    currentQuarter = map.getKey();
                    break;
                }
            }
        }
        // 已学习季度 大于当前周目所属季度，所有学习均已完成
        if (studyQuarter > currentQuarter) {
            studyRecord.setWeek(week);
            studyRecord.setDay(Constants.SIX);
            studyRecord.setListen(Constants.ONE_HUNDRED);
            studyRecord.setLook(Constants.ONE_HUNDRED);
            studyRecord.setInduction(Constants.ONE_HUNDRED);
            studyRecord.setAnswer(Constants.ONE_HUNDRED);
            studyRecord.setPair(Constants.ONE_HUNDRED);
            studyRecord.setGameDifficulty(Constants.TWO);
            studyRecord.setComputeSchedule(Constants.ONE_HUNDRED);
        } else if (studyQuarter < currentQuarter) {
            studyRecord.setWeek(week);
            studyRecord.setDay(Constants.ONE);
            studyRecord.setListen(Constants.BURDEN_ONE);
            studyRecord.setLook(Constants.BURDEN_ONE);
            studyRecord.setInduction(Constants.BURDEN_ONE);
            studyRecord.setAnswer(Constants.BURDEN_ONE);
            studyRecord.setPair(Constants.BURDEN_ONE);
            studyRecord.setGameDifficulty(null);
            studyRecord.setComputeSchedule(Constants.ZERO);
        } else {
            List<TStudy> tStudies = integerListMap.get(studyQuarter);
            List<Integer> weekList = tStudies.stream().map(TStudy::getWeek).collect(Collectors.toList());
            int i = weekList.indexOf(studyWeek);
            int i1 = weekList.indexOf(week);
            if (i > i1) {
                studyRecord.setWeek(week);
                studyRecord.setDay(Constants.SIX);
                studyRecord.setListen(Constants.ONE_HUNDRED);
                studyRecord.setLook(Constants.ONE_HUNDRED);
                studyRecord.setInduction(Constants.ONE_HUNDRED);
                studyRecord.setAnswer(Constants.ONE_HUNDRED);
                studyRecord.setPair(Constants.ONE_HUNDRED);
                studyRecord.setGameDifficulty(Constants.TWO);
                studyRecord.setComputeSchedule(Constants.ONE_HUNDRED);
            } else if (i < i1) {
                studyRecord.setWeek(week);
                studyRecord.setDay(Constants.ONE);
                studyRecord.setListen(Constants.BURDEN_ONE);
                studyRecord.setLook(Constants.BURDEN_ONE);
                studyRecord.setInduction(Constants.BURDEN_ONE);
                studyRecord.setAnswer(Constants.BURDEN_ONE);
                studyRecord.setPair(Constants.BURDEN_ONE);
                studyRecord.setGameDifficulty(null);
                studyRecord.setComputeSchedule(Constants.ZERO);
            }
        }
        return studyRecord;
    }

    /**
     * @param userId 用户id
     * @param week   该季度下的周目
     * @return 当前周目是否学习
     */
    private Boolean checkWeekCanStudyNew(Integer userId, TStudy study, Integer week) {
        // 剩余周目
        List<TStudy> studyList = this.lambdaQuery().eq(TStudy::getDisabled, 0)
                .eq(TStudy::getType, Constants.ONE)
                .orderByAsc(TStudy::getWeek).list();
        TUserStudy userStudy = userStudyService.lambdaQuery()
                .eq(TUserStudy::getUserId, userId)
                .eq(TUserStudy::getDisabled, 0).one();
        if (null == userStudy) {
            userStudy = new TUserStudy();
            userStudy.setUserId(userId);
            // 学习周目
            TStudy tStudy = this.lambdaQuery().eq(TStudy::getQuarter, Constants.ONE)
                    .orderByAsc(TStudy::getWeek).last("limit 1").one();
            userStudy.setWeek(tStudy.getWeek());
            userStudy.setDay(Constants.ONE);
            userStudy.setTotalStudy(Constants.ZERO);
            userStudy.setTodayStudy(Constants.ZERO);
            userStudy.setWeekStudy(Constants.ZERO);
            userStudy.setMonthStudy(Constants.ZERO);
            userStudy.setListen(Constants.BURDEN_ONE);
            userStudy.setLook(Constants.BURDEN_ONE);
            userStudy.setInduction(Constants.BURDEN_ONE);
            userStudy.setAnswer(Constants.BURDEN_ONE);
            userStudy.setPair(Constants.BURDEN_ONE);
            userStudyService.save(userStudy);
        }
        // 获取当前学习周目为哪一个季度
        TStudy studyQuarterVo = this.lambdaQuery()
                .eq(TStudy::getWeek, userStudy.getWeek())
                .eq(TStudy::getDisabled, 0).one();
        // 已学习到的周目
        Integer studyWeek = userStudy.getWeek();
        // 学习到的季度
        Integer studyQuarter = studyQuarterVo.getQuarter();
        // 当前所点击进入的周目所属季度
        Integer currentQuarter = 1;
        // 根据季度分组封装
        Map<Integer, List<TStudy>> integerListMap = getIntegerListMap(studyList);
        for (Map.Entry<Integer, List<TStudy>> map : integerListMap.entrySet()) {
            List<TStudy> list = map.getValue();
//            for (TStudy data : list) {
//                Integer itemWeek = data.getWeek();
//                if (studyWeek.equals(itemWeek)) {
//                    studyQuarter = map.getKey();
//                    break;
//                }
//            }
            for (TStudy data : list) {
                Integer itemWeek = data.getWeek();
                if (week.equals(itemWeek)) {
                    currentQuarter = map.getKey();
                    break;
                }
            }
        }
        // 已学习季度 大于当前周目所属季度，所有学习均已完成
        if (studyQuarter > currentQuarter) {
            return Boolean.TRUE;
        } else if (studyQuarter < currentQuarter) {
            return Boolean.FALSE;
        } else {
            List<TStudy> tStudies = integerListMap.get(studyQuarter);
            List<Integer> weekList = tStudies.stream().map(TStudy::getWeek).collect(Collectors.toList());
            int i = weekList.indexOf(studyWeek);
            int i1 = weekList.indexOf(week);
            if (i >= i1) {
                return Boolean.TRUE;
            } else {
                return Boolean.FALSE;
            }
        }
    }

    /**
     * @param userId 用户id
     * @return 当前周目是否学习
     */
    private Boolean checkWeekCanStudy(Integer userId, TStudy study, Integer week) {
        // 剩余周目
        List<TStudy> studyList = this.lambdaQuery().eq(TStudy::getDisabled, 0)
                .eq(TStudy::getType, Constants.ONE)
                .orderByAsc(TStudy::getWeek).list();
        TUserStudy userStudy = userStudyService.lambdaQuery()
                .eq(TUserStudy::getUserId, userId)
                .eq(TUserStudy::getDisabled, 0).one();
        if (null == userStudy) {
            userStudy = new TUserStudy();
            userStudy.setUserId(userId);
            // 学习周目
            TStudy tStudy = this.lambdaQuery().eq(TStudy::getQuarter, Constants.ONE)
                    .orderByAsc(TStudy::getWeek).last("limit 1").one();
            userStudy.setWeek(tStudy.getWeek());
            userStudy.setDay(Constants.ONE);
            userStudy.setTotalStudy(Constants.ZERO);
            userStudy.setTodayStudy(Constants.ZERO);
            userStudy.setWeekStudy(Constants.ZERO);
            userStudy.setMonthStudy(Constants.ZERO);
            userStudy.setListen(Constants.BURDEN_ONE);
            userStudy.setLook(Constants.BURDEN_ONE);
            userStudy.setInduction(Constants.BURDEN_ONE);
            userStudy.setAnswer(Constants.BURDEN_ONE);
            userStudy.setPair(Constants.BURDEN_ONE);
            userStudyService.save(userStudy);
        }
        // 获取当前学习周目为哪一个季度
        TStudy studyQuarterVo = this.lambdaQuery()
                .eq(TStudy::getWeek, userStudy.getWeek())
                .eq(TStudy::getDisabled, 0).one();
        // 已学习到的周目
        Integer studyWeek = userStudy.getWeek();
        // 学习到的季度
        Integer studyQuarter = studyQuarterVo.getQuarter();
        // 当前所点击进入的周目所属季度
        Integer currentQuarter = 1;
        // 根据季度分组封装
        Map<Integer, List<TStudy>> integerListMap = getIntegerListMap(studyList);
        for (Map.Entry<Integer, List<TStudy>> map : integerListMap.entrySet()) {
            List<TStudy> list = map.getValue();
            for (TStudy data : list) {
                Integer itemWeek = data.getWeek();
                if (week.equals(itemWeek)) {
                    currentQuarter = map.getKey();
                    break;
                }
            }
        }
        // 已学习季度 大于当前周目所属季度，所有学习均已完成
        if (studyQuarter > currentQuarter) {
            return Boolean.TRUE;
        } else if (studyQuarter < currentQuarter) {
            return Boolean.FALSE;
        } else {
            List<TStudy> tStudies = integerListMap.get(studyQuarter);
            List<Integer> weekList = tStudies.stream().map(TStudy::getWeek).collect(Collectors.toList());
            int i = weekList.indexOf(studyWeek);
            int i1 = weekList.indexOf(week);
            if (i >= i1) {
                return Boolean.TRUE;
            } else {
                return Boolean.FALSE;
            }
        }
    }

    @Override
    public void checkDifficulty(Integer difficulty, Integer week, TGame game, Integer userid) {
        // 判断用户是否完成上一个等级
        if (!Constants.ZERO.equals(difficulty)) {
            Integer level = GAME_DIFFICULTY_MAP.get(difficulty);
            if (null == level) {
                throw new GlobalException("游戏等级异常，请重试！");
            }
            // 游戏通关率
            String clearanceRate = game.getRate().split(",")[level];
            // 获取用户游戏进度
            List<TGameRecord> list = gameRecordService.lambdaQuery().eq(TGameRecord::getUserId, userid)
                    .eq(TGameRecord::getGameId, game.getId())
                    .ge(TGameRecord::getAccuracy, clearanceRate)
                    .eq(TGameRecord::getGameDifficulty, level).list();
            if (list.isEmpty()) {
                throw new GlobalException("请先完成上一难度再挑战当前难度！");
            }
        }
    }

    @Override
    public StudyListenResultVO listenSelectPicture(Integer week, Integer day, List<TStudyListen> studyListens, Integer userid) {
        if (studyListens.isEmpty()) {
            throw new GlobalException("当前学习周目题目数量不足！");
        }
        // 题组信息
        LearnStudyVO learnStudy = new LearnStudyVO();
        String ids = studyListens.stream().map(TStudyListen::getId).map(String::valueOf)
                .collect(Collectors.joining(","));
        learnStudy.setId(ids);
        int total = 0;
        for (TStudyListen data : studyListens) {
            if (null != data) {
                total += data.getIntegral();
            }
        }
        learnStudy.setIntegral(total);
        // 语音及图片
        List<List<TSubject>> subjectList = new ArrayList<>();

        StudyListenResultVO studyListenResultVO = new StudyListenResultVO(learnStudy, subjectList);
        List<TSubjectRecordDetail> subjectRecordDetails = subjectRecordDetailService.lambdaQuery().eq(TSubjectRecordDetail::getUserId, userid)
                .eq(TSubjectRecordDetail::getWeek, week).eq(BaseModel::getDisabled, 0).list();
        List<TSubjectRecordDetail> listenList = subjectRecordDetails.stream().filter(e -> e.getType() == 1).collect(Collectors.toList());
        int listenPass = (int) listenList.stream().filter(e -> e.getStatus() == 2).count();
        int listenSize = listenList.size();
        if (listenSize!=0){
            // 计算当前通关率
            double listenRate = (double) listenPass /listenSize;
            TStudyListen one = studyListenService.lambdaQuery().eq(TStudyListen::getWeek, week)
                    .eq(TStudyListen::getDay, 1).last("limit 1").one();
            if (one!=null){
                if (listenRate<(Double.parseDouble(one.getRate())/100)){
                    // 清空答题记录
                    subjectRecordDetailService.remove(new LambdaQueryWrapper<TSubjectRecordDetail>()
                            .eq(TSubjectRecordDetail::getUserId, userid)
                            .eq(TSubjectRecordDetail::getWeek, week)
                            .eq(TSubjectRecordDetail::getDay,day)
                            .eq(TSubjectRecordDetail::getType
                            ,1));
                }
            }
        }
        List<TSubjectRecordDetail> list = subjectRecordDetailService.lambdaQuery().eq(TSubjectRecordDetail::getUserId, userid)
                .eq(TSubjectRecordDetail::getWeek, week)
                .eq(TSubjectRecordDetail::getDay, day)
                .eq(TSubjectRecordDetail::getType, 1).list();
        if (list.isEmpty()) {
            List<TSubjectRecordDetail> tSubjectRecordDetails = new ArrayList<>();
            for (TStudyListen studyListen : studyListens) {
                List<String> subjectIds = Arrays.stream(studyListen.getSubject().split(",")).collect(Collectors.toList());
                List<TSubject> subs = new ArrayList<>();
                // 图片及语音集合
                int i=0;
                for (String id : studyListen.getSubject().split( ",")) {
                    TSubject data = subjectService.lambdaQuery().eq(TSubject::getId, id)
                            .eq(TSubject::getDisabled, 0).one();
                    if(studyListen.getType()!=null && studyListen.getType()==2 && i<2){
                        data.setStudyType(2);
                    }

                    TSubjectRecordDetail tSubjectRecordDetail = new TSubjectRecordDetail();
                    tSubjectRecordDetail.setUserId(userid);
                    tSubjectRecordDetail.setWeek(week);
                    tSubjectRecordDetail.setDay(day);
                    tSubjectRecordDetail.setType(1);
                    tSubjectRecordDetail.setStatus(1);
                    tSubjectRecordDetail.setObjectId(studyListen.getId());
                    tSubjectRecordDetail.setSubjectId(data.getId());
                    tSubjectRecordDetails.add(tSubjectRecordDetail);
                    subjectRecordDetailService.save(tSubjectRecordDetail);
                    i++;
                    data.setTSubjectRecordDetail(tSubjectRecordDetail);
                    subs.add(data);
                }
                if(studyListen.getSubject().equals("10325,10327,10326,10328")){
                    System.out.println("数据3331"+subs);
                }
                subjectList.add(subs);

                if(studyListen.getSubject().equals("10325,10327,10326,10328")){
                    System.out.println("数据4441"+subjectList);
                }
            }
//            subjectRecordDetailService.saveBatch(tSubjectRecordDetails);
            studyListenResultVO.setList(tSubjectRecordDetails);
            studyListenResultVO.setAccuracy(new BigDecimal("0.00"));

        } else {

            List<TSubjectRecordDetail> tSubjectRecordDetails = new ArrayList<>();
            for (TStudyListen studyListen : studyListens) {
                List<String> subjectIds = Arrays.stream(studyListen.getSubject().split(",")).collect(Collectors.toList());
                List<TSubject> subs = new ArrayList<>();
                List<TSubject> subsTemp = new ArrayList<>();
                // 图片及语音集合
                int temp=0;
                for (String id : studyListen.getSubject().split( ",")) {
                    TSubject data = subjectService.lambdaQuery().eq(TSubject::getId, id)
                            .eq(TSubject::getDisabled, 0).one();
                    if(studyListen.getType()!=null && studyListen.getType()==2 && temp<2){
                        data.setStudyType(2);
                    }
                    temp++;
                    subs.add(data);
                }
                if(studyListen.getSubject().equals("10325,10327,10326,10328")){
                    System.out.println("数据3332"+subs);
                }

                List<TSubjectRecordDetail> tSubjectRecordDetail1 = list.stream()
                        .filter(e -> e.getObjectId().equals(studyListen.getId())).collect(Collectors.toList());

                if (tSubjectRecordDetail1.isEmpty()){
                    for (int i = 0; i < 4; i++) {
                        TSubjectRecordDetail tSubjectRecordDetail = new TSubjectRecordDetail();
                        tSubjectRecordDetail.setUserId(userid);
                        tSubjectRecordDetail.setWeek(week);
                        tSubjectRecordDetail.setDay(day);
                        tSubjectRecordDetail.setType(1);
                        tSubjectRecordDetail.setStatus(1);
                        tSubjectRecordDetail.setObjectId(studyListen.getId());
                        TSubject tSubject = subs.get(i);
                        tSubjectRecordDetail.setSubjectId(tSubject.getId());
                        subjectRecordDetailService.save(tSubjectRecordDetail);
                        tSubjectRecordDetails.add(tSubjectRecordDetail);
                        tSubject.setTSubjectRecordDetail(tSubjectRecordDetail);
                        subsTemp.add(tSubject);
                    }
                }else{
                    for (int i = 0; i < 4; i++) {
                        TSubjectRecordDetail tSubjectRecordDetail = tSubjectRecordDetail1.get( i);
                        Integer subjectId = tSubjectRecordDetail.getSubjectId();
                        TSubject tSubject = subs.stream().filter(e -> e.getId().equals(subjectId)).findFirst().orElse(null);
                        if(tSubject!=null){
                            tSubject.setTSubjectRecordDetail(tSubjectRecordDetail);
                            subsTemp.add(tSubject);
                        }else {
                            TSubject tSubject1 = subs.get(i);
                            tSubjectRecordDetail.setSubjectId(tSubject1.getId());

                            tSubject1.setTSubjectRecordDetail(tSubjectRecordDetail);
                            subsTemp.add(tSubject1);
                        }
                        subjectRecordDetailService.setSubjectId(tSubjectRecordDetail);
                        tSubjectRecordDetails.add(tSubjectRecordDetail);
                    }
                }
                if(studyListen.getSubject().equals("10325,10327,10326,10328")){
                    System.out.println("数据55552"+subsTemp);
                }

                // 单独处理排序问题
                String subject = studyListen.getSubject();
                String[] split = subject.split(",");
                List<TSubject> subsTempNext = new ArrayList<>();
                for (String s : split) {
                    TSubject tSubject = subsTemp.stream().filter(e -> e.getId().equals(s)).findFirst().orElse(null);
                    subsTempNext.add(tSubject);
                }
                if(studyListen.getSubject().equals("10325,10327,10326,10328")){
                    System.out.println("数据4442"+subsTempNext);
                }

                subjectList.add(subsTemp);
            }

            studyListenResultVO.setList(tSubjectRecordDetails);
            // 计算正确率
            BigDecimal accuracy = new BigDecimal(tSubjectRecordDetails.stream().filter(tSubjectRecordDetail -> tSubjectRecordDetail.getStatus().equals(2)).count())
                    .divide(new BigDecimal(tSubjectRecordDetails.size()), 2, RoundingMode.HALF_UP);
            studyListenResultVO.setAccuracy(accuracy);
        }
        studyListenResultVO.setSubjectList(subjectList);
        System.out.println("数据！！！"+subjectList);
        return studyListenResultVO;
    }

    @Override
    public R<StudyLookResultVO> pictureSelectVoice(Integer week, Integer day, List<TStudyLook> lookList, Integer userid) {
        if (lookList.isEmpty()) {
            throw new GlobalException("当前学习周目题目数量不足！");
        }
        // 题组信息
        LearnStudyVO learnStudy = new LearnStudyVO();
        String ids = lookList.stream().map(TStudyLook::getId).map(String::valueOf)
                .collect(Collectors.joining(","));
        learnStudy.setId(ids);
        int total = 0;
        for (TStudyLook data : lookList) {
            if (null != data) {
                total += data.getIntegral();
            }
        }
        learnStudy.setIntegral(total);
        // 语音及图片
        List<List<TSubject>> subjectList = new ArrayList<>();

        StudyLookResultVO studyListenResultVO = new StudyLookResultVO(learnStudy, subjectList);
        List<TSubjectRecordDetail> subjectRecordDetails = subjectRecordDetailService.lambdaQuery().eq(TSubjectRecordDetail::getUserId, userid)
                .eq(TSubjectRecordDetail::getWeek, week).eq(BaseModel::getDisabled, 0).list();
        List<TSubjectRecordDetail> listenList = subjectRecordDetails.stream().filter(e -> e.getType() == 1).collect(Collectors.toList());
        int listenPass = (int) listenList.stream().filter(e -> e.getStatus() == 2).count();
        int listenSize = listenList.size();
        if (listenSize!=0){
            // 先计算上一天的通关率 设置为两位小数
            double listenRate = (double) listenPass /listenSize;
            BigDecimal divide = new BigDecimal(listenPass).divide(new BigDecimal(listenSize), 2, RoundingMode.HALF_UP);
            TStudyListen one = studyListenService.lambdaQuery().eq(TStudyListen::getWeek, week)
                    .eq(TStudyListen::getDay, 1).last("limit 1").one();
            if (one!=null){
                if (listenRate<(Double.parseDouble(one.getRate())/100)){
                    return R.fail("听音选图未达到通关率"+one.getRate()+"%,"+"当前通关率:"+divide.multiply(new BigDecimal(100))+"%");
                }
            }
        }
        List<TSubjectRecordDetail> lookList1 = subjectRecordDetails.stream().filter(e -> e.getType() == 2).collect(Collectors.toList());
        int lookPass = (int) lookList1.stream().filter(e -> e.getStatus() == 2).count();
        int lookSize = lookList1.size();
        if (lookSize!=0){
            // 计算当前通关率
            double listenRate = (double) lookPass /lookSize;
            TStudyLook one = studyLookService.lambdaQuery().eq(TStudyLook::getWeek, week)
                    .eq(TStudyLook::getDay, 2).last("limit 1").one();
            if (one!=null){
                // 通关率未达标
                if (listenRate<(Double.parseDouble(one.getRate())/100)){
                    // 清空答题记录
                    subjectRecordDetailService.remove(new LambdaQueryWrapper<TSubjectRecordDetail>()
                            .eq(TSubjectRecordDetail::getUserId, userid)
                            .eq(TSubjectRecordDetail::getWeek, week)
                            .eq(TSubjectRecordDetail::getDay,day)
                            .eq(TSubjectRecordDetail::getType
                                    ,2));
                }
            }
        }
        List<TSubjectRecordDetail> list = subjectRecordDetailService.lambdaQuery().eq(TSubjectRecordDetail::getUserId, userid)
                .eq(TSubjectRecordDetail::getWeek, week)
                .eq(TSubjectRecordDetail::getDay, day)
                .eq(TSubjectRecordDetail::getType, 2).list();
        if (list.isEmpty()) {
            List<TSubjectRecordDetail> tSubjectRecordDetails = new ArrayList<>();
            for (TStudyLook studyLook : lookList) {
                List<String> sortList = Arrays.stream(studyLook.getSort().split(",")).collect(Collectors.toList());
                List<String> subjectIds = Arrays.stream(studyLook.getSubject().split(",")).collect(Collectors.toList());
                List<TSubject> subjects = new ArrayList<>();
                // 图片及语音集合
                for (int i = 0; i < subjectIds.size(); i++) {
                    TSubject data = subjectService.lambdaQuery().eq(TSubject::getId, subjectIds.get(i))
                            .eq(TSubject::getDisabled, 0).one();
                    data.setSort(Integer.parseInt(sortList.get(i)));
                    subjects.add(data);
                }
                // 根据顺序排序
                subjects.sort(Comparator.comparingInt(TSubject::getSort));
                subjectList.add(subjects);
                TSubjectRecordDetail tSubjectRecordDetail = new TSubjectRecordDetail();
                tSubjectRecordDetail.setUserId(userid);
                tSubjectRecordDetail.setWeek(week);
                tSubjectRecordDetail.setDay(day);
                tSubjectRecordDetail.setType(2);
                tSubjectRecordDetail.setStatus(1);
                tSubjectRecordDetail.setObjectId(studyLook.getId());
                tSubjectRecordDetails.add(tSubjectRecordDetail);
            }

            studyListenResultVO.setSubjectList(subjectList);
            subjectRecordDetailService.saveBatch(tSubjectRecordDetails);
            studyListenResultVO.setList(tSubjectRecordDetails);
            studyListenResultVO.setAccuracy(new BigDecimal("0.00"));

        } else {
            List<TSubjectRecordDetail> tSubjectRecordDetails = new ArrayList<>();
            List<Integer> collect1 = lookList.stream().map(TStudyLook::getId).collect(Collectors.toList());
            List<TSubjectRecordDetail> collect3 = list.stream().filter(e -> !collect1.contains(e.getObjectId())).collect(Collectors.toList());
            subjectRecordDetailService.removeBatchByIds(collect3);
            for (TStudyLook studyLook : lookList) {
                List<String> sortList = Arrays.stream(studyLook.getSort().split(",")).collect(Collectors.toList());
                List<String> subjectIds = Arrays.stream(studyLook.getSubject().split(",")).collect(Collectors.toList());
                List<TSubject> subjects = new ArrayList<>();
                // 图片及语音集合
                for (int i = 0; i < subjectIds.size(); i++) {
                    TSubject data = subjectService.lambdaQuery().eq(TSubject::getId, subjectIds.get(i))
                            .eq(TSubject::getDisabled, 0).one();
                    data.setSort(Integer.parseInt(sortList.get(i)));
                    subjects.add(data);
                }
                // 根据顺序排序
                subjects.sort(Comparator.comparingInt(TSubject::getSort));
                subjectList.add(subjects);
                List<TSubjectRecordDetail> tSubjectRecordDetail1 = list.stream().filter(e -> e.getObjectId().equals(studyLook.getId())).collect(Collectors.toList());
                if (tSubjectRecordDetail1.isEmpty()){
                    TSubjectRecordDetail tSubjectRecordDetail = new TSubjectRecordDetail();
                    tSubjectRecordDetail.setUserId(userid);
                    tSubjectRecordDetail.setWeek(week);
                    tSubjectRecordDetail.setDay(day);
                    tSubjectRecordDetail.setType(3);
                    tSubjectRecordDetail.setStatus(1);
                    tSubjectRecordDetail.setObjectId(studyLook.getId());
                    tSubjectRecordDetails.add(tSubjectRecordDetail);
                    subjectRecordDetailService.save(tSubjectRecordDetail);
                }else{
                    tSubjectRecordDetails.addAll(tSubjectRecordDetail1);
                }


            }

            studyListenResultVO.setAccuracy(new BigDecimal(tSubjectRecordDetails.stream().filter(tSubjectRecordDetail -> tSubjectRecordDetail.getStatus().equals(2)).count())
                    .divide(new BigDecimal(tSubjectRecordDetails.size()), 2, RoundingMode.HALF_UP));
            studyListenResultVO.setList(tSubjectRecordDetails);
            studyListenResultVO.setSubjectList(subjectList);
        }
        return R.ok(studyListenResultVO);
    }

    @Override
    public R<StudyInductionResultVO> induceExclude(Integer week, Integer day, List<TStudyInduction> inductionList, Integer userid) {
        if (inductionList.isEmpty()) {
            throw new GlobalException("当前学习周目题目数量不足！");
        }
        // 题组信息
        LearnStudyVO learnStudy = new LearnStudyVO();
        String ids = inductionList.stream().map(TStudyInduction::getId).map(String::valueOf)
                .collect(Collectors.joining(","));
        learnStudy.setId(ids);
        int total = 0;
        for (TStudyInduction data : inductionList) {
            if (null != data) {
                total += data.getIntegral();
            }
        }
        learnStudy.setIntegral(total);
        // 语音及图片
        List<List<TSubject>> subjectList = new ArrayList<>();

        StudyInductionResultVO studyListenResultVO = new StudyInductionResultVO(learnStudy, subjectList);

        List<TSubjectRecordDetail> list = subjectRecordDetailService.lambdaQuery().eq(TSubjectRecordDetail::getUserId, userid)
                .eq(TSubjectRecordDetail::getWeek, week)
                .eq(TSubjectRecordDetail::getDay, day)
                .eq(TSubjectRecordDetail::getType, 3).list();
        List<TSubjectRecordDetail> subjectRecordDetails = subjectRecordDetailService.lambdaQuery().eq(TSubjectRecordDetail::getUserId, userid)
                .eq(TSubjectRecordDetail::getWeek, week).eq(BaseModel::getDisabled, 0).list();
        List<TSubjectRecordDetail> listenList = subjectRecordDetails.stream().filter(e -> e.getType() == 2).collect(Collectors.toList());
        int listenPass = (int) listenList.stream().filter(e -> e.getStatus() == 2).count();
        int listenSize = listenList.size();
        if (listenSize!=0){
            // 先计算上一天的通关率 设置为两位小数
            double listenRate = (double) listenPass /listenSize;
            BigDecimal divide = new BigDecimal(listenPass).divide(new BigDecimal(listenSize), 2, RoundingMode.HALF_UP);
            TStudyLook one = studyLookService.lambdaQuery().eq(TStudyLook::getWeek, week)
                    .eq(TStudyLook::getDay, 2).last("limit 1").one();
            if (one!=null){
                if (listenRate<(Double.parseDouble(one.getRate())/100)){
                    return R.fail("看图选音未达到通关率"+one.getRate()+"%,"+"当前通关率:"+divide.multiply(new BigDecimal(100))+"%");
                }
            }
        }
        List<TSubjectRecordDetail> lookList1 = subjectRecordDetails.stream().filter(e -> e.getType() == 3).collect(Collectors.toList());
        int lookPass = (int) lookList1.stream().filter(e -> e.getStatus() == 2).count();
        int lookSize = lookList1.size();
        if (lookSize!=0){
            // 计算当前通关率
            double listenRate = (double) lookPass /lookSize;
            TStudyInduction one = studyInductionService.lambdaQuery().eq(TStudyInduction::getWeek, week)
                    .eq(TStudyInduction::getDay, 3).last("limit 1").one();
            if (one!=null){
                // 通关率未达标
                if (listenRate<(Double.parseDouble(one.getRate())/100)){
                    // 清空答题记录
                    subjectRecordDetailService.remove(new LambdaQueryWrapper<TSubjectRecordDetail>()
                            .eq(TSubjectRecordDetail::getUserId, userid)
                            .eq(TSubjectRecordDetail::getWeek, week)
                            .eq(TSubjectRecordDetail::getDay,day)
                            .eq(TSubjectRecordDetail::getType
                                    ,3));
                }
            }
        }
        if (list.isEmpty()) {
            List<TSubjectRecordDetail> tSubjectRecordDetails = new ArrayList<>();
            for (TStudyInduction data : inductionList) {
                List<String> subjectIds = Arrays.stream(data.getSubject().split(",")).collect(Collectors.toList());
                List<TSubject> subjectLists = new ArrayList<>();
                // 第一组题 固定下标为0,1,2的题
                for (int i = 0; i < Constants.THREE; i++) {
                    String id = subjectIds.get(i);
                    if (!id.startsWith("-")) {
                        subjectLists.add(subjectService.getById(id));
                    }
                }
                for (int i = 0; i < Constants.THREE; i++) {
                    String id = subjectIds.get(i);
                    if (id.startsWith("-")) {
                        id = id.replace("-", "");
                        subjectLists.add(subjectService.getById(id));
                    }
                }
                // 第二组题，固定下标为3,4的题
                for (int i = Constants.THREE; i < Constants.FIVE; i++) {
                    String id = subjectIds.get(i);
                    if (!id.startsWith("-")) {
                        subjectLists.add(subjectService.getById(id));
                    }
                }
                for (int i = Constants.THREE; i < Constants.FIVE; i++) {
                    String id = subjectIds.get(i);
                    if (id.startsWith("-")) {
                        id = id.replace("-", "");
                        subjectLists.add(subjectService.getById(id));
                    }
                }
                subjectLists.add(subjectService.getById(subjectIds.get(subjectIds.size() - 1).replace("-", "")));
                subjectList.add(subjectLists);
                TSubjectRecordDetail tSubjectRecordDetail = new TSubjectRecordDetail();
                tSubjectRecordDetail.setUserId(userid);
                tSubjectRecordDetail.setWeek(week);
                tSubjectRecordDetail.setObjectId(data.getId());
                tSubjectRecordDetail.setDay(day);
                tSubjectRecordDetail.setType(3);
                tSubjectRecordDetail.setStatus(1);
                tSubjectRecordDetails.add(tSubjectRecordDetail);
            }
            studyListenResultVO.setSubjectList(subjectList);

            subjectRecordDetailService.saveBatch(tSubjectRecordDetails);
            studyListenResultVO.setList(tSubjectRecordDetails);
            studyListenResultVO.setAccuracy(new BigDecimal("0.00"));

        } else {
            List<Integer> collect1 = inductionList.stream().map(TStudyInduction::getId).collect(Collectors.toList());
            List<TSubjectRecordDetail> collect3 = list.stream().filter(e -> !collect1.contains(e.getObjectId())).collect(Collectors.toList());
            subjectRecordDetailService.removeBatchByIds(collect3);
            List<TSubjectRecordDetail> tSubjectRecordDetails = new ArrayList<>();
            for (TStudyInduction data : inductionList) {
                List<String> subjectIds = Arrays.stream(data.getSubject().split(",")).collect(Collectors.toList());
                List<TSubject> subjectLists = new ArrayList<>();
                // 第一组题 固定下标为0,1,2的题
                for (int i = 0; i < Constants.THREE; i++) {
                    String id = subjectIds.get(i);
                    if (!id.startsWith("-")) {
                        subjectLists.add(subjectService.getById(id));
                    }
                }
                for (int i = 0; i < Constants.THREE; i++) {
                    String id = subjectIds.get(i);
                    if (id.startsWith("-")) {
                        id = id.replace("-", "");
                        subjectLists.add(subjectService.getById(id));
                    }
                }
                // 第二组题，固定下标为3,4的题
                for (int i = Constants.THREE; i < Constants.FIVE; i++) {
                    String id = subjectIds.get(i);
                    if (!id.startsWith("-")) {
                        subjectLists.add(subjectService.getById(id));
                    }
                }
                for (int i = Constants.THREE; i < Constants.FIVE; i++) {
                    String id = subjectIds.get(i);
                    if (id.startsWith("-")) {
                        id = id.replace("-", "");
                        subjectLists.add(subjectService.getById(id));
                    }
                }
                subjectLists.add(subjectService.getById(subjectIds.get(subjectIds.size() - 1).replace("-", "")));
                subjectList.add(subjectLists);

                TSubjectRecordDetail tSubjectRecordDetail1 = list.stream().filter(e -> e.getObjectId().equals(data.getId())).findFirst().orElse(null);
                if (tSubjectRecordDetail1==null){
                    TSubjectRecordDetail tSubjectRecordDetail = new TSubjectRecordDetail();
                    tSubjectRecordDetail.setUserId(userid);
                    tSubjectRecordDetail.setWeek(week);
                    tSubjectRecordDetail.setDay(day);
                    tSubjectRecordDetail.setType(3);
                    tSubjectRecordDetail.setStatus(1);
                    tSubjectRecordDetail.setObjectId(data.getId());
                    subjectRecordDetailService.save(tSubjectRecordDetail);

                    tSubjectRecordDetails.add(tSubjectRecordDetail);
                }else{
                    tSubjectRecordDetails.add(tSubjectRecordDetail1);
                }
            }
            studyListenResultVO.setList(tSubjectRecordDetails);
            studyListenResultVO.setAccuracy(new BigDecimal(tSubjectRecordDetails.stream().filter(tSubjectRecordDetail -> tSubjectRecordDetail.getStatus().equals(2)).count())
                    .divide(new BigDecimal(tSubjectRecordDetails.size()), 2, RoundingMode.HALF_UP));
        }
        studyListenResultVO.setSubjectList(subjectList);
        System.err.println("归纳排除题目"+subjectList);
        return R.ok(studyListenResultVO);
    }

    @Override
    public R<StudyAnswerResultVO> questionsAndAnswers(Integer week, Integer day, List<TStudyAnswer> answerList, Integer userid) {
        if (answerList.isEmpty()) {
            throw new GlobalException("当前学习周目题目数量不足！");
        }
        if (answerList.size()<4){
            throw new GlobalException("当前学习周目题目数量不足！");
        }
        if (answerList.size()%4!=0){
            throw new GlobalException("当前学习周目题目数量不足");
        }
        // 题组信息
        LearnStudyVO learnStudy = new LearnStudyVO();
        String ids = answerList.stream().map(TStudyAnswer::getId).map(String::valueOf)
                .collect(Collectors.joining(","));
        learnStudy.setId(ids);
        int total = 0;
        for (TStudyAnswer data : answerList) {
            if (null != data) {
                total += data.getIntegral();
            }
        }
        learnStudy.setIntegral(total);
        // 题目语音及图片信息
        List<List<QuestionsAnswersSubjectVO>> subjectList = new ArrayList<>();

        StudyAnswerResultVO studyListenResultVO = new StudyAnswerResultVO(learnStudy, subjectList);

        List<TSubjectRecordDetail> list = subjectRecordDetailService.lambdaQuery().eq(TSubjectRecordDetail::getUserId, userid)
                .eq(TSubjectRecordDetail::getWeek, week)
                .eq(TSubjectRecordDetail::getDay, day)
                .eq(TSubjectRecordDetail::getType, 4).list();
        List<TSubjectRecordDetail> subjectRecordDetails = subjectRecordDetailService.lambdaQuery().eq(TSubjectRecordDetail::getUserId, userid)
                .eq(TSubjectRecordDetail::getWeek, week).eq(BaseModel::getDisabled, 0).list();
        List<TSubjectRecordDetail> listenList = subjectRecordDetails.stream().filter(e -> e.getType() == 3).collect(Collectors.toList());
        int listenPass = (int) listenList.stream().filter(e -> e.getStatus() == 2).count();
        int listenSize = listenList.size();
        if (listenSize!=0){
            // 先计算上一天的通关率 设置为两位小数
            double listenRate = (double) listenPass /listenSize;
            BigDecimal divide = new BigDecimal(listenPass).divide(new BigDecimal(listenSize), 2, RoundingMode.HALF_UP);
            TStudyInduction one = studyInductionService.lambdaQuery().eq(TStudyInduction::getWeek, week)
                    .eq(TStudyInduction::getDay, 3).last("limit 1").one();
            if (one!=null){
                if (listenRate<(Double.parseDouble(one.getRate())/100)){
                    return R.fail("归纳排除未达到通关率"+one.getRate()+"%,"+"当前通关率:"+divide.multiply(new BigDecimal(100))+"%");
                }
            }
        }
        List<TSubjectRecordDetail> lookList1 = subjectRecordDetails.stream().filter(e -> e.getType() == 4).collect(Collectors.toList());
        int lookPass = (int) lookList1.stream().filter(e -> e.getStatus() == 2).count();
        int lookSize = lookList1.size();
        if (lookSize!=0){
            // 计算当前通关率
            double listenRate = (double) lookPass /lookSize;
            TStudyAnswer one = studyAnswerService.lambdaQuery().eq(TStudyAnswer::getWeek, week)
                    .eq(TStudyAnswer::getDay, 4).last("limit 1").one();
            if (one!=null){
                // 通关率未达标
                if (listenRate<(Double.parseDouble(one.getRate())/100)){
                    // 清空答题记录
                    subjectRecordDetailService.remove(new LambdaQueryWrapper<TSubjectRecordDetail>()
                            .eq(TSubjectRecordDetail::getUserId, userid)
                            .eq(TSubjectRecordDetail::getWeek, week)
                            .eq(TSubjectRecordDetail::getDay,day)
                            .eq(TSubjectRecordDetail::getType
                                    ,4));
                }
            }
        }
        if (list.isEmpty()) {
            List<TSubjectRecordDetail> tSubjectRecordDetails = new ArrayList<>();
            for (int i = 0; i < answerList.size(); i += Constants.TWO) {
                List<QuestionsAnswersSubjectVO> voList = new ArrayList<>();
                // 一组题目为四道题，
                TStudyAnswer one = answerList.get(i);
                TStudyAnswer two = answerList.get(i + 1);
                voAdd(voList, one);
                voAdd(voList, two);
                subjectList.add(voList);
                TSubjectRecordDetail tSubjectRecordDetail = new TSubjectRecordDetail();
                tSubjectRecordDetail.setUserId(userid);
                tSubjectRecordDetail.setWeek(week);
                tSubjectRecordDetail.setDay(day);
                tSubjectRecordDetail.setType(4);
                tSubjectRecordDetail.setStatus(1);
                tSubjectRecordDetail.setOne(one.getId());
                tSubjectRecordDetail.setTwo(two.getId());
                tSubjectRecordDetails.add(tSubjectRecordDetail);
            }

            subjectRecordDetailService.saveBatch(tSubjectRecordDetails);
            studyListenResultVO.setList(tSubjectRecordDetails);
            studyListenResultVO.setAccuracy(new BigDecimal("0.00"));

        } else {
            List<TSubjectRecordDetail> tSubjectRecordDetails1 = new ArrayList<TSubjectRecordDetail>();
            List<TSubjectRecordDetail> tSubjectRecordDetails = new ArrayList<>();
            for (int i = 0; i < answerList.size(); i += Constants.TWO) {
                List<QuestionsAnswersSubjectVO> voList = new ArrayList<>();
                // 一组题目为四道题，
                TStudyAnswer one = answerList.get(i);
                TStudyAnswer two = answerList.get(i + 1);
                voAdd(voList, one);
                voAdd(voList, two);
                subjectList.add(voList);
                TSubjectRecordDetail tSubjectRecordDetail = new TSubjectRecordDetail();
                tSubjectRecordDetail.setUserId(userid);
                tSubjectRecordDetail.setWeek(week);
                tSubjectRecordDetail.setDay(day);
                tSubjectRecordDetail.setType(4);
                tSubjectRecordDetail.setStatus(1);
                tSubjectRecordDetail.setOne(one.getId());
                tSubjectRecordDetail.setTwo(two.getId());
                tSubjectRecordDetails.add(tSubjectRecordDetail);
                tSubjectRecordDetails1.add(tSubjectRecordDetail);
            }
            List<Long> collect = list.stream().map(TSubjectRecordDetail::getId).collect(Collectors.toList());
            subjectRecordDetailService.removeBatchByIds(collect);
            subjectRecordDetailService.saveBatch(tSubjectRecordDetails1);

            studyListenResultVO.setList(tSubjectRecordDetails);
            studyListenResultVO.setAccuracy(new BigDecimal(tSubjectRecordDetails.stream().filter(tSubjectRecordDetail -> tSubjectRecordDetail.getStatus().equals(2)).count())
                    .divide(new BigDecimal(tSubjectRecordDetails.size()), 2, RoundingMode.HALF_UP));
        }
        studyListenResultVO.setSubjectList(subjectList);
        return R.ok(studyListenResultVO);
    }

    private void voAdd(List<QuestionsAnswersSubjectVO> voList, TStudyAnswer one) {
        // 第一道题问题及答案
        Integer subject = one.getSubject();
        Integer answerSubject = one.getAnswerSubject();
        // 问题题目信息
        QuestionsAnswersSubjectVO oneVO = new QuestionsAnswersSubjectVO();
        TSubject one1 = subjectService.lambdaQuery().eq(TSubject::getId, subject)
                .eq(TSubject::getDisabled, 0).one();
        copyProperties(one1, oneVO);
        // 回答题目信息
        QuestionsAnswersSubjectVO twoVO = new QuestionsAnswersSubjectVO();
        TSubject two1 = subjectService.lambdaQuery().eq(TSubject::getId, answerSubject)
                .eq(TSubject::getDisabled, 0).one();
        copyProperties(two1, twoVO);
        // 判断第一组题目的问题题目及回答题目，哪个是答案
        if (Constants.ZERO.equals(one.getIsAnswer())) {
            oneVO.setIsQuestion(1);
            twoVO.setIsQuestion(0);
        } else {
            oneVO.setIsQuestion(0);
            twoVO.setIsQuestion(1);
        }
        voList.add(oneVO);
        voList.add(twoVO);
    }

    private void copyProperties(TSubject subject, QuestionsAnswersSubjectVO vo) {
        vo.setId(subject.getId());
        vo.setName(subject.getName());
        vo.setEnglish(subject.getEnglish());
        vo.setType(subject.getType());
        vo.setState(subject.getState());
        vo.setImg(subject.getImg());
        vo.setCorrect(subject.getCorrect());
        vo.setError(subject.getError());
        vo.setSort(subject.getSort());
    }

    @Override
    public R<StudyPairResultVO> pictureMateVoice(Integer week, Integer day, List<TStudyPair> pair, Integer userid) {
        if (pair.isEmpty()) {
            throw new GlobalException("当前学习周目题目数量不足！");
        }
        // 题组信息
        LearnStudyVO learnStudy = new LearnStudyVO();
        String ids = pair.stream().map(TStudyPair::getId).map(String::valueOf)
                .collect(Collectors.joining(","));
        learnStudy.setId(ids);
        int total = 0;
        for (TStudyPair data : pair) {
            if (null != data) {
                total += data.getIntegral();
            }
        }
        learnStudy.setIntegral(total);
        // 语音及图片
        List<List<TSubject>> subjectList = new ArrayList<>();

        StudyPairResultVO studyListenResultVO = new StudyPairResultVO(learnStudy, subjectList);

        List<TSubjectRecordDetail> list = subjectRecordDetailService.lambdaQuery().eq(TSubjectRecordDetail::getUserId, userid)
                .eq(TSubjectRecordDetail::getWeek, week)
                .eq(TSubjectRecordDetail::getDay, day)
                .eq(TSubjectRecordDetail::getType, 5).list();
        List<TSubjectRecordDetail> subjectRecordDetails = subjectRecordDetailService.lambdaQuery().eq(TSubjectRecordDetail::getUserId, userid)
                .eq(TSubjectRecordDetail::getWeek, week).eq(BaseModel::getDisabled, 0).list();
        List<TSubjectRecordDetail> listenList = subjectRecordDetails.stream().filter(e -> e.getType() == 4).collect(Collectors.toList());
        int listenPass = (int) listenList.stream().filter(e -> e.getStatus() == 2).count();
        int listenSize = listenList.size();
        if (listenSize!=0){
            // 先计算上一天的通关率 设置为两位小数
            double listenRate = (double) listenPass /listenSize;
            BigDecimal divide = new BigDecimal(listenPass).divide(new BigDecimal(listenSize), 2, RoundingMode.HALF_UP);
            TStudyAnswer one = studyAnswerService.lambdaQuery().eq(TStudyAnswer::getWeek, week)
                    .eq(TStudyAnswer::getDay, 4).last("limit 1").one();
            if (one!=null){
                if (listenRate<(Double.parseDouble(one.getRate())/100)){
                    return R.fail("归纳排除未达到通关率"+one.getRate()+"%,"+"当前通关率:"+divide.multiply(new BigDecimal(100))+"%");
                }
            }
        }
        List<TSubjectRecordDetail> lookList1 = subjectRecordDetails.stream().filter(e -> e.getType() == 5).collect(Collectors.toList());
        int lookPass = (int) lookList1.stream().filter(e -> e.getStatus() == 2).count();
        int lookSize = lookList1.size();
        if (lookSize!=0){
            // 计算当前通关率
            double listenRate = (double) lookPass /lookSize;
            TStudyPair one = studyPairService.lambdaQuery().eq(TStudyPair::getWeek, week)
                    .eq(TStudyPair::getDay, 5).last("limit 1").one();
            if (one!=null){
                // 通关率未达标
                if (listenRate<(Double.parseDouble(one.getRate())/100)){
                    // 清空答题记录
                    subjectRecordDetailService.remove(new LambdaQueryWrapper<TSubjectRecordDetail>()
                            .eq(TSubjectRecordDetail::getUserId, userid)
                            .eq(TSubjectRecordDetail::getWeek, week)
                            .eq(TSubjectRecordDetail::getDay,day)
                            .eq(TSubjectRecordDetail::getType
                                    ,5));
                }
            }
        }
        if (list.isEmpty()) {
            List<TSubjectRecordDetail> tSubjectRecordDetails = new ArrayList<>();
            for (TStudyPair data : pair) {
                TSubjectRecordDetail tSubjectRecordDetail = new TSubjectRecordDetail();
                tSubjectRecordDetail.setUserId(userid);
                tSubjectRecordDetail.setWeek(week);
                tSubjectRecordDetail.setDay(day);
                tSubjectRecordDetail.setType(5);
                tSubjectRecordDetail.setStatus(1);
                tSubjectRecordDetail.setObjectId(data.getId());
                tSubjectRecordDetails.add(tSubjectRecordDetail);

                List<String> subjectIds = Arrays.stream(data.getSubject().split(",")).collect(Collectors.toList());
                List<TSubject> subjectLists = new ArrayList<>();
                for (String id : data.getSubject().split( ",")) {
                    if (id.startsWith("-")) {
                        id = id.replace("-", "");
                    }
                    subjectLists.add(subjectService.getById(id));
                }
                subjectList.add(subjectLists);
            }
            studyListenResultVO.setSubjectList(subjectList);
            subjectRecordDetailService.saveBatch(tSubjectRecordDetails);
            studyListenResultVO.setList(tSubjectRecordDetails);
            studyListenResultVO.setAccuracy(new BigDecimal("0.00"));

        } else {
            List<Integer> collect1 = pair.stream().map(TStudyPair::getId).collect(Collectors.toList());
            List<TSubjectRecordDetail> collect3 = list.stream().filter(e -> !collect1.contains(e.getObjectId())).collect(Collectors.toList());
            subjectRecordDetailService.removeBatchByIds(collect3);
            List<TSubjectRecordDetail> tSubjectRecordDetails = new ArrayList<>();
            for (TStudyPair data : pair) {
                List<String> subjectIds = Arrays.stream(data.getSubject().split(",")).collect(Collectors.toList());
                List<TSubject> subjectLists = new ArrayList<>();
                for (String id : data.getSubject().split(",")) {
                    if (id.startsWith("-")) {
                        id = id.replace("-", "");
                    }
                    subjectLists.add(subjectService.getById(id));
                }
                subjectList.add(subjectLists);
                List<TSubjectRecordDetail> tSubjectRecordDetail1 = list.stream().filter(e -> e.getObjectId().equals(data.getId())).collect(Collectors.toList());

                if (tSubjectRecordDetail1.isEmpty()){
                    TSubjectRecordDetail tSubjectRecordDetail = new TSubjectRecordDetail();
                    tSubjectRecordDetail.setUserId(userid);
                    tSubjectRecordDetail.setWeek(week);
                    tSubjectRecordDetail.setDay(day);
                    tSubjectRecordDetail.setType(5);
                    tSubjectRecordDetail.setStatus(1);
                    tSubjectRecordDetail.setObjectId(data.getId());
                    subjectRecordDetailService.save(tSubjectRecordDetail);
                    tSubjectRecordDetails.add(tSubjectRecordDetail);
                }else{
                    tSubjectRecordDetails.addAll(tSubjectRecordDetail1);
                }
            }
            studyListenResultVO.setList(tSubjectRecordDetails);
            studyListenResultVO.setSubjectList(subjectList);
            studyListenResultVO.setAccuracy(new BigDecimal(tSubjectRecordDetails.stream().filter(tSubjectRecordDetail -> tSubjectRecordDetail.getStatus().equals(2)).count())
                    .divide(new BigDecimal(tSubjectRecordDetails.size()), 2, RoundingMode.HALF_UP));
        }
        System.err.println("音图相配返回VO"+studyListenResultVO.getList());
        return R.ok(studyListenResultVO);
    }

    @Override
    public int computeSchedule(TUserStudy result, Integer week) {
        System.err.println("用户学习进度"+result);
        List<TStudy> studyList = this.lambdaQuery().eq(TStudy::getDisabled, 0)
                .orderByAsc(TStudy::getWeek).list();
        // 基础学习进度
        Integer day = result.getDay();
        Integer studyWeek = result.getWeek();
        Map<Integer, List<TStudy>> studyMap = new HashMap<>(8);
        for (TStudy study : studyList) {
            Integer quarter = study.getQuarter();
            List<TStudy> itemList = studyMap.get(quarter);
            if (null == itemList) {
                itemList = new ArrayList<>();
            }
            itemList.add(study);
            studyMap.put(quarter, itemList);
        }
        // 学习进度所属季度
        int studyQuarter = 1;
        // 当前进入周目所属季度
        int thisQuarter = 1;
        for (Map.Entry<Integer, List<TStudy>> map : studyMap.entrySet()) {
            Integer key = map.getKey();
            List<TStudy> list = map.getValue();
            List<Integer> collect = list.stream().map(TStudy::getWeek).collect(Collectors.toList());
            if (collect.contains(studyWeek)) {
                studyQuarter = key;
            }
            if (collect.contains(week)) {
                thisQuarter = key;
            }
        }
        System.err.println("当前进入周目所属季度"+studyQuarter);
        System.err.println("进入周目所属季度"+thisQuarter);
        // 默认进度为 0
        int defaultSchedule;
        // 季度判断
        if (studyQuarter > thisQuarter) {
            defaultSchedule = 100;
        } else if (studyQuarter < thisQuarter) {
            defaultSchedule = 0;
        } else {
            List<TStudy> tStudies = studyMap.get(studyQuarter);
            List<Integer> weekList = tStudies.stream().map(TStudy::getWeek).collect(Collectors.toList());
            int studyIndex = weekList.indexOf(studyWeek);
            int weekIndex = weekList.indexOf(week);
            if (studyIndex > weekIndex) {
                defaultSchedule = 100;
            } else if (studyIndex < weekIndex) {
                defaultSchedule = 0;
            } else {
                System.err.println("学习到Day"+day);
                // 根据day初始化学习进度
                if (Constants.ONE.equals(day)) {
                    defaultSchedule = 0;
                } else if (Constants.TWO.equals(day)) {
                    defaultSchedule = 20;
                } else if (Constants.THREE.equals(day)) {
                    defaultSchedule = 40;
                } else if (Constants.FOUR.equals(day)) {
                    defaultSchedule = 60;
                } else if (Constants.FIVE.equals(day)) {
                    defaultSchedule = 80;
                } else {
                    defaultSchedule = 80;
                }
                // 根据五种学习计算进度
                Integer listen = result.getListen();
                if (!Constants.BURDEN_ONE.equals(listen)) {
                    defaultSchedule += (int) (((double) listen / 100) * 4);
                }
                Integer look = result.getLook();
                if (!Constants.BURDEN_ONE.equals(look)) {
                    defaultSchedule += (int) (((double) look / 100) * 4);
                }
                Integer induction = result.getInduction();
                if (!Constants.BURDEN_ONE.equals(induction)) {
                    defaultSchedule += (int) (((double) induction / 100) * 4);
                }
                Integer answer = result.getAnswer();
                if (!Constants.BURDEN_ONE.equals(answer)) {
                    defaultSchedule += (int) (((double) answer / 100) * 4);
                }
                Integer pair = result.getPair();
                if (!Constants.BURDEN_ONE.equals(pair)) {
                    defaultSchedule += (int) (((double) pair / 100) * 4);
                }
            }
        }

        return defaultSchedule;
    }

    @Override
    public int computeTotalIntegral(List<String> studyIds, Integer type, Integer accuracy) {
        int sum = 0;
        if (Constants.ONE.equals(type)) {
            List<TStudyListen> list = studyListenService.lambdaQuery().in(TStudyListen::getId, studyIds)
                    .eq(TStudyListen::getDisabled, 0).list();
            Optional<TStudyListen> any = list.stream().findAny();
            if (any.isPresent()) {
                sum = any.get().getIntegral();
            }
        } else if (Constants.TWO.equals(type)) {
            List<TStudyLook> list = studyLookService.lambdaQuery().in(TStudyLook::getId, studyIds)
                    .eq(TStudyLook::getDisabled, 0).list();
            Optional<TStudyLook> any = list.stream().findAny();
            if (any.isPresent()) {
                sum = any.get().getIntegral();
            }
        } else if (Constants.THREE.equals(type)) {
            List<TStudyInduction> list = studyInductionService.lambdaQuery().in(TStudyInduction::getId, studyIds)
                    .eq(TStudyInduction::getDisabled, 0).list();
            Optional<TStudyInduction> any = list.stream().findAny();
            if (any.isPresent()) {
                sum = any.get().getIntegral();
            }
        } else if (Constants.FOUR.equals(type)) {
            List<TStudyAnswer> list = studyAnswerService.lambdaQuery().in(TStudyAnswer::getId, studyIds)
                    .eq(TStudyAnswer::getDisabled, 0).list();
            Optional<TStudyAnswer> any = list.stream().findAny();
            if (any.isPresent()) {
                sum = any.get().getIntegral();
            }
        } else if (Constants.FIVE.equals(type)) {
            List<TStudyPair> list = studyPairService.lambdaQuery().in(TStudyPair::getId, studyIds)
                    .eq(TStudyPair::getDisabled, 0).list();
            Optional<TStudyPair> any = list.stream().findAny();
            if (any.isPresent()) {
                sum = any.get().getIntegral();
            }
        } else {
            throw new GlobalException("题目信息异常！");
        }
        if (accuracy >= 100) {
            return sum;
        } else {
            return (int) (sum * ((double) accuracy / 100));
        }
    }

    @Override
    public int residueWeek(TUserStudy studyRecord, List<TStudy> studyList) {
        // 已学习周目
        int residueWeek = 0;
        // 已学习到的周目
        Integer studyWeek = studyRecord.getWeek();
        // 根据季度分组封装
        Map<Integer, List<TStudy>> itemMap = getIntegerListMap(studyList);
        // 计算已学习周目
        boolean v = false;
        for (Map.Entry<Integer, List<TStudy>> map : itemMap.entrySet()) {
            List<TStudy> list = map.getValue();
            for (int i = 0; i < list.size(); i++) {
                TStudy item = list.get(i);
                if (item.getWeek().equals(studyWeek)) {
                    Integer listen = studyRecord.getListen();
                    Integer answer = studyRecord.getAnswer();
                    Integer look = studyRecord.getLook();
                    Integer induction = studyRecord.getInduction();
                    Integer pair = studyRecord.getPair();
                    Integer gameDifficulty = studyRecord.getGameDifficulty();
                    // 听音选图、看图选音、音图相配、有问有答、归纳排除的进度是否 100%，并且超级听力的游戏难度是否为2
                    boolean isStudy = Constants.ONE_HUNDRED.equals(listen) && Constants.ONE_HUNDRED.equals(look) &&
                            Constants.ONE_HUNDRED.equals(induction) && Constants.ONE_HUNDRED.equals(pair) &&
                            Constants.ONE_HUNDRED.equals(answer) && Constants.TWO.equals(gameDifficulty);
                    // 并且超级听力难度2已通过
                    TStudy study = this.lambdaQuery().eq(TStudy::getWeek, studyRecord.getWeek())
                            .eq(TStudy::getDisabled, 0)
                            .one();
                    TGame game = gameService.lambdaQuery()
                            .eq(TGame::getStudyId, study.getId())
                            .eq(TGame::getDisabled, 0)
                            .eq(TGame::getWeek, study.getWeek())
                            .one();
                    if (null != game) {
                        String rate = game.getRate().split(",")[2];
                        List<TGameRecord> gameRecordList = gameRecordService.lambdaQuery()
                                .eq(TGameRecord::getGameDifficulty, Constants.TWO)
                                .ge(TGameRecord::getAccuracy, rate)
                                .eq(TGameRecord::getUserId, studyRecord.getUserId())
                                .eq(TGameRecord::getGameId, game.getId())
                                .list();
                        if (gameRecordList.isEmpty()) {
                            isStudy = false;
                        }
                        List<TGameRecord> recordList = gameRecordService.lambdaQuery()
                                .ge(TGameRecord::getAccuracy, game.getAnswerRate())
                                .eq(TGameRecord::getUserId, studyRecord.getUserId())
                                .eq(TGameRecord::getGameId, game.getId())
                                .last("and gameDifficulty is null")
                                .list();
                        if (recordList.isEmpty()) {
                            isStudy = false;
                        }
                    }
                    if (isStudy) {
                        residueWeek++;
                    }
                    v = true;
                    break;
                } else {
                    residueWeek++;
                }
            }
            if (v) {
                break;
            }
        }
        return studyList.size() - residueWeek;
    }

    private Map<Integer, List<TStudy>> getIntegerListMap(List<TStudy> studyList) {
        Map<Integer, List<TStudy>> studyMap = new HashMap<>(8);
        for (TStudy study : studyList) {
            Integer quarter = study.getQuarter();
            List<TStudy> itemList = studyMap.get(quarter);
            if (null == itemList) {
                itemList = new ArrayList<>();
            }
            itemList.add(study);
            studyMap.put(quarter, itemList);
        }
        // 顺序排序
        Map<Integer, List<TStudy>> itemMap = new HashMap<>(8);
        List<Integer> keyList = new ArrayList<>();
        for (Map.Entry<Integer, List<TStudy>> map : studyMap.entrySet()) {
            Integer key = map.getKey();
            keyList.add(key);
        }
        Collections.sort(keyList);
        for (Integer key : keyList) {
            List<TStudy> itemList = studyMap.get(key);
            itemMap.put(key, itemList);
        }
        return itemMap;
    }

    @Override
    public void checkClearance(TGame game, Integer userid) {
        String rate = game.getRate().split(",")[Constants.TWO];
        // 获取用户游戏进度
        List<TGameRecord> list = gameRecordService.lambdaQuery().eq(TGameRecord::getUserId, userid)
                .eq(TGameRecord::getGameId, game.getId())
                .ge(TGameRecord::getAccuracy, rate)
                .eq(TGameRecord::getGameDifficulty, Constants.TWO).list();
        if (list.isEmpty()) {
            throw new GlobalException("超级听力暂未通关！");
        }
    }

    @Override
    public Integer userGameDifficulty(TUserStudy studyRecord, Integer week) {
        List<TStudy> studyList = this.lambdaQuery().eq(TStudy::getDisabled, 0)
                .eq(TStudy::getType, 1)
                .orderByAsc(TStudy::getWeek).list();
        // 基础学习进度
        Integer day = studyRecord.getDay();
        Integer studyWeek = studyRecord.getWeek();
        Map<Integer, List<TStudy>> studyMap = new HashMap<>(8);
        for (TStudy study : studyList) {
            Integer quarter = study.getQuarter();
            List<TStudy> itemList = studyMap.get(quarter);
            if (null == itemList) {
                itemList = new ArrayList<>();
            }
            itemList.add(study);
            studyMap.put(quarter, itemList);
        }
        // 学习进度所属季度
        int studyQuarter = 1;
        // 当前进入周目所属季度
        int thisQuarter = 1;
        for (Map.Entry<Integer, List<TStudy>> map : studyMap.entrySet()) {
            Integer key = map.getKey();
            List<TStudy> list = map.getValue();
            List<Integer> collect = list.stream().map(TStudy::getWeek).collect(Collectors.toList());
            if (collect.contains(studyWeek)) {
                studyQuarter = key;
            }
            if (collect.contains(week)) {
                thisQuarter = key;
            }
        }
        // 默认进度为 0
        int defaultSchedule;
        // 季度判断
        if (studyQuarter > thisQuarter) {
            defaultSchedule = 2;
        } else if (studyQuarter < thisQuarter) {
            defaultSchedule = 0;
        } else {
            List<TStudy> tStudies = studyMap.get(studyQuarter);
            List<Integer> weekList = tStudies.stream().map(TStudy::getWeek).collect(Collectors.toList());
            int studyIndex = weekList.indexOf(studyWeek);
            int weekIndex = weekList.indexOf(week);
            if (studyIndex > weekIndex) {
                defaultSchedule = 2;
            } else if (studyIndex < weekIndex) {
                defaultSchedule = 0;
            } else {
                defaultSchedule = studyRecord.getGameDifficulty();
            }
        }
        return defaultSchedule;
    }

}