package com.qxueyou.scc.admin.classes.service.impl;

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.querydsl.core.QueryResults;
import com.querydsl.core.types.Order;
import com.querydsl.core.types.OrderSpecifier;
import com.querydsl.jpa.impl.JPAQuery;
import com.qxueyou.scc.admin.classes.model.ClsSubjectChapter;
import com.qxueyou.scc.admin.classes.model.ClsSubjectLecture;
import com.qxueyou.scc.admin.classes.service.IClassLectureService;
import com.qxueyou.scc.admin.progress.dao.ProgressDAO;
import com.qxueyou.scc.admin.progress.model.Progress;
import com.qxueyou.scc.admin.progress.model.QProgress;
import com.qxueyou.scc.admin.progress.model.view.SubjectProgressTreeV;
import com.qxueyou.scc.admin.progress.service.IProgressService;
import com.qxueyou.scc.base.model.Pager;
import com.qxueyou.scc.base.model.Result;
import com.qxueyou.scc.base.service.impl.CommonAppService;
import com.qxueyou.scc.base.util.ClientUtils;
import com.qxueyou.scc.base.util.CollectionUtils;
import com.qxueyou.scc.base.util.QBeanUtils;
import com.qxueyou.scc.base.util.QueryDslOptionBuilder;
import com.qxueyou.scc.base.util.TraceUtils;
import com.qxueyou.scc.msg.model.MsgInfo;
import com.qxueyou.scc.msg.service.IMsgInfoService;
import com.qxueyou.scc.school.model.SchHandout;
import com.qxueyou.scc.teach.res.model.Res;
import com.qxueyou.scc.teach.res.model.ResItemDoc;
import com.qxueyou.scc.teach.res.service.IResService;
import com.qxueyou.scc.teach.subject.model.QSubjectLecture;
import com.qxueyou.scc.teach.subject.model.Subject;
import com.qxueyou.scc.teach.subject.model.SubjectChapter;
import com.qxueyou.scc.teach.subject.model.SubjectLecture;
import com.qxueyou.scc.teach.subject.model.view.MyLectureV;
import com.qxueyou.scc.teach.subject.model.view.QMyLectureV;
import com.qxueyou.scc.teach.subject.service.ILectureService;
import com.qxueyou.scc.teach.subject.service.ISubjectService;

@Service
public class ClassLectureService extends CommonAppService implements IClassLectureService {

	private final Logger log = LogManager.getLogger(ClassLectureService.class);

    @Autowired
    IResService resService;

    @Autowired
    ILectureService lectureService;

    @Autowired
    IProgressService progressService;

    @Autowired
    ISubjectService subjectService;

    @Autowired
    ProgressDAO progressDao;

	@Autowired
	IMsgInfoService msgInfoService;

    @Override
    public Result addChapter(String parentChapterId, String name) {

        ClsSubjectChapter parent = read(ClsSubjectChapter.class, parentChapterId);

        ClsSubjectChapter chapter = new ClsSubjectChapter();

        TraceUtils.setCreateTrace(chapter);
        chapter.setName(name);
        chapter.setParentChapterId(parentChapterId);
        chapter.setSubjectId(parent.getSubjectId());
        chapter.setClassId(parent.getClassId());
        save(chapter);

        return new Result(true, "success",
                CollectionUtils.newObjectMap("id", chapter.getChapterId(), "name", chapter.getName()));

    }

    @Override
    public List<MyLectureV> listLectureV(String learnerId, String chapterId, String keyword, Integer pageSize,
                                         Integer pageNum, String type) {
        StringBuffer hql = new StringBuffer("from MyLectureV where subjectId=? and id.userId=?");
        List<Object> args = CollectionUtils.newList(chapterId, learnerId);
        List<MyLectureV> myLectureVList = findList(hql.toString(), new Pager(pageSize, pageNum), args, MyLectureV.class);

        if(myLectureVList.size() < 1){

        }else {
            hql = new StringBuffer("from MyLectureV where chapterId=? and id.userId=? order by lectureCreateTime desc");
            args = CollectionUtils.newList(myLectureVList.get(0).getChapterId(), learnerId);
        }

        if (StringUtils.isNotEmpty(type)) {
            hql.append(" and lectureType=?");
            args.add(type);
        }
        List<MyLectureV> result = findList(hql.toString(), new Pager(pageSize, pageNum), args, MyLectureV.class);
        return result;
    }

    /**
     * 课程课件
     *
     */
    @Override
    public Map<String,Object> listLectureBySubjectOrderCreateTime(String subjectId, String classId, String sort, Pager pager) {
    	Subject subject = this.read(Subject.class, subjectId);
    	if(Subject.TYPE_PUBLIC_SUBJECT == subject.getType()) {//公开课课件
    		return this.listOpenLectureBySubjectOrderCreateTime(subjectId, sort, pager);
    	}

    	QMyLectureV qMyLectureV = QMyLectureV.myLectureV;

    	OrderSpecifier<Date> order = "desc".equals(sort)?new OrderSpecifier<Date>(Order.DESC, qMyLectureV.lectureCreateTime):
			new OrderSpecifier<Date>(Order.ASC, qMyLectureV.lectureCreateTime);

    	JPAQuery<MyLectureV> query = this.getQueryFactory().selectFrom(qMyLectureV)
    		    .where(qMyLectureV.subjectId.eq(subjectId).
    		    		and(qMyLectureV.classId.eq(classId)).and(qMyLectureV.id.userId.eq(ClientUtils.getUserId())));

    	long count = query.fetchCount();

    	return CollectionUtils.newObjectMap("count", count, "listData", query.limit(pager.getPageSize()).offset(pager.getOffset())
    		    .orderBy(order)
    		    .fetch().stream()
    		    .map(tuple -> {
    		    	Map<String,Object> map = new HashMap<String,Object>();
    		    	map.put("lectureName", tuple.getLectureName());
    		    	map.put("chapterId", tuple.getChapterId());
    		    	map.put("lectureType", tuple.getLectureType());
    		    	map.put("progressPercent", tuple.getPercent());
    		    	map.put("lectureId", tuple.getId().getLectureId());
    		    	map.put("createTime", tuple.getLectureCreateTime());
    		    	return map;
    		    }).collect(Collectors.toList()));
    }

    /**
	 * 公开课课件
	 *
	 * @param subjectId
	 * @param sort
	 * @param pager
	 * @return
	 */
    @Override
    public Map<String,Object> listOpenLectureBySubjectOrderCreateTime(String subjectId, String sort, Pager pager) {
    	QSubjectLecture qSubjectLecture = QSubjectLecture.subjectLecture;
    	QProgress qProgress = QProgress.progress;

    	OrderSpecifier<Date> order = "desc".equals(sort)?new OrderSpecifier<Date>(Order.DESC, qSubjectLecture.createTime):
			new OrderSpecifier<Date>(Order.ASC, qSubjectLecture.createTime);

    	JPAQuery<SubjectLecture> query = this.getQueryFactory().selectFrom(qSubjectLecture).where(qSubjectLecture.subjectId.eq(subjectId).and(qSubjectLecture.deleteFlag.isFalse()).and(qSubjectLecture.status.eq(SubjectLecture.STATUS_DRAFT)));

    	long count = query.fetchCount();

    	return CollectionUtils.newObjectMap("count", count, "listData", query.limit(pager.getPageSize()).offset(pager.getOffset())
    		    .orderBy(order)
    		    .fetch().stream()
    		    .map(tuple -> {
    		    	Map<String,Object> map = new HashMap<String,Object>();
    		    	map.put("lectureName", tuple.getName());
    		    	map.put("chapterId", tuple.getChapterId());
    		    	map.put("lectureType", tuple.getLectureType());
    		    	map.put("progressPercent", this.getQueryFactory().select(qProgress.progressPercent).from(qProgress).where(
							qProgress.deleteFlag.isFalse().and(qProgress.targetId.eq(tuple.getLectureId())
									.and(qProgress.learnerId.eq(ClientUtils.getUserId())))).fetchFirst());
    		    	map.put("lectureId", tuple.getLectureId());
    		    	map.put("createTime", tuple.getCreateTime());
    		    	return map;
    		    }).collect(Collectors.toList()));
    }

    @Override
    public Result updateChapter(String chapterId, String name) {

        ClsSubjectChapter chapter = read(ClsSubjectChapter.class, chapterId);
        TraceUtils.setUpdateTrace(chapter);
        chapter.setName(name);
        save(chapter);
        return new Result(true, "success", CollectionUtils.newObjectMap("id", chapter.getChapterId(), "name", name));
    }

    @Override
    public Result deleteChapter(String[] chapterIds) {
        for (String chapterId : chapterIds) {
            deleteChapter(chapterId);
        }
        return new Result(true, "success");
    }

    /**
     * 删除单个章节
     *
     * @param chapterId 章节id
     * @return
     */
    private Result deleteChapter(String chapterId) {

        ClsSubjectChapter chapter = read(ClsSubjectChapter.class, chapterId);

        TraceUtils.setUpdateTrace(chapter);
        chapter.setDeleteFlag(true);
        save(chapter);
        Result result = deleteCourseware4Chapter(chapterId);
        if (!result.isSuccess()) {
            return result;
        }
        return new Result(true, "success");
    }

    @Override
    public Result addClsLecture(String chapterId, String resId) {
        ClsSubjectChapter chapter = read(ClsSubjectChapter.class, chapterId);

        Res res = resService.read(resId);
        ClsSubjectLecture lecture = new ClsSubjectLecture();
        TraceUtils.setCreateTrace(lecture);
        lecture.setChapterId(chapterId);
        lecture.setLectureType(res.getType());
        lecture.setName(res.getName());
        lecture.setRemark(res.getRemark());
        lecture.setSubjectId(chapter.getSubjectId());
        lecture.setResItemId(res.getResId());
        lecture.setClassId(chapter.getClassId());
        lecture.setStatus(res.getStatus());
        save(lecture);

        // 发送消息
        doPublishMsg(lecture);

        return new Result(true, "success");
    }

    //添加课程，发送消息
    private void doPublishMsg(ClsSubjectLecture lecture){
    	Subject subject = this.read(Subject.class, lecture.getSubjectId());

    	if(!subject.getStatus().equals(Subject.STATUS_ISSUED)){
    		return ;
    	}

		//查询直播关联的班级
		String hql = "select userId from StuStudent  where classId =:classId and deleteFlag is false ";

		List<String> lstUserIds = this.findByComplexHql(hql, CollectionUtils.newObjectMap("classId",lecture.getClassId()), String.class);

		if(lstUserIds!=null && lstUserIds.size()>0){
			Map<String,String> attrs = CollectionUtils.newStringMap("lectureId",lecture.getLectureId(),"lectureName",lecture.getName(),"subjectId",subject.getSubjectId(),
					"lectureType",lecture.getLectureType(),"subjectName",subject.getName());

			msgInfoService.doSendTextMsgToUsers(lstUserIds.toArray(new String[lstUserIds.size()]),MsgInfo.TYPE_COURSEWARE,"发布了课件",attrs);
		}
	}

    public Result updateLecturetime(String targetId) {

        ClsSubjectLecture lecture = read(ClsSubjectLecture.class, targetId);
        if(lecture == null){
            SubjectLecture lecture1 = read(SubjectLecture.class,targetId);
            TraceUtils.setUpdateTrace(lecture1);

            lecture1.setUpdateTime(new Date());
            lecture1.setUpdator(ClientUtils.getUserId());
            save(lecture1);
        }else {
            TraceUtils.setUpdateTrace(lecture);

            lecture.setUpdateTime(new Date());
            lecture.setUpdator(ClientUtils.getUserId());
            save(lecture);
        }

        return new Result(true, "success");
    }
    @Override
    public Result updateLecture(String lectureId, String resId) {

        ClsSubjectLecture lecture = read(ClsSubjectLecture.class, lectureId);

        Res res = resService.read(resId);

        TraceUtils.setUpdateTrace(lecture);
        lecture.setLectureType(res.getType());
        lecture.setName(res.getName());
        lecture.setRemark(res.getRemark());
        lecture.setResItemId(res.getResId());

        save(lecture);

        return new Result(true, "success");
    }

    @Override
    public Result deleteLecture(String[] lectureIds) {
        for (String lectureId : lectureIds) {
            deleteLecture(lectureId);
        }

        return new Result(true, "success");
    }

    /**
     * @param lectureId 课件id
     * @return
     */
    private Result deleteLecture(String lectureId) {
        ClsSubjectLecture lecture = read(ClsSubjectLecture.class, lectureId);

        TraceUtils.setUpdateTrace(lecture);
        lecture.setDeleteFlag(true);
        save(lecture);
        deleteProgress(lectureId);// 删除对应的进度
        return new Result(true, "success");
    }

    /**
     *
     */
    private Result deleteProgress(String targetId) {
        String hql = "update Progress set deleteFlag = true where deleteFlag is  false and targetId = ?";
        bulkUpdate(hql, new String[]{targetId});
        return new Result(true);
    }

    @Override
    public Result doCopyLecture(String lectureId, String destChapterId, String name) {

        return null;
    }

    @Override
    public Result doMoveLecture(String lectureId, String destChapterId, String name) {

        return null;
    }

    @Override
    public List<ClsSubjectLecture> listLecture(String chapterId, String keyword, Integer pageSize, Integer pageNum,
                                               String type, String classId) {
        StringBuffer hql = new StringBuffer("from ClsSubjectLecture where chapterId = ? and deleteFlag is false");

        List<Object> args = CollectionUtils.newList(chapterId);

        if (StringUtils.isNotEmpty(type)) {
            hql.append(" and lectureType=? order by createTime desc");
            args.add(type);
        } else {
            hql.append(" order by createTime desc");
        }

        List<ClsSubjectLecture> result = findList(hql.toString(), new Pager(pageSize, pageNum), args,
                ClsSubjectLecture.class);

        return result;
    }

    @Override
    public List<Map<String, Object>> listLectureBySubject(String subjectId, String type, String classId) {
        StringBuffer hql = new StringBuffer("select name as lectureName, "
        		+ " lectureId as lectureId, "
        		+ " lectureType as lectureType, "
        		+ " chapterId as chapterId, "
        		+ " status as status, "
        		+ " updateTime as updateTime "
        		+ " from ClsSubjectLecture where subjectId = :subjectId and classId = :classId and deleteFlag is false and status = :status");

        Map<String, Object> args = CollectionUtils.newObjectMap("subjectId", subjectId, "classId", classId, "status", Res.STATUS_DRAFT);

        if (StringUtils.isNotEmpty(type)) {
            hql.append(" and lectureType= :lectureType");
            args.put("lectureType", type);
        }
        hql.append(" order by createTime desc");

        return this.findListWithMapByHql(hql.toString(), args);
    }


    @Override
    public List<Map<String, Object>> listStuLectureBySubject(String subjectId, String classId) {
    	if(StringUtils.isEmpty(subjectId) || StringUtils.isEmpty(classId)) {
    		return new ArrayList<>();
    	}
    	QMyLectureV qMyLectureV = QMyLectureV.myLectureV;

		return this.getQueryFactory().selectFrom(qMyLectureV)
				.where(qMyLectureV.classId.eq(classId).and(
						qMyLectureV.subjectId.eq(subjectId).and(qMyLectureV.id.userId.eq(ClientUtils.getUserId()))))
				.orderBy(qMyLectureV.lectureCreateTime.desc()).fetch().stream().map(tuple -> {
					Map<String, Object> map = new HashMap<String, Object>(6);
					map.put("lectureName", tuple.getLectureName());
					map.put("lectureId", tuple.getId().getLectureId());
					map.put("lectureType", tuple.getLectureType());
					map.put("chapterId", tuple.getChapterId());
					map.put("subjectId", tuple.getSubjectId());
					map.put("progressPercent", tuple.getPercent());
					map.put("createTime", tuple.getLectureCreateTime());
					return map;
				}).collect(Collectors.toList());
    }

    /**
     * 我的公开课课件查询
     *
     * @param subjectId
     * @return
     */
    public List<Map<String, Object>> listStuLectureByOpenSubject(String subjectId) {
    	QSubjectLecture qSubjectLecture = QSubjectLecture.subjectLecture;
    	QProgress qProgress = QProgress.progress;
		return this.getQueryFactory().selectFrom(qSubjectLecture)
				.where(qSubjectLecture.subjectId.eq(subjectId).and(qSubjectLecture.status.eq(SubjectLecture.STATUS_DRAFT)).and(qSubjectLecture.deleteFlag.isFalse()))
				.orderBy(qSubjectLecture.createTime.desc()).fetch().stream().map(tuple -> {
					Map<String, Object> map = new HashMap<String, Object>(6);
					map.put("lectureName", tuple.getName());
					map.put("lectureId", tuple.getLectureId());
					map.put("lectureType", tuple.getLectureType());
					map.put("chapterId", tuple.getChapterId());
					map.put("subjectId", tuple.getSubjectId());
					map.put("progressPercent",
							this.getQueryFactory().select(qProgress.progressPercent).from(qProgress).where(
									qProgress.deleteFlag.isFalse().and(qProgress.targetId.eq(tuple.getLectureId())
											.and(qProgress.learnerId.eq(ClientUtils.getUserId())))).fetchFirst());
					map.put("createTime", tuple.getCreateTime());
					map.put("updateTime", tuple.getUpdateTime());
					return map;
				}).collect(Collectors.toList());
    }

    /**
     * 查询数量
     *
     * @param subjectId
     * @param classId
     * @return
     */
    @Override
    public long stuLectureCountBySubject(String subjectId, String classId) {
    	QMyLectureV qMyLectureV = QMyLectureV.myLectureV;

		return this.getQueryFactory().selectFrom(qMyLectureV)
				.where(qMyLectureV.classId.eq(classId).and(
						qMyLectureV.subjectId.eq(subjectId).and(qMyLectureV.id.userId.eq(ClientUtils.getUserId())))).fetchCount();
    }

    @Override
    public Result readLectureAccessPath(String lectureId, String attribute) {
        ClsSubjectLecture lecture = read(ClsSubjectLecture.class, lectureId);
		String resItemId = null;
		if(lecture == null) {
			resItemId = read(SubjectLecture.class, lectureId).getResItemId();//班级课件
		}else {
			resItemId = lecture.getResItemId();
		}
        return resService.readAccessPath(resItemId, attribute);
    }

    @Override
    public ClsSubjectLecture readClsLecture(String id) {

        return read(ClsSubjectLecture.class, id);
    }

    @Override
    public ClsSubjectChapter readChapter(String chapterId) {

        return read(ClsSubjectChapter.class, chapterId);
    }

    @Override
    public int listLectureCount(String chapterId, String keyword, String type) {
        String hql = "from ClsSubjectLecture where deleteFlag is false and chapterId =:chapterId ";
        Map<String, Object> args = CollectionUtils.newObjectMap("chapterId", chapterId);
        if (StringUtils.isNotBlank(type)) {
            hql = hql.concat(" and lectureType =:type");
            args.put("type", type);
        }
        int count = findCountByComplexHql(hql, args);
        return count;
    }

    @Override
    public List<ClsSubjectChapter> getListChapter(String classId, String subjectId, String parentChapterId) {

        StringBuffer hql = new StringBuffer(
                "from ClsSubjectChapter where classId=? and subjectId=? and deleteFlag is false ");

        List<Object> args = CollectionUtils.newList(classId,subjectId);

        if (StringUtils.isNotEmpty(parentChapterId)) {
        	hql = hql.append(" and parentChapterId=? ");
            args.add(parentChapterId);
        }

        List<ClsSubjectChapter> result = find(hql.toString(), args, ClsSubjectChapter.class);

        return result;
    }

    public List<SubjectChapter> getListOpenChapter(String subjectId) {

        StringBuffer hql = new StringBuffer(
                "from SubjectChapter where subjectId=? and deleteFlag is false ");

        List<Object> args = CollectionUtils.newList(subjectId);

        return find(hql.toString(), args, SubjectChapter.class);
    }

    @Override
    public List<ClsSubjectChapter> doGetListChapter(String classId,String subjectId, String parentChapterId) {

        List<ClsSubjectChapter> result = getListChapter(classId,subjectId, StringUtils.isEmpty(parentChapterId)?ClsSubjectChapter.ROOT_CHAPTER_ID:parentChapterId);

        return result;
    }

    @Override
    public Result doClearLecturesToClass( String classId,String subjectId) {
    	this.bulkUpdate("update ClsSubjectLecture set deleteFlag = true where classId=? and  subjectId = ? ",
                   new String[]{classId,subjectId});

    	this.bulkUpdate("update ClsSubjectChapter set deleteFlag = true where classId=? and  subjectId = ? ",
                new String[]{classId,subjectId});

        return new Result(true);
    }

    @Override
    public Result doCopyLecturesToClass(String origSubjectId, String subjectId, String classId) {
        Map<String, String> subjectIdMap = CollectionUtils.newStringMap(SubjectChapter.ROOT_CHAPTER_ID,
                SubjectChapter.ROOT_CHAPTER_ID);

        List<SubjectChapter> chapterLst = lectureService.getAllChapterBySubjectId(origSubjectId);
        ClsSubjectChapter clsChapter = null;

        for (SubjectChapter subjectChapter : chapterLst) {
            clsChapter = new ClsSubjectChapter();
            clsChapter.setClassId(classId);
            clsChapter.setName(subjectChapter.getName());
            clsChapter.setOrderNum(subjectChapter.getOrderNum());
            clsChapter.setParentChapterId(subjectIdMap.get(subjectChapter.getParentChapterId()));
            clsChapter.setSubjectId(subjectId);
            TraceUtils.setCreateTrace(clsChapter);
            clsChapter.setCreateTime(subjectChapter.getCreateTime());
            save(clsChapter);
            subjectIdMap.put(subjectChapter.getChapterId(), clsChapter.getChapterId());
        }

        List<SubjectLecture> lectureLst = lectureService.listLectureBySubjectId(origSubjectId);
        ClsSubjectLecture clsLecture = null;
        for (SubjectLecture lecture : lectureLst) {
            clsLecture = new ClsSubjectLecture();
            clsLecture.setChapterId(subjectIdMap.get(lecture.getChapterId()));
            clsLecture.setClassId(classId);
            clsLecture.setLectureType(lecture.getLectureType());
            clsLecture.setName(lecture.getName());
            clsLecture.setRemark(lecture.getRemark());
            clsLecture.setResItemId(lecture.getResItemId());
            clsLecture.setSubjectId(subjectId);
            clsLecture.setDeleteFlag(false);
            clsLecture.setStatus(lecture.getStatus());
            TraceUtils.setCreateTrace(clsLecture);
            save(clsLecture);
        }

        return new Result(true);
    }

    @Override
    public Result doStudy(String clsLectureId, Double from, Double to) {
        return progressService.addProgress(Progress.PROGRESS_TYPE_LECTURE, clsLectureId, from.intValue(), to.intValue(),
                ClientUtils.getUserId());
    }

    @Override
    public List<ClsSubjectLecture> listLecture(String subjectId) {

        StringBuffer hql = new StringBuffer("from ClsSubjectLecture where subjectId = ? and deleteFlag is false");

        List<Object> args = CollectionUtils.newList(subjectId);

        return find(hql.toString(), args, ClsSubjectLecture.class);

    }

    @Override
    public Result listSubjectLecture(String classId, String sort, Pager pager) {
    	if(StringUtils.isEmpty(classId)) {
    		return new Result(false, "班级id不能为空");
    	}
    	QMyLectureV qMyLectureV = QMyLectureV.myLectureV;

    	OrderSpecifier<Date> order = "desc".equals(sort)?new OrderSpecifier<Date>(Order.DESC, qMyLectureV.lectureCreateTime):
			new OrderSpecifier<Date>(Order.ASC, qMyLectureV.lectureCreateTime);

    	JPAQuery<MyLectureV> query = this.getQueryFactory()
    			.selectFrom(qMyLectureV)
    			.where(new QueryDslOptionBuilder()
    					.and(qMyLectureV.classId::eq, classId).and(qMyLectureV.id.userId::eq,ClientUtils.getUserId())
    					.build()
    					);

    	long count = query.fetchCount();

    	// 获取查询结果集合
		QueryResults<MyLectureV> results = query.limit(pager.getPageSize()).offset(pager.getOffset()).orderBy(order).fetchResults();

		List<Map<String,Object>> resultLst =
				results.getResults()
				.stream()
			    .map(tuple -> {
			    	Map<String,Object> map = new HashMap<String,Object>(8);
			    	map.put("lectureName", tuple.getLectureName());
			    	map.put("lectureId", tuple.getId().getLectureId());
			    	map.put("lectureType", tuple.getLectureType());
			    	map.put("chapterId", tuple.getChapterId());
			    	map.put("subjectName", tuple.getSubjectName());
			    	map.put("subjectId", tuple.getSubjectId());
			    	map.put("progressPercent", tuple.getPercent());
			    	map.put("createTime", tuple.getLectureCreateTime());
			    	return map;
			    }).collect(Collectors.toList());

        return new Result(true, "", CollectionUtils.newObjectMap("count", count, "listData", resultLst));

    }

    @Override
    public List<SubjectProgressTreeV> getChapterTreeVList(String subjectId, String parentChapterId) {

        if (parentChapterId == null) {
            return progressService.getSubjectChapterTreeVList(subjectId, ClientUtils.getUserId());
        }

        return progressService.getSubjectChapterTreeVList(parentChapterId, ClientUtils.getUserId());
    }

    /**
     * 删除对应的课件
     *
     * @param chapterId
     * @return
     */
    private Result deleteCourseware4Chapter(String chapterId) {

        this.bulkUpdate("update ClsSubjectLecture set deleteFlag = true where chapterId = ?",
                new String[]{chapterId});
        return new Result(true);

    }


    /**
     * 获取章节下的课件
     *
     * @param chapterLst
     * @param lectures
     * @return
     */
    public List<ClsSubjectChapter> getChapterLectures(List<ClsSubjectChapter> chapterLst, List<Map<String, Object>> lectures){
    	if (chapterLst != null && chapterLst.size() > 0 && lectures != null) {
			for (ClsSubjectChapter objClsSubjectChapter : chapterLst) {
				for (Map<String, Object> objClsSubjectLecture : lectures) {
					if (objClsSubjectChapter.getChapterId().equals(objClsSubjectLecture.get("chapterId"))) {
						objClsSubjectChapter.getLectures().add(objClsSubjectLecture);
					}
				}
			}

			this.getTopChapters(chapterLst);

			for (int i=chapterLst.size()-1;i>=0;i--) {
				ClsSubjectChapter objClsSubjectChapter = chapterLst.get(i);
				if(objClsSubjectChapter.getLectures() == null || objClsSubjectChapter.getLectures().isEmpty()) {
					chapterLst.remove(i);
				}
			}
		}

    	return chapterLst;
    }

    /**
     * 获取章节的第一层数据
     *
     * @param chapterLst
     * @return
     */
    private List<ClsSubjectChapter> getTopChapters(List<ClsSubjectChapter> chapterLst){
    	int count = 0;
    	if (chapterLst != null && chapterLst.size() > 0) {
    		for (int i=chapterLst.size()-1;i>=0;i--) {
				ClsSubjectChapter objClsSubjectChapter = chapterLst.get(i);
				for (ClsSubjectChapter objClsSubjectChapter2 : chapterLst) {
					if(StringUtils.isNotBlank(objClsSubjectChapter.getChapterId()) && !ClsSubjectChapter.ROOT_CHAPTER_ID.equals(objClsSubjectChapter.getParentChapterId())
							&& objClsSubjectChapter.getChapterId().equals(objClsSubjectChapter2.getParentChapterId())
							&& objClsSubjectChapter2.getLectures() != null) {
						if(objClsSubjectChapter.getLectures() == null) {
							objClsSubjectChapter.setLectures(new ArrayList<Map<String,Object>>());
						}
						objClsSubjectChapter.getLectures().addAll(objClsSubjectChapter2.getLectures());
						count++;
						objClsSubjectChapter2.setLectures(null);
						break;
					}
				}
			}
    		if(count != 0) {
    			chapterLst = this.getTopChapters(chapterLst);
    		}
		}

    	return chapterLst;
    }


	@Override
	public int readDocPageCount(String resItemId) {
		ResItemDoc resItemDoc = read(ResItemDoc.class, resItemId);
		if (resItemDoc == null || ResItemDoc.STATUS_DRAFT != resItemDoc.getStatus()) {
			return 0;
		}
		SchHandout schHandout = read(SchHandout.class, resItemDoc.getHandoutId());

		if (schHandout == null) {
			return 0;
		}

		return schHandout.getPageCount();
	}

	 /**
     * 课件按目录分类
     *
     * @param classId
     * @param subjectId
     * @param type
     * @return
     */
    public Result coursewareChapterList(String classId,String subjectId, String type) {
    	Subject subject = this.read(Subject.class, subjectId);

    	if(Subject.TYPE_PUBLIC_SUBJECT == subject.getType() || Subject.TYPE_ORG_SUBJECT == subject.getType()) {//公开课和管理员课程
    		QSubjectLecture qSubjectLecture = QSubjectLecture.subjectLecture;
    		//课件
    		List<Map<String, Object>> lectures = this.listStuLectureByOpenSubject(subjectId);

    		List<SubjectChapter> lstSubjectChapterLst = this.getListOpenChapter(subjectId);
    		List<ClsSubjectChapter> lstClsSubjectChapter = new ArrayList<>();
    		if(lstSubjectChapterLst != null && !lstSubjectChapterLst.isEmpty()) {
    			ClsSubjectChapter objClsSubjectChapter = null;
    			for(SubjectChapter objSubjectChapter : lstSubjectChapterLst) {
    				objClsSubjectChapter = new ClsSubjectChapter();
    				try {
						BeanUtils.copyProperties(objClsSubjectChapter, objSubjectChapter);
					} catch (IllegalAccessException e) {
						log.error("拷贝属性失败BeanUtils.copyProperties(objClsSubjectChapter, objSubjectChapter)", e);
					} catch (InvocationTargetException e) {
						log.error("拷贝属性失败BeanUtils.copyProperties(objClsSubjectChapter, objSubjectChapter)", e);
					}

    				lstClsSubjectChapter.add(objClsSubjectChapter);
    			}
    		}
    		//章节
    		List<ClsSubjectChapter> chapterLst = this.getChapterLectures(lstClsSubjectChapter, lectures);

    		long count =  this.getQueryFactory().selectFrom(qSubjectLecture)
    				.where(qSubjectLecture.subjectId.eq(subjectId).and(qSubjectLecture.deleteFlag.isFalse()).
    						and(qSubjectLecture.status.eq(SubjectLecture.STATUS_DRAFT))).fetchCount();

    		return new Result(true, "success", CollectionUtils.newObjectMap("count",count, "listData", QBeanUtils.listBean2ListMap(chapterLst,
    				CollectionUtils.newStringMap("name", "name", "chapterId", "chapterId", "lectures", "lectures"))));

    	}else{
    		//课件
    		List<Map<String, Object>> lectures = this.listStuLectureBySubject(subjectId, classId);
    		//章节
    		List<ClsSubjectChapter> chapterLst = this.getChapterLectures(this.getListChapter(classId, subjectId, null), lectures);

    		return new Result(true, "success", CollectionUtils.newObjectMap("count",this.stuLectureCountBySubject(subjectId, classId), "listData", QBeanUtils.listBean2ListMap(chapterLst,
    				CollectionUtils.newStringMap("name", "name", "chapterId", "chapterId", "lectures", "lectures"))));
    	}
    }

}