package jnpf.cultivate.service.impl;

import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
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.ActionResult;
import jnpf.base.entity.SuperBaseEntity;
import jnpf.cultivate.event.impl.course.JnpfApplicationEventCourseService;
import jnpf.cultivate.mapper.*;
import jnpf.cultivate.service.*;
import jnpf.cultivate.utils.UserApiV2Util;
import jnpf.model.cultivate.dto.course.*;
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.FtbCultivateChapterTest;
import jnpf.model.cultivate.po.course.FtbCultivateCourse;
import jnpf.model.cultivate.po.course.FtbCultivateCourseSetting;
import jnpf.model.cultivate.po.position.FtbCultivatePositionCourceLearning;
import jnpf.model.cultivate.po.position.FtbCultivatePositionCourse;
import jnpf.model.cultivate.po.position.FtbCultivatePositionCourseExam;
import jnpf.model.cultivate.resp.InnerExamDto;
import jnpf.model.cultivate.vo.course.web.*;
import jnpf.model.enums.CourseEnums;
import jnpf.model.enums.SelfrowingEnum;
import jnpf.permission.vo.v2.position.PositionVO;
import jnpf.util.SelfGrowthUtil;
import jnpf.util.context.SpringContext;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

@Service
@Slf4j
public class FtbCultivateCourseServiceImpl extends ServiceImpl<FtbCultivateCourseMapper, FtbCultivateCourse> implements FtbCultivateCourseService {

    @Resource
    private FtbCultivatePositionCourceLearningMapper ftbCultivatePositionCourceLearningMapper;
    @Resource
    private FtbCultivatePositionCourseMapper ftbCultivatePositionCourseMapper;
    @Resource
    private FtbCultivatePositionCourseExamMapper ftbCultivatePositionCourseExamMapper;
    @Resource
    private FtbCultivateExamUserService ftbCultivateExamUserService;
    @Resource
    private FtbCultivateQuestionBankService ftbCultivateQuestionBankService;
    @Resource
    private FtbCultivateCourseSettingService ftbCultivateCourseSettingService;
    @Resource
    private FtbCultivateChapterTestMapper ftbCultivateChapterTestMapper;
    @Resource
    private FtbCultivatePositionCourseService ftbCultivatePositionCourseService;

    @Autowired
    private FtbCultivateCourseChapterMapper ftbCultivateCourseChapterMapper;

    @Autowired
    private UserApiV2Util userApiV2Util;
    @Autowired
    private JnpfApplicationEventCourseService jnpfApplicationEventCourseService;
    @Autowired
    @Lazy
    private FtbCultivateCourseService ftbCultivateCourseService;




    @Override
    public String add(FtbCultivateCourseDTO ftbCultivateCourseDTO) {
        FtbCultivateCourse ftbCultivateCourse = ftbCultivateCourseService.realAdd(ftbCultivateCourseDTO);
        // 岗位学习课程同步
        synchronousInitializationOfJobLearningCourses(ftbCultivateCourseDTO.getLabel(), ftbCultivateCourseDTO.getLearnJob(),
                ftbCultivateCourseDTO.getCoursePositionSync(), ftbCultivateCourse.getId(), ftbCultivateCourse.getCourseUpdate());
        return ftbCultivateCourse.getId();
    }

    @Transactional
    @Override
    public FtbCultivateCourse realAdd(FtbCultivateCourseDTO ftbCultivateCourseDTO) {
        FtbCultivateCourse ftbCultivateCourse = ftbCultivateCourseDTO.convertFtbCultivateCourse(ftbCultivateCourseDTO);
        // 校验课程名是否重复
        LambdaQueryWrapper<FtbCultivateCourse> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(FtbCultivateCourse::getEnableMark, 0);
        queryWrapper.eq(FtbCultivateCourse::getName, ftbCultivateCourse.getName());
        if (baseMapper.selectCount(queryWrapper) > 0) {
            throw new RuntimeException("课程名不能重复");
        }
        // 自定义课程
        ftbCultivateCourse.setCourseId(SelfGrowthUtil.provideACustomIDBasedOnTheModule(SelfrowingEnum.COURSE));
        ftbCultivateCourse.setChapterNumber(0);
        ftbCultivateCourse.setLastModifyTime(new Date());
        baseMapper.insert(ftbCultivateCourse);
        FtbCultivateCourseSetting ftbCultivateCourseSetting = ftbCultivateCourseDTO.convertFtbCultivateCourseSetting(ftbCultivateCourseDTO);
        ftbCultivateCourseSetting.setCourseId(ftbCultivateCourse.getId());
        ftbCultivateCourseSettingService.save(ftbCultivateCourseSetting);
        return ftbCultivateCourse;
    }

    @Override
    @Transactional
    public void upperLower(FtbCultivateShelvesDTO ftbCultivateShelvesDTO) {
        LambdaUpdateWrapper<FtbCultivateCourse> updateWrapper = Wrappers.lambdaUpdate();
        updateWrapper.eq(SuperBaseEntity.SuperIBaseEntity::getId, ftbCultivateShelvesDTO.getId());
        updateWrapper.set(FtbCultivateCourse::getIsGroundIng, ftbCultivateShelvesDTO.getIsGroundIng());
        baseMapper.update(new FtbCultivateCourse(), updateWrapper);
        baseMapper.selectById(ftbCultivateShelvesDTO.getId());
    }

    @Override
    public FtbCultivateCourseNumberVO listCount() {
        FtbCultivateCourseNumberVO ftbCultivateCourseNumberVO = new FtbCultivateCourseNumberVO();
        ftbCultivateCourseNumberVO.initData();
        //课程格式（1视频，2音频，3图文,4通用格式）
        List<FtbCommonKeyAndValDto> media = baseMapper.getCountMediaList();
        if (CollUtil.isNotEmpty(media)) {
            Map<Integer, Integer> mediaMap = media.stream().collect(Collectors.toMap(FtbCommonKeyAndValDto::getK, FtbCommonKeyAndValDto::getV));
            Integer video = mediaMap.get(1);
            if (video != null) {
                ftbCultivateCourseNumberVO.setNumberOfVideoCourses(video);
            }

            Integer audio = mediaMap.get(2);
            if (audio != null) {
                ftbCultivateCourseNumberVO.setNumberOfAudioCourses(audio);
            }

            Integer graphic = mediaMap.get(3);
            if (graphic != null) {
                ftbCultivateCourseNumberVO.setNumberOfGraphicCourses(graphic);
            }

            Integer numberOfCommonFormatCourses = mediaMap.get(4);
            if (numberOfCommonFormatCourses != null) {
                ftbCultivateCourseNumberVO.setNumberOfCommonFormatCourses(numberOfCommonFormatCourses);
            }
        }
        //课程格式（1全局课程，2岗位学习课程）
        List<FtbCommonKeyAndValDto> typeList = baseMapper.getCountLabelList();
        if (CollUtil.isNotEmpty(typeList)) {
            Map<Integer, Integer> typeMap = typeList.stream().collect(Collectors.toMap(FtbCommonKeyAndValDto::getK, FtbCommonKeyAndValDto::getV));

            Integer global = typeMap.get(1);
            if (global != null) {
                ftbCultivateCourseNumberVO.setNumberOfGlobalCourses(global);
            }
            Integer onTheJobLearning = typeMap.get(2);
            if (onTheJobLearning != null) {
                ftbCultivateCourseNumberVO.setNumberOfOnTheJobLearningCourses(onTheJobLearning);
            }
            ftbCultivateCourseNumberVO.setTotalNumberOfCourses(ftbCultivateCourseNumberVO.getNumberOfGlobalCourses() + ftbCultivateCourseNumberVO.getNumberOfOnTheJobLearningCourses());
        }

        return ftbCultivateCourseNumberVO;
    }


    @Override
    public FtbCultivateCourseDetailsVO courseDetails(String id) {
        LambdaQueryWrapper<FtbCultivateCourse> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(SuperBaseEntity.SuperIBaseEntity::getId, id);
        FtbCultivateCourse ftbCultivateCourse = baseMapper.selectOne(queryWrapper);
        FtbCultivateCourseDetailsVO ftbCultivateCourseDetailsVO = FtbCultivateCourseDetailsVO.convertFtbCultivateCourseDetailsVO(ftbCultivateCourse);
        // 课程学习设置
        ftbCultivateCourseSettingService.buildUpCourseLearningSettings(ftbCultivateCourseDetailsVO, id);
        return ftbCultivateCourseDetailsVO;
    }

    @Override
    public Page<FtbCultivateCoursePageVO> pagingQuery(Page<FtbCultivateCoursePageVO> page, FtbCultivateCourseQueryDTO ftbCultivateCourseQueryDTO) {
        Page<FtbCultivateCoursePageVO> ftbCultivateCoursePageVOPage = baseMapper.pagingQuery(page, ftbCultivateCourseQueryDTO);
        if (CollUtil.isNotEmpty(ftbCultivateCoursePageVOPage.getRecords())) {
            if (ftbCultivateCourseQueryDTO.getIsSelectDuration() != null && ftbCultivateCourseQueryDTO.getIsSelectDuration() == 1) {
                fillDuration(ftbCultivateCoursePageVOPage.getRecords());
            }
        }
        return ftbCultivateCoursePageVOPage;
    }

    /**
     * 填充课程的时长
     *
     * @param records
     */
    private void fillDuration(List<FtbCultivateCoursePageVO> records) {
        records.forEach(record -> {
            Long duration = ftbCultivateCourseChapterMapper.querySumDuration(record.getId());
            if (duration == null) {
                duration = 0L;
            }
            record.setSumDuration(duration);
        });
    }

    @Override
    @Transactional
    public void delete(String id) {
        LambdaUpdateWrapper<FtbCultivateCourse> updateWrapper = Wrappers.lambdaUpdate();
        updateWrapper.eq(SuperBaseEntity.SuperIBaseEntity::getId, id);
        updateWrapper.set(FtbCultivateCourse::getEnableMark, 1);
        baseMapper.update(new FtbCultivateCourse(), updateWrapper);
        LambdaQueryWrapper<FtbCultivatePositionCourseExam> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(FtbCultivatePositionCourseExam::getEnabledMark, 0);
        queryWrapper.eq(FtbCultivatePositionCourseExam::getCourseId, id);
        // 课程关联考试
        List<FtbCultivatePositionCourseExam> ftbCultivatePositionCourseExams = ftbCultivatePositionCourseExamMapper.selectList(queryWrapper);
        ftbCultivatePositionCourseExams.forEach(ftbCultivatePositionCourseExam -> {
            InnerExamDto innerExamDto = new InnerExamDto();
            innerExamDto.setExamId(ftbCultivatePositionCourseExam.getExamId());
            innerExamDto.setRelationRankId(ftbCultivatePositionCourseExam.getPostRankId());
            innerExamDto.setExamSource(1);
            innerExamDto.setRelationId(ftbCultivatePositionCourseExam.getId());
            ftbCultivateExamUserService.cancelPositionExam(innerExamDto);
        });
        // 删除题库
        ftbCultivateQuestionBankService.deleteQuestionBankRelationCourse(List.of(id));
        // 课程学习设置
        LambdaUpdateWrapper<FtbCultivateCourseSetting> courseSettingLambdaUpdateWrapper = Wrappers.lambdaUpdate();
        courseSettingLambdaUpdateWrapper.eq(FtbCultivateCourseSetting::getCourseId, id);
        courseSettingLambdaUpdateWrapper.set(FtbCultivateCourseSetting::getEnableMark, 1);
        ftbCultivateCourseSettingService.update(new FtbCultivateCourseSetting(), courseSettingLambdaUpdateWrapper);
        // 随堂测试
        LambdaUpdateWrapper<FtbCultivateChapterTest> chapterTestLambdaUpdateWrapper = Wrappers.lambdaUpdate();
        chapterTestLambdaUpdateWrapper.eq(FtbCultivateChapterTest::getCourseId, id);
        chapterTestLambdaUpdateWrapper.set(FtbCultivateChapterTest::getEnableMark, 1);
        ftbCultivateChapterTestMapper.update(new FtbCultivateChapterTest(), chapterTestLambdaUpdateWrapper);
    }

    @Override
    public void updateCourse(FtbCultivateCourseUpdateDTO ftbCultivateCourseUpdateDTO) {
        ftbCultivateCourseService.realUpdateCourse(ftbCultivateCourseUpdateDTO);
        FtbCultivateCourse ftbCultivateCourse = baseMapper.selectById(ftbCultivateCourseUpdateDTO.getId());
        // 岗位学习课程同步
        synchronousInitializationOfJobLearningCourses(ftbCultivateCourse.getLabel(), ftbCultivateCourse.getLearnJob(),
                ftbCultivateCourse.getCoursePositionSync(), ftbCultivateCourse.getId(), ftbCultivateCourse.getCourseUpdate());
    }


    @Override
    @Transactional
    public void realUpdateCourse(FtbCultivateCourseUpdateDTO ftbCultivateCourseUpdateDTO) {
        // 校验课程名是否重复
        LambdaQueryWrapper<FtbCultivateCourse> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(FtbCultivateCourse::getEnableMark, 0);
        queryWrapper.eq(FtbCultivateCourse::getName, ftbCultivateCourseUpdateDTO.getName());
        queryWrapper.ne(FtbCultivateCourse::getId, ftbCultivateCourseUpdateDTO.getId());
        if (baseMapper.selectCount(queryWrapper) > 0) {
            throw new RuntimeException("该课程名称已经存在，修改失败!");
        }
        LambdaUpdateWrapper<FtbCultivateCourse> updateWrapper = Wrappers.lambdaUpdate();
        updateWrapper.eq(SuperBaseEntity.SuperIBaseEntity::getId, ftbCultivateCourseUpdateDTO.getId());
        updateWrapper.set(FtbCultivateCourse::getName, ftbCultivateCourseUpdateDTO.getName());
        updateWrapper.set(FtbCultivateCourse::getFormat, ftbCultivateCourseUpdateDTO.getFormat());
        if (StringUtils.isNotEmpty(ftbCultivateCourseUpdateDTO.getSubtitle())) {
            updateWrapper.set(FtbCultivateCourse::getSubtitle, ftbCultivateCourseUpdateDTO.getSubtitle());
        } else {
            updateWrapper.set(FtbCultivateCourse::getSubtitle, "");
        }
        updateWrapper.set(FtbCultivateCourse::getHighLights, ftbCultivateCourseUpdateDTO.getHighLights());
        updateWrapper.set(FtbCultivateCourse::getTypeId, ftbCultivateCourseUpdateDTO.getTypeId());
        updateWrapper.set(FtbCultivateCourse::getLabel, ftbCultivateCourseUpdateDTO.getLabel());
        updateWrapper.set(FtbCultivateCourse::getLearnJob, ftbCultivateCourseUpdateDTO.getLearnJob());
        updateWrapper.set(FtbCultivateCourse::getCourseUpdate, ftbCultivateCourseUpdateDTO.getCourseUpdate());
        updateWrapper.set(FtbCultivateCourse::getCoursePositionSync, ftbCultivateCourseUpdateDTO.getCoursePositionSync());
        baseMapper.update(new FtbCultivateCourse(), updateWrapper);
        // 课程学习设置
        FtbCultivateCourseSettingMapper mapper = (FtbCultivateCourseSettingMapper) ftbCultivateCourseSettingService.getBaseMapper();
        if (mapper.isThereACourseLearningSetting(ftbCultivateCourseUpdateDTO.getId()) > 0) {
            LambdaUpdateWrapper<FtbCultivateCourseSetting> courseSettingLambdaUpdateWrapper = ftbCultivateCourseUpdateDTO.updateFtbCultivateCourseSetting(ftbCultivateCourseUpdateDTO);
            courseSettingLambdaUpdateWrapper.eq(FtbCultivateCourseSetting::getCourseId, ftbCultivateCourseUpdateDTO.getId());
            ftbCultivateCourseSettingService.update(new FtbCultivateCourseSetting(), courseSettingLambdaUpdateWrapper);
        } else {
            FtbCultivateCourseSetting ftbCultivateCourseSetting = ftbCultivateCourseUpdateDTO.convertFtbCultivateCourseSetting(ftbCultivateCourseUpdateDTO);
            ftbCultivateCourseSetting.setCourseId(ftbCultivateCourseUpdateDTO.getId());
            ftbCultivateCourseSettingService.save(ftbCultivateCourseSetting);
        }

    }

    @Override
    public Page<FtbCourseDeleteJobLearnVO> deleteJobLearningList(Page<FtbCourseDeleteJobLearnVO> page, String courseId) {
        Page<FtbCourseDeleteJobLearnVO> ftbCourseDeleteJobLearnVOPage = baseMapper.listJobLearningByCourseId(page, courseId);
        ftbCourseDeleteJobLearnVOPage.getRecords().forEach(ftbCourseDeleteJobLearnVO -> {
            // 当前学习人数
            LambdaQueryWrapper<FtbCultivatePositionCourceLearning> queryWrapper = Wrappers.lambdaQuery();
            queryWrapper.eq(FtbCultivatePositionCourceLearning::getCourceId, courseId);
            ftbCourseDeleteJobLearnVO.setCurrentNumberOfStudents(ftbCultivatePositionCourceLearningMapper.selectCount(queryWrapper));
            // 岗位名称
            PositionVO positionGradesInfoBoundVOS = userApiV2Util.infoPosition(ftbCourseDeleteJobLearnVO.getPositionId(), null);
            if(positionGradesInfoBoundVOS!=null) {
                ftbCourseDeleteJobLearnVO.setPositionTitle(positionGradesInfoBoundVOS.getFullName());
            }
        });
        return ftbCourseDeleteJobLearnVOPage;
    }

    @Override
    public Page<FtbCourseDeleteQuestionBankVO> deleteRelatedQuestionBankList(Page<FtbCourseDeleteQuestionBankVO> page, String courseId) {
        Page<FtbCourseDeleteQuestionBankVO> ftbCourseDeleteQuestionBankVOPage = baseMapper.listRelatedQuestionBankList(page, courseId);
        ftbCourseDeleteQuestionBankVOPage.getRecords().forEach(ftbCourseDeleteJobLearnVO -> {
            // 涵盖题库题目的试卷数
            ftbCourseDeleteJobLearnVO.setNumberOfTestPapers(
                    Long.valueOf(baseMapper.getCountTestPaperByQuestionBankId(ftbCourseDeleteJobLearnVO.getId())));
        });
        return ftbCourseDeleteQuestionBankVOPage;
    }

    @Override
    public List<PromotionChannelLearnCourseVO> promotionPathwayCourses(String userId) {
        return baseMapper.promotionPathwayCourses(userId);
    }

    @Override
    public ActionResult<FtbCourseDeleteVO> deleteCheck(String id) {
        // 校验岗位学习
        if (baseMapper.getCountLearnByCourseId(id) > 0) {
            return ActionResult.success(new FtbCourseDeleteVO(true, false));
        }
        // 校验关联题库
        if (baseMapper.getCountQuestionBankByCourseId(id) > 0) {
            return ActionResult.success(new FtbCourseDeleteVO(false, true));
        }
        return ActionResult.success(new FtbCourseDeleteVO(false, false));
    }

    @Override
    public void learnMapRelearn(String userId, String positionId) {
        // 该岗位是否绑定课程
        List<String> couseIds = ftbCultivatePositionCourseMapper.learnMapRelearn(positionId);
        if (CollectionUtils.isNotEmpty(couseIds)) {
            SpringContext.getApplicationContext().publishEvent(new JnpfApplicationEvent<>(CourseEventDTO.builder()
                    .courseIds(couseIds).userIds(List.of(userId)).whetherToChange(false).build()));
        }
    }

    @Override
    public List<FtbCourseDeleteJobLearnVO.FtbCultivateJobBindingCoursesVO> queryJobBindingCourses(List<String> postIds) {
        List<FtbCultivateCourseDTO.PositionLearnCourseInternal> queryJobBindingCourses = getBaseMapper().queryJobBindingCourses(postIds);
        List<String> existPostIds = queryJobBindingCourses.stream()
                .map(FtbCultivateCourseDTO.PositionLearnCourseInternal::getPostId)
                .collect(Collectors.toList());
        List<String> noPositionExists = postIds.stream()
                .filter(a -> !existPostIds.contains(a))
                .collect(Collectors.toList());
        if (CollUtil.isEmpty(noPositionExists)) {
            return new ArrayList<>();
        }
        List<PositionVO> positionNames = userApiV2Util.listPositionDetailInfoByIds(noPositionExists, null);

        Map<String, String> positionNameMaps = positionNames.stream()
                .collect(Collectors.toMap(PositionVO::getId, PositionVO::getFullName));
        return noPositionExists.stream().map(a -> {
            FtbCourseDeleteJobLearnVO.FtbCultivateJobBindingCoursesVO ftbCultivateJobBindingCoursesVO = new FtbCourseDeleteJobLearnVO.FtbCultivateJobBindingCoursesVO();
            ftbCultivateJobBindingCoursesVO.setPositionId(a);
            ftbCultivateJobBindingCoursesVO.setPositionTitle(positionNameMaps.get(a));
            return ftbCultivateJobBindingCoursesVO;
        }).collect(Collectors.toList());
    }


    /**
     * 岗位学习课程同步
     *
     * @param label              课程标签（1全局课程，2岗位学习课程）
     * @param learnJob           学习岗位
     * @param coursePositionSync 同步添加至对应岗位学习课程列表0否1是
     * @param courseId           课程主键ID
     * @param courseId           课程内容更新需要重新学习（1是，2否）
     */
    private void synchronousInitializationOfJobLearningCourses(Integer label, String learnJob, Integer coursePositionSync, String courseId, Integer courseUpdate) {
        if (label != 2) {
            if (courseUpdate == 1) {
                // 课程进度，参与培训所有人员需要学习的课程,线下培训课程需要和岗位学习课程同步
                jnpfApplicationEventCourseService.handlerCourseEvent(
                        CourseEventDTO.builder()
                                .courseIds(List.of(courseId))
                                .userIds(new ArrayList<>())
                                .whetherToChange(true)
                                .build());

            }
            return;
        }

        List<String> postIds = new ArrayList<>();
        List<FtbCultivateCourseDTO.PositionLearnCourseInternal> queryJobBindingCourses = new ArrayList<>();
        if (StringUtils.isNotEmpty(learnJob)) {
            postIds = List.of(learnJob.split(StringPool.COMMA));
            queryJobBindingCourses = getBaseMapper().queryJobBindingCourses(postIds);
        }
        if (CollUtil.isEmpty(queryJobBindingCourses)) {
            return;
        }
        List<String> pendingPositions = queryJobBindingCourses.stream()
                .map(FtbCultivateCourseDTO.PositionLearnCourseInternal::getPostId)
                .collect(Collectors.toList());
        if (CollUtil.isEmpty(pendingPositions)) {
            return;
        }

        //已经存在的岗位课程关联数据
        QueryWrapper<FtbCultivatePositionCourse> existPositionCourseQuery = new QueryWrapper<>();
        existPositionCourseQuery.lambda()
                .eq(FtbCultivatePositionCourse::getEnabledMark, 0)
                .eq(FtbCultivatePositionCourse::getCourseId, courseId);
        List<FtbCultivatePositionCourse> existPositionCourseList = ftbCultivatePositionCourseMapper.selectList(existPositionCourseQuery);


        List<String> existPostionCourseIdList = new ArrayList<>();
        for (FtbCultivatePositionCourse ftbCultivatePositionCourse : existPositionCourseList) {
            existPostionCourseIdList.add(ftbCultivatePositionCourse.getPostRankId() + "-" + ftbCultivatePositionCourse.getPostLearnId());
        }
        // 已存在的岗位学习课程
        if (coursePositionSync == 1) {
            // 岗位学习课程
            List<FtbCultivatePositionCourse> ftbCultivatePositionCourses = queryJobBindingCourses.stream().map(a -> {
                FtbCultivatePositionCourse ftbCultivatePositionCourse = new FtbCultivatePositionCourse();
                ftbCultivatePositionCourse.setCourseId(courseId);
                ftbCultivatePositionCourse.setPostRankId(a.getPostId());
                ftbCultivatePositionCourse.setPostLearnId(a.getPostLearnId());
                return ftbCultivatePositionCourse;
            }).collect(Collectors.toList());

            //过滤掉已存在的岗位学习关联数据
            ftbCultivatePositionCourses = ftbCultivatePositionCourses.stream().filter(postionCourse -> {
                String idCode = postionCourse.getPostRankId() + "-" + postionCourse.getPostLearnId();
                return !existPostionCourseIdList.contains(idCode);
            }).collect(Collectors.toList());

            if (CollUtil.isNotEmpty(ftbCultivatePositionCourses)) {
                ftbCultivatePositionCourseService.saveBatch(ftbCultivatePositionCourses);
            }
            Boolean whetherToChange = false;
            if (courseUpdate == 1) {
                whetherToChange = true;
            }
            // 岗位课程事件
            SpringContext.getApplicationContext().publishEvent(new JnpfApplicationEvent<>(
                    PositionCourseEventDTO.builder()
                            .courseIds(List.of(courseId))
                            .postIds(pendingPositions)
                            .eventType(PositionCourseEventDTO.EventType.POST)
                            .whetherToChange(whetherToChange)
                            .build()));

        } else {
            if (courseUpdate == 1) {
                // 课程进度，参与培训所有人员需要学习的课程,线下培训课程需要和岗位学习课程同步
                jnpfApplicationEventCourseService.handlerCourseEvent(
                        CourseEventDTO.builder()
                                .courseIds(List.of(courseId))
                                .userIds(new ArrayList<>())
                                .whetherToChange(true)
                                .build());

            }
        }
    }
}
