package com.qxueyou.scc.evaluate.service.impl;

import java.math.BigDecimal;
import java.math.BigInteger;
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.Tuple;
import com.querydsl.core.types.Predicate;
import com.qxueyou.scc.admin.classes.model.QClsClass;
import com.qxueyou.scc.admin.classes.model.QClsClassReSubject;
import com.qxueyou.scc.admin.teacher.service.ITeacherService;
import com.qxueyou.scc.base.model.Pager;
import com.qxueyou.scc.base.model.Result;
import com.qxueyou.scc.base.model.ResultJson;
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.QueryDslOptionBuilder;
import com.qxueyou.scc.base.util.TraceUtils;
import com.qxueyou.scc.evaluate.dao.EvaluateRepository;
import com.qxueyou.scc.evaluate.service.IEvaluateService;
import com.qxueyou.scc.evaluate.service.IEvaluateTemplateService;
import com.qxueyou.scc.exercise.model.ExerciseGroup;
import com.qxueyou.scc.exercise.model.ExerciseItem;
import com.qxueyou.scc.exercise.model.ExerciseItemAnswerU;
import com.qxueyou.scc.exercise.model.ExerciseItemOption;
import com.qxueyou.scc.exercise.model.ExerciseItemScore;
import com.qxueyou.scc.exercise.model.ExerciseObjectImg;
import com.qxueyou.scc.exercise.model.ExerciseRecord;
import com.qxueyou.scc.exercise.model.QExerciseGroup;
import com.qxueyou.scc.exercise.model.QExerciseItemAnswerU;
import com.qxueyou.scc.exercise.model.QExerciseRecord;
import com.qxueyou.scc.exercise.service.IExerciseService;
import com.qxueyou.scc.exercise.util.ExerciseUtils;
import com.qxueyou.scc.msg.model.MsgInfo;
import com.qxueyou.scc.msg.service.IMsgInfoService;
import com.qxueyou.scc.school.model.EvaluateStuStudentV;
import com.qxueyou.scc.school.model.QEvaluateStuStudentV;
import com.qxueyou.scc.school.model.QSchEvaRecordRe;
import com.qxueyou.scc.school.model.QSchEvaluate;
import com.qxueyou.scc.school.model.QSchEvaluateTemplate;
import com.qxueyou.scc.school.model.SchEvaRecordRe;
import com.qxueyou.scc.school.model.SchEvaluate;
import com.qxueyou.scc.school.model.SchEvaluateDetail;
import com.qxueyou.scc.school.model.SchEvaluateTemplate;
import com.qxueyou.scc.school.model.TeachEvaScoreData;
import com.qxueyou.scc.school.model.TeachEvaScoreResult;
import com.qxueyou.scc.teach.student.model.QStuStudent;
import com.qxueyou.scc.teach.student.model.StuStudent;
import com.qxueyou.scc.teach.subject.model.QSubject;
import com.qxueyou.scc.teach.subject.model.Subject;
import com.qxueyou.scc.user.model.QUser;

@Service
public class EvaluateService extends CommonAppService implements IEvaluateService {
	
	private final Logger log = LogManager.getLogger(EvaluateService.class);
	
	@Autowired
	EvaluateRepository evaRepository;
	
	@Autowired
	IEvaluateTemplateService templateService;
	
	@Autowired
	ITeacherService teacherService;
	
	@Autowired
	IExerciseService exerciseService;
	
	@Autowired
	IMsgInfoService msgInfoService;

	/**
	 * ²éѯÁбíÊý¾Ý
	 * @param pageNum
	 * @param pageSize
	 * @return
	 */
	@Override
	public ResultJson queryList(Integer pageNum, Integer pageSize, String keyword, String sort) {
		
		QSchEvaluate qEva = QSchEvaluate.schEvaluate;
		QSchEvaluateTemplate template = QSchEvaluateTemplate.schEvaluateTemplate;
		QExerciseGroup group = QExerciseGroup.exerciseGroup;
		QSubject subject = QSubject.subject;
		
		// ËÑË÷Ãû
		keyword = StringUtils.isBlank(keyword) ? null : "%"+keyword+"%";
		
		// »ñÈ¡²éѯ½á¹û¼¯ºÏ
		QueryResults<Tuple> results = this.getQueryFactory()
			.select(qEva, group,subject)
			.from(qEva, template, group,subject)
			.where(new QueryDslOptionBuilder()
					.and(qEva.evalTemplateId::eq, template.evaluateTemplateId)
					.and(template.groupId::eq,group.groupId)
					.and(qEva.evalRangeId::eq,subject.subjectId)
					.and(qEva.createId::eq,ClientUtils.getUserId())
					.and(qEva.evaluateName::like, keyword)
					.and(qEva.deleteFlag::eq,false)
					.build()
					)
			.orderBy(qEva.createTime.desc())
			.fetchResults();
		
		// ·â×°²ÎÊý
		List<Map<String,Object>> resultLst = 
				results.getResults()
				.stream()
			    .map(tuple -> {
			    	Map<String,Object> map = new HashMap<String,Object>(2);
			    	map.put("evaluateId", tuple.get(qEva).getEvaluateId());
			    	map.put("evaluateName", tuple.get(qEva).getEvaluateName());
			    	map.put("evalRangeId", tuple.get(qEva).getEvalRangeId());
			    	map.put("evalRangeType", tuple.get(qEva).getEvalRangeType());
			    	map.put("evalRangeName", tuple.get(subject).getName());
			    	map.put("evalRangeCount", tuple.get(qEva).getEvalRangeCount());
			    	map.put("evalObjectName", tuple.get(qEva).getEvalObjectName());
			    	map.put("status", tuple.get(qEva).getStatus());
			    	map.put("endTime", tuple.get(qEva).getEndTime());
			    	map.put("createTime", tuple.get(qEva).getCreateTime());
			    	map.put("groupId",  tuple.get(group).getGroupId());
			    	map.put("exerCount",  tuple.get(group).getAllCount());
			    	map.put("evaluateCount",  this.getEvaluateCount(tuple.get(qEva).getEvaluateId()));//ÒÑÆÀ¹ÀÈËÊý
			    	map.put("evaluateAllCount",  this
							.queryEvaluateAllCount(tuple.get(qEva).getEvalRangeType(), tuple.get(qEva).getEvalRangeId().split(",")));//Ó¦ÆÀ¹ÀÈËÊý
			    	return map;
			    }).collect(Collectors.toList());
		
		
		return new ResultJson(true, "success", 
				CollectionUtils.newObjectMap("allCount",results.getTotal(),"datas",resultLst));
	}

	/**
	 * »ñÈ¡·¶Î§Ñ¡Ôñ
	 * 
	 * type:   lesson:¿Î³Ì  class:°à¼¶     person:ÈËÔ±
	 * 
	 * @return
	 */
	@Override
	public ResultJson queryRangeList(String type,String searchName) {
		
		List<Tuple> tupleLst = null;
		// ËÑË÷Ãû
		searchName = StringUtils.isBlank(searchName) ? null : "%"+searchName+"%";
		
		if(ClientUtils.isAdmin()){// ¹ÜÀíÔ±
			
			tupleLst = getAdminRangeList(type,searchName);
		}else{// ÀÏʦ
			
			tupleLst = getTeacherRangeList(type,searchName);
		}
		
		// ͳһ´¦Àí·µ»ØÊý¾Ý
		List<Map<String,Object>> resultLst = tupleLst.stream()
			    .map(tuple -> {
			    	Map<String,Object> map = new HashMap<String,Object>(2);
			    	map.put("name", tuple.get(0, String.class));
			    	map.put("id",  tuple.get(1, String.class));
			    	return map;
			    }).collect(Collectors.toList());
		
		return new ResultJson(true, "success", resultLst);
	}

	/**
	 * »ñÈ¡¹ÜÀíÔ±·¶Î§Ñ¡Ôñ
	 * @param type
	 * @return
	 */
	private List<Tuple> getAdminRangeList(String type,String searchName){
		QSubject subject = QSubject.subject;
		QClsClass cls = QClsClass.clsClass;
		QUser user = QUser.user;
		List<Tuple> tupleLst = null;
		
		if(SchEvaluate.EVALUATE_RANGE_LESSON.equals(type)){//¿Î³Ì
			
			tupleLst = this.getQueryFactory().select(subject.name.as("name"),subject.subjectId.as("id")).distinct()
			    .from(subject)
			    .where(subject.type.eq(Subject.TYPE_ORG_SUBJECT)
						.and(subject.status.eq(Subject.STATUS_ISSUED))
						.and(subject.origSubjectId.isNull())
						.and(subject.deleteFlag.isFalse()))
			    .orderBy(subject.createTime.desc())
			    .fetch();
			
		}else if(SchEvaluate.EVALUATE_RANGE_CLASS.equals(type)){//°à¼¶
			
			tupleLst = this.getQueryFactory().select(cls.name.as("name"),cls.classId.as("id")).distinct()
				    .from(cls)
				    .where( new QueryDslOptionBuilder()
							.and(cls.name::like, searchName)
							.and(cls.deleteFlag::eq, false)
							.build())
				    .orderBy(cls.createTime.desc())
				    .fetch();
		}else if(SchEvaluate.EVALUATE_RANGE_PERSON.equals(type)){//ÈËÔ±
			QStuStudent stu = QStuStudent.stuStudent;

			tupleLst = this.getQueryFactory().select(user.name.as("name"),user.userId.as("id")).distinct()
				    .from(stu, user)
				    .where(new QueryDslOptionBuilder()
							.and(stu.name::like, searchName)
							.and(stu.deleteFlag::eq, false).and(user.userId::eq, stu.userId).and(user.deleteFlag::eq, false)
							.and(stu.status::eq, StuStudent.STATUS_ACTIVE)
							.build())
				    .orderBy(stu.createTime.desc())
				    .fetch();
		}
		
		return tupleLst;
	}
	
	/**
	 * 	»ñÈ¡ÀÏʦ·¶Î§Ñ¡Ôñ
	 * @param type
	 * @return
	 */
	private List<Tuple> getTeacherRangeList(String type,String searchName){
		QSubject subject = QSubject.subject;
		QClsClassReSubject re = QClsClassReSubject.clsClassReSubject;
		QClsClass cls = QClsClass.clsClass;
		
		List<Tuple> tupleLst = null;
		String teacherId =  teacherService.getTeacherIdByUserId(ClientUtils.getUserId());
		
		if(SchEvaluate.EVALUATE_RANGE_LESSON.equals(type)){//¿Î³Ì
			
			tupleLst = this.getQueryFactory().select(subject.name.as("name"),subject.subjectId.as("id")).distinct()
				    .from(subject)
				    .where(subject.createId.eq(ClientUtils.getUserId())
							.and(subject.type.eq(Subject.TYPE_ORG_SUBJECT))
							.and(subject.status.eq(Subject.STATUS_ISSUED))
							.and(subject.origSubjectId.isNull())
							.and(subject.deleteFlag.isFalse()))
				    .orderBy(subject.createTime.desc())
				    .fetch();
			
		}else if(SchEvaluate.EVALUATE_RANGE_CLASS.equals(type)){//°à¼¶
			
			tupleLst = this.getQueryFactory().select(cls.name.as("name"),cls.classId.as("id")).distinct()
				    .from(subject, re, cls)
				    .where(new QueryDslOptionBuilder()
							.and(subject.subjectId::eq, re.subjectId)
							.and(re.classId::eq, cls.classId)
							.and(subject.teacherId::eq, teacherId)
							.and(subject.name::like, searchName)
							.and(subject.status::eq, Subject.STATUS_ISSUED)
							.and(subject.deleteFlag::eq, false)
							.and(cls.deleteFlag::eq, false)
							.build()).groupBy(cls.classId)
				    .orderBy(subject.createTime.desc())
				    .fetch();
			
		}else if(SchEvaluate.EVALUATE_RANGE_PERSON.equals(type)){//ÈËÔ±
			QStuStudent stu = QStuStudent.stuStudent;
			
			tupleLst = this.getQueryFactory().select(stu.name.as("name"),stu.userId.as("id")).distinct()
				    .from(stu,cls,subject, re)
				    .where(new QueryDslOptionBuilder()
							.and(stu.classId::like, cls.classId)
							.and(stu.status::eq, StuStudent.STATUS_ACTIVE)
							.and(stu.name::like, searchName)
							.and(stu.deleteFlag::eq, false)
							.and(subject.subjectId::eq, re.subjectId)
							.and(re.classId::eq, cls.classId)
							.and(subject.teacherId::eq, teacherId)
							.and(subject.name::like, searchName)
							.and(subject.status::eq, Subject.STATUS_ISSUED)
							.and(subject.deleteFlag::eq, false)
							.and(cls.deleteFlag::eq, false)
							.build()
							).groupBy(stu.userId)
				    .orderBy(stu.createTime.desc())
				    .fetch();
		}
		
		return tupleLst;
	}

	/**
	 * ºǫ́ÐÂÔöÆÀ¹À
	 * @param eva
	 * @return
	 */
	@Override
	public ResultJson addOrUpdateEvaluate(SchEvaluate eva) {
		String evaluateId = eva.getEvaluateId();
		String groupId = null;
		if(StringUtils.isBlank(evaluateId)){// ÐÂÔö
			//1¡¢²åÈë×é
			ExerciseGroup obj = this.insertExerciseGroup(eva.getEvaluateName(),
					ExerciseGroup.TYPE_EXERCISE_TEACH_EVALUATE);
			
			//2¡¢²åÈëÆÀ¹ÀÄ£°å
			SchEvaluateTemplate objTemplate = new SchEvaluateTemplate();
			TraceUtils.setCreateTrace(objTemplate);
			objTemplate.setEvaluateTemplateName(eva.getEvaluateName());
			objTemplate.setGroup_name(obj.getName());
			objTemplate.setGroupId(obj.getGroupId());
			objTemplate.setOrgId(ClientUtils.getOrgId());
			objTemplate.setOrgName(ClientUtils.getOrgName());
			this.save(objTemplate);
			
			// 3¡¢²åÈëÆÀ¹À±í
			eva.setEvalTemplateId(objTemplate.getEvaluateTemplateId());
			eva.setEvalTemplateName(objTemplate.getEvaluateTemplateName());
			eva.setEvaluateCount(BigInteger.ZERO);
			eva.setScore(BigDecimal.ZERO);
			eva.setStatus((short)0);
			eva.setDeleteFlag(false);
			TraceUtils.setCreateTrace(eva);
			evaRepository.save(eva);
			
			evaluateId = eva.getEvaluateId();
			groupId = obj.getGroupId();
		}else{// ±à¼­
			SchEvaluate newEva = this.read(SchEvaluate.class, eva.getEvaluateId());
			
			newEva.setEvaluateName(eva.getEvaluateName());
			newEva.setEvalObjectName(eva.getEvalObjectName());
			newEva.setEndTime(eva.getEndTime());
			newEva.setEvalRangeType(eva.getEvalRangeType());
			newEva.setEvalRangeId(eva.getEvalRangeId());
			newEva.setEvalRangeName(eva.getEvalRangeName());
			TraceUtils.setUpdateTrace(newEva);
			evaRepository.save(newEva);
		}
		
		return new ResultJson(true, "success", CollectionUtils.newObjectMap("evaluateId", evaluateId, "groupId", groupId));
	}
	
	/**
	 * £ººǫ́ ²åÈëÆÀ¹ÀÄ£°åʱµ÷ÓÃ
	 * 
	 * @param name
	 * @param type
	 * @return
	 */
	public ExerciseGroup insertExerciseGroup(String name, short type) {

		ExerciseGroup obj = new ExerciseGroup();
		TraceUtils.setCreateTrace(obj);
		obj.setName(name);
		obj.setType(type);
		obj.setClassId(ClientUtils.getClassId());
		obj.setOrgId(ClientUtils.getOrgId());
		obj.setAllCount(BigInteger.ZERO);
		this.save(obj);

		// ±£´æ
		return obj;
	}

	/**
	 * ²éѯ»ù±¾ÐÅÏ¢
	 */
	@Override
	public ResultJson queryBaseInfo(String evaluateId) {
		
		SchEvaluate eva = evaRepository.getOne(evaluateId);
		QSchEvaluate qEva = QSchEvaluate.schEvaluate;
		QSchEvaluateTemplate template = QSchEvaluateTemplate.schEvaluateTemplate;
		QExerciseGroup group = QExerciseGroup.exerciseGroup;
		
		// »ñÈ¡²éѯ½á¹û¼¯ºÏ
		ExerciseGroup g = this.getQueryFactory()
			.select(group)
			.from(qEva, template, group)
			.where(new QueryDslOptionBuilder()
					.and(qEva.evalTemplateId::eq, template.evaluateTemplateId)
					.and(template.groupId::eq,group.groupId)
					.and(qEva.evaluateId::eq,evaluateId)
					.and(qEva.deleteFlag::eq,false)
					.build()
					)
			.fetchOne();
		
		return new ResultJson(true, "success", 
				CollectionUtils.newObjectMap("evaluateName",eva.getEvaluateName(),
					"evaluateId",eva.getEvaluateId(),
					"evalObjectName",eva.getEvalObjectName(),
					"endTime",eva.getEndTime(),
					"createTime",eva.getCreateTime(),
					"evalRangeType",eva.getEvalRangeType(),
					"evaluateCount",g.getAllCount(),
					"evalRangeId",eva.getEvalRangeId(),
					"evalRangeName",eva.getEvalRangeName()));
	}
	
	/**
	 * ɾ³ý
	 */
	@Override
	public ResultJson delete(String evaluateIds){
		QSchEvaluate qEva = QSchEvaluate.schEvaluate;
		
		this.getQueryFactory()
		.update(qEva)
		.set(qEva.deleteFlag, true)
		.where(qEva.evaluateId.in(evaluateIds.split(",")))
		.execute();
		
		return new ResultJson(true, "success");
	}
	
	/**
	 * ¼¤»î
	 */
	@Override
	public ResultJson doActive(String evaluateIds){
		
		QSchEvaluate qEva = QSchEvaluate.schEvaluate;
		
		 this.getQueryFactory()
		 .update(qEva)
		 .set(qEva.status, SchEvaluate.STATUS_EVA)
		 .where(qEva.evaluateId.in(evaluateIds.split(",")))
		 .execute();
		 
		if(StringUtils.isNotEmpty(evaluateIds)){
			String []  arrIds = evaluateIds.split(",");
			for(String evaluateId:arrIds){
				this.doSendhMsg(evaluateId);
			}
		}
		 
		return new ResultJson(true, "success");
	}
	
	//·¢²¼ÏûÏ¢
    private void doSendhMsg(String evaluateId){
    	SchEvaluate  evaluate = this.read(SchEvaluate.class,evaluateId);
    	
    	List<Map<String,Object>> lst=  this.queryNotAnswerEvaLst(evaluateId,  new ArrayList<String>(1));
    	
    	List<String> lstUserIds = null;
    	if(lst!=null && lst.size()>0){
    		lstUserIds = new ArrayList<String>(lst.size());
    		for(Map<String,Object> map:lst){
    			lstUserIds.add((String)map.get("userId"));
    		}
    		
    		Map<String,String> attrs = CollectionUtils.newStringMap("evaluateId",evaluate.getEvaluateId(),"evaluateName",evaluate.getEvaluateName(),
					"templateId",evaluate.getEvalTemplateId(),"evalRangeName",evaluate.getEvalRangeName(),"creator",evaluate.getCreator());
    		
    		msgInfoService.doSendTextMsgToUsersLoop(lstUserIds, MsgInfo.TYPE_EVALUATE, "·¢²¼ÁËÎʾíµ÷²é", attrs);
    	}
	}
	
	/**
	 *»ØÍË
	 */
	@Override
	public ResultJson doWithdraw(String evaluateIds){
		QSchEvaluate qEva = QSchEvaluate.schEvaluate;
		
		this.getQueryFactory()
		 .update(qEva)
		 .set(qEva.status, SchEvaluate.STATUS_NOT_EVA)
		 .where(qEva.evaluateId.in(evaluateIds.split(",")))
		 .execute();
		
		return new ResultJson(true, "success");
	}
	
	/**
	 * ¸´ÖÆ
	 */
	@Override
	public ResultJson doCopy(SchEvaluate eva){
		try {
			SchEvaluate schEva = evaRepository.getOne(eva.getEvaluateId());
			SchEvaluateTemplate oldTemplate = this.read(SchEvaluateTemplate.class, schEva.getEvalTemplateId());
			
			// 1¡¢Éú³ÉÏ°Ìâ×é
			String newGroupId = exerciseService.doCopyExerciseByEvaluate(oldTemplate.getGroupId());
			
			// 2¡¢Éú³ÉÄ£°å
			SchEvaluateTemplate newTemplate = new SchEvaluateTemplate();
			
			BeanUtils.copyProperties(newTemplate, oldTemplate);
			newTemplate.setEvaluateTemplateId(null);
			newTemplate.setGroupId(newGroupId);
			TraceUtils.setCreateTrace(newTemplate);
			this.save(newTemplate);
		
			// 3¡¢Éú³ÉÆÀ¹À±í
			SchEvaluate newEva = new SchEvaluate();
			BeanUtils.copyProperties(newEva, eva);
			newEva.setEvaluateId(null);
			newEva.setEvalTemplateId(newTemplate.getEvaluateTemplateId());
			newEva.setEvalTemplateName(newTemplate.getEvaluateTemplateName());
			newEva.setEvaluateCount(BigInteger.ZERO);
			newEva.setScore(BigDecimal.ZERO);
			newEva.setStatus((short)0);
			newEva.setDeleteFlag(false);
			TraceUtils.setCreateTrace(newEva);
			this.save(newEva);
			
			return new ResultJson(true, "success", CollectionUtils.newObjectMap("evaluateId", newEva.getEvaluateId(), "groupId", newGroupId));
			
		} catch (Exception e) {
			log.error("doCopyÆÀ¹À¸´ÖÆ£º¸´ÖÆÁ·Ï°BeanUtils.copyProperties()·½·¨copyʧ°Ü", e);
		}
		
		return new ResultJson(false);
	}
	
	/**
	 *  ²é¿´½á¹û  ÎʾíÕûÌåÇé¿ö
	 * @param evaluateId
	 * @param groupId
	 * @param evalRangeType
	 * @return
	 */
	@Override
	public ResultJson queryEvaluateDetail(String evaluateId,String groupId){
		
		// 1¡¢²éѯÒÑÌá½»Îʾílist
		List<Map<String, Object>> answerUserLst = queryAnswerEvaLst(evaluateId);
		
		// ÒѾ­´ðÌâ¹ýµÄѧԱid
		List<String> userAnswerList = new ArrayList<String>(answerUserLst.size());
		for(Map<String,Object> map:answerUserLst){
			userAnswerList.add(String.valueOf(map.get("userId")));
		}
		
		// 2¡¢²éѯδÌá½»´ð°¸list
		List<Map<String,Object>> notAnswerUserLst = this.queryNotAnswerEvaLst(evaluateId, userAnswerList);
		
		
		return new ResultJson(true, "success", 
				CollectionUtils.newObjectMap("answerUserLst",answerUserLst,
						"notAnswerUserLst",notAnswerUserLst));
	}

	/**
	 *  ²éѯÒÑ´ðÌâµÄѧԱlist
	 * @param evaluateId
	 * @return
	 */
	private List<Map<String, Object>> queryAnswerEvaLst(String evaluateId) {
		
		QExerciseRecord record = QExerciseRecord.exerciseRecord;
		QSchEvaRecordRe reEva = QSchEvaRecordRe.schEvaRecordRe;
		
		List<Map<String,Object>> answerUserLst = this.getQueryFactory()
				.select(record).from(record, reEva)
				.where(record.recordId.eq(reEva.exerciseRecordId)
					.and(reEva.evaluateId.eq(evaluateId))
					.and(record.deleteFlag.eq(false)))
				.orderBy(record.submitTime.desc())
				.fetch()
				.stream()
			    .map(tuple -> {
			    	Map<String,Object> map = new HashMap<String,Object>(4);
			    	map.put("recordId", tuple.getRecordId());
			    	map.put("userId", tuple.getUserId());
			    	map.put("userName", tuple.getUserName());
			    	map.put("submitTime", tuple.getSubmitTime());
			    	return map;
			    }).collect(Collectors.toList());
		
		return answerUserLst;
	}
	
	/**
	 * ²éѯδ´ðÌâµÄѧԱlist
	 * @param rangeType
	 * @param evalRangeIds
	 * @param userAnswerList
	 * @return
	 */
	private List<Map<String,Object>> queryNotAnswerEvaLst(String evaluateId,List<String> userAnswerList ){
		
		SchEvaluate eva = this.read(SchEvaluate.class, evaluateId);
		String[] evalRangeIds = eva.getEvalRangeId().split(",");
		String rangeType = eva.getEvalRangeType();
		
		QClsClassReSubject re = QClsClassReSubject.clsClassReSubject;
		QStuStudent stu = QStuStudent.stuStudent;
		QSubject qSubject = QSubject.subject;
		
		Predicate predicate = null;
		if(SchEvaluate.EVALUATE_RANGE_LESSON.equals(rangeType)){//¿Î³Ì
			
			predicate = stu.classId.in(getQueryFactory().select(re.classId).from(re,qSubject)
					.where(qSubject.origSubjectId.in(evalRangeIds).and(re.subjectId.eq(qSubject.subjectId))
							.and(qSubject.deleteFlag.isFalse()).and(re.deleteFlag.eq(false))));
		}else if(SchEvaluate.EVALUATE_RANGE_CLASS.equals(rangeType)){//°à¼¶
			
			predicate = stu.classId.in(evalRangeIds);
		}else if(SchEvaluate.EVALUATE_RANGE_PERSON.equals(rangeType)){//ÈËÔ±
			
			predicate = stu.userId.in(evalRangeIds);
		}
		
		List<Map<String,Object>> notAnswerUserLst = this.getQueryFactory().select(stu.userId, stu.name).distinct()
			    .from(stu)
			    .where(stu.userId.notIn(userAnswerList)// ¹ýÂ˵ôÒѾ­´ðÌâ¹ýµÄѧԱ
			    		.and(stu.deleteFlag.eq(false))
			    		.and(predicate))
			    .orderBy(stu.createTime.desc())
			    .fetch()
				.stream()
			    .map(tuple -> {
			    	Map<String,Object> map = new HashMap<String,Object>(4);
			    	map.put("recordId", null);
			    	map.put("userId", tuple.get(0,String.class));
			    	map.put("userName", tuple.get(1,String.class));
			    	map.put("submitTime", null);
			    	return map;
			    }).collect(Collectors.toList());
			    
		return notAnswerUserLst;
	}
	
	
	/**  ------Ç°¶Ë       ---------------------------start------------------------------------------------------------------ */
	
	/**
	 * Ìá½»´ð°¸
	 * @param score
	 * @return
	 */
	@Override
	public ResultJson doSubmitTeachEvalScoreData(TeachEvaScoreResult scoreResult, String userId) {
		
		List<TeachEvaScoreData> lstScore = scoreResult.getItems();
		String evaluateId = scoreResult.getEvaluateId();
		
		// 1.²Ù×÷ExerciseRecord×öÌâ¼Ç¼
		ExerciseRecord record = this.doOperExerciseRecord(scoreResult);
		
		if(null == record){
			return new ResultJson(false,"ÄúÒѾ­Ìá½»£¬²»ÄÜÖظ´Ìá½»");
		}
		String exerciseRecordId = record.getRecordId();
		
		if(!scoreResult.getItems().isEmpty()){
			// 2.¼Ç¼Á·Ï°´ð°¸  ExerciseItemAnswerU
			this.doOperExerciseItemAnswerUBatch(lstScore, exerciseRecordId);
		}
		
		// 3.²åÈëÆÀ¹À¼Ç¼¹ØÁª±í
		this.doOperSchEvaRecordRe(exerciseRecordId, evaluateId);
		
		// 4.¸üÐÂÆÀ¹À±íµÄÍê³ÉÈËÊý
		SchEvaluate eval = this.updateEvaluateCount(evaluateId);
		
		if(!scoreResult.getItems().isEmpty()){
			// 5.²åÈëÆÀ¹ÀÃ÷ϸ±í
			this.insertEvaluateDetailBatch(lstScore,evaluateId);
		}
		
		return new ResultJson(true, "²Ù×÷³É¹¦", 
				CollectionUtils.newObjectMap("doNumber", eval.getEvaluateCount(), "recordId", exerciseRecordId));
	}
	
	
	/**
	 * ²Ù×÷±¾´Î×öÌâ¼Ç¼
	 * @return
	 */
	public ExerciseRecord doOperExerciseRecord(TeachEvaScoreResult scoreResult) {
		
		String hql = "select count(r.recordId) from SchEvaRecordRe re, ExerciseRecord r "
				+ " where re.exerciseRecordId=r.recordId and re.evaluateId=? and r.userId=? and r.deleteFlag is false";
		
		int count = this.findCount(hql, CollectionUtils.newList(scoreResult.getEvaluateId(), ClientUtils.getUserId()));
		
		if(count > 0){
			return null;
		}
		
		String doCount = String.valueOf(scoreResult.getItems().size());
		
		// 2.²éѯ×ÜÌâÄ¿Êý
		ExerciseGroup group = this.findUnique("select g from ExerciseGroup g,SchEvaluate e,SchEvaluateTemplate t "
				+ "where g.groupId=t.groupId and e.evalTemplateId=t.evaluateTemplateId and e.evaluateId=?"
				+ " and g.deleteFlag is false and e.deleteFlag is false ",  
				CollectionUtils.newList(scoreResult.getEvaluateId()), ExerciseGroup.class);
		BigInteger allCount = group.getAllCount();
		
		// 3.²éѯ×öÌâ¼Ç¼obj
		BigDecimal completionRate =  ExerciseUtils.parseStrToBigDecimal(doCount, String.valueOf(allCount));
		
		ExerciseRecord record = new ExerciseRecord();
		record.setExerciseGroupId(group.getGroupId());
		record.setUserId(ClientUtils.getUserId());
		record.setDeleteFlag(false);
		record.setScore(scoreResult.getScore());
		record.setTitleMaxNumber(scoreResult.getCurrTitleNum());
		record.setStatus(ExerciseRecord.STATUS_SUBMIT);
		record.setSubmitTime(new Date(System.currentTimeMillis()));
		record.setCompletionRate(completionRate);
		record.setDoCount(new BigInteger(doCount));
		TraceUtils.setCreateTrace(record);
		this.save(record);
		
		return record;
	}
	
	/**
	 * ÅúÁ¿Ôö¼Ó»òÐÞ¸ÄÁ·Ï°¼Ç¼´ð°¸
	 * @return
	 */
	public Result doOperExerciseItemAnswerUBatch(List<TeachEvaScoreData> lstScore, String exerciseRecordId) {
		String userId = ClientUtils.getUserId();
		
		List<ExerciseItemAnswerU> lstNewAnswerU = new ArrayList<ExerciseItemAnswerU>(lstScore.size());
		// ×é×°´ð°¸¼Ç¼
		ExerciseItemAnswerU	answerU = null;
		for(TeachEvaScoreData score:lstScore){
			if(StringUtils.isBlank(score.getAnswer())){
				continue;
			}
			answerU = new ExerciseItemAnswerU();
			
			answerU.setExerciseItemId(score.getExerciseId());
			answerU.setExerciseRecordId(exerciseRecordId);
			answerU.setAnswer(score.getAnswer());
			answerU.setUserId(userId);
			answerU.setDeleteFlag(false);
			TraceUtils.setCreateTrace(answerU);
			lstNewAnswerU.add(answerU);
		}
		
		// ÅúÁ¿±£´æ
		this.saveOrUpdateAll(lstNewAnswerU);
		
		return new Result(true);
	}
	
	/**
	 * ÅúÁ¿Ôö¼Ó»òÐÞ¸ÄÆÀ¹ÀÃ÷ϸ¼Ç¼
	 * @return
	 */
	public Result insertEvaluateDetailBatch(List<TeachEvaScoreData> lstScore,String evaluateId) {
		
		Map<String, Object> argsMap = new HashMap<String, Object>(lstScore.size());
		
		Object[] args = new Object[lstScore.size()];
		for(int i=0; i<lstScore.size(); i++){
			args[i] = lstScore.get(i).getExerciseId();
		}
		argsMap.put("exerciseIds", args);
		
		String hql_score = "from ExerciseItemScore where exerciseItemId in (:exerciseIds)  and deleteFlag is false ";
		List<ExerciseItemScore> lstscores = this.findByComplexHql(hql_score, argsMap, ExerciseItemScore.class);
		Map<String, String> scoreMap = new HashMap<String,String>(lstscores.size());
		for(ExerciseItemScore score:lstscores){
			scoreMap.put(score.getExerciseItemId()+score.getExerciseItemAnswer(), score.getScore());
		}
		
		String userId = ClientUtils.getUserId();
		String userName = ClientUtils.getUserName();
		
		List<SchEvaluateDetail> lstDetail = new ArrayList<SchEvaluateDetail>(lstScore.size());
		SchEvaluateDetail record = null;
		for(TeachEvaScoreData score:lstScore){
			record = new SchEvaluateDetail();
			record.setEvaluateId(evaluateId);
			if(scoreMap.get(score.getExerciseId()+score.getAnswer()) == null){
				record.setScore(BigDecimal.ZERO);
			}else{
				record.setScore(new BigDecimal(scoreMap.get(score.getExerciseId()+score.getAnswer())));
			}
			record.setEvaluaterId(userId);
			record.setEvaluater(userName);
			record.setDeleteFlag(false);
			TraceUtils.setCreateTrace(record);
			
			lstDetail.add(record);
		}
		
		// ÅúÁ¿±£´æ
		this.saveOrUpdateAll(lstDetail);
		
		return new Result(true);
	}
	
	/**
	 * ÐÂÔöÆÀ¹ÀÓë¼Ç¼¹ØÁª±í
	 * @param groupId
	 * @return 
	 */
	public Result doOperSchEvaRecordRe(String recordId, String evaluateId) {

		String hql = "from SchEvaRecordRe where evaluateId=? and exerciseRecordId=?";
		
		List<SchEvaRecordRe> recordLst = this.find(hql, 
				CollectionUtils.newList(evaluateId, recordId), SchEvaRecordRe.class);
		
		if(!recordLst.isEmpty()){
			return new Result(true);
		}
		
		SchEvaRecordRe record = new SchEvaRecordRe();
		record.setEvaluateId(evaluateId);
		record.setExerciseRecordId(recordId);
		//¼Ç¼´ðÌâËùÔڰ༶
		if(null != ClientUtils.getUserInfo()){
			record.setClassId(ClientUtils.getClassId());
			record.setOrgId(ClientUtils.getOrgId());
		}
		
		this.save(record);
		
		return new Result(true);
	}
	
	/**
	 * ¸üÐÂÆÀ¹À±í¼Ç¼
	 * @return
	 */
	public SchEvaluate updateEvaluateCount(String evaluateId) {
		
		SchEvaluate record = this.read(SchEvaluate.class, evaluateId);
		
		if(record == null){
			return null; 
		}
		
		record.setEvaluateCount(BigInteger.valueOf(this.getEvaluateCount(evaluateId)));
		TraceUtils.setUpdateTrace(record);
		
		// ±£´æ
		this.save(record);
		
		return record;
	}
	
	/**
	 * ²éѯÎʾíͳ¼Æ
	 * @param groupId
	 * @param evaluateId
	 * @return
	 */
	@Override
	public ResultJson queryEvaluateStatis(String groupId, String evaluateId) {

		List<ExerciseItem> items =  exerciseService.readExerciseItems4Evaluate(groupId);
		
		SchEvaluate objSchEvaluate = this.read(SchEvaluate.class, evaluateId);
		
		QExerciseRecord record = QExerciseRecord.exerciseRecord;
		QExerciseItemAnswerU answerU = QExerciseItemAnswerU.exerciseItemAnswerU;
		QSchEvaRecordRe re = QSchEvaRecordRe.schEvaRecordRe;
		QUser qUser = QUser.user;
		
		for (ExerciseItem objExerciseItem : items) {
			
			List<Tuple> lstTuple = this.getQueryFactory().select(answerU, qUser)
			.from(record,answerU,re,qUser)
			.where(record.recordId.eq(answerU.exerciseRecordId)
					.and(record.recordId.eq(re.exerciseRecordId))
					.and(re.evaluateId.eq(evaluateId)).and(qUser.userId.eq(record.userId))
					.and(answerU.exerciseItemId.eq(objExerciseItem.getExerciseId()))
					.and(answerU.deleteFlag.eq(false))
					.and(record.deleteFlag.eq(false))
					).orderBy(answerU.createTime.desc()).fetch();
			
			if(lstTuple != null && !lstTuple.isEmpty()) {
				List<ExerciseItemAnswerU> lstExerciseItemAnswerU = new ArrayList<>();
				for(Tuple tuple : lstTuple) {
					ExerciseItemAnswerU objExerciseItemAnswerU = tuple.get(answerU);
					objExerciseItemAnswerU.setImgPath(tuple.get(qUser).getImgPath());
					lstExerciseItemAnswerU.add(objExerciseItemAnswerU);
				}
				
				// ²éѯ´ð°¸
				objExerciseItem.setExerciseItemAnswerU(lstExerciseItemAnswerU);
			}
		}
		objSchEvaluate.setEvaluateCount(BigInteger.valueOf(this.getEvaluateCount(evaluateId)));
		// ²éѯӦÆÀ¹À×ÜÈËÊý
		objSchEvaluate.setEvaluateAllCount(BigInteger.valueOf(this
				.queryEvaluateAllCount(objSchEvaluate.getEvalRangeType(),objSchEvaluate.getEvalRangeId().split(","))));
		
		//Æ´×°Ç°¶ËËùÐèÒªµÄÊý¾Ý
		 Map<String, Object> resultMap = 
				 ExerciseUtils.packageExerciseDetail(items, objSchEvaluate);
		
		return new ResultJson(true, "success", resultMap);
	}
	
	/**
	 * ²éѯӦÆÀ¹ÀÈËÊý
	 * @param rangeType
	 * @param evalRangeIds
	 * @return
	 */
	private long queryEvaluateAllCount(String rangeType, String[] evalRangeIds){
		
		QClsClassReSubject re = QClsClassReSubject.clsClassReSubject;
		QStuStudent stu = QStuStudent.stuStudent;
		QSubject qSubject = QSubject.subject;
		
		Predicate predicate = null;
		if(SchEvaluate.EVALUATE_RANGE_LESSON.equals(rangeType)){//¿Î³Ì
			
			predicate = stu.classId.in(getQueryFactory().select(re.classId).from(re,qSubject)
					.where(qSubject.origSubjectId.in(evalRangeIds).and(re.subjectId.eq(qSubject.subjectId))
							.and(qSubject.deleteFlag.isFalse()).and(re.deleteFlag.eq(false))));
		}else if(SchEvaluate.EVALUATE_RANGE_CLASS.equals(rangeType)){//°à¼¶
			
			predicate = stu.classId.in(evalRangeIds);
		}else if(SchEvaluate.EVALUATE_RANGE_PERSON.equals(rangeType)){//ÈËÔ±
			
			return evalRangeIds.length;
		}
		
		long allCount = this.getQueryFactory()
			    .from(stu)
			    .where(stu.deleteFlag.eq(false).and(predicate).and(stu.status.eq(StuStudent.STATUS_ACTIVE))).groupBy(stu.userId)
			    .fetchCount();
		
		return allCount;
	}
	
	/**
	 * »ñÈ¡Îʾí´ð¾íÈËÊý
	 * 
	 * @param schEvaluateId
	 * @param classId
	 * @return
	 */
	private long getEvaluateCount(String evaluateId){
		QSchEvaRecordRe re = QSchEvaRecordRe.schEvaRecordRe;
		QExerciseRecord record = QExerciseRecord.exerciseRecord;
		
		long count = this.getQueryFactory().from(re,record)
				.where(re.exerciseRecordId.eq(record.recordId)
						.and(record.deleteFlag.eq(false))
						.and(re.evaluateId.eq(evaluateId))
						).groupBy(record.userId)
				.fetchCount();
		
		return count;
	}

	/**
	 * ²éѯѧÉúÆÀ¹Àlist
	 * @return
	 */
	@Override
	public ResultJson queryStuEvaluateList(Pager pager) {
		
		QEvaluateStuStudentV view = QEvaluateStuStudentV.evaluateStuStudentV;
		List<EvaluateStuStudentV> lstView = this.getQueryFactory()
				.selectFrom(view)
				.where(view.id.userId.eq(ClientUtils.getUserId())).limit(pager.getPageSize()).offset(pager.getOffset())
				.orderBy(view.createTime.desc())
				.fetch();
		
		QSchEvaRecordRe re = QSchEvaRecordRe.schEvaRecordRe;
		QExerciseRecord r= QExerciseRecord.exerciseRecord;
		
		ExerciseRecord record = null;
		for(EvaluateStuStudentV evaV:lstView){
			
			record = this.getQueryFactory().select(r)
			.from(re,r)
			.where(re.exerciseRecordId.eq(r.recordId)
					.and(re.evaluateId.eq(evaV.getId().getEvaluateId()))
					.and(r.userId.eq(evaV.getId().getUserId()))
					.and(r.deleteFlag.eq(false))
					).groupBy(r.userId).fetchOne();
			if(record != null) {
				evaV.setExerciseRecordId(record.getRecordId());
				evaV.setGroupId(record.getExerciseGroupId());
			}
			
			evaV.setEvaluateId(evaV.getId().getEvaluateId());
			evaV.setUserId(evaV.getId().getUserId());
		}
		
		return new ResultJson(true,"success",lstView);
	}
	
	/**
	 * ²éѯѧÉúÆÀ¹Àcount
	 * @return
	 */
	@Override
	public Map<String, Object> queryStuEvaluateCount() {
		
		QEvaluateStuStudentV view = QEvaluateStuStudentV.evaluateStuStudentV;
		
		long allCount = this.getQueryFactory()
				.selectFrom(view)
				.where(view.id.userId.eq(ClientUtils.getUserId()))
				.fetchCount();
		QSchEvaRecordRe re = QSchEvaRecordRe.schEvaRecordRe;
		QExerciseRecord r= QExerciseRecord.exerciseRecord;
		
		long doCount = this.getQueryFactory().select(view).distinct()
			.from(re,r, view)
			.where(re.exerciseRecordId.eq(r.recordId)
					.and(re.evaluateId.eq(view.id.evaluateId))
					.and(r.userId.eq(ClientUtils.getUserId())).and(view.id.userId.eq(ClientUtils.getUserId()))
					.and(r.deleteFlag.eq(false))
					).fetchCount();
		
		return CollectionUtils.newObjectMap("allCount", allCount, "doCount", doCount);
	}

	/**
	 * »ñÈ¡ÆÀ¹ÀÌâÄ¿
	 * @param templateId
	 * @param status
	 * @param exerciseRecordId
	 * @return
	 */
	@Override
	public ResultJson doGetEvalExerItemResponseDataNew(String evaluateId) {
		String groupId = this.findUnique("select t.groupId from SchEvaluateTemplate t,SchEvaluate e "
				+ "where t.evaluateTemplateId=e.evalTemplateId and e.evaluateId=?", 
				CollectionUtils.newList(evaluateId),String.class);
		
		// 2.²éÕÒÆÀ¹À×éÏÂËùÓжÔÓ¦µÄÁ·Ï°
		String hql_item = "select item"
				+ " from ExerciseItem item, ExerciseGroupItemRe re, ExerciseGroup g"
				+ " where item.exerciseId=re.exerciseItemId "
				+ "	and re.exerciseGroupId=g.groupId"
				+ " and g.groupId=? "
				+ " and g.deleteFlag is false"
				+ " and re.deleteFlag is false"
				+ " and item.deleteFlag is false"
				+ " order by re.itemOrder";
				
		List<ExerciseItem> lstItems = this.find(hql_item, CollectionUtils.newList(groupId), ExerciseItem.class);
		if(lstItems.isEmpty()){
			return new ResultJson(false,"µ±Ç°ÆÀ¹ÀδÌí¼ÓÌâÄ¿");
		}
		//²éѯÓû§ËùÌî´ð°¸
		List<ExerciseItemAnswerU> lstUserAnswer = null;
		String exerciseRecordId = this.findUnique("select r.recordId from SchEvaRecordRe re, ExerciseRecord r "
				+ "where re.exerciseRecordId=r.recordId and re.evaluateId=? and r.deleteFlag is false and r.userId = ?",
				CollectionUtils.newList(evaluateId, ClientUtils.getUserId()), String.class);
		if(StringUtils.isNoneBlank(exerciseRecordId)){
			String hql_options = "select o from ExerciseItemAnswerU o where o.exerciseRecordId = ? and o.deleteFlag is false";
			lstUserAnswer = this.find(hql_options, CollectionUtils.newList(exerciseRecordId), ExerciseItemAnswerU.class);
		}
		// 2.1.×é×°²ÎÊý ÓÃÓÚ²éѯÎʾíÑ¡ÏîͼƬ
		Map<String, Object> argsImgMap = new HashMap<String, Object>();
		String argImgs = "";
		Map<String, Object> argsMap = new HashMap<String, Object>();
		Object[] args = new Object[lstItems.size()];
		for(int i=0; i<lstItems.size(); i++){
			ExerciseItem objExerciseItem = lstItems.get(i);
			args[i] = objExerciseItem.getExerciseId();
			objExerciseItem.setAnswer(null);
			List<ExerciseItemOption> options = objExerciseItem.getOptions();
			if(options == null || options.isEmpty()){
				continue;
			}else{
				for(int j=0; j<options.size(); j++){
					argImgs = argImgs.concat(options.get(j).getOptionId().concat(j == (options.size() - 1)?"":";"));
				}
			}
		}
		argsMap.put("exerciseIds", args);
		argsImgMap.put("optionIds", argImgs.split(";"));
		// 2-3-1²éѯÌâÄ¿ÊÇ·ñ¹ØÁªÍ¼Æ¬
		String hql_itemImgs = "from ExerciseObjectImg where exerciseObjectId in (:exerciseIds) and deleteFlag is false and objectType=1 order by exerciseObjectId,imgOrder ";
		List<ExerciseObjectImg> lstItemImgs = this.findByComplexHql(hql_itemImgs, argsMap, ExerciseObjectImg.class);
		// 2-3-2²éѯÌâÄ¿Ñ¡ÏîÊÇ·ñ¹ØÁªÍ¼Æ¬
		String hql_optionImgs = "from ExerciseObjectImg where exerciseObjectId in (:optionIds) and deleteFlag is false and objectType=2";
		List<ExerciseObjectImg> lstOptionImgs = this.findByComplexHql(hql_optionImgs, argsImgMap, ExerciseObjectImg.class);

		// ÖØÐÂ×é×°Á·Ï°Ñ¡Ïî
		ExerciseUtils.packageExerciseItem(lstItems, lstUserAnswer, lstOptionImgs);
		
		Map<String, List<ExerciseObjectImg>> imgItemMap = ExerciseUtils.packageExerciseItemImg(lstItemImgs);
		
		for(ExerciseItem item:lstItems){
			// 4.5ÌâÄ¿ÖÐÊÇ·ñÓÐͼƬ
			if(imgItemMap.get(item.getExerciseId()) != null){
				item.setImgs(imgItemMap.get(item.getExerciseId()));
			}
		}
		
		
		return new ResultJson(true,"success",lstItems);
	}
	
}