@Data
public class CoursePublishVo {
    private String id;
    private String title;
    private String cover;
    private Integer lessonNum;
    private String subjectLevelOne;
    private String subjectLevelTwo;
    private String teacherName;
    private String price;//只用于显示
}

public interface EduCourseMapper extends BaseMapper<EduCourse> {
    CoursePublishVo getCoursePublishInfo(String courseId);
}

// 根据id查询课程全部信息
@PostMapping("getCoursePublishInfo/{courseId}")
public R getCoursePublishInfo(@PathVariable String courseId) {
    CoursePublishVo coursePublishInfo = courseService.getCoursePublishInfo(courseId);
    return R.ok().data("coursePublishInfo", coursePublishInfo);
}

// 根据id查询课程全部信息
@Override
public CoursePublishVo getCoursePublishInfo(String courseId) {
    return baseMapper.getCoursePublishInfo(courseId);
}

// 发布课程（修改status字段值）
@PostMapping("publishCourse/{courseId}")
public R publishCourse(@PathVariable String courseId) {
    EduCourse eduCourse = courseService.getById(courseId);
    eduCourse.setStatus("Normal");
    courseService.updateById(eduCourse);
    return R.ok();
}

// TODO 完善条件查询带分页
@GetMapping("getCourseList")
public R getCourseList() {
    List<EduCourse> list = courseService.list(null);
    return R.ok().data("courseList", list);
}

// 删除课程
@DeleteMapping("{courseId}")
public R deleteCourse(@PathVariable String courseId) {
    courseService.deleteCourse(courseId);
    return R.ok();
}

// 根据课程id删除课程及其描述和章节
@Override
public void deleteCourse(String courseId) {
    // 1、删除小节
    videoService.removeByCourseId(courseId);
    // 2、删除章节
    chapterService.removeByCourseId(courseId);
    // 3、删除描述
    descriptionService.removeById(courseId);
    // 4、删除课程
    int row = baseMapper.deleteById(courseId);
    if (row == 0) {
        throw new GuliException(20001, "删除课程失败");
    }
}

// 根据课程id删除章节
@Override
public void removeByCourseId(String courseId) {
    QueryWrapper<EduChapter> queryWrapper = new QueryWrapper<>();
    queryWrapper.eq("course_id", courseId);
    baseMapper.delete(queryWrapper);
}

public class TestVod {

    public static void main(String[] args) throws ClientException {
        // 1、根据视频id获取视频播放地址
        // 创建初始化对象(传入oss的id和秘钥)
        DefaultAcsClient client = InitObject.initVodClient("", "");
        // 创建获取视频地址的request
        GetPlayInfoRequest request = new GetPlayInfoRequest();
        // 向request中设置id
        request.setVideoId("");
        // 调用初始化对象的方法，传递request，获取response
        GetPlayInfoResponse acsResponse = client.getAcsResponse(request);

        // 获取response中的信息
        List<GetPlayInfoResponse.PlayInfo> playInfoList = acsResponse.getPlayInfoList();
        //播放地址
        for (GetPlayInfoResponse.PlayInfo playInfo : playInfoList) {
            System.out.print("PlayInfo.PlayURL = " + playInfo.getPlayURL() + "\n");
        }
        //Base信息
        System.out.print("VideoBase.Title = " + acsResponse.getVideoBase().getTitle() + "\n");
        System.out.println(acsResponse);
    }
}

public static void main(String[] args) throws ClientException {
    // 根据视频id获得视频凭证
    // 创建初始化对象(传入oss的id和秘钥)
    DefaultAcsClient client = InitObject.initVodClient("", "");
    // 创建获取视频地址的request
    GetVideoPlayAuthRequest request = new GetVideoPlayAuthRequest();
    // 向request中设置id
    request.setVideoId("");
    // 调用初始化对象的方法，传递request，获取response
    GetVideoPlayAuthResponse acsResponse = client.getAcsResponse(request);
    System.out.println("视频凭证: " + acsResponse.getPlayAuth());
}

public static void main(String[] args) throws ClientException {
    String accessKeyId = "";
    String accessKeySecret = "";

    String title = "6 - What If I Want to Move Faster - upload by sdk";   //上传之后文件名称
    String fileName = "D:/MyProject/6 - What If I Want to Move Faster.mp4";  //本地文件路径和名称
    //上传视频的方法
    UploadVideoRequest request = new UploadVideoRequest(accessKeyId, accessKeySecret, title, fileName);
    /* 可指定分片上传时每个分片的大小，默认为2M字节 */
    request.setPartSize(2 * 1024 * 1024L);
    /* 可指定分片上传时的并发线程数，默认为1，(注：该配置会占用服务器CPU资源，需根据服务器情况指定）*/
    request.setTaskNum(1);

    UploadVideoImpl uploader = new UploadVideoImpl();
    UploadVideoResponse response = uploader.uploadVideo(request);

    if (response.isSuccess()) {
        System.out.print("VideoId=" + response.getVideoId() + "\n");
    } else {
        /* 如果设置回调URL无效，不影响视频上传，可以返回VideoId同时会返回错误码。其他情况上传失败时，VideoId为空，此时需要根据返回错误码分析具体错误原因 */
        System.out.print("VideoId=" + response.getVideoId() + "\n");
        System.out.print("ErrorCode=" + response.getCode() + "\n");
        System.out.print("ErrorMessage=" + response.getMessage() + "\n");
    }
}

// 类存储配置文件中的数据以便调用
@Component
public class ConstantVodUtils implements InitializingBean {

    @Value("${aliyun.vod.file.keyid}")
    private String keyid;

    @Value("${aliyun.vod.file.keysecret}")
    private String keysecret;

    public static String ACCESS_KEY_SECRET;
    public static String ACCESS_KEY_ID;

    @Override
    public void afterPropertiesSet() throws Exception {
        ACCESS_KEY_ID = keyid;
        ACCESS_KEY_SECRET = keysecret;
    }
    
}

@Component
public class InitVodClient {

    public static DefaultAcsClient initVodClient(String accessKeyId, String accessKeySecret) throws ClientException {
        String regionId = "cn-shanghai";  // 点播服务接入区域
        DefaultProfile profile = DefaultProfile.getProfile(regionId, accessKeyId, accessKeySecret);
        DefaultAcsClient client = new DefaultAcsClient(profile);
        return client;
    }

}

@SpringBootApplication(exclude = DataSourceAutoConfiguration.class) // 不需要引入数据库的配置
@ComponentScan(basePackages = {"com.atguigu"})
public class VodApplication {
    public static void main(String[] args) {
        SpringApplication.run(VodApplication.class, args);
    }
}

@RestController
@RequestMapping("/eduvod/video")
@CrossOrigin
public class VodController {
    @Autowired
    private VodService vodService;

    // 上传视频至阿里云
    @PostMapping("uploadVideo")
    public R uploadVideo(MultipartFile file) {
        String videoId = vodService.uploadVideo(file);
        return R.ok();
    }
    
    // 根据id删除视频
    @DeleteMapping("removeVideo/{videoId}")
    public R removeVideo(@PathVariable String videoId) {
        vodService.removeVideo(videoId);
        return R.ok();
    }
}

@Service
public class VodServiceImpl implements VodService {
    // 上传视频至阿里云
    @Override
    public String uploadVideo(MultipartFile file) {

        try {
            //fileName：上传文件原始名称
            String fileName = file.getOriginalFilename();
            //title：上传之后显示名称
            String title = fileName.substring(0, fileName.lastIndexOf("."));
            //inputStream：上传文件输入流
            InputStream inputStream = file.getInputStream();
            //accessKeyId, accessKeySecret
            UploadStreamRequest request = new UploadStreamRequest(ConstantVodUtils.ACCESS_KEY_ID, ConstantVodUtils.ACCESS_KEY_SECRET, title, fileName, inputStream);

            UploadVideoImpl uploader = new UploadVideoImpl();
            UploadStreamResponse response = uploader.uploadStream(request);

            String videoId = null;
            if (response.isSuccess()) {
                videoId = response.getVideoId();
            } else { //如果设置回调URL无效，不影响视频上传，可以返回VideoId同时会返回错误码。其他情况上传失败时，VideoId为空，此时需要根据返回错误码分析具体错误原因
                System.out.print("VideoId=" + response.getVideoId() + "\n");
                System.out.print("ErrorCode=" + response.getCode() + "\n");
                System.out.print("ErrorMessage=" + response.getMessage() + "\n");
            }
            return videoId;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    // 根据id删除视频
    @Override
    public void removeVideo(String videoId) {
        try {
            // 初始化对象
            DefaultAcsClient client = InitVodClient.initVodClient(ConstantVodUtils.ACCESS_KEY_ID, ConstantVodUtils.ACCESS_KEY_SECRET);
            // 创建删除video的request对象,并设置id
            DeleteVideoRequest request = new DeleteVideoRequest();
            request.setVideoIds(videoId);
            // 调用初始化对象方法
            DeleteVideoResponse acsResponse = client.getAcsResponse(request);
        } catch (Exception e) {
            e.printStackTrace();
            throw new GuliException(20001, "删除视频失败");
        }
    }
}

// 删除小节视频
    deleteVideoAli(videoId) {
        return request({
            url: `/eduvod/video/removeVideo/` + videoId,
            method: 'delete',
        })
    }

@EnableDiscoveryClient  // nacos注册
public class EduApplication {
    public static void main(String[] args) {
        SpringApplication.run(EduApplication.class, args);
    }
}

@SpringBootApplication
@ComponentScan(basePackages = {"com.atguigu"})
@EnableDiscoveryClient  // nacos注册
@EnableFeignClients     // 使用Feign
public class EduApplication {
    public static void main(String[] args) {
        SpringApplication.run(EduApplication.class, args);
    }
}

@FeignClient("service-vod") // 调用服务（服务名），这里的服务名要和对应服务的配置文件中的spring.application.name对应
@Component
public interface VodClient {
    // 定义要调用的方法的路径（注意要完全路径）
    // 根据id删除视频
    @DeleteMapping("/eduvod/video/removeVideo/{videoId}")
    public R removeVideo(@PathVariable("videoId") String videoId);
}

@RestController
@RequestMapping("/eduservice/video")
@CrossOrigin    // 跨域
public class EduVideoController {
    @Autowired
    private VodClient vodClient;    // 注入接口调用其他服务
    // TODO 删除小节
    @DeleteMapping("{videoId}")
    public R deleteVideo(@PathVariable("videoId") String videoId) {
       // 实现调用删除阿里云视频，这里需要的是sourceID
        EduVideo eduVideo = videoService.getById(videoId);
        String videoSourceId = eduVideo.getVideoSourceId();
        vodClient.removeVideo(videoSourceId);
        // 删除数据库视频
        videoService.removeById(videoId);
        return R.ok();
    }
}

@Component
public class VodFileDegradeFeignClient implements VodClient {
    @Override
    public R removeVideo(String videoId) {
        return R.error().message("出错了");
    }

    @Override
    public R deleteVideoBatch(List<String> videoIdList) {
        return R.error().message("出错了");
    }
}

// fallback = "实现类的class"，熔断器
@FeignClient(name = "service-vod", fallback = VodFileDegradeFeignClient.class)
// 调用服务（服务名），这里的服务名要和对应服务的配置文件中的spring.application.name对应
@Component
public interface VodClient {
}

// 删除多个阿里云视频
@DeleteMapping("deleteVideoBatch")
public R deleteVideoBatch(@RequestParam("videoIdList") List<String> videoIdList) {
    vodService.removeBatch(videoIdList);
    return R.ok();
}

// 删除多个阿里云视频
@Override
public void removeVideoBatch(List<String> videoIdList) {
    try {
        // 初始化对象
        DefaultAcsClient client = InitVodClient.initVodClient(ConstantVodUtils.ACCESS_KEY_ID, ConstantVodUtils.ACCESS_KEY_SECRET);
        // 创建删除video的request对象,并设置id
        DeleteVideoRequest request = new DeleteVideoRequest();

        // 将list转化成1,2,3的格式
        String list = StringUtils.join(videoIdList.toArray(), ",");

        request.setVideoIds(list);
        // 调用初始化对象方法
        DeleteVideoResponse acsResponse = client.getAcsResponse(request);
    } catch (Exception e) {
        e.printStackTrace();
        throw new GuliException(20001, "删除视频失败");
    }
}

@FeignClient("service-vod") // 调用服务（服务名），这里的服务名要和对应服务的配置文件中的spring.application.name对应
@Component
public interface VodClient {
    // 定义要调用的方法的路径（注意要完全路径）
    // 根据id删除视频
    @DeleteMapping("/eduvod/video/removeVideo/{videoId}")
    public R removeVideo(@PathVariable("videoId") String videoId);

    // 删除多个阿里云视频
    @DeleteMapping("/eduvod/video/deleteVideoBatch")
    public R deleteVideoBatch(@RequestParam("videoIdList") List<String> videoIdList);
}

@Service
public class EduVideoServiceImpl extends ServiceImpl<EduVideoMapper, EduVideo> implements EduVideoService {

    @Autowired
    private VodClient vodClient;

    // 根据课程id删除小节
    @Override
    public void removeByCourseId(String courseId) {
        // 删除该课程下的所有视频（阿里云）
        List<String> idList = baseMapper.getVideoIdListByCourse(courseId);
        vodClient.deleteVideoBatch(idList);
        // 删除小节（数据库）
        QueryWrapper wrapper = new QueryWrapper();
        wrapper.eq("course_id", courseId);
        baseMapper.delete(wrapper);
    }
}