package com.xinquan.user.controller.client;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.xinquan.common.core.domain.R;
import com.xinquan.common.core.utils.page.PageDTO;
import com.xinquan.common.core.web.domain.BaseModel;
import com.xinquan.common.security.service.TokenService;
import com.xinquan.common.security.utils.SecurityUtils;
import com.xinquan.course.api.domain.Course;
import com.xinquan.course.api.domain.CourseChapter;
import com.xinquan.course.api.domain.OrderCourseVO;
import com.xinquan.course.api.feign.RemoteCourseService;
import com.xinquan.meditation.api.domain.Meditation;
import com.xinquan.meditation.api.feign.RemoteMeditationService;
import com.xinquan.system.api.domain.*;
import com.xinquan.system.api.domain.vo.AppUserVO;
import com.xinquan.system.api.model.LoginUser;
import com.xinquan.user.api.feign.RemoteAppUserService;
import com.xinquan.user.service.AppUserEnergyRecordService;
import com.xinquan.user.service.AppUserService;
import com.xinquan.user.service.AppUserTreeService;
import com.xinquan.user.service.AppUserViewingHistoryService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import io.swagger.models.auth.In;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

/**
 * <p>
 * 用户观看历史 前端控制器
 * </p>
 *
 * @author mitao
 * @since 2024-09-06
 */
@Api(tags = {"用户端-观看历史相关接口"})
@RestController
@RequiredArgsConstructor
@RequestMapping("/user/app-user-viewing-history")
public class ClientAppUserViewingHistoryController {

    private final AppUserViewingHistoryService appUserViewingHistoryService;
    @Resource
    private TokenService tokenService;
    @Resource
    private AppUserTreeService appUserTreeService;
    @Resource
    private AppUserService appUserService;
    @Resource
    private RemoteMeditationService remoteMeditationService;
    @Resource
    private RemoteCourseService courseUserFavoriteService;
    @Resource
    private RemoteCourseService remoteCourseService;
    private final RemoteAppUserService remoteAppUserService;

    /**
     * 远程调用 根据章节id和用户id查询是否观看完毕
     *
     * @param id
     * @return
     */
    @PostMapping("/getCourseChapterHistoryState/{id}/{chapterId}")
    public R<Integer> getCourseChapterHistoryState(@PathVariable("id") Long id, @PathVariable("chapterId") Long chapterId) {
        List<AppUserViewingHistory> list = appUserViewingHistoryService.lambdaQuery()
                .eq(AppUserViewingHistory::getChapterId, chapterId)
                .eq(AppUserViewingHistory::getAppUserId, id)
                .eq(AppUserViewingHistory::getViewingType, 2)
                .list();
        for (AppUserViewingHistory appUserViewingHistory : list) {
            if (appUserViewingHistory.getIsOver() != null && appUserViewingHistory.getIsOver() == 1) {
                return R.ok(1);
            }
        }
        return R.ok(2);
    }

    /**
     * 远程调用查询用户观看了哪些课程
     *
     * @return
     */
    @PostMapping("/getCourseHistoryByUserId/{id}")
    public R<List<Long>> getCourseHistoryByUserId(@PathVariable("id") Long id) {
        List<Long> one = appUserViewingHistoryService.lambdaQuery()
                .eq(AppUserViewingHistory::getAppUserId, id)
                .eq(AppUserViewingHistory::getViewingType, 2)
                .list().stream().map(AppUserViewingHistory::getBizId)
                .collect(Collectors.toList());
        return R.ok(one);
    }

    @PostMapping("/getMeditationHistoryCount/{id}")
    public R<Long> getMeditationHistoryCount(@PathVariable("id") Long id) {
        List<AppUserViewingHistory> list = appUserViewingHistoryService.lambdaQuery()
                .eq(AppUserViewingHistory::getBizId, id)
                .eq(AppUserViewingHistory::getViewingType, 1)
                .groupBy(AppUserViewingHistory::getAppUserId)
                .list();
        return R.ok(Long.valueOf(list.size()));
    }

    @PostMapping("/getMeditationHistoryCountAll")
    public R<List<AppUserViewingHistory>> getMeditationHistoryCountAll() {
        List<AppUserViewingHistory> list = appUserViewingHistoryService.lambdaQuery()
                .eq(AppUserViewingHistory::getViewingType, 1)
                .groupBy(AppUserViewingHistory::getAppUserId)
                .list();
        return R.ok(list);
    }

    @PostMapping("/getCourseHistoryCount/{id}")
    public R<Long> getCourseHistoryCount(@PathVariable("id") Long id) {
        List<AppUserViewingHistory> list = appUserViewingHistoryService.lambdaQuery()
                .eq(AppUserViewingHistory::getBizId, id)
                .eq(AppUserViewingHistory::getViewingType, 2)
                .list();
        return R.ok(Long.valueOf(list.size()));
    }

    @PostMapping("/getCourseChapterHistoryCount/{id}")
    public R<Long> getCourseChapterHistoryCount(@PathVariable("id") Long id) {
        List<AppUserViewingHistory> list = appUserViewingHistoryService.lambdaQuery()
                .eq(AppUserViewingHistory::getChapterId, id)
                .eq(AppUserViewingHistory::getViewingType, 2)
                .groupBy(AppUserViewingHistory::getAppUserId)
                .list();
        return R.ok(Long.valueOf(list.size()));
    }

    @PostMapping("/lookHistory")
    @ApiOperation(value = "观看历史")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "state", value = "1冥想 2课程", dataType = "Integer", required = true),
            @ApiImplicitParam(name = "pageCurr", value = "分页参数，当前页码", dataType = "Integer", required = true),
            @ApiImplicitParam(name = "pageSize", value = "分页参数，每页数量", dataType = "Integer", required = true)
    })
    public R<List<OrderCourseVO>> lookHistory(Integer state, Integer pageCurr, Integer pageSize) {
        LoginUser loginUser = tokenService.getLoginUser();
        if (loginUser == null) {
            return R.tokenError("登录失效");
        }
        Long userId = loginUser.getUserid();
        List<OrderCourseVO> orderCourseVOS = new ArrayList<>();

        switch (state) {
            case 1:
                List<Long> collect1 = appUserViewingHistoryService.lambdaQuery()
                        .eq(AppUserViewingHistory::getAppUserId, userId)
                        .eq(AppUserViewingHistory::getViewingType, 1).list()
                        .stream().map(AppUserViewingHistory::getBizId).collect(Collectors.toList());
                List<Long> collect2 = collect1.stream().distinct().collect(Collectors.toList());
                StringBuilder temp = new StringBuilder();
                if (collect1.isEmpty()) {
                    temp = temp.append("-1");
                } else {
                    for (Long l : collect2) {
                        temp.append(l).append(",");
                    }
                    temp.deleteCharAt(temp.length() - 1);
                }
                Page<Meditation> data = remoteMeditationService.getMeditationByIds(pageCurr, pageSize, temp.toString()).getData();

                for (Meditation meditation : data.getRecords()) {
                    OrderCourseVO orderCourseVO = new OrderCourseVO();
                    orderCourseVO.setBusinessId(meditation.getId());
                    orderCourseVO.setCourseTitle(meditation.getMeditationTitle());
                    orderCourseVO.setDescription(meditation.getDetailDescription());
                    orderCourseVO.setChargeType(meditation.getChargeType());
                    orderCourseVO.setGeneralPrice(meditation.getGeneralPrice());
                    orderCourseVO.setIosPrice(meditation.getIosPrice());
                    orderCourseVO.setCoverUrl(meditation.getCoverUrl());
                    orderCourseVO.setCount(meditation.getRealLearnedNum() + meditation.getVirtualLearnedNum());
                    orderCourseVO.setCoverDescription(meditation.getCoverDescription());
                    orderCourseVOS.add(orderCourseVO);
                }
                break;
            case 2:
                List<Long> collect3 = appUserViewingHistoryService.lambdaQuery()
                        .eq(AppUserViewingHistory::getAppUserId, userId)
                        .eq(AppUserViewingHistory::getViewingType, 2).list()
                        .stream().map(AppUserViewingHistory::getBizId).collect(Collectors.toList());
                List<Long> collect4 = collect3.stream().distinct().collect(Collectors.toList());
                StringBuilder temp1 = new StringBuilder();
                if (collect4.isEmpty()) {
                    temp1 = temp1.append("-1");
                } else {
                    for (Long l : collect4) {
                        temp1.append(l).append(",");
                    }
                    temp1.deleteCharAt(temp1.length() - 1);
                }
                Page<Course> data2 = remoteCourseService.getCourseByIds(pageCurr, pageSize, temp1.toString()).getData();
                for (Course record : data2.getRecords()) {
                    OrderCourseVO orderCourseVO = new OrderCourseVO();
                    orderCourseVO.setBusinessId(record.getId());
                    orderCourseVO.setCourseTitle(record.getCourseTitle());
                    orderCourseVO.setDescription(record.getDescription());
                    orderCourseVO.setChargeType(record.getChargeType());
                    orderCourseVO.setGeneralPrice(record.getGeneralPrice());
                    orderCourseVO.setIosPrice(record.getIosPrice());
                    orderCourseVO.setCoverUrl(record.getCoverUrl());
                    List<CourseChapter> data1 = remoteCourseService.getChapterByCourseId(orderCourseVO.getBusinessId() + "").getData();
                    int a = 0;
                    int b = 0;
                    for (CourseChapter courseChapter : data1) {
                        a += courseChapter.getVirtualLearnedNum();
                        Long data9 = remoteAppUserService.getCourseChapterHistoryCount(courseChapter.getId()).getData();
                        b += data9;
                    }
                    orderCourseVO.setCount(a + b);
                    orderCourseVOS.add(orderCourseVO);
                }
                break;
        }
        return R.ok(orderCourseVOS);
    }

    /**
     * 记录用户观看记录
     */
    @PostMapping("/testLookHistory")
    @ApiOperation(value = "记录用户观看冥想记录", tags = {"用户端-用户相关接口"})
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id", value = "冥想id", dataType = "Long", required = true),
            @ApiImplicitParam(name = "timeLook", value = "播放时长单位秒", dataType = "Integer", required = true)
    })
    public R<?> testLookHistory(@RequestParam("id") Long id,
                                  @RequestParam("timeLook") Integer timeLook) {

//        AppUserViewingHistory appUserViewingHistory = new AppUserViewingHistory();
//        appUserViewingHistory.setAppUserId(1907408237773807618L);
//        appUserViewingHistory.setBizId(id);
//        appUserViewingHistory.setViewingType(1);
//        appUserViewingHistory.setTimeLook(timeLook);
//        appUserViewingHistory.setCreateTime(LocalDateTime.now());
//        // 先查询用户当天有没有观看过该音频
//        AppUserViewingHistory appUserViewingHistory3 = appUserViewingHistoryService.lambdaQuery().eq(AppUserViewingHistory::getAppUserId, 1907408237773807618L)
//                .eq(AppUserViewingHistory::getBizId, id)
//                .apply("date_format(create_time,'%Y-%M-%D')=date_format(now(),'%Y-%M-%D')")
//                .eq(AppUserViewingHistory::getViewingType, 1).last("limit 1").one();
//        if (appUserViewingHistory3 != null) {
//            appUserViewingHistory3.setTimeLook(appUserViewingHistory3.getTimeLook() + timeLook);
//            appUserViewingHistoryService.updateById(appUserViewingHistory3);
//        } else {
//            appUserViewingHistoryService.save(appUserViewingHistory);
//        }
//        List<Long> collect = appUserService.list().stream().map(AppUser::getId).collect(Collectors.toList());
        List<Long> collect = appUserViewingHistoryService.list(new LambdaQueryWrapper<AppUserViewingHistory>()
                .groupBy(AppUserViewingHistory::getAppUserId)).stream().map(AppUserViewingHistory::getAppUserId).collect(Collectors.toList());

        for (Long l : collect) {
            List<AppUserViewingHistory> list = appUserViewingHistoryService.lambdaQuery()
                    .eq(AppUserViewingHistory::getAppUserId, l)
                    .eq(AppUserViewingHistory::getViewingType, 1)
                    .last("GROUP BY date_format(create_time,'%Y-%M-%D')").list();
            for (AppUserViewingHistory appUserViewingHistory : list) {
                List<AppUserViewingHistory> list1 = appUserViewingHistoryService.lambdaQuery().eq(AppUserViewingHistory::getAppUserId, appUserViewingHistory.getAppUserId())
                        .eq(AppUserViewingHistory::getViewingType, 1)
                        .ne(AppUserViewingHistory::getId, appUserViewingHistory.getId())
                        .eq(AppUserViewingHistory::getBizId, appUserViewingHistory.getBizId())
                        .apply("date_format(CONVERT_TZ(create_time, '+00:00', '+08:00'), '%Y-%m-%d')="+"'"+appUserViewingHistory.getCreateTime().toLocalDate()+"'").list();
                Integer timeLook1 = appUserViewingHistory.getTimeLook();
                for (AppUserViewingHistory userViewingHistory : list1) {
                    timeLook1+=userViewingHistory.getTimeLook();
                    appUserViewingHistoryService.removeById(userViewingHistory.getId());

                }
                appUserViewingHistory.setTimeLook(timeLook1);
                appUserViewingHistoryService.updateById(appUserViewingHistory);
            }
        }

        return R.ok();
    }




    /**
     * 记录用户观看记录
     */
    @PostMapping("/saveViewingHistory")
    @ApiOperation(value = "记录用户观看冥想记录", tags = {"用户端-用户相关接口"})
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id", value = "冥想id", dataType = "Long", required = true),
            @ApiImplicitParam(name = "timeLook", value = "播放时长单位秒", dataType = "Integer", required = true)
    })
    public R<?> saveViewingRecord(@RequestParam("id") Long id,
                                  @RequestParam("timeLook") Integer timeLook
    ) {
        LoginUser loginUser = tokenService.getLoginUser();
        if (loginUser == null) {
            return R.tokenError("登录失效");
        }
        Long userId = loginUser.getUserid();
        AppUserViewingHistory appUserViewingHistory = new AppUserViewingHistory();
        appUserViewingHistory.setAppUserId(userId);
        appUserViewingHistory.setBizId(id);
        appUserViewingHistory.setViewingType(1);
        appUserViewingHistory.setTimeLook(timeLook);
        appUserViewingHistory.setCreateTime(LocalDateTime.now());
        // 先查询用户当天有没有观看过该音频
        AppUserViewingHistory appUserViewingHistory3 = appUserViewingHistoryService.lambdaQuery().eq(AppUserViewingHistory::getAppUserId, userId)
                .eq(AppUserViewingHistory::getBizId, id)
                .apply("date_format(create_time,'%Y-%M-%D')=date_format(now(),'%Y-%M-%D')")
                .eq(AppUserViewingHistory::getViewingType, 1).last("limit 1").one();
        if (appUserViewingHistory3!=null){
            appUserViewingHistory3.setTimeLook(appUserViewingHistory3.getTimeLook()+timeLook);
            appUserViewingHistoryService.updateById(appUserViewingHistory3);
        }else{
            appUserViewingHistoryService.save(appUserViewingHistory);
        }
        AppUser byId = appUserService.getById(userId);
        appUserService.updateById(byId);
        // 查询用户今日观看疗愈多少秒
        LocalDateTime now = LocalDateTime.now();
        LocalDateTime startOfDay = now.toLocalDate().atStartOfDay();
        LocalDateTime endOfDay = now.toLocalDate().atTime(LocalTime.MAX);
        List<AppUserViewingHistory> list = appUserViewingHistoryService
                .lambdaQuery().eq(AppUserViewingHistory::getAppUserId, userId)
                .eq(AppUserViewingHistory::getViewingType, 1)
                .eq(BaseModel::getDelFlag, 0)
                .between(AppUserViewingHistory::getCreateTime, startOfDay, endOfDay).list();
        int temp = 0;
        for (AppUserViewingHistory appUserViewingHistory1 : list) {
            if (appUserViewingHistory1.getTimeLook() != null) {
                temp += appUserViewingHistory1.getTimeLook();
            }
        }
        AppUserTree one = appUserTreeService.lambdaQuery().eq(AppUserTree::getAppUserId, userId)
                .eq(AppUserTree::getSowAgain, 2).one();

        if (one == null) {
            AppUserTree appUserTree = new AppUserTree();
            appUserTree.setTime(LocalDateTime.now());
            appUserTree.setAppUserId(userId);
            appUserTree.setTreeLevelType(1);
            appUserTree.setGrowthValue(0);
            appUserTree.setSowAgain(2);
            appUserTree.setCreateTime(LocalDateTime.now());
            // 如果用户的签到时间是今天 那么修改为已签到
            if (byId.getSignTime() != null && byId.getSignTime().toLocalDate().equals(LocalDateTime.now().toLocalDate())) {
                appUserTree.setIsSign(1);
            } else {
                appUserTree.setIsSign(2);
            }
            if (temp >= 3600) {
                if (appUserTree.getTaskOne() == 2) {
                    AppUserEnergyRecord appUserEnergyRecord = new AppUserEnergyRecord();
                    appUserEnergyRecord.setAppUserId(userId);
                    appUserEnergyRecord.setChangeType(1);
                    appUserEnergyRecord.setEnergyValue(10);
                    appUserEnergyRecord.setReason("完成【每日疗愈30分钟】任务");
                    appUserEnergyRecordService.save(appUserEnergyRecord);
                    byId.setTotalEnergyValue(byId.getTotalEnergyValue() + 10);
                    byId.setEnergyValue(byId.getEnergyValue() + 10);

                }
                if (appUserTree.getTaskTwo() == 2) {
                    AppUserEnergyRecord appUserEnergyRecord = new AppUserEnergyRecord();
                    appUserEnergyRecord.setAppUserId(userId);
                    appUserEnergyRecord.setChangeType(1);
                    appUserEnergyRecord.setEnergyValue(20);
                    appUserEnergyRecord.setReason("完成【每日疗愈60分钟】任务");
                    appUserEnergyRecordService.save(appUserEnergyRecord);
                    byId.setTotalEnergyValue(byId.getTotalEnergyValue() + 20);
                    byId.setEnergyValue(byId.getEnergyValue() + 20);

                }
                appUserTree.setTaskOne(1);
                appUserTree.setTaskTwo(1);
            } else if (temp >= 1800) {
                if (appUserTree.getTaskOne() == 2) {
                    AppUserEnergyRecord appUserEnergyRecord = new AppUserEnergyRecord();
                    appUserEnergyRecord.setAppUserId(userId);
                    appUserEnergyRecord.setChangeType(1);
                    appUserEnergyRecord.setEnergyValue(10);
                    appUserEnergyRecord.setReason("完成【每日疗愈30分钟】任务");
                    appUserEnergyRecordService.save(appUserEnergyRecord);
                    byId.setTotalEnergyValue(byId.getTotalEnergyValue() + 10);
                    byId.setEnergyValue(byId.getEnergyValue() + 10);
                }
                appUserTree.setTaskOne(2);
                appUserTree.setTaskTwo(1);
            } else {
                appUserTree.setTaskOne(2);
                appUserTree.setTaskTwo(2);
            }
            appUserTree.setEnergyValue(byId.getEnergyValue());
            appUserTree.setNextLevel(1000);
            appUserTreeService.save(appUserTree);
            appUserTree.setTotalEnergyValue(byId.getTotalEnergyValue());
            return R.ok(appUserTree);
        } else {
            if (temp >= 3600) {
                if (one.getTaskOne() == 2) {
                    AppUserEnergyRecord appUserEnergyRecord = new AppUserEnergyRecord();
                    appUserEnergyRecord.setAppUserId(userId);
                    appUserEnergyRecord.setChangeType(1);
                    appUserEnergyRecord.setEnergyValue(10);
                    appUserEnergyRecord.setReason("完成【每日疗愈30分钟】任务");
                    appUserEnergyRecordService.save(appUserEnergyRecord);
                    byId.setTotalEnergyValue(byId.getTotalEnergyValue() + 10);
                    one.setTaskOne(1);
                    byId.setEnergyValue(byId.getEnergyValue() + 10);

                }
                if (one.getTaskTwo() == 2) {
                    AppUserEnergyRecord appUserEnergyRecord = new AppUserEnergyRecord();
                    appUserEnergyRecord.setAppUserId(userId);
                    appUserEnergyRecord.setChangeType(1);
                    appUserEnergyRecord.setEnergyValue(20);
                    appUserEnergyRecord.setReason("完成【每日疗愈60分钟】任务");
                    appUserEnergyRecordService.save(appUserEnergyRecord);
                    byId.setTotalEnergyValue(byId.getTotalEnergyValue() + 20);
                    one.setTaskTwo(1);
                    byId.setEnergyValue(byId.getEnergyValue() + 20);

                }

            } else if (temp >= 1800) {
                if (one.getTaskOne() == 2) {
                    AppUserEnergyRecord appUserEnergyRecord = new AppUserEnergyRecord();
                    appUserEnergyRecord.setAppUserId(userId);
                    appUserEnergyRecord.setChangeType(1);
                    appUserEnergyRecord.setEnergyValue(10);
                    appUserEnergyRecord.setReason("完成【每日疗愈30分钟】任务");
                    appUserEnergyRecordService.save(appUserEnergyRecord);
                    byId.setTotalEnergyValue(byId.getTotalEnergyValue() + 10);
                    one.setTaskOne(1);
                    byId.setEnergyValue(byId.getEnergyValue() + 10);
                }
            } else {
                one.setTaskOne(2);
                one.setTaskTwo(2);
            }
            appUserTreeService.updateById(one);
            appUserService.updateById(byId);
            return R.ok();
        }
    }

    @Resource
    private AppUserEnergyRecordService appUserEnergyRecordService;

    @PostMapping("/saveCourseStudyHistory")
    @ApiOperation(value = "记录用户观看课程记录", tags = {"用户端-用户相关接口"})
    @ApiImplicitParams({
            @ApiImplicitParam(name = "chapterId", value = "章节id", dataType = "Long", required = true),
            @ApiImplicitParam(name = "isOver", value = "是否观看完成 1是2否", dataType = "int", required = true),
            @ApiImplicitParam(name = "minuteLook", value = "观看到xx分钟", dataType = "int", required = true),
            @ApiImplicitParam(name = "secondLook", value = "观看到xx秒", dataType = "int", required = true),
    })
    public R<?> saveCourseStudyHistory(@RequestParam("chapterId") Long chapterId,
                                       @RequestParam("minuteLook") Integer minuteLook,
                                       @RequestParam("secondLook") Integer secondLook,
                                       @RequestParam("isOver") Integer isOver
    ) {
        LoginUser loginUser = tokenService.getLoginUser();
        if (loginUser == null) {
            return R.tokenError("登录失效");
        }
        Long userId = loginUser.getUserid();
        AppUserViewingHistory one = appUserViewingHistoryService.lambdaQuery()
                .eq(AppUserViewingHistory::getAppUserId, userId)
                .eq(AppUserViewingHistory::getViewingType, 2)
                .eq(AppUserViewingHistory::getChapterId, chapterId).one();
        if (one != null) {
            if (one.getIsOver() == 1) {
                // 如果已经看完了 那么不更新状态 只更新观看时间
                one.setMinuteLook(minuteLook);
                one.setSecondLook(secondLook);
                one.setTimeLook(secondLook);
            } else {
                one.setIsOver(isOver);
            }
            appUserViewingHistoryService.updateById(one);
        } else {
            AppUserViewingHistory appUserViewingHistory = new AppUserViewingHistory();
            appUserViewingHistory.setAppUserId(userId);
            appUserViewingHistory.setBizId(chapterId);
            appUserViewingHistory.setViewingType(2);
            appUserViewingHistory.setMinuteLook(minuteLook);
            appUserViewingHistory.setSecondLook(secondLook);
            appUserViewingHistory.setChapterId(chapterId);
            appUserViewingHistory.setIsOver(isOver);
            appUserViewingHistory.setTimeLook(secondLook);

            appUserViewingHistoryService.save(appUserViewingHistory);
        }
        return R.ok();
    }

    @PostMapping("/getCourseStudyHistory")
    public R<AppUserViewingHistory> getCourseStudyHistory(@RequestParam("chapterId") Long chapterId) {
        LoginUser loginUser = tokenService.getLoginUser();
        if (loginUser == null) {
            return R.tokenError("登录失效");
        }
        Long userId = loginUser.getUserid();
        AppUserViewingHistory one = appUserViewingHistoryService.lambdaQuery()
                .eq(AppUserViewingHistory::getAppUserId, userId)
                .eq(AppUserViewingHistory::getViewingType, 2)
                .eq(AppUserViewingHistory::getChapterId, chapterId).one();
        if (one == null) {
            AppUserViewingHistory appUserViewingHistory = new AppUserViewingHistory();
            appUserViewingHistory.setAppUserId(userId);
            appUserViewingHistory.setBizId(chapterId);
            appUserViewingHistory.setViewingType(2);
            appUserViewingHistory.setMinuteLook(0);
            appUserViewingHistory.setSecondLook(0);
            appUserViewingHistory.setChapterId(chapterId);
            appUserViewingHistory.setIsOver(2);
            appUserViewingHistoryService.save(appUserViewingHistory);
            return R.ok(appUserViewingHistory);
        }
        return R.ok(one);
    }

//    @PostMapping("/studyRecord")
//    @ApiOperation(value = "学习页面记录观看到xx分钟xx秒")
//    @ApiImplicitParams({
//            @ApiImplicitParam(value = "章节id", name = "chapterId", required = true, dataType = "String"),
//            @ApiImplicitParam(value = "上次观看到xx分钟", name = "minuteLook", required = true, dataType = "Integer"),
//            @ApiImplicitParam(value = "上次观看到xx秒", name = "secondLook", required = true, dataType = "Integer"),
//            @ApiImplicitParam(value = "是否观看完成", name = "isOver", required = true, dataType = "Integer"),
//    })
//    public R studyRecord(@RequestParam(value = "chapterId")Long chapterId,
//                                                 @RequestParam(value = "minuteLook") Integer minuteLook,
//                                                 @RequestParam(value = "secondLook") Integer secondLook,
//                                                 @RequestParam(value = "isOver") Integer isOver
//    ) {
//        Long userId = tokenService.getLoginUser().getUserid();
//        if(userId ==null || userId == 0)return R.tokenError("登录失效");
//        AppUserViewingHistory one = appUserViewingHistoryService.lambdaQuery()
//                .eq(AppUserViewingHistory::getAppUserId, userId)
//                .eq(AppUserViewingHistory::getViewingType, 2)
//                .eq(AppUserViewingHistory::getChapterId, chapterId).one();
//        if (one!=null){
//            if (one.getIsOver() == 1){
//                // 如果已经看完了 那么不更新状态 只更新观看时间
//                one.setMinuteLook(minuteLook);
//                one.setSecondLook(secondLook);
//            }else{
//                one.setIsOver(isOver);
//            }
//            appUserViewingHistoryService.updateById(one);
//        }else{
//            AppUserViewingHistory appUserViewingHistory = new AppUserViewingHistory();
//            appUserViewingHistory.setAppUserId(userId);
//            appUserViewingHistory.setBizId(chapterId);
//            appUserViewingHistory.setViewingType(2);
//            appUserViewingHistory.setMinuteLook(minuteLook);
//            appUserViewingHistory.setSecondLook(secondLook);
//            appUserViewingHistory.setChapterId(chapterId);
//            appUserViewingHistory.setIsOver(isOver);
//            appUserViewingHistoryService.save(appUserViewingHistory);
//        }
//        return R.ok();
//    }
}