package cn.stylefeng.guns.modular.business.controller;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.crypto.SecureUtil;
import cn.stylefeng.guns.modular.business.entity.CounsellingReservationWork;
import cn.stylefeng.guns.modular.business.entity.Course;
import cn.stylefeng.guns.modular.business.entity.CourseChapter;
import cn.stylefeng.guns.modular.business.entity.CourseTag;
import cn.stylefeng.guns.modular.business.service.ICourseChapterService;
import cn.stylefeng.guns.modular.business.service.ICourseService;
import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.util.StrUtil;
import cn.stylefeng.guns.modular.business.service.ICourseTagService;
import cn.stylefeng.roses.kernel.auth.api.context.LoginContext;
import cn.stylefeng.roses.kernel.db.api.factory.PageFactory;
import cn.stylefeng.roses.kernel.db.api.factory.PageResultFactory;
import cn.stylefeng.roses.kernel.db.api.pojo.page.PageResult;
import cn.stylefeng.roses.kernel.rule.annotation.BusinessLog;
import cn.stylefeng.roses.kernel.rule.enums.ResBizTypeEnum;
import cn.stylefeng.roses.kernel.rule.pojo.response.ErrorResponseData;
import cn.stylefeng.roses.kernel.rule.pojo.response.ResponseData;
import cn.stylefeng.roses.kernel.rule.pojo.response.SuccessResponseData;
import cn.stylefeng.roses.kernel.scanner.api.annotation.ApiResource;
import cn.stylefeng.roses.kernel.scanner.api.annotation.GetResource;
import cn.stylefeng.roses.kernel.scanner.api.annotation.PostResource;
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.extension.conditions.query.QueryChainWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.models.auth.In;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

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

/**
 * 课程管理管理类
 * @author guo
 */
@RestController
@Api(tags = "课程管理管理类")
@ApiResource(name = "课程管理管理类", resBizType = ResBizTypeEnum.BUSINESS)
@RequestMapping("/business")
public class CourseController  {

    @Resource
    private ICourseService courseService;

    @Resource
    private ICourseChapterService courseChapterService;

    @Resource
    private ICourseTagService courseTagService;

    /**
     * 添加课程管理
     */
    @ApiOperation("添加课程管理")
    @PostResource(name = "添加课程管理", path = "/course/add")
    @BusinessLog
    @Transactional
    public ResponseData<?> add(@RequestBody Course course) {
        //判断课程名称是否重复
        long count = this.courseService.count(new LambdaQueryWrapper<Course>().eq(Course::getCourseName,course.getCourseName())
                .eq(Course::getIsDelete,false));
        if (count>0){
            return new ErrorResponseData<>("500","课程名称已存在，请勿重复添加!");
        }
        course.setCreateUser(LoginContext.me().getLoginUser().getUserId());
        this.courseService.save(course);
        //添加课程章节
        if (CollectionUtil.isNotEmpty(course.getCourseChapterList())){
          this.saveCourseChapter(course.getCourseChapterList(),course.getId(),null);
        }
        LambdaQueryWrapper<CourseChapter> courseChapterLambdaQueryWrapper = new QueryWrapper<CourseChapter>().select(" sum(minute_num) num ").lambda();
        Map<String,Object> map = this.courseChapterService.getMap(courseChapterLambdaQueryWrapper.eq(CourseChapter::getCourseId,course.getId()).eq(CourseChapter::getIsDelete,0));
        Long minu = 0l;
        if (map != null){
            minu = Long.parseLong(map.get("num").toString());
        }
        LambdaQueryWrapper<CourseChapter> courseChapterLambdaQueryWrapper2 = new QueryWrapper<CourseChapter>().select(" sum(second_num) num ").lambda();
        Map<String,Object> map2 = this.courseChapterService.getMap(courseChapterLambdaQueryWrapper2.eq(CourseChapter::getCourseId,course.getId()).eq(CourseChapter::getIsDelete,0));
        Long sec = 0l;
        if (map2 != null){
            sec = Long.parseLong(map2.get("num").toString());
        }
        Long allTime = minu*60+sec;
        course.setTotalTime(allTime);
        this.courseService.updateById(course);
        return new SuccessResponseData<>();
    }

    /**
     * 迭代添加课程章节
     * @param courseChapterList 章节列表
     * @param courseId 课程id
     * @param courseChapterParent 父级章节
     */
    private void saveCourseChapter(List<CourseChapter> courseChapterList,Long courseId,CourseChapter courseChapterParent){
        if (CollectionUtil.isNotEmpty(courseChapterList)){
            for (CourseChapter courseChapter:courseChapterList){
                courseChapter.setCourseId(courseId);
                courseChapter.setCreateUser(LoginContext.me().getLoginUser().getUserId());
                courseChapter.setUpdateUser(LoginContext.me().getLoginUser().getUserId());
                courseChapter.setIsDelete(0);
                if (courseChapterParent == null){
                    courseChapter.setParentId(0L);
                }else{
                    courseChapter.setParentId(courseChapterParent.getId());
                }
                this.courseChapterService.saveOrUpdate(courseChapter);
                //判断章节子集是否为null
                if (CollectionUtil.isNotEmpty(courseChapter.getChildList())){
                    this.saveCourseChapter(courseChapter.getChildList(),courseId,courseChapter);
                }
            }
        }
    }


    /**
     * 删除课程管理
     */
    @ApiOperation("删除课程管理")
    @PostResource(name = "删除课程管理", path = "/course/delete")
    @BusinessLog
    public ResponseData<?> delete(@RequestParam String ids) {
        if (StrUtil.isBlank(ids)){
            return new ErrorResponseData<>("500","id不能为空");
        }
        //判断课程是否已被使用
        long count = this.courseChapterService.count(new LambdaQueryWrapper<CourseChapter>().in(CourseChapter::getCourseId,ids.split(","))
                .eq(CourseChapter::getIsDelete,0));
        if (count >0){
            return new ErrorResponseData<>("500","课程已被引用，无法进行删除！");
        }
        LambdaUpdateWrapper<Course> lambdaUpdateWrapper = new LambdaUpdateWrapper<Course>().set(Course::getIsDelete,true);
        lambdaUpdateWrapper.in(Course::getId, ListUtil.toList(ids.split(",")));
        this.courseService.update(lambdaUpdateWrapper);
        return new SuccessResponseData<>();
    }

    /**
     * 修改课程管理
     */
    @ApiOperation("修改课程管理")
    @PostResource(name = "修改课程管理", path = "/course/edit")
    @BusinessLog
    @Transactional
    public ResponseData<?> edit(@RequestBody Course course) {
        //判断课程名称是否重复
        long count = this.courseService.count(new LambdaQueryWrapper<Course>().eq(Course::getCourseName,course.getCourseName())
                .eq(Course::getIsDelete,false).ne(Course::getId,course.getId()));
        if (count>0){
            return new ErrorResponseData<>("500","课程名称已存在，请勿重复添加!");
        }
        course.setUpdateUser(LoginContext.me().getLoginUser().getUserId());
        this.courseService.updateById(course);
        //批量更新课程章节逻辑删除
        this.courseChapterService.update(new LambdaUpdateWrapper<CourseChapter>().set(CourseChapter::getIsDelete,true)
                .eq(CourseChapter::getCourseId,course.getId()));
        //添加或更新课程章节
        if (CollectionUtil.isNotEmpty(course.getCourseChapterList())){
            this.saveCourseChapter(course.getCourseChapterList(),course.getId(),null);
        }
        LambdaQueryWrapper<CourseChapter> courseChapterLambdaQueryWrapper = new QueryWrapper<CourseChapter>().select(" sum(minute_num) num ").lambda();
        Map<String,Object> map = this.courseChapterService.getMap(courseChapterLambdaQueryWrapper.eq(CourseChapter::getCourseId,course.getId()).eq(CourseChapter::getIsDelete,0));
        Long minu = 0l;
        if (map != null){
            minu = Long.parseLong(map.get("num").toString());
        }
        LambdaQueryWrapper<CourseChapter> courseChapterLambdaQueryWrapper2 = new QueryWrapper<CourseChapter>().select(" sum(second_num) num ").lambda();
        Map<String,Object> map2 = this.courseChapterService.getMap(courseChapterLambdaQueryWrapper2.eq(CourseChapter::getCourseId,course.getId()).eq(CourseChapter::getIsDelete,0));
        Long sec = 0l;
        if (map2 != null){
            sec = Long.parseLong(map2.get("num").toString());
        }
        Long allTime = minu*60+sec;
        course.setTotalTime(allTime);
        this.courseService.updateById(course);

        return new SuccessResponseData<>();
    }

    /**
     * 获取课程管理详情
     */
    @ApiOperation("获取课程管理详情")
    @GetResource(name = "获取课程管理详情", path = "/course/detail/{id}", requiredPermission = false)
    public ResponseData<Course> detail(@PathVariable("id") Long id) {
        Course course = this.courseService.getById(id);
        //查询课程章节信息
        course.setCourseChapterList(this.courseChapterService.getAllByCourseId(course.getId()));
        //获取课程标签名称
        LambdaQueryWrapper<CourseTag> courseTagLambdaQueryWrapper = new QueryWrapper<CourseTag>().select(" GROUP_CONCAT(tag_name)  tagName ").lambda();
        Map<String,Object> map = courseTagService.getMap(courseTagLambdaQueryWrapper.in(CourseTag::getId,course.getCourseTagIds().split(",")));
        if (ObjectUtil.isNotEmpty(map)){
            course.setCourseTagNames(map.get("tagName").toString());
        }
        return new SuccessResponseData<>(course);
    }

    /**
     * 获取课程管理列表
     *
     */
    @ApiOperation("获取课程管理列表")
    @GetResource(name = "获取课程管理列表", path = "/course/list", requiredPermission = false)
    public ResponseData<List<Course>> list(Course course) {
          LambdaQueryWrapper<Course> lambdaQueryWrapper = new LambdaQueryWrapper<Course>().eq(Course::getIsDelete,false)
                        .orderByDesc(Course::getId);
        lambdaQueryWrapper.like(StrUtil.isNotBlank(course.getCourseName()),Course::getCourseName,course.getCourseName());
        lambdaQueryWrapper.eq(course.getListingStatus() != null,Course::getListingStatus,course.getListingStatus());

        return new SuccessResponseData<>(courseService.list(lambdaQueryWrapper));
    }

    /**
     * 获取课程管理列表(分页)
     */
    @ApiOperation("获取课程管理列表(分页)")
    @GetResource(name = "获取课程管理列表(分页)", path = "/course/page", requiredPermission = false)
    public ResponseData<PageResult<Course>> page(Course course) {
        LambdaQueryWrapper<Course> lambdaQueryWrapper = new LambdaQueryWrapper<Course>().eq(Course::getIsDelete,false)
                    .orderByAsc(Course::getSort);
        lambdaQueryWrapper.like(StrUtil.isNotBlank(course.getCourseName()),Course::getCourseName,course.getCourseName());
        lambdaQueryWrapper.eq(course.getListingStatus() != null,Course::getListingStatus,course.getListingStatus());

        Page<Course> page = this.courseService.page(PageFactory.defaultPage(), lambdaQueryWrapper);
        if (CollectionUtil.isNotEmpty(page.getRecords())){
            page.getRecords().forEach(course1 -> {
                //获取课程标签名称
                LambdaQueryWrapper<CourseTag> courseTagLambdaQueryWrapper = new QueryWrapper<CourseTag>().select(" GROUP_CONCAT(tag_name)  tagName ").lambda();
                Map<String,Object> map = courseTagService.getMap(courseTagLambdaQueryWrapper.in(CourseTag::getId,course1.getCourseTagIds().split(",")));
                if (ObjectUtil.isNotEmpty(map)){
                    course1.setCourseTagNames(map.get("tagName").toString());
                }
                //获取课程节数
                long chapterNum = this.courseChapterService.count(new LambdaQueryWrapper<CourseChapter>().eq(CourseChapter::getCourseId,course1.getId()).eq(CourseChapter::getIsDelete,false)
                        .eq(CourseChapter::getParentId,0L));
                if (chapterNum > 0){
                    long chapterCourseNum = this.courseChapterService.count(new LambdaQueryWrapper<CourseChapter>().eq(CourseChapter::getCourseId,course1.getId()).eq(CourseChapter::getIsDelete,false)
                            .ne(CourseChapter::getParentId,0L));
                    course1.setCourseContent("共"+chapterNum+"章"+chapterCourseNum+"节课");
                }else{
                    course1.setCourseContent("无");
                }

            });
        }
        return new SuccessResponseData<>(PageResultFactory.createPageResult(page));
    }


    @ApiOperation("修改课程上架状态")
    @PostResource(name = "修改课程上架状态", path = "/course/updateStatus")
    @BusinessLog
    public ResponseData<?> updateStatus(String ids, Integer status) {
        if (StrUtil.isBlank(ids)){
            return new ErrorResponseData<>("500","id不能为空");
        }
        LambdaUpdateWrapper<Course> lambdaUpdateWrapper = new LambdaUpdateWrapper<Course>();
        lambdaUpdateWrapper.in(Course::getId, ListUtil.toList(ids.split(",")));
        lambdaUpdateWrapper.set(Course::getListingStatus,status);
        this.courseService.update(lambdaUpdateWrapper);
        return new SuccessResponseData<>();
    }


}