package com.qxueyou.scc.exam.action;

import java.io.IOException;
import java.math.BigDecimal;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.qxueyou.scc.exercise.model.ExerciseGroup;
import com.qxueyou.scc.teach.student.model.StuStudent;
import com.qxueyou.scc.teach.student.service.IStudentService;
import org.apache.commons.lang3.RandomStringUtils;
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.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import com.alibaba.fastjson.JSON;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.qxueyou.scc.admin.classes.model.ClsClass;
import com.qxueyou.scc.admin.classes.service.IClassService;
import com.qxueyou.scc.base.dao.CommonDAO;
import com.qxueyou.scc.base.model.Pager;
import com.qxueyou.scc.base.model.Result;
import com.qxueyou.scc.base.service.ICommonService;
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.exam.model.ExamBatchInfo;
import com.qxueyou.scc.exam.model.ExamInfo;
import com.qxueyou.scc.exam.model.ExamPaperInfo;
import com.qxueyou.scc.exam.model.ExamReExamPaper;
import com.qxueyou.scc.exam.model.ExamResultV;
import com.qxueyou.scc.exam.service.IExamPaperService;
import com.qxueyou.scc.exam.service.IExamService;
import com.qxueyou.scc.exercise.model.ExerciseDataSubmitLog;
import com.qxueyou.scc.exercise.model.ExerciseRecord;
import com.qxueyou.scc.exercise.model.ExerciseSubmitAnswerData;
import com.qxueyou.scc.exercise.service.IExerciseGroupService;
import com.qxueyou.scc.exercise.service.IExerciseVerService;
import com.qxueyou.scc.user.model.User;
import com.qxueyou.scc.user.service.IUserService;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;

import javax.servlet.http.HttpServletRequest;

/**
 * exam controller.
 *
 * @author kevin
 * @history 2018-03-11 create kevin
 *
 */
@Api(tags = "考试管理接口")
@Controller
@CrossOrigin(origins="*",maxAge=3600)
@RequestMapping(value = "/exam/exam")
public class ExamController {
	private final Logger log = LogManager.getLogger(ExamController.class);

	// 分页查询中，默认记录条数和页数
	private static final int DEFAULT_PAGE_SIZE = 10;
	private static final int DEFAULT_PAGE_NUM = 1;

	//生成密码长度
	private static final int EXAM_CERT_PWD_LENGTH = 8;

	@Autowired
	private CommonDAO commonDAO;

	@Autowired
	IStudentService studentService;

	@Autowired
	@Qualifier("commonAppService")
	ICommonService commonService;

	@Autowired
	IExerciseGroupService exerciseGroupService;

	@Autowired
	IExamService examService;

	@Autowired
	IUserService userService;

	@Autowired
	IExamPaperService examPaperService;

	@Autowired
	private IExerciseVerService exerciseVerService;

	@Autowired
	IClassService classService;

	/**
	 * 考试列表
	 */
	@SuppressWarnings("unchecked")
	@RequestMapping(value = "list", method = RequestMethod.GET)
	public @ResponseBody Result list(String keyword,String classId,String subjectId,Short status,Integer pageSize,Integer pageNum) {
		pageSize = pageSize != null && pageSize > 0 ? pageSize : DEFAULT_PAGE_SIZE;
		pageNum = pageNum != null && pageNum > 0 ? pageNum : DEFAULT_PAGE_NUM;
		//总考试数量
		int totalCount = examService.listCount(keyword == null ? "" : keyword.trim(),classId,subjectId,status);
		Pager pager = new Pager(pageSize,pageNum);
		pager.setTotalCount(totalCount);

		List<ExamInfo> list = examService.list(keyword == null ? "" : keyword.trim(),classId,subjectId,status,pageSize,pageNum);

		List<Map<String, Object>> listResult =QBeanUtils.listBean2ListMap(list,
	            CollectionUtils.newStringMap("examId", "examId", "examName", "examName", "examStatus", "examStatus","examType","examType",
	            		"totalScore","totalScore","creator", "creator", "updateTime", "updateTime","reExamPapers","reExamPapers",
	            		"subject.name","subjectName","examBatchInfos","examBatchInfos"));



		if(listResult!=null && listResult.size()>0){
			//查询待批阅，已批阅，未提交数量
			Map<String,Integer> countMap = examService.queryExamResultStatusCount(QBeanUtils.listPropertyVal(list, "examId"));
			countMap = countMap==null?new HashMap<String,Integer>(1):countMap;
			Integer tempCount = null;

			for (Map<String, Object> item : listResult) {
				List<ExamReExamPaper> reExamPapers  =  (List<ExamReExamPaper>)item.get("reExamPapers");
				if(reExamPapers!= null && reExamPapers.size()>0){
					String [] arrPaperNames = new String[reExamPapers.size()];
					for(int i =0;i<reExamPapers.size();i++){
						arrPaperNames[i] = reExamPapers.get(i).getExamPaperName();
					}
					item.put("paperNames", arrPaperNames);
				}else{
					item.put("paperNames", new String[]{});
				}

				item.put("progressStatus", this.getExamProgressStatus((List<ExamBatchInfo>) item.get("examBatchInfos")));

				tempCount = countMap.get(item.get("examId") + "-" + ExerciseRecord.STATUS_CHECK);
				item.put("checkedCount", tempCount==null?0:tempCount);

				tempCount = countMap.get(item.get("examId") + "-" + ExerciseRecord.STATUS_SUBMIT);
				item.put("toCheckCount",tempCount==null?0:tempCount);

				tempCount = countMap.get(item.get("examId") + "-" + ExerciseRecord.STATUS_NOT_SUBMIT);
				item.put("unCommitCount",tempCount==null?0:tempCount);

				item.remove("examBatchInfos");
				item.remove("reExamPapers");
			}
		}

		return new Result(true,"",CollectionUtils.newObjectMap("examList",listResult,"page",pager));
	}

	private String getExamProgressStatus(List<ExamBatchInfo> lstBatchInfos){

		if(lstBatchInfos == null ||lstBatchInfos.size()==0){
			return "已结束";
		}

		String progressStatus="待开始";
		Date now = new Date();

		//根据开始时间倒序
		lstBatchInfos.sort(new Comparator<ExamBatchInfo>(){
			@Override
			public int compare(ExamBatchInfo o1, ExamBatchInfo o2) {
				return (int)(o1.getStartTime().getTime()- o2.getStartTime().getTime());
			}
		});

			//如果所有批次都小于当前时间，则已结束，如果有一个批次正在进行中，则进行中
		if(lstBatchInfos.get(0).getEndTime().getTime()<now.getTime()){
			progressStatus="已结束";
		}else{
			for(ExamBatchInfo f : lstBatchInfos){
				if(f.getStartTime().getTime()<=now.getTime() && f.getEndTime().getTime()>=now.getTime()){
					progressStatus = "进行中";
					break;
				}
			}
		}
		return progressStatus;
	}


	/**
	 * 教师查看考试成绩列表
	 *
	 * @return
	 */
	@ApiOperation(value = "老师查看学生考试结果列表")
	@ApiImplicitParams({
		@ApiImplicitParam(name="examId", dataType="String", paramType="query", value="考试id", required=true),
		@ApiImplicitParam(name="examBatchId", dataType="String", paramType="query", value="批次id", required=true),
		@ApiImplicitParam(name="classId", dataType="String", paramType="query", value="班级id", required=true),
	})
	@RequestMapping(value = "teacher/examresultlist", method = RequestMethod.GET)
	public @ResponseBody Result queryStudentExamResultList(String examId, String examBatchId, String classId,String keyword, Integer pageSize, Integer pageNum) {
		pageSize = pageSize != null && pageSize > 0 ? pageSize : DEFAULT_PAGE_SIZE;
		pageNum = pageNum != null && pageNum > 0 ? pageNum : DEFAULT_PAGE_NUM;

		//总考试数量
		int totalCount = examService.listResultCount(examId,
					StringUtils.isEmpty(examBatchId)?null:new String[]{examBatchId}, classId, keyword == null ? "" : keyword.trim());

		Pager pager = new Pager(pageSize,pageNum);
		pager.setTotalCount(totalCount);

		List<ExamResultV> list = examService.listResult(examId,
					StringUtils.isEmpty(examBatchId)?null:new String[]{examBatchId}, classId, keyword == null ? "" : keyword.trim(), pageSize,pageNum);

		List<Map<String, Object>> listResult =QBeanUtils.listBean2ListMap(list,
	            CollectionUtils.newStringMap("id.studentNo", "studentNo", "studentName", "studentName", "id.classId", "classId",
	            		"className","className","id.examBatchId","examBatchId","examBatchNo","examBatchNo","startTime", "startTime", "endTime", "endTime","submitTime","submitTime",
	            		"score","studentScore","status","status","paperCode","paperCode","accuracy","accuracy","completionRate","completeRate",
	            		"userId","studentUserId","passingScore","passingScore","sex","sex","mobilePhone","mobilePhone"));

		int rank = 1;
		for(Map<String, Object>  map:listResult){
			map.put("rank", rank);
			map.put("isPass", (map.get("studentScore")==null ? BigDecimal.ZERO :(BigDecimal)map.get("studentScore"))
					.compareTo((BigDecimal)map.get("passingScore")) == -1 ? "否" : "是");
			rank++;
		}

		return new Result(true,"",CollectionUtils.newObjectMap("list",listResult,"page",pager,"examInfo",this.commonDAO.read(ExamInfo.class, examId)));
	}

	/**
	 * 详情页面数据
	 *
	 * @param examId
	 * @return
	 */
	@ApiOperation(value = "详情页面数据")
	@ApiImplicitParams({
		@ApiImplicitParam(name="examId", dataType="String", paramType="query", value="考试id", required=true),
	})
	@RequestMapping(value = "/detail", method = RequestMethod.GET)
	public @ResponseBody Result detail(String examId) {
		return new Result(true,"",CollectionUtils.newObjectMap("detail",examService.queryExamDetail(examId)));
	}

	@ApiOperation(value = "获取补考考试，根据maxLateMin标记")
	@ApiImplicitParams({
//		@ApiImplicitParam(name="examId", dataType="String", paramType="query", value="考试id", required=true),
	})
	@RequestMapping(value = "/getReExam", method = RequestMethod.GET)
	public @ResponseBody Result getReExam() {
		return new Result(true,"",CollectionUtils.newObjectMap("examInfo",examService.queryReExam()));
	}

	/**
	 * 保存
	 *
	 * @param examInfo
	 * @return
	 */
	@RequestMapping(value = "/save", method = RequestMethod.POST)
	public @ResponseBody Result save(@RequestBody ExamInfo examInfo) {
		Result result = null;
		if (StringUtils.isEmpty(examInfo.getExamId())) {
			examInfo.setOrgId(ClientUtils.getOrgId());
			String examId = examService.addExam(examInfo);
			result = new Result(true,"",CollectionUtils.newObjectMap("examId", examId));
		} else {
			result = examService.updateExam(examInfo);
		}
		return result;
	}

	/**
	 * 保存
	 * @param
	 * @return
	 */
	@RequestMapping(value = "/saveRemedy", method = RequestMethod.POST)
	public @ResponseBody Result saveRemedy(@RequestBody ExamBatchInfo examBatchInfo) {
		Result result = null;
		//获取考试ID
		String examId = examBatchInfo.getExamId();
		//获取开始时间
		Date startTime = examBatchInfo.getStartTime();
		//获取结束时间
		Date endTime = examBatchInfo.getEndTime();
		//生成补考考试
			examService.addRemedy(examId,startTime,endTime);
			result = new Result(true,"",CollectionUtils.newObjectMap("examId", examId));

		return result;
	}

	/**
	 * 删除
	 *
	 * @param examIds
	 * @return
	 */
	@ApiOperation(value = "删除考试", notes = "根据传入的考试ID字符串参数进行删除(多个ID以逗号分割， 如：examId1,examId2)", httpMethod = "GET")
	@ApiImplicitParam(name = "examIds", value = "考试ID字符串", required = true, dataType = "String", paramType = "body")
	@RequestMapping(value = "delete", method = RequestMethod.GET)
	public @ResponseBody Result delete(String examIds) {
		Result result = new Result(true);
		if (StringUtils.isNotEmpty(examIds)) {
			result = examService.deleteExam(examIds.split(","));
		}
		return result;
	}

   /**
	 * 设置考试题目
	 *
	 * @param examInfo
	 * @return
	 */
	@RequestMapping(value = "/savePaper", method = RequestMethod.POST)
	public @ResponseBody Result savePaper(@RequestBody ExamInfo examInfo) {
		return examService.updateExamPaperInfo(examInfo);
	}

	/**
	 * 发布考试
	 *
	 * @param
	 * @return
	 */
	@RequestMapping(value = "/publish", method = RequestMethod.GET)
	public @ResponseBody Result publishExam(String examIds) {
		if (StringUtils.isEmpty(examIds)) {
			return new Result(false, "参数错误");
		}
		return this.examService.doPublishExam(examIds.split(","));
	}

	/**
	 * 撤回考试
	 *
	 * @param
	 * @return
	 */
	@RequestMapping(value = "/revoke", method = RequestMethod.GET)
	public @ResponseBody Result revokeExam(String examIds) {
		if (StringUtils.isEmpty(examIds)) {
			return new Result(false, "参数错误");
		}
		return this.examService.doRevokeExam(examIds.split(","));
	}

	/**
	 * 学生考试信息列表
	 *
	 * @return
	 */
	@ApiOperation(value = "学生考试信息列表")
	@ApiImplicitParams({
		@ApiImplicitParam(name="keyword", dataType="String", paramType="query", value="关键字考试名称模糊查询"),
		@ApiImplicitParam(name="classId", dataType="String", paramType="query", value="班级id"),
		@ApiImplicitParam(name="subjectId", dataType="String", paramType="query", value="课程id", required=false),
		@ApiImplicitParam(name="status", dataType="String", paramType="query", value="状态（默认全部，1未开始，2未交卷，3已交卷，4逾期未交,5已批阅）", required=false),
	})
	@RequestMapping(value = "/student/list", method = RequestMethod.GET)
	public @ResponseBody Result queryStudentExamList(String keyword, String classId, String subjectId, Integer status, Integer pageSize, Integer pageNum) {
		pageSize = pageSize != null && pageSize > 0 ? pageSize : DEFAULT_PAGE_SIZE;
		pageNum = pageNum != null && pageNum > 0 ? pageNum : DEFAULT_PAGE_NUM;
		if(classId==null){
			classId=ClientUtils.getClassId();
		}
		System.out.println("avcd"+ClientUtils.getUserId());
//		System.out.println(ClientUtils.getUserId()+"--cla"+classId+"--sub"+subjectId+"--sta"+status+"--key"+keyword+"--pag"+pageNum+"---siz"+pageSize);
		String [] classIds= null;
		if(!StringUtils.isEmpty(classId)){
			classIds = new String[]{classId};
		}else{
			List<ClsClass> listClasses = classService.queryStudentClassesByUserId(ClientUtils.getUserId());
			if(listClasses!=null && listClasses.size()>0){
				classIds = QBeanUtils.listPropertyVal(listClasses, "classId").toArray(new String [listClasses.size()]);
			}
		}

		int totalCount = examService.listStudentExamCount(keyword == null ? "" : keyword.trim(),classIds,subjectId,status);
//		System.out.println("totalCount"+totalCount);
		List<ExamResultV> list = examService.listStudentExam(keyword == null ? "" : keyword.trim(),classIds,subjectId,status,pageSize,pageNum,ClientUtils.getUserId());
//		System.out.println("totalCount"+list);
		List<Map<String, Object>> listResult =QBeanUtils.listBean2ListMap(list,
	            CollectionUtils.newStringMap("examId", "examId", "examName", "examName", "id.examBatchId", "examBatchId", "startTime","startTime","endTime", "endTime",
	            							 "id.classId", "classId","totalScore","totalScore","passingScore","passingScore","remainingSeconds","remainingSeconds",
	            							 "exerciseGroupId","groupId","score","score","status","status","subjectName","subjectName"));

		if(listResult!=null && listResult.size()>0){
			for(Map<String, Object> map : listResult){
				map.put("status", map.get("status")==null?0:Integer.valueOf((String)map.get("status")));
			}
		}
		return new Result(true,"",CollectionUtils.newObjectMap("stuExams",listResult,"examCount",totalCount));
	}
	/**
	 * 学生考试信息列表
	 *
	 * @return
	 */
	@ApiOperation(value = "学生考试信息列表")
	@ApiImplicitParams({
		@ApiImplicitParam(name="classId", dataType="String", paramType="query", value="班级id"),
	})
	@RequestMapping(value = "/student/nowExam", method = RequestMethod.GET)
	public @ResponseBody Result queryStudentExam(String classId) {
		//获取当前考试列表以结束时间排序最新的在最前面
		String [] classIds= null;
		if(!StringUtils.isEmpty(classId)){
			classIds = new String[]{classId};
		}else{
			List<ClsClass> listClasses = classService.queryStudentClassesByUserId(ClientUtils.getUserId());
			if(listClasses!=null && listClasses.size()>0){
				classIds = QBeanUtils.listPropertyVal(listClasses, "classId").toArray(new String [listClasses.size()]);
			}
		}
		List<ExamResultV> list = examService.studentExam(classIds);

		List<Map<String, Object>> listResult =QBeanUtils.listBean2ListMap(list,
	            CollectionUtils.newStringMap("examId", "examId", "examName", "examName", "id.examBatchId", "examBatchId", "startTime","startTime","endTime", "endTime",
												 "id.classId", "classId","totalScore","totalScore","passingScore","passingScore","remainingSeconds","remainingSeconds",
	            							 "exerciseGroupId","groupId","score","score","status","status","subjectName","subjectName"));

		if(listResult!=null && listResult.size()>0){
			for(Map<String, Object> map : listResult){
				map.put("status", map.get("status")==null?0:Integer.valueOf((String)map.get("status")));
			}
		}
		return new Result(true,"",CollectionUtils.newObjectMap("stuExams",listResult!=null && listResult.size()>0?listResult.get(0):null));
	}

	@ApiOperation(value = "学生考试信息列表")
	@ApiImplicitParams({
		@ApiImplicitParam(name="examBatchId", dataType="String", paramType="query", value="班级id"),
		@ApiImplicitParam(name="classId", dataType="String", paramType="query", value="班级id")
	})
	@RequestMapping(value = "/student/record", method = RequestMethod.GET)
	public @ResponseBody Result queryStudentRecord(String examBatchId, String classId) {
		// 查询是否有进行中的考试
		ExerciseRecord record = commonDAO.findUnique(
				"from ExerciseRecord where examBatchId=? and classId=? and userId = ? and deleteFlag is false ",
				CollectionUtils.newList(examBatchId,classId,ClientUtils.getUserId()),
				ExerciseRecord.class);

		return new Result(true,"",CollectionUtils.newObjectMap("record",record));
	}

	/**
	 * 学生考试信息列表
	 *
	 * @return
	 */
	@ApiOperation(value = "学生考试信息列表")
	@ApiImplicitParams({
		@ApiImplicitParam(name="classId", dataType="String", paramType="query", value="班级id"),
	})
	@RequestMapping(value = "/student/stuMessage", method = RequestMethod.GET)
	public @ResponseBody Result queryStudent() {
		StuStudent student = studentService.getStudentByUserId(ClientUtils.getUserId());
		return new Result(true,"",CollectionUtils.newObjectMap("student",student));
	}

	/**
	 * 根据考试批次ID获取考试题目信息
	 *
	 * @param examBatchId
	 * @return
	 */
	@ApiOperation(value = "学生开始考试接口")
	@ApiImplicitParams({
		@ApiImplicitParam(name="examBatchId", dataType="String", paramType="query", value="考试批次id", required=true),
		@ApiImplicitParam(name="classId", dataType="String", paramType="query", value="班级id", required=false)
	})
	@RequestMapping(value = "/student/startexam", method = RequestMethod.GET)
	public @ResponseBody Result doStartExam(String examBatchId, String classId,String studentUserId) {

		if (StringUtils.isEmpty(examBatchId) || StringUtils.isEmpty(classId)) {
			return new Result(false, "参数错误,班级，考试批次不能为空");
		}

		Result result = this.examService.doStartExam(examBatchId,classId,StringUtils.isNotEmpty(studentUserId)?studentUserId:ClientUtils.getUserId());
		ExamPaperInfo paper = (ExamPaperInfo)result.getData("paperInfo");
		//&& paper.getExerciseGroup().getItems().isEmpty()
		if(paper!=null ){
			ExerciseGroup exerciseGroup = exerciseGroupService.queryExerciseGroupDetail((String) result.getData("groupId"), examBatchId);
			paper.setExerciseGroup(exerciseGroup);
		}

		return result;
	}
	@ApiOperation(value = "学生开始补考接口")
	@ApiImplicitParams({
		@ApiImplicitParam(name="examId", dataType="String", paramType="query", value="考试批次id", required=true),
	})
	@RequestMapping(value = "/student/startReExam", method = RequestMethod.GET)
	public @ResponseBody Result doStartReExam(String examId) {
		Result result = this.examService.doStartReExam(examId,ClientUtils.getUserId());
		ExamPaperInfo paper = (ExamPaperInfo)result.getData("paperInfo");
		//&& paper.getExerciseGroup().getItems().isEmpty()
		if(paper!=null ){
			ExerciseGroup exerciseGroup = exerciseGroupService.queryReExerciseGroupDetail((String) result.getData("groupId"), examId);
			paper.setExerciseGroup(exerciseGroup);
		}
		return result;
	}
	@ApiOperation(value = "学生补考记录")
	@ApiImplicitParams({
//		@ApiImplicitParam(name="examId", dataType="String", paramType="query", value="考试批次id", required=true),
	})
	@RequestMapping(value = "/student/getReExamRecordList", method = RequestMethod.GET)
	public @ResponseBody Result getReExamRecordList() {
		ExamInfo examInfo = examService.queryReExam();
		if(examInfo!=null){
			Result reExamRecordList = this.examService.getReExamRecordList(examInfo.getExamId(), ClientUtils.getUserId());
			List<ExerciseRecord> exerciseRecords= (List<ExerciseRecord>)reExamRecordList.getData();
			exerciseRecords.forEach(exerciseRecord -> {
				exerciseRecord.setName(examInfo.getExamName());
			});
			return reExamRecordList;
		}
		return new Result(false,"没有设置补考");
	}

	@ApiOperation(value = "学生考试详情")
	@ApiImplicitParams({@ApiImplicitParam(name="examBatchId", dataType="String", paramType="query", value="考试批次id", required=true)})
	@RequestMapping(value = "/student/examdetail", method = RequestMethod.GET)
	public @ResponseBody Result viewExamDetail(String examBatchId) {
		ExamBatchInfo batchInfo = this.commonService.read(ExamBatchInfo.class, examBatchId);
		//考试信息
		ExamInfo examInfo =this.examService.queryExamDetail(batchInfo.getExamId());
		examInfo.setExamStartTime(batchInfo.getStartTime());
		examInfo.setExamEndTime(batchInfo.getEndTime());

		// 获取考卷信息
		Map<String, ExamPaperInfo> paperStatistic  =null;
		if(examInfo.getExamType()!=ExamInfo.EXAM_TYPE_RANDOM && examInfo.getExamType()!=ExamInfo.EXAM_TYPE_RANDOM_BY_GROUP){
			paperStatistic = examPaperService.queryExamPaperItemsStatistic(
					QBeanUtils.listPropertyVal(examInfo.getReExamPapers(), "examPaperId").toArray(new String[examInfo.getReExamPapers().size()]));
		}
		return new Result(true,"",CollectionUtils.newObjectMap("examInfo",examInfo,"paperStatistic",paperStatistic));
	}

	@ApiOperation(value = "提交考试答案")
	@ApiImplicitParams({@ApiImplicitParam(name="answers", dataType="String", paramType="query", value="提交答案", required=true)})
	@RequestMapping(value = "/student/submitExam", method = RequestMethod.POST)
	public @ResponseBody Object doSubmitExamAnswer(@RequestParam(value = "answers") String answers) throws IOException {
		Result result = new Result(true);
		// 用户本次做题提交的数据
		String recordId =null;
//		try {
			ExerciseSubmitAnswerData answerData = new ObjectMapper().readValue(answers, ExerciseSubmitAnswerData.class);
			recordId = answerData.getExerciseRecordId();
			// 提交试卷答案
			result = new Result(true, "答案提交成功",exerciseVerService.doOperExerciseAnswerData(answerData));
			// 记录提交的数据日志
			exerciseVerService.doSaveExerciseDataSubmitLog(answers, recordId,ExerciseDataSubmitLog.TYPE_SUBMIT_ANSWER, ExerciseDataSubmitLog.STATUS_SUCCESS,"/exercise/Exercise/exerAnswers");
//		} catch (Exception e) {
//			log.error("考试保存错误", e);
//			result = new Result(false, "提交考试答案请求异常");
//			exerciseVerService.doSaveExerciseDataSubmitLog(answers, recordId,ExerciseDataSubmitLog.TYPE_SUBMIT_ANSWER, ExerciseDataSubmitLog.STATUS_FAILED,"/exercise/Exercise/exerAnswers");
//		}
		return result;
	}

	@ApiOperation(value = "老师阅卷")
	@ApiImplicitParams({@ApiImplicitParam(name="answerData", dataType="object", paramType="query", value="提交答案", required=true)})
	@RequestMapping(value = "/teacher/checkExam", method = RequestMethod.POST)
	public @ResponseBody Object doCheckExam(@RequestBody ExerciseSubmitAnswerData answerData) {
		Result result = new Result(true);
		String recordId = null;
		try {
			// 提交记录id
			recordId = answerData.getExerciseRecordId();
			// 提交试卷答案
			result = new Result(true, "答案提交成功",exerciseVerService.doOperExerciseAnswerData(answerData));
			// 记录提交的数据日志
			exerciseVerService.doSaveExerciseDataSubmitLog(JSON.toJSONString(answerData),recordId,ExerciseDataSubmitLog.TYPE_SUBMIT_ANSWER, ExerciseDataSubmitLog.STATUS_SUCCESS,"/exam/exam/teacher/checkExam");
		} catch (Exception e) {
			log.error("考试保存错误", e);
			result = new Result(false, "提交练习答案请求异常");
			exerciseVerService.doSaveExerciseDataSubmitLog(JSON.toJSONString(answerData),recordId,ExerciseDataSubmitLog.TYPE_SUBMIT_ANSWER, ExerciseDataSubmitLog.STATUS_FAILED,"/exam/exam/teacher/checkExam");
		}
		return result;
	}

	/**
	 * 查询考试凭证信息列表
	 *
	 * @return
	 */
	@ApiOperation(value = "查询学生考试凭证")
	@RequestMapping(value = "/teacher/examacertificatelist", method = RequestMethod.GET)
	public @ResponseBody Result queryStudentExamCertificateList(String examId, String classId, String examBatchId,
			String keyword, Integer pageSize, Integer pageNum) {
		Map<String, Object> queryParams = new HashMap<String, Object>();
		StringBuffer hql = new StringBuffer(500);
		hql.append("select r.classId from  ExamBatchInfo f,ExamBatchClassRe r where f.examBatchId = r.examBatchId and f.deleteFlag is false and r.deleteFlag is false ");

		// 如果examBatchId为空，则获取考试对应的所有批次
		if (StringUtils.isNotEmpty(examBatchId)) {
			hql.append(" and f.examBatchId=:examBatchId");
			queryParams.put("examBatchId", examBatchId);
		}else{
			hql.append(" and f.examId=:examId");
			queryParams.put("examId", examId);
		}

		List<String> classLst =this.commonDAO.findByComplexHql(hql.toString(), queryParams, String.class);
		//如果不存在关联的班级信息，则直接返回
		if (classLst == null || classLst.size() == 0) {
			return new Result(false,"无班级考生信息",CollectionUtils.newObjectMap("list",null));
		}

		// 查询记录数
		int totalCount = commonDAO.findCountByComplexHql("from StuStudent t WHERE t.classId in(:classIds) and t.deleteFlag is false",
				CollectionUtils.newObjectMap("classIds",classLst.toArray(new String[]{})));

		// page赋值
		Pager page = new Pager();
		page.setTotalCount(totalCount);
		page.setPageSize(pageSize != null && pageSize > 0 ? pageSize : DEFAULT_PAGE_SIZE);
		page.setPageNum(pageNum != null && pageNum > 0 ? pageNum : DEFAULT_PAGE_NUM);

		List<Map<String,Object>> lstMap = this.commonDAO.findListWithMapByHql(
					"select u.userId as userId,c.name as className, u.name as name,u.account as account,u.password as password from StuStudent t,User u,ClsClass c "
					+ " WHERE t.userId=u.userId and t.classId=c.classId AND t.classId in(:classIds) and t.deleteFlag is false and u.deleteFlag is false",
				CollectionUtils.newObjectMap("classIds",classLst.toArray(new String[]{})),page);

		return new Result(true,"",CollectionUtils.newObjectMap("list", lstMap,"page", page));
	}

	/**
	 * 学生考试信息列表
	 *
	 * @return
	 */
	@ApiOperation(value = "生成学生考试凭证")
	@RequestMapping(value = "/teacher/genstudentacertificate", method = RequestMethod.GET)
	public @ResponseBody Result queryStudentExamCertificateList(String examId, String examBatchId) {
		Map<String, Object> queryParams = new HashMap<String, Object>(1);

		// 如果examBatchId为空，则获取考试对应的所有批次
		String hql ="select distinct r.classId from  ExamBatchInfo f,ExamBatchClassRe r where f.examBatchId = r.examBatchId  and f.deleteFlag is false and r.deleteFlag is false";

		if (StringUtils.isNotEmpty(examBatchId)) {
			hql = hql.concat(" and f.examBatchId=:examBatchId  ");
			queryParams.put("examBatchId", examBatchId);
		}else{
			hql = hql.concat(" and f.examId=:examId ");
			queryParams.put("examId", examId);
		}

		List<String> classLst =this.commonDAO.findByComplexHql(hql, queryParams, String.class);

		//如果不存在关联的班级信息，则直接返回
		if (classLst == null || classLst.size() == 0) {
			return new Result(false, "无班级考生信息",CollectionUtils.newObjectMap("list", null));
		}

		//查询所有学生用户信息
		List<User> lstUser = this.commonDAO.findByComplexHql(
				"select distinct u from StuStudent t,User u WHERE t.userId=u.userId AND t.classId in(:classIds) and t.deleteFlag is false and u.deleteFlag is false",
				CollectionUtils.newObjectMap("classIds",classLst.toArray(new String[]{})),User.class);

		if(lstUser!=null && lstUser.size()>0){
			for(User user:lstUser){
				user.setPassword(RandomStringUtils.random(EXAM_CERT_PWD_LENGTH, false, true));
			}
		}

		if(!this.userService.doBatchUpdateUser(lstUser)){
			return new Result(false,"更新学生考试凭证密码失败!");
		}

		return new Result(true);
	}
}