package com.peanut.modules.master.controller;

import com.aliyun.vod20170321.models.GenerateKMSDataKeyResponseBody;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.peanut.common.utils.R;
import com.peanut.common.utils.SpdbUtil;
import com.peanut.modules.common.dao.CourseCatalogueChapterVideoDao;
import com.peanut.modules.common.dao.VideoM3u8Dao;
import com.peanut.modules.common.entity.*;
import com.peanut.modules.common.to.EditCourseRecordDto;
import com.peanut.modules.common.to.ParamTo;
import com.peanut.modules.common.to.ChangeCatalogueFeeDto;
import com.peanut.modules.master.service.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import ws.schild.jave.MultimediaObject;

import java.net.URL;
import java.util.List;
import java.util.Map;

@Slf4j
@RestController("masterCourse")
@RequestMapping("master/course")
public class
CourseController {

    @Autowired
    private CourseService courseService;
    @Autowired
    private CourseCatalogueService courseCatalogueService;
    @Autowired
    private CourseCatalogueChapterService courseCatalogueChapterService;
    @Autowired
    private CourseCatalogueChapterVideoService courseCatalogueChapterVideoService;
    @Autowired
    private CourseCatalogueChapterVideoDao courseCatalogueChapterVideoDao;
    @Autowired
    private SysCourseDirectService sysCourseDirectService;
    @Autowired
    private ShopProductService shopProductService;
    @Autowired
    private VideoM3u8Dao videoM3u8Dao;
    @Autowired
    private SpdbUtil spdbUtil;


    @RequestMapping("/getCourseList")
    public R getCourseList(@RequestBody Map<String,Object> map){
        Page courseList = courseService.getCourseList(map);
        return R.ok().put("page",courseList);
    }

    @RequestMapping("/addCourse")
    public R addCourse(@RequestBody CourseEntity course){
        courseService.save(course);
        return R.ok();
    }

    @RequestMapping("/delCourse")
    public R delCourse(int id){
        return courseService.delCourse(id);
    }

    @RequestMapping("/editCourse")
    public R editCourse(@RequestBody CourseEntity course){
        courseService.updateById(course);
        return R.ok();
    }

    @RequestMapping("/pushM3u8Video")
    public R pushM3u8Video(@RequestBody Map<String,String> map) throws Exception {
        String s = map.get("vid");
        GenerateKMSDataKeyResponseBody kms = SpdbUtil.KMS();
        VideoM3u8Entity videoM3u8Entity = new VideoM3u8Entity();
        assert kms != null;
        videoM3u8Entity.setEdk(kms.getCiphertextBlob());
        videoM3u8Entity.setVid(s);
        videoM3u8Dao.insert(videoM3u8Entity);
        SpdbUtil.startM3u8(s,kms.getCiphertextBlob());
        return R.ok();
    }

    @RequestMapping("/searchCourse")
    public R searchCourse(@RequestBody ParamTo param){
        List<CourseEntity> courseEntities = courseService.searchCourse(param.getKeywords());
        return R.ok().put("List",courseEntities);
    }

    @RequestMapping("/cossVod")
    public R cossVod(@RequestBody Map<String,Integer> map) throws Exception {
        int p = map.get("page");
        int l = map.get("limit");
        LambdaQueryWrapper<CourseCatalogueChapterVideoEntity> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(CourseCatalogueChapterVideoEntity::getType,1);
        Page<CourseCatalogueChapterVideoEntity> courseCatalogueChapterVideoEntityPage = courseCatalogueChapterVideoService.getBaseMapper().selectPage(new Page<>(p, l), wrapper);
        for (CourseCatalogueChapterVideoEntity c :courseCatalogueChapterVideoEntityPage.getRecords()){
            spdbUtil.vodTranslationM3u8(c.getVideo());
        }
        return R.ok();
    }

    @RequestMapping("/cossVod1")
    public R cossVod1() throws Exception {
        MPJLambdaWrapper<CourseCatalogueChapterVideoEntity> wrapper = new MPJLambdaWrapper<>();
        wrapper.selectAll(CourseCatalogueChapterVideoEntity.class);
        wrapper.leftJoin(VideoM3u8Entity.class,VideoM3u8Entity::getVid,CourseCatalogueChapterVideoEntity::getVideo);
        wrapper.eq(CourseCatalogueChapterVideoEntity::getType,1);
        wrapper.isNull(VideoM3u8Entity::getId);
        List<CourseCatalogueChapterVideoEntity> courseCatalogueChapterVideoEntities = courseCatalogueChapterVideoDao.selectJoinList(CourseCatalogueChapterVideoEntity.class, wrapper);
        for (CourseCatalogueChapterVideoEntity c:courseCatalogueChapterVideoEntities){
            spdbUtil.vodTranslationM3u8(c.getVideo());
        }
        return R.ok().put("list",courseCatalogueChapterVideoEntities);
    }



    @RequestMapping("/getCoursedetail")
    public R getCoursedetail(@RequestBody ParamTo param){
        CourseEntity course = courseService.getById(param.getId());
        List<ShopProduct> shopProductList = null;
        //课程关联商品
        if (StringUtils.isNotEmpty(course.getRelationProductIds())){
            String[] ids = course.getRelationProductIds().split(",");
            shopProductList = shopProductService.list(new LambdaQueryWrapper<ShopProduct>()
                    .in(ShopProduct::getProductId, ids)
                    .orderByAsc(ShopProduct::getSort));
        }
        return R.ok().put("course",course).put("shopProductList",shopProductList);
    }

    @RequestMapping("/getCourseCatalogues")
    public R getCourseCatalogues(@RequestBody ParamTo param){
        List<CourseCatalogueEntity> courseCatalogues = courseCatalogueService.getCourseCatalogues(param.getId());
        return R.ok().put("catalogues",courseCatalogues);
    }

    @RequestMapping("/createProductForCatalogue")
    public R createProductForCatalogue(@RequestBody Map<String,Integer> map){
        int id = map.get("id");
        return courseCatalogueService.createProductForCatalogue(id);
    }

    @RequestMapping("/addCourseCatalogue")
    public R addCourseCatalogue(@RequestBody CourseCatalogueEntity courseCatalogue){
        courseCatalogueService.addCourseCatalogue(courseCatalogue);
        return R.ok();
    }

    @RequestMapping("/delCourseCatalogue")
    public R delCourseCatalogue(@RequestBody ParamTo param){
        return courseCatalogueService.delCourseCatalogue(param.getId());
    }

    @RequestMapping("/editCourseCatalogue")
    public R editCourseCatalogue(@RequestBody CourseCatalogueEntity c){
        courseCatalogueService.updateById(c);
        return R.ok();
    }

    @RequestMapping("/getCourseCatalogueChapterList")
    public R getCourseCatalogueChapterList(@RequestBody ParamTo param){
        Page courseCatalogueChapterList = courseCatalogueChapterService.getCourseCatalogueChapterList(param);
        return R.ok().put("page",courseCatalogueChapterList);
    }

    @RequestMapping("/addCourseCatalogueChapter")
    public R addCourseCatalogueChapter(@RequestBody CourseCatalogueChapterEntity courseCatalogueChapterEntity){
        if (courseCatalogueChapterService.save(courseCatalogueChapterEntity)){
            if (courseCatalogueChapterEntity.getVideoList()!=null&&courseCatalogueChapterEntity.getVideoList().size() > 0){
                for (CourseCatalogueChapterVideoEntity c:courseCatalogueChapterEntity.getVideoList()) {
                    c.setChapterId(courseCatalogueChapterEntity.getId());
                    courseCatalogueChapterVideoService.save(c);
                }
            }
        }
        return R.ok();
    }

    @RequestMapping("/delCourseCatalogueChapter")
    public R delCourseCatalogueChapter(@RequestBody ParamTo param){
        return courseCatalogueChapterService.delCourseCatalogueChapter(param.getId());
    }

    @RequestMapping("/editCourseCatalogueChapter")
    @Transactional
    public R editCourseCatalogueChapter(@RequestBody CourseCatalogueChapterEntity courseCatalogueChapterEntity){
        courseCatalogueChapterService.updateById(courseCatalogueChapterEntity);
        //修改视频
        if (courseCatalogueChapterEntity.getVideoList()!=null&&courseCatalogueChapterEntity.getVideoList().size() > 0){
            for (CourseCatalogueChapterVideoEntity c:courseCatalogueChapterEntity.getVideoList()) {
                if (c.getId()==0){
                    courseCatalogueChapterVideoService.save(c);
                }else {
                    courseCatalogueChapterVideoService.saveOrUpdate(c);
                }
            }
        }
        return R.ok();
    }

    @RequestMapping("/getCourseCatalogueChapterVideoList")
    public R getCourseCatalogueChapterVideoList(@RequestBody ParamTo param){
        Page courseCatalogueChapterVideoList = courseCatalogueChapterVideoService.getCourseCatalogueChapterVideoList(param);
        return R.ok().put("page",courseCatalogueChapterVideoList);
    }

    @RequestMapping("/addCourseCatalogueChapterVideo")
    public R addCourseCatalogueChapterVideo(@RequestBody CourseCatalogueChapterVideoEntity courseCatalogueChapterVideoEntity){
        boolean save = courseCatalogueChapterVideoService.save(courseCatalogueChapterVideoEntity);
        if (courseCatalogueChapterVideoEntity.getType()==2){
            int duration = getMP3Duration(courseCatalogueChapterVideoEntity);
            courseCatalogueChapterVideoEntity.setDuration(duration);
            courseCatalogueChapterVideoService.updateById(courseCatalogueChapterVideoEntity);
        }
        return save?R.ok():R.error("error");
    }

    @RequestMapping("/delCourseCatalogueChapterVideo")
    public R delCourseCatalogueChapterVideo(@RequestBody ParamTo param){
        courseCatalogueChapterVideoService.removeById(param.getId());
        return R.ok();
    }

    @RequestMapping("/changeCatalogueFee")
    public R changeCatalogueFee(@RequestBody ChangeCatalogueFeeDto p){
        return courseCatalogueService.changeCatalogueFee(p);
    }

    /**
     * 获取课程说明
     * @param map
     * @return
     */
    @RequestMapping("/getCourseRecord")
    public R getCourseRecord(@RequestBody Map<String,Integer> map){
        SysCourseDirectEntity info = sysCourseDirectService.getOne(new LambdaQueryWrapper<SysCourseDirectEntity>().eq(SysCourseDirectEntity::getType, map.get("type")));
        return R.ok().put("result",info);
    }

    @RequestMapping("/editCourseRecord")
    public R editCourseRecord(@RequestBody EditCourseRecordDto editCourseRecordDto){
        SysCourseDirectEntity sysCourseDirectEntity = sysCourseDirectService.editCourseRecord(editCourseRecordDto);
        return R.ok().put("result",sysCourseDirectEntity);
    }

    //课程目录迁移
    @RequestMapping("/courseCatalogueTransfer")
    public R courseCatalogueTransfer(@RequestBody Map<String,Object> param){
        return courseService.courseCatalogueTransfer(param);
    }

    //查询课程被哪些标签关联
    @RequestMapping("/getCourseLableLinkList")
    public R getCourseLableLinkList(@RequestBody Map<String,Object> param){
        return courseService.getCourseLableLinkList(param);
    }




    @RequestMapping("/editCourseCatalogueChapterVideo")
    public R editCourseCatalogueChapterVideo(@RequestBody CourseCatalogueChapterVideoEntity courseCatalogueChapterVideoEntity){
        courseCatalogueChapterVideoService.updateById(courseCatalogueChapterVideoEntity);
        if (courseCatalogueChapterVideoEntity.getType()==2){
            int duration = getMP3Duration(courseCatalogueChapterVideoEntity);
            courseCatalogueChapterVideoEntity.setDuration(duration);
            courseCatalogueChapterVideoService.updateById(courseCatalogueChapterVideoEntity);
        }
        return R.ok();
    }

    @RequestMapping("/testCourse")
    public R testCourse(){
        courseService.testCourse();
        return R.ok();
    }

    @RequestMapping("/getProductListForCourse")
    public R getProductListForCourse(@RequestBody Map<String,Object> param){
        Page<ShopProduct> shopProductListhopProducts = courseService.getProductListForCourse(param);
        return R.ok().put("shopProductListhopProducts",shopProductListhopProducts);
    }

    //获取音频时长
    public int getMP3Duration(CourseCatalogueChapterVideoEntity video){
        try{
            String s_str = "";
            if (video.getVideo().startsWith("article/")) {
                s_str = "http://oss.taihumed.com/voice/article/";
            }else if (video.getVideo().startsWith("mingyijingcai/")) {
                s_str = "http://oss.taihumed.com/voice/";
            }else {
                s_str = "http://oss.taihumed.com/voice/taiHuClass/";
            }
            URL url = new URL(s_str+video.getVideo());
            MultimediaObject multimediaObject = new MultimediaObject(url);
            long duration = (multimediaObject.getInfo().getDuration())/1000;
            return Integer.parseInt(duration+"");
        }catch (Exception e){
            e.printStackTrace();
        }
        return 0;
    }

}