package jnpf.cultivate.service.impl;

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.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.FtbCultivateCoursePackageMapper;
import jnpf.cultivate.service.FtbCultivateCoursePackageService;
import jnpf.cultivate.service.FtbCultivatePackageCourseService;
import jnpf.cultivate.utils.UserApiV2Util;
import jnpf.enums.cultivate.course.CourseTypeEnum;
import jnpf.model.cultivate.dto.coursepackage.FtbCultivateCoursePackageAddDTO;
import jnpf.model.cultivate.dto.coursepackage.FtbCultivateCoursePackageQueryDTO;
import jnpf.model.cultivate.dto.coursepackage.FtbCultivateCoursePackageUpdateDTO;
import jnpf.model.cultivate.po.coursepackage.FtbCultivateCoursePackage;
import jnpf.model.cultivate.po.coursepackage.FtbCultivatePackageCourse;
import jnpf.model.cultivate.vo.coursepackage.FtbCultivateCoursePackageDetailsVO;
import jnpf.model.cultivate.vo.coursepackage.FtbCultivateCoursePackagePageVO;
import jnpf.model.enums.SelfrowingEnum;
import jnpf.permission.UserApi;
import jnpf.permission.entity.UserEntity;
import jnpf.util.SelfGrowthUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

@Service
public class FtbCultivateCoursePackageServiceImpl extends ServiceImpl<FtbCultivateCoursePackageMapper, FtbCultivateCoursePackage> implements FtbCultivateCoursePackageService {

    @Resource
    private FtbCultivatePackageCourseService ftbCultivatePackageCourseService;
    @Autowired
    private UserApiV2Util userApiV2Util;

    @Override
    @Transactional
    public void add(FtbCultivateCoursePackageAddDTO ftbCultivateCoursePackageAddDTO) {
        // 课程包名称是否重复
        LambdaQueryWrapper<FtbCultivateCoursePackage> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(FtbCultivateCoursePackage::getEnabledMark, 0);
        queryWrapper.eq(FtbCultivateCoursePackage::getName, ftbCultivateCoursePackageAddDTO.getName());
        if (this.count(queryWrapper) > 0) {
            throw new RuntimeException("课程包名称重复");
        }
        FtbCultivateCoursePackage ftbCultivateCoursePackage = ftbCultivateCoursePackageAddDTO.convertFtbCultivateCoursePackage(ftbCultivateCoursePackageAddDTO);
        // 自定义课程包ID
        ftbCultivateCoursePackage.setCoursePackageId(SelfGrowthUtil.provideACustomIDBasedOnTheModule(SelfrowingEnum.COURSE_PACKAGE));
        getBaseMapper().insert(ftbCultivateCoursePackage);
        // 关联课程包
        List<FtbCultivatePackageCourse> ftbCultivatePackageCourses = ftbCultivateCoursePackageAddDTO.convertFtbCultivatePackageCourse(ftbCultivateCoursePackage.getId());
        ftbCultivatePackageCourseService.saveBatch(ftbCultivatePackageCourses);
    }

    @Override
    public Page<FtbCultivateCoursePackagePageVO> pagingQuery(Page<FtbCultivateCoursePackagePageVO> page, FtbCultivateCoursePackageQueryDTO ftbCultivateCoursePackageQueryDTO) {
        Page<FtbCultivateCoursePackagePageVO> ftbCultivateCoursePackagePageVOPage = getBaseMapper().pagingQuery(page, ftbCultivateCoursePackageQueryDTO);
        List<String> creatorUserIds = ftbCultivateCoursePackagePageVOPage.getRecords()
                .stream()
                .map(FtbCultivateCoursePackagePageVO::getCreateUserId)
                .collect(Collectors.toList());
        List<String> updateUserIds = ftbCultivateCoursePackagePageVOPage.getRecords()
                .stream()
                .map(FtbCultivateCoursePackagePageVO::getUpdateUserId)
                .filter(StrUtil::isNotBlank)
                .collect(Collectors.toList());
        creatorUserIds.addAll(updateUserIds);
        Map<String, UserEntity> userNameMaps = userApiV2Util.getUserNameAndCopyForUserIds(creatorUserIds);
        ftbCultivateCoursePackagePageVOPage.getRecords().forEach(a -> {
            UserEntity userEntity = userNameMaps.get(a.getCreateUserId());
            if(userEntity!=null) {
                a.setCreateUserName(userEntity.getRealName());
            }
            UserEntity userEntity1 = userNameMaps.get(a.getUpdateUserId());
            if(userEntity1!=null) {
                a.setUpdateUserName(userEntity1.getRealName());
            }
        });
        return ftbCultivateCoursePackagePageVOPage;
    }

    @Override
    @Transactional
    public void updateCoursePackage(FtbCultivateCoursePackageUpdateDTO ftbCultivateCoursePackageUpdateDTO) {
        // 课程包名称是否重复
        LambdaQueryWrapper<FtbCultivateCoursePackage> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(FtbCultivateCoursePackage::getEnabledMark, 0);
        queryWrapper.eq(FtbCultivateCoursePackage::getName, ftbCultivateCoursePackageUpdateDTO.getName());
        queryWrapper.ne(SuperBaseEntity.SuperIBaseEntity::getId, ftbCultivateCoursePackageUpdateDTO.getCoursePackageId());
        if (this.count(queryWrapper) > 0) {
            throw new RuntimeException("课程包名称重复");
        }
        LambdaUpdateWrapper<FtbCultivateCoursePackage> updateWrapper = ftbCultivateCoursePackageUpdateDTO.convertUpdate(ftbCultivateCoursePackageUpdateDTO);
        getBaseMapper().update(new FtbCultivateCoursePackage(), updateWrapper);
        // 关联课程包
        LambdaQueryWrapper<FtbCultivatePackageCourse> ftbCultivatePackageCourseLambdaQueryWrapper = Wrappers.lambdaQuery();
        ftbCultivatePackageCourseLambdaQueryWrapper.eq(FtbCultivatePackageCourse::getCoursePackageId, ftbCultivateCoursePackageUpdateDTO.getCoursePackageId());
        ftbCultivatePackageCourseService.remove(ftbCultivatePackageCourseLambdaQueryWrapper);
        List<FtbCultivatePackageCourse> ftbCultivatePackageCourses = ftbCultivateCoursePackageUpdateDTO
                .convertFtbCultivatePackageCourse(ftbCultivateCoursePackageUpdateDTO.getCoursePackageId());
        ftbCultivatePackageCourseService.saveBatch(ftbCultivatePackageCourses);
    }

    @Override
    @Transactional
    public void deleteCoursePackage(String id) {
        // 忽略课程包关联的课程，由主表控制
        LambdaUpdateWrapper<FtbCultivateCoursePackage> updateWrapper = Wrappers.lambdaUpdate();
        updateWrapper.eq(FtbCultivateCoursePackage::getId, id);
        updateWrapper.set(FtbCultivateCoursePackage::getEnabledMark, 1);
        this.update(new FtbCultivateCoursePackage(), updateWrapper);
    }

    @Override
    public List<FtbCultivateCoursePackageDetailsVO> get(String id) {
        return getBaseMapper().getPackageDetails(id);
    }

    @Override
    public List<FtbCultivateCoursePackageDetailsVO> queryCoursePackageCourses(List<String> coursePackageIds) {
        List<FtbCultivateCoursePackageDetailsVO> voList = getBaseMapper().queryCoursePackageCourses(coursePackageIds);
        for (FtbCultivateCoursePackageDetailsVO vo : voList) {
            String msg = CourseTypeEnum.getMsg(vo.getFormat());
            vo.setCourseType(msg);
        }
        return voList;
    }

}
