package jnpf.cultivate.service.impl;


import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import jnpf.base.entity.SuperBaseEntity;
import jnpf.cultivate.mapper.CultivateCourseMsgMapper;
import jnpf.cultivate.mapper.FtbCultivateChapterTestResultMapper;
import jnpf.cultivate.mapper.FtbCultivateCourseChapterMapper;
import jnpf.cultivate.mapper.FtbCultivateCourseMapper;
import jnpf.cultivate.service.FtbCultivateChapterTestOptionService;
import jnpf.cultivate.service.FtbCultivateChapterTestService;
import jnpf.cultivate.service.FtbCultivateCourseChapterService;
import jnpf.cultivate.service.FtbCultivateCourseSettingService;
import jnpf.model.cultivate.CultivatePage;
import jnpf.model.cultivate.dto.course.FtbCultivateCourseChapterDTO;
import jnpf.model.cultivate.dto.course.FtbCultivateCourseChapterUpdateDTO;
import jnpf.model.cultivate.dto.course.app.FtbGlobalCurriculumAppWrapDTO;
import jnpf.model.cultivate.dto.course.testoption.FtbCultivateChapterTestDTO;
import jnpf.model.cultivate.event.JnpfApplicationEvent;
import jnpf.model.cultivate.event.dto.course.CourseEventDTO;
import jnpf.model.cultivate.event.dto.course.PositionCourseEventDTO;
import jnpf.model.cultivate.po.course.*;
import jnpf.model.cultivate.po.course.app.CultivateCourseMsg;
import jnpf.model.cultivate.po.position.FtbCultivatePositionCourceChapterLearning;
import jnpf.model.cultivate.po.position.FtbCultivatePositionCourceLearning;
import jnpf.model.cultivate.v2.course.vo.app.V2ChapterAppDetails;
import jnpf.model.cultivate.v2.course.vo.app.V2CultivateChapterTestDto;
import jnpf.model.cultivate.v2.course.vo.app.V2CultivateChapterTestOptionDto;
import jnpf.model.cultivate.vo.course.app.FtbGlobalCurriculumAppVO;
import jnpf.model.cultivate.vo.course.app.FtbGlobalCurriculumAppWrapVO;
import jnpf.model.cultivate.vo.course.web.FtbCultivateCourseChapterDetailsVO;
import jnpf.model.cultivate.vo.course.web.FtbCultivateCourseChapterVO;
import jnpf.util.UserProvider;
import jnpf.util.context.SpringContext;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class FtbCultivateCourseChapterServiceImpl extends ServiceImpl<FtbCultivateCourseChapterMapper, FtbCultivateCourseChapter> implements FtbCultivateCourseChapterService {
    @Resource
    private FtbCultivateCourseMapper ftbCultivateCourseMapper;

    @Resource
    private FtbCultivateCourseChapterMapper ftbCultivateCourseChapterMapper;

    @Resource
    private FtbCultivatePositionCourceLearningService ftbCultivatePositionCourceLearningService;

    @Resource
    private FtbCultivatePositionCourceChapterLearningService ftbCultivatePositionCourceChapterLearningService;

    @Resource
    private FtbCultivateChapterTestService ftbCultivateChapterTestService;

    @Resource
    private FtbCultivateChapterTestOptionService ftbCultivateChapterTestOptionService;

    @Resource
    private FtbCultivateCourseSettingService ftbCultivateCourseSettingService;

    @Resource
    private CultivateCourseMsgMapper cultivateCourseMsgMapper;


    @Override
    @Transactional
    public void add(FtbCultivateCourseChapterDTO ftbCultivateCourseDTO) {
        FtbCultivateCourseChapter ftbCultivateCourseChapter = ftbCultivateCourseDTO.convertFtbCultivateCourseChapter(ftbCultivateCourseDTO);
        // 课程章节数+1
        LambdaQueryWrapper<FtbCultivateCourse> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(SuperBaseEntity.SuperIBaseEntity::getId, ftbCultivateCourseDTO.getCourseId());
        FtbCultivateCourse ftbCultivateCourse = ftbCultivateCourseMapper.selectOne(queryWrapper);
        ftbCultivateCourse.setChapterNumber(ftbCultivateCourse.getChapterNumber() + 1);
        ftbCultivateCourseMapper.updateById(ftbCultivateCourse);
        baseMapper.insert(ftbCultivateCourseChapter);
        // 随堂测试
        doAddInClassTest(ftbCultivateCourseDTO, ftbCultivateCourse.getFormat(), ftbCultivateCourseChapter.getId());

        // 学习课程章节发生变化
        SpringContext.getApplicationContext().publishEvent(new JnpfApplicationEvent<>(CourseEventDTO.builder()
                .courseIds(List.of(ftbCultivateCourseDTO.getCourseId())).userIds(new ArrayList<>()).whetherToChange(true).build()));
        asyncPosition(ftbCultivateCourse);
    }

    /**
     * 同步位置课程
     *
     * @param ftbCultivateCourse
     */
    @Override
    public void asyncPosition(FtbCultivateCourse ftbCultivateCourse) {
        Integer coursePositionSync = ftbCultivateCourse.getCoursePositionSync();
//        if(ftbCultivateCourse.getIsGroundIng()==0){
//            return;
//        }
        if (coursePositionSync == null || coursePositionSync == 0) {
            return;
        }
        String learnJob = ftbCultivateCourse.getLearnJob();
        if (StringUtils.isEmpty(learnJob)) {
            return;
        }
        List<String> postion = List.of(learnJob.split(","));
        Boolean whetherToChange = false;
        if (ftbCultivateCourse.getCourseUpdate() == 1) {
            whetherToChange = true;
        }
        // 岗位课程事件
        SpringContext.getApplicationContext().publishEvent(new JnpfApplicationEvent<>(
                PositionCourseEventDTO.builder()
                        .courseIds(List.of(ftbCultivateCourse.getId()))
                        .postIds(postion)
                        .eventType(PositionCourseEventDTO.EventType.POST)
                        .whetherToChange(whetherToChange)
                        .build()));
    }

    @Override
    @Transactional
    public void delete(String id) {
        LambdaUpdateWrapper<FtbCultivateCourseChapter> updateWrapper = Wrappers.lambdaUpdate();
        updateWrapper.eq(SuperBaseEntity.SuperIBaseEntity::getId, id);
        updateWrapper.set(FtbCultivateCourseChapter::getEnableMark, 1);
        baseMapper.update(new FtbCultivateCourseChapter(), updateWrapper);
        // 查询章节所绑定的课程id
        LambdaQueryWrapper<FtbCultivateCourseChapter> ftbCultivateCourseChapterLambdaQueryWrapper = Wrappers.lambdaQuery();
        ftbCultivateCourseChapterLambdaQueryWrapper.eq(SuperBaseEntity.SuperIBaseEntity::getId, id);
        FtbCultivateCourseChapter ftbCultivateCourseChapter = baseMapper.selectOne(ftbCultivateCourseChapterLambdaQueryWrapper);
        // 更新课程章节
        LambdaQueryWrapper<FtbCultivateCourse> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(SuperBaseEntity.SuperIBaseEntity::getId, ftbCultivateCourseChapter.getCourseId());
        FtbCultivateCourse ftbCultivateCourse = ftbCultivateCourseMapper.selectOne(queryWrapper);
        ftbCultivateCourse.setChapterNumber(ftbCultivateCourse.getChapterNumber() - 1);
        ftbCultivateCourseMapper.updateById(ftbCultivateCourse);
        // 随堂测试删除
        LambdaUpdateWrapper<FtbCultivateChapterTest> chapterTestLambdaUpdateWrapper = Wrappers.lambdaUpdate();
        chapterTestLambdaUpdateWrapper.eq(FtbCultivateChapterTest::getCourseChapterId, id);
        chapterTestLambdaUpdateWrapper.set(FtbCultivateChapterTest::getEnableMark, 1);
        ftbCultivateChapterTestService.update(new FtbCultivateChapterTest(), chapterTestLambdaUpdateWrapper);
        // 学习课程章节发生变化
        SpringContext.getApplicationContext().publishEvent(new JnpfApplicationEvent<>(CourseEventDTO.builder()
                .courseIds(List.of(ftbCultivateCourseChapter.getCourseId())).userIds(new ArrayList<>()).whetherToChange(true).build()));
        asyncPosition(ftbCultivateCourse);
    }

    @Override
    public Page<FtbCultivateCourseChapterVO> queryList(Page<FtbCultivateCourseChapterVO> page, String courseId) {
        return baseMapper.queryList(page, courseId);
    }

    @Override
    @Transactional
    public void updateChapter(FtbCultivateCourseChapterUpdateDTO ftbCultivateCourseDTO) {
        // 章节更新
        LambdaUpdateWrapper<FtbCultivateCourseChapter> updateWrapper = Wrappers.lambdaUpdate();
        updateWrapper.eq(SuperBaseEntity.SuperIBaseEntity::getId, ftbCultivateCourseDTO.getId());
        updateWrapper.set(FtbCultivateCourseChapter::getName, ftbCultivateCourseDTO.getName());
        updateWrapper.set(FtbCultivateCourseChapter::getSortCode, ftbCultivateCourseDTO.getSortCode());
        updateWrapper.set(FtbCultivateCourseChapter::getAnnex, ftbCultivateCourseDTO.getAnnex());
        updateWrapper.set(FtbCultivateCourseChapter::getAnnexName, ftbCultivateCourseDTO.getAnnexName());
        updateWrapper.set(FtbCultivateCourseChapter::getDetailDesc, ftbCultivateCourseDTO.getDetailDesc());
        updateWrapper.set(FtbCultivateCourseChapter::getDuration, ftbCultivateCourseDTO.getDuration());
        updateWrapper.set(FtbCultivateCourseChapter::getWhetherTesting, ftbCultivateCourseDTO.getWhetherTesting());
        updateWrapper.set(FtbCultivateCourseChapter::getForcedStudy, ftbCultivateCourseDTO.getForcedStudy());
        updateWrapper.set(FtbCultivateCourseChapter::getChapterType, ftbCultivateCourseDTO.getChapterType());
        updateWrapper.set(FtbCultivateCourseChapter::getLibraryId, ftbCultivateCourseDTO.getLibraryId());
        baseMapper.update(new FtbCultivateCourseChapter(), updateWrapper);
        // 随堂测试删除
        LambdaQueryWrapper<FtbCultivateCourse> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.select(FtbCultivateCourse::getFormat, FtbCultivateCourse::getCourseUpdate, SuperBaseEntity.SuperIBaseEntity::getId);
        queryWrapper.eq(SuperBaseEntity.SuperIBaseEntity::getId, ftbCultivateCourseDTO.getCourseId());
        FtbCultivateCourse ftbCultivateCourse = ftbCultivateCourseMapper.selectOne(queryWrapper);
        // 视频格式且启用随堂测试
        if (ftbCultivateCourse.getFormat() == 1) {
            if (ftbCultivateCourseDTO.getWhetherTesting() == 0) {
                LambdaQueryWrapper<FtbCultivateChapterTest> deleteCourseChapterWrapper = Wrappers.lambdaQuery();
                deleteCourseChapterWrapper.eq(FtbCultivateChapterTest::getCourseChapterId, ftbCultivateCourseDTO.getId());
                List<FtbCultivateChapterTest> ftbCultivateChapterTests = ftbCultivateChapterTestService.list(deleteCourseChapterWrapper);

                List<String> chapterTestIds = ftbCultivateChapterTests.stream()
                        .map(SuperBaseEntity.SuperIBaseEntity::getId)
                        .collect(Collectors.toList());

                LambdaQueryWrapper<FtbCultivateChapterTestOption> deleteCourseChapterOptionWrapper = Wrappers.lambdaQuery();
                deleteCourseChapterOptionWrapper.in(FtbCultivateChapterTestOption::getChapterTestId, chapterTestIds);
                if (CollUtil.isNotEmpty(chapterTestIds)) {
                    ftbCultivateChapterTestOptionService.getBaseMapper().delete(deleteCourseChapterOptionWrapper);
                    ftbCultivateChapterTestService.getBaseMapper().delete(deleteCourseChapterWrapper);

                }
                doAddInClassTest(ftbCultivateCourseDTO, ftbCultivateCourse.getFormat(), ftbCultivateCourseDTO.getId());
            }
        }

        // 课程内容更新需要重新学习（1是，2否）
        if (ftbCultivateCourse.getCourseUpdate() == 2) {
            // 有附件发生变化时才提示
            if (StrUtil.isNotBlank(ftbCultivateCourseDTO.getAnnex())) {
                CultivateCourseMsg cultivateCourseMsg = new CultivateCourseMsg();
                cultivateCourseMsg.setDesc("该课程附件已发生变化。");
                cultivateCourseMsg.setState(1);
                cultivateCourseMsg.setCourseId(ftbCultivateCourse.getId());
                cultivateCourseMsgMapper.insert(cultivateCourseMsg);
            }
        } else if (ftbCultivateCourse.getCourseUpdate() == 1) {
            SpringContext.getApplicationContext().publishEvent(new JnpfApplicationEvent<>(CourseEventDTO.builder()
                    .courseIds(List.of(ftbCultivateCourseDTO.getCourseId())).userIds(new ArrayList<>()).whetherToChange(true).build()));
        }

        asyncPosition(ftbCultivateCourse);
    }

    @Override
    @Transactional
    public FtbGlobalCurriculumAppWrapVO generalCourseList(Page<FtbGlobalCurriculumAppVO> page, FtbGlobalCurriculumAppWrapDTO ftbGlobalCurriculumAppWrapDTO) {
        FtbGlobalCurriculumAppWrapVO ftbGlobalCurriculumAppWrapVO = new FtbGlobalCurriculumAppWrapVO();
        String userId = UserProvider.getUser().getUserId();
        // 检测当前全局课程
        LambdaQueryWrapper<FtbCultivateCourse> ftbCultivateCourseLambdaQueryWrapper = Wrappers.lambdaQuery();
        ftbCultivateCourseLambdaQueryWrapper.select(FtbCultivateCourse::getId);
        ftbCultivateCourseLambdaQueryWrapper.eq(FtbCultivateCourse::getEnableMark, 0);
        ftbCultivateCourseLambdaQueryWrapper.eq(FtbCultivateCourse::getLabel, 1);
        List<FtbCultivateCourse> ftbCultivateCourses = ftbCultivateCourseMapper.selectList(ftbCultivateCourseLambdaQueryWrapper);
        // 查询此用户不在课程中的学习记录
        LambdaQueryWrapper<FtbCultivatePositionCourceLearning> ftbCultivatePositionCourceLearningLambdaQueryWrapper = Wrappers.lambdaQuery();
        ftbCultivatePositionCourceLearningLambdaQueryWrapper.select(FtbCultivatePositionCourceLearning::getCourceId);
        ftbCultivatePositionCourceLearningLambdaQueryWrapper.eq(FtbCultivatePositionCourceLearning::getUserId, userId);
        ftbCultivatePositionCourceLearningLambdaQueryWrapper.eq(FtbCultivatePositionCourceLearning::getEnabledMark, 0);
        List<FtbCultivatePositionCourceLearning> ftbCultivatePositionCourceLearnings = ftbCultivatePositionCourceLearningService.list(ftbCultivatePositionCourceLearningLambdaQueryWrapper);
        if (CollectionUtils.isNotEmpty(ftbCultivateCourses) && CollectionUtils.isNotEmpty(ftbCultivatePositionCourceLearnings)) {
            List<String> existCourseIds = ftbCultivatePositionCourceLearnings.stream()
                    .map(FtbCultivatePositionCourceLearning::getCourceId)
                    .collect(Collectors.toList());
            ftbCultivateCourses.removeIf(ftbCultivateCourse -> existCourseIds.contains(ftbCultivateCourse.getId()));
        }
        // 校验是否有全局课程更新
        checkCourse(ftbCultivateCourses, userId);
        page = ftbCultivateCourseMapper.generalCourseList(page, userId, ftbGlobalCurriculumAppWrapDTO);
        page.getRecords().forEach(ftbGlobalCurriculumAppVO -> {
            // 学习总人数
            LambdaQueryWrapper<FtbCultivatePositionCourceLearning> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.in(FtbCultivatePositionCourceLearning::getState, List.of(1, 2));
            queryWrapper.eq(FtbCultivatePositionCourceLearning::getCourceId, ftbGlobalCurriculumAppVO.getCourseId());
            queryWrapper.eq(FtbCultivatePositionCourceLearning::getEnabledMark, 0);
            ftbGlobalCurriculumAppVO.setLearnTotalNumber(ftbCultivatePositionCourceLearningService.getBaseMapper().selectCount(queryWrapper));
            // 课程学习设置
            ftbCultivateCourseSettingService.buildUpCourseLearningSettings(ftbGlobalCurriculumAppVO, ftbGlobalCurriculumAppVO.getCourseId());
        });
        ftbGlobalCurriculumAppWrapVO.setPageListVO(CultivatePage.coverPageList(page));
        Integer learnTotalNumber = ftbCultivateCourseMapper.learnTotalNumber(userId, ftbGlobalCurriculumAppWrapDTO.getCourseTypeId());
        ftbGlobalCurriculumAppWrapVO.setLearnTotalNumber(learnTotalNumber);
        return ftbGlobalCurriculumAppWrapVO;
    }

    @Override
    public FtbCultivateCourseChapterDetailsVO courseDetails(String id) {
        FtbCultivateCourseChapter currentChapter = baseMapper.selectById(id);
        FtbCultivateCourseChapterDetailsVO chapterDetailsVO = FtbCultivateCourseChapterDetailsVO.convert(currentChapter);
        // 开启随堂测试
        if (currentChapter.getWhetherTesting() == 0) {
            LambdaQueryWrapper<FtbCultivateChapterTest> chapterTestLambdaQueryWrapper = Wrappers.lambdaQuery();
            chapterTestLambdaQueryWrapper.eq(FtbCultivateChapterTest::getCourseChapterId, id);
            chapterTestLambdaQueryWrapper.eq(FtbCultivateChapterTest::getEnableMark, 0);
            chapterTestLambdaQueryWrapper.orderByAsc(FtbCultivateChapterTest::getForcedStudy);
            List<FtbCultivateChapterTest> ftbCultivateChapterTests = ftbCultivateChapterTestService.list(chapterTestLambdaQueryWrapper);
            List<FtbCultivateCourseChapterDetailsVO.FtbCultivateChapterTestUpdateDTO> cultivateChapterTestUpdate = new ArrayList<>();
            for (FtbCultivateChapterTest ftbCultivateChapterTest : ftbCultivateChapterTests) {
                // 随堂测试
                FtbCultivateCourseChapterDetailsVO.FtbCultivateChapterTestUpdateDTO ftbCultivateChapterTestUpdateDTO =
                        FtbCultivateCourseChapterDetailsVO.convertFtbCultivateChapterTestUpdateDTO(ftbCultivateChapterTest);
                // 随堂测试选项
                LambdaQueryWrapper<FtbCultivateChapterTestOption> chapterTestOptionsQuery = Wrappers.lambdaQuery();
                chapterTestOptionsQuery.eq(FtbCultivateChapterTestOption::getChapterTestId, ftbCultivateChapterTest.getId());
                chapterTestOptionsQuery.eq(FtbCultivateChapterTestOption::getEnableMark, 0);
                chapterTestOptionsQuery.orderByAsc(FtbCultivateChapterTestOption::getSortCode);
                List<FtbCultivateChapterTestOption> chapterTestOptions = ftbCultivateChapterTestOptionService.list(chapterTestOptionsQuery);
                List<FtbCultivateCourseChapterDetailsVO.FtbCultivateChapterTestOptionUpdateDTO> chapterTestOptionUpdateDTOS = chapterTestOptions.stream()
                        .map(FtbCultivateCourseChapterDetailsVO::convertFtbCultivateChapterTestOptionUpdateDTO)
                        .collect(Collectors.toList());
                ftbCultivateChapterTestUpdateDTO.setChapterTestOptionUpdateDTOS(chapterTestOptionUpdateDTOS);
                cultivateChapterTestUpdate.add(ftbCultivateChapterTestUpdateDTO);
            }
            chapterDetailsVO.setCultivateChapterTestUpdate(cultivateChapterTestUpdate);
        }
        return chapterDetailsVO;
    }

    private void checkCourse(List<FtbCultivateCourse> ftbCultivateCourses, String userId) {
        if (CollectionUtils.isNotEmpty(ftbCultivateCourses)) {
            List<FtbCultivatePositionCourceLearning> ftbCultivatePositionCourceLearnings = new ArrayList<>();
            List<FtbCultivatePositionCourceChapterLearning> ftbCultivatePositionCourceChapterLearningList = new ArrayList<>();
            ftbCultivateCourses.forEach(ftbCultivateCourse -> {
                // 课程
                FtbCultivatePositionCourceLearning ftbCultivatePositionCourceLearning = new FtbCultivatePositionCourceLearning();
                ftbCultivatePositionCourceLearning.setCourceId(ftbCultivateCourse.getId());
                ftbCultivatePositionCourceLearning.setLearnTime(0);
                ftbCultivatePositionCourceLearning.setUserId(userId);
                ftbCultivatePositionCourceLearning.setState(0);
                ftbCultivatePositionCourceLearnings.add(ftbCultivatePositionCourceLearning);
                // 章节
                LambdaQueryWrapper<FtbCultivateCourseChapter> ftbCultivateCourseChapterLambdaQueryWrapper = Wrappers.lambdaQuery();
                ftbCultivateCourseChapterLambdaQueryWrapper.eq(FtbCultivateCourseChapter::getEnableMark, 0);
                ftbCultivateCourseChapterLambdaQueryWrapper.eq(FtbCultivateCourseChapter::getCourseId, ftbCultivateCourse.getId());
                List<FtbCultivateCourseChapter> ftbCultivateCourseChapters = ftbCultivateCourseChapterMapper.selectList(ftbCultivateCourseChapterLambdaQueryWrapper);
                if (CollectionUtils.isNotEmpty(ftbCultivateCourseChapters)) {
                    ftbCultivateCourseChapters.forEach(ftbCultivateCourseChapter -> {
                        FtbCultivatePositionCourceChapterLearning ftbCultivatePositionCourceChapterLearning = new FtbCultivatePositionCourceChapterLearning();
                        ftbCultivatePositionCourceChapterLearning.setChapterId(ftbCultivateCourseChapter.getId());
                        ftbCultivatePositionCourceChapterLearning.setState(0);
                        ftbCultivatePositionCourceChapterLearning.setCourceId(ftbCultivateCourse.getId());
                        ftbCultivatePositionCourceChapterLearning.setChapterTime(0);
                        ftbCultivatePositionCourceChapterLearning.setUserId(userId);
                        ftbCultivatePositionCourceChapterLearningList.add(ftbCultivatePositionCourceChapterLearning);
                    });
                }
            });
            ftbCultivatePositionCourceLearningService.saveBatch(ftbCultivatePositionCourceLearnings);
            ftbCultivatePositionCourceChapterLearningService.saveBatch(ftbCultivatePositionCourceChapterLearningList);
        }
    }

    private void doAddInClassTest(FtbCultivateCourseChapterDTO ftbCultivateCourseDTO, Integer format, String chapterId) {
        // 视频格式和音频格式校验
        ftbCultivateCourseDTO.audioAndVideoVerification(format, ftbCultivateCourseDTO);
        // 随堂测试，视频格式
        if (format == 1) {
            // 启用随堂测试
            if (ftbCultivateCourseDTO.getWhetherTesting() == 0) {
                List<FtbCultivateChapterTest> chapterTests = new ArrayList<>();
                List<FtbCultivateChapterTestOption> chapterOptionList = new ArrayList<>();
                FtbCultivateChapterTestDTO.onTheGoTestDataAssembly(chapterTests, chapterOptionList, chapterId,
                        ftbCultivateCourseDTO);
                ftbCultivateChapterTestService.saveBatch(chapterTests);
                ftbCultivateChapterTestOptionService.saveBatch(chapterOptionList);
            }
        }
    }


    @Override
    public V2ChapterAppDetails courseDetailsV2(String id) {
        FtbCultivateCourseChapter chapter = baseMapper.selectById(id);

        V2ChapterAppDetails vo = new V2ChapterAppDetails();
        vo.setId(chapter.getId());
        vo.setCourseId(chapter.getCourseId());
        vo.setName(chapter.getName());
        vo.setSortCode(chapter.getSortCode());
        vo.setAnnex(chapter.getAnnex());
        vo.setAnnexName(chapter.getAnnexName());
        vo.setDetailDesc(chapter.getDetailDesc());
        vo.setDuration(chapter.getDuration());
        vo.setForcedStudy(chapter.getForcedStudy());
        vo.setWhetherTesting(chapter.getWhetherTesting());
        vo.setChapterType(chapter.getChapterType());
        vo.setSource(chapter.getSource());
        vo.setParentId(chapter.getParentId());
        vo.setPath(chapter.getPath());
        vo.setVideoActionType(chapter.getVideoActionType());
        vo.setSize(chapter.getSize());
        vo.setLibraryId(chapter.getLibraryId());

        // 开启随堂测试
        if (chapter.getWhetherTesting() == 0) {
            LambdaQueryWrapper<FtbCultivateChapterTest> chapterTestLambdaQueryWrapper = Wrappers.lambdaQuery();
            chapterTestLambdaQueryWrapper.eq(FtbCultivateChapterTest::getCourseChapterId, id);
            chapterTestLambdaQueryWrapper.eq(FtbCultivateChapterTest::getEnableMark, 0);
            chapterTestLambdaQueryWrapper.orderByAsc(FtbCultivateChapterTest::getForcedStudy);
            List<FtbCultivateChapterTest> ftbCultivateChapterTests = ftbCultivateChapterTestService.list(chapterTestLambdaQueryWrapper);
            List<V2CultivateChapterTestDto> testDtoList = new ArrayList<>();
            for (FtbCultivateChapterTest ftbCultivateChapterTest : ftbCultivateChapterTests) {
                // 随堂测试
                V2CultivateChapterTestDto testDto = new V2CultivateChapterTestDto();
                testDto.setChapterTestId(ftbCultivateChapterTest.getId());
                testDto.setTopicName(ftbCultivateChapterTest.getTopicName());
                testDto.setAnswerAnalysis(ftbCultivateChapterTest.getAnswerAnalysis());
                testDto.setForcedStudy(ftbCultivateChapterTest.getForcedStudy());
                // 随堂测试选项
                LambdaQueryWrapper<FtbCultivateChapterTestOption> chapterTestOptionsQuery = Wrappers.lambdaQuery();
                chapterTestOptionsQuery.eq(FtbCultivateChapterTestOption::getChapterTestId, ftbCultivateChapterTest.getId());
                chapterTestOptionsQuery.eq(FtbCultivateChapterTestOption::getEnableMark, 0);
                chapterTestOptionsQuery.orderByAsc(FtbCultivateChapterTestOption::getSortCode);
                List<FtbCultivateChapterTestOption> chapterTestOptions = ftbCultivateChapterTestOptionService.list(chapterTestOptionsQuery);
                if (CollUtil.isNotEmpty(chapterTestOptions)) {
                    List<V2CultivateChapterTestOptionDto> optionDtoList = new ArrayList<>();
                    for (FtbCultivateChapterTestOption chapterTestOption : chapterTestOptions) {
                        V2CultivateChapterTestOptionDto optionDto = new V2CultivateChapterTestOptionDto();
                        optionDto.setIsRightOption(chapterTestOption.getIsRightOption());
                        optionDto.setContent(chapterTestOption.getContent());
                        optionDto.setSortCode(chapterTestOption.getSortCode());
                        optionDto.setChapterTestOptionId(chapterTestOption.getId());
                        optionDtoList.add(optionDto);
                    }
                    testDto.setOptionDtoList(optionDtoList);
                }

                testDtoList.add(testDto);
            }
            vo.setChapterTestDtoList(testDtoList);

        }
        return vo;
    }

}
