package com.qxueyou.scc.exercise.action;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

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.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.qxueyou.scc.base.dao.CommonDAO;
import com.qxueyou.scc.base.model.Constants;
import com.qxueyou.scc.base.model.Pager;
import com.qxueyou.scc.base.model.Result;
import com.qxueyou.scc.exercise.model.ExciseExtendReqData;
import com.qxueyou.scc.exercise.model.ExciseExtendReqListData;
import com.qxueyou.scc.exercise.model.ExerGroupResponseData;
import com.qxueyou.scc.exercise.model.ExerItemResponseData;
import com.qxueyou.scc.exercise.model.ExerciseDataSubmitLog;
import com.qxueyou.scc.exercise.model.ExerciseExtendRecordData;
import com.qxueyou.scc.exercise.model.ExerciseFaultRecord;
import com.qxueyou.scc.exercise.model.ExerciseFavoriteRecord;
import com.qxueyou.scc.exercise.model.ExerciseRecord;
import com.qxueyou.scc.exercise.model.ExerciseSubmitAnswerData;
import com.qxueyou.scc.exercise.model.ExerciseSubmitAnswerDataList;
import com.qxueyou.scc.exercise.service.IExerciseExtendService;

/**
 * Á·Ï°À©Õ¹¿ØÖÆ  
 * ÈçÊÕ²Ø ´íÌ⠱ʼÇ
 * @author zhiyong
 *
 */
@Controller
@RequestMapping(value = "/exercise/Extend")
public class ExerciseExtendController {
	/** ÈÕÖ¾ */
	private static final Logger log = LogManager.getLogger("ExerciseExtendController");
	
	/** commonDAO */
	@Autowired
	private CommonDAO commonDAO;
	
	/** Á·Ï°À©Õ¹service */
	@Autowired
	private IExerciseExtendService exerciseExtendService;
	
	/**-----------------------------------------APP  V2.0 ½Ó¿Ú start----------------------------------------------------------- */
	
	/**
	 * APP2.0: ²éѯ´íÌâ±¾ListItem
	 * URL:    /exercise/Extend/faultList
	 * 
	 * ÇëÇó²ÎÊý={
			subjectId:¿Î³Ìid£¬//¿ÉÑ¡£¬ÓÃÓÚ¸ßУ°æ
			exerType:Á·Ï°ÀàÐÍ,//±Ø´«
			page:µ±Ç°Ò³,//±Ø´«,´óÓÚ0
			limit:ÿҳÏÞÖÆÌõÊý,//±Ø´«,´óÓÚ0
			}
	  ·µ»Ø²ÎÊý=[
		    {
		        "groupId":"×éid",
		        "classId":°à¼¶id,
		        "courseId":¿ÆÄ¿id,
		        "orgId":»ú¹¹id,
		        "subjectId":¿Î³Ìid,
		        "name":"×éÃû",
		        "type":×éÀàÐÍ ,
		        "updateTime":¸üÐÂʱ¼ä,
		        "answerUpdateTime":±¾Ì×Ìâ´ðÌâ¸üÐÂʱ¼ä,
		        "allCount":ÌâÄ¿×ÜÊý,
		        "exerciseTime":"¿¼ÊÔʱ¼ä",
		        "exerciseRecordId":"¼Ç¼id",
		        "doCount": ×öÌâ¸öÊý,
		        "correctCount": ÕýÈ·¸öÊý,
		        "submitNumber":ÒÑÌá½»ÈËÊý(¼ÒÍ¥×÷Òµ),
		        "currTitleNumber":µ±Ç°×öÌâÐòºÅ,
		        "status":×öÌâ״̬(0£ºÎ´Ìá½» 1£ºÒÑÌá½»),
		        "completionRate": Íê³ÉÂÊ, 
		        "accuracy": ÕýÈ·ÂÊ, 
		        "score": ·ÖÊý,
		        "extendAllCount":´íÌâ±¾¡¢Êղر¾×ÜÊý
		    },
		    ...Ñ­»·¶à¸ö
		]
	 * 
	 * @return
	 */
	@RequestMapping(value = "faultList", method = RequestMethod.GET)
	public @ResponseBody List<ExerGroupResponseData> queryFaultList(
			@RequestParam(value="exerType") int exerType,// 0 ±íʾȫ²¿´íÌâ
			@RequestParam(value="subjectId", required = false) String subjectId,
			@RequestParam(value="page", required = false) Integer page,
			@RequestParam(value="limit", required = false) Integer limit)  {

		// µÃµ½·ÖÒ³Êý¾Ý
		Pager pager = getPager(page, limit);
		
		// ²éѯ½á¹û
		List<ExerGroupResponseData> lstResult = exerciseExtendService.
				queryExerciseFaultListData(exerType, null, pager);
		
		if(null == lstResult){// ½á¹ûת»»³É []
			lstResult = new ArrayList<ExerGroupResponseData>();
		}
		
		return lstResult;
	}
	
	/**
	 * APP2.0: ²éѯÊղر¾ListItem
	 * URL:    /exercise/Extend/favorList
	 * 
	 * @return 
	 */
	@RequestMapping(value = "favorList", method = RequestMethod.GET)
	public @ResponseBody List<ExerGroupResponseData> queryFavorList(
			@RequestParam(value="exerType") int exerType,// 0È«²¿ÊÕ²Ø
			@RequestParam(value="subjectId", required = false) String subjectId,
			@RequestParam(value="page", required = false) Integer page,
			@RequestParam(value="limit", required = false) Integer limit)  {
		
		// µÃµ½·ÖÒ³Êý¾Ý
		Pager pager = getPager(page, limit);
		
		// ²éѯ½á¹û
		List<ExerGroupResponseData> lstResult = exerciseExtendService.
				queryExerciseFavorListData(exerType, null, pager);
		
		if(null == lstResult){// ½á¹ûת»»³É []
			lstResult = new ArrayList<ExerGroupResponseData>();
		}
		
		return lstResult;
	}
	
	
	/**
	 * APP2.0: »ñÈ¡´íÌâÁ·Ï°ÌâÄ¿Êý¾Ý
	 * URL:    /exercise/Exercise/faultExercise
	 * @param groupId ×éid
	 * @param exerciseRecordId Á·Ï°¼Ç¼id
	 * @return
	 */
	@RequestMapping(value = "faultExercise", method = RequestMethod.GET)
	public @ResponseBody ExerItemResponseData getFaultExerciseData(
			@RequestParam(value = "groupId") String groupId)  {
		
			// ²éѯ½á¹û
			ExerItemResponseData resultData = exerciseExtendService.queryExerciseFaultData(groupId);
			
			return resultData;
	}
	
	/**
	 * ²éѯ¶àÌ×ÌâÊÕ²ØÌâÄ¿
	 * @param groupId ¸ñʽ"111,222,333...."
	 * @return
	 */
	@RequestMapping(value = "faultMutiExercise", method = RequestMethod.GET)
	public @ResponseBody List<Map<String,Object>> getFaultrMutiExerciseData(
			@RequestParam(value = "groupId") String groupId)  {
			
			String[] groupIds = groupId.split(",");
			
			if(groupIds.length<1){
				return null;
			}
			
			List<Map<String,Object>> resultDataLst = new ArrayList<Map<String,Object>>(groupIds.length);
			
			
			for(String exerGroupId:groupIds){
				try{
					// ²éѯ½á¹û
					resultDataLst.add(exerciseExtendService.queryExerciseMutiFaultData(exerGroupId));
					
				}catch(Exception e){
					
					log.error("²éѯ¶àÌ×ÌâfaultMutiExercise½á¹ûʧ°Ü£¬groupId="+exerGroupId,e);
				}
			}
			
			return resultDataLst;
	}
	
	/**
	 * 
	 * @param page
	 * @param limit
	 * @return
	 */
	private Pager getPager(Integer page,  Integer limit){
		
		Integer pageNum = page;
		Integer pageSize = limit;
		
		Pager pager = new Pager();
		
		if(pageNum == null){
			pageNum = 1;
			pageSize=Integer.MAX_VALUE;
		}
		
		pager.setPageNum(pageNum);
		pager.setPageSize(pageSize);
		
		return pager;
	}
	
	/**
	 * APP2.0: »ñÈ¡È«²¿´íÌâÁ·Ï°ÌâÄ¿Êý¾Ý
	 * URL:    /exercise/Extend/allFaultExercise
	 * @return
	 */
	@RequestMapping(value = "allFaultExercise", method = RequestMethod.GET)
	public @ResponseBody ExerItemResponseData getAllFaultExerciseData(
			@RequestParam(value="limit", required = false) Integer limit,
			@RequestParam(value="page", required = false) Integer page)  {
			
			// µÃµ½·ÖÒ³Êý¾Ý
			Pager pager = getPager(page, limit);
		
			// ²éѯ½á¹û
			ExerItemResponseData resultData = exerciseExtendService.queryAllExerciseFaultData(pager);
			
			return resultData;
	}
	
	/**
	 * APP2.0: »ñÈ¡ÊÕ²ØÁ·Ï°ÌâÄ¿Êý¾Ý
	 * URL:    /exercise/Exercise/favorExercise
	 * 
		·µ»ØÊý¾Ý={
		    "items":[// ÌâÄ¿¼¯ºÏ
		        {
		            "exerciseId":Á·Ï°id,
		            "chapterId":null,
		            "lessonId":null,
		            "title":±êÌâ,
		            "type":ÌâÄ¿ÀàÐÍ,
		            "answer":ÕýÈ·´ð°¸,
		            "options":[
		                {
		                    "optionId":Ñ¡Ïîid,
		                    "checked":true,
		                    "content":ÄÚÈÝ,
		                    "optionOrder":ÌâÄ¿ÐòºÅ,
		                    "exerciseItemId":"Á·Ï°id",
		                    "imgs":[
		                        {
		                            "imgId":"ͼƬid",
		                            "exerciseObjectId":null,
		                            "imgPath":ͼƬ·¾¶,
		                            "imgOrder":ÅÅÐò,
		                            "objectType":ͼƬÀàÐÍ 1£ºÌâÄ¿ 2£ºÑ¡Ïî
		                        },
		                        ... Ñ­»·¶à¸ö
		                    ]
		                },
		                ... Ñ­»·¶à¸ö
		            ],
		            "scores":null,
		            "itemNo":null,
		            "analisisResult":{
		                "allAccuracy":ȫվͳ¼Æ ÕýÈ·ÂÊ,
		                "analysis":"½âÎö",
		                "submitAllNumber":È«Õ¾ Ìá½»×ÜÊý,
		                "usualFaultAnswers":Ò×´íÌâ,
		                "exerciseAnalisisUId":null,
		                "accuracy":¸öÈËͳ¼Æ ÕýÈ·ÂÊ,
		                "submitNumber":¸öÈËͳ¼Æ  Ìá½»×ÜÊý,
		                "submitErrorNumber":¸öÈËͳ¼Æ  Ìá½»´íÎó×ÜÊý,
		            },
		            "imgs":[
		                {
		                   "imgId":"ͼƬid",
		                    "exerciseObjectId":null,
		                    "imgPath":ͼƬ·¾¶,
		                    "imgOrder":ÅÅÐò,
		                    "objectType":ͼƬÀàÐÍ 1£ºÌâÄ¿ 2£ºÑ¡Ïî
		                },
		                ... Ñ­»·¶à¸ö
		            ],
		            "commentFlag": null,
		        }
		    ],
		    "answers":[// ¸öÈ˴𰸼¯ºÏ
		        {
		            "answerUId":"Ö÷¼üid",
		            "answer":Ñ¡Ôñ´ð°¸  È磺¶àѡΪ(A,B,C),
		            "correct":0,
		            "exerciseItemId":Á·Ï°id,
		            "exerciseRecordId":¼Ç¼id,
		            "userId":Óû§id
		        },
		        ... Ñ­»·¶à¸ö
		    ]
		}
	 * 
	 * @param groupId ×éid
	 * @param exerciseRecordId Á·Ï°¼Ç¼id
	 * @return
	 */
	@RequestMapping(value = "favorExercise", method = RequestMethod.GET)
	public @ResponseBody ExerItemResponseData getFavorExerciseData(
			@RequestParam(value = "groupId") String groupId)  {
		
			// ²éѯ½á¹û
			ExerItemResponseData resultData = exerciseExtendService.queryExerciseFavorData(groupId);
			
			return resultData;
	}
	
	/**
	 * ²éѯ¶àÌ×ÌâÊÕ²ØÌâÄ¿
	 * @param groupId ¸ñʽ"111,222,333...."
	 * @return
	 */
	@RequestMapping(value = "favorMutiExercise", method = RequestMethod.GET)
	public @ResponseBody List<Map<String,Object>> getFavorMutiExerciseData(
			@RequestParam(value = "groupId") String groupId)  {
			
			String[] groupIds = groupId.split(",");
			
			if(groupIds.length<1){
				return null;
			}
			
			List<Map<String,Object>> resultDataLst = new ArrayList<Map<String,Object>>(groupIds.length);
			
			
			for(String exerGroupId:groupIds){
				try{
					// ²éѯ½á¹û
					resultDataLst.add(exerciseExtendService.queryExerciseMutiFavorData(exerGroupId));
					
				}catch(Exception e){
					
					log.error("²éѯ¶àÌ×ÌâfavorMutiExercise½á¹ûʧ°Ü£¬groupId="+exerGroupId,e);
				}
			}
			
			return resultDataLst;
	}
	
	
	
	/**
	 * APP2.0: »ñÈ¡È«²¿ÊÕ²ØÁ·Ï°ÌâÄ¿Êý¾Ý
	 * URL:    /exercise/Exercise/allFavorExercise
	 * @return
	 */
	@RequestMapping(value = "allFavorExercise", method = RequestMethod.GET)
	public @ResponseBody ExerItemResponseData getAllFavorExerciseData(
			@RequestParam(value="limit", required = false) Integer limit,
			@RequestParam(value="page", required = false) Integer page)  {
		
			// µÃµ½·ÖÒ³Êý¾Ý
			Pager pager = getPager(page, limit);
		
			// ²éѯ½á¹û
			ExerItemResponseData resultData = exerciseExtendService.queryAllExerciseFavorData(pager);
			
			return resultData;
	}
	
	/**
	 * APP2.0: Ìá½»´íÌâ±¾µÄ¼Ç¼µ½DB
	 * URL:    /exercise/Extend/submitFaultData
	 * 
	 * 	  ·µ»ØÊý¾Ý={
	   		"exerciseGroupType": Á·Ï°ÀàÐÍ, 
		    "exerciseGroupId": Á·Ï°×éid, 
		    "items":[
			   	{
				    "exerciseId": Á·Ï°id, 
				    "flag": ״̬, // (true:Ìí¼Ó  false:ÒƳý)
	
			   	},
			   	.....
	   		] 	
		  }
		  
	 * @param records
	 * @return
	 */
	@RequestMapping(value = "submitFaultData", method = RequestMethod.POST)
	public @ResponseBody Result doSubmitExerFaultRecord(
			@RequestParam(value = "records") String records,
			@RequestParam(value="subjectId", required = false) String subjectId)  {
		
		Result result = new Result(false);
		
		try {
			ObjectMapper mapper = new ObjectMapper();
			// ×°»»jsonµ½¶ÔÏó
			ExciseExtendReqData recordResult = mapper.readValue(records, ExciseExtendReqData.class);
			List<ExerciseExtendRecordData> lstRecords = recordResult.getItems();
			
			if(lstRecords.isEmpty()){
				return result; 
			}
			
			// Ìá½»½á¹û
			Map<String,Object> resultMap = exerciseExtendService.doOperExerciseFaultRecordData(null, recordResult);
			result.setResult(true);
			result.setData(resultMap);
			
		} catch (Exception e) {
			result = new Result(false);
			log.error(e);
		}
		
		return result; 
	}
	
	
	/**
	 * APP2.0: Ìá½»´íÌâ±¾µÄ¼Ç¼µ½DB
	 * URL:    /exercise/Extend/submitFaultData
	 * 
	 * 	  ·µ»ØÊý¾Ý={
	   		"exerciseGroupType": Á·Ï°ÀàÐÍ, 
		    "exerciseGroupId": Á·Ï°×éid, 
		    "items":[
			   	{
				    "exerciseId": Á·Ï°id, 
				    "flag": ״̬, // (true:Ìí¼Ó  false:ÒƳý)
	
			   	},
			   	.....
	   		] 	
		  }
		  
	 * @param records
	 * @return
	 */
	@RequestMapping(value = "submitFaultMutiData", method = RequestMethod.POST)
	public @ResponseBody Object doSubmitExerFaultMutiRecord(
			@RequestParam(value = "records") String records)  {
		
		Map<String,Object> resultMap = new HashMap<String,Object>(2);
		Map<String,Object> returnMap = null;
		resultMap.put("success", false);
		resultMap.put("attrs", null);
		List<Map<String,Object>> resultList = null;
		try {
			ObjectMapper mapper = new ObjectMapper();
			
			// ×°»»jsonµ½¶ÔÏó
			ExciseExtendReqListData recordData = mapper.readValue(records, ExciseExtendReqListData.class);
			
			//String subjectId = recordData.getSubjectId();
			List<ExciseExtendReqData> recordResults = recordData.getDatas();
			
			resultList = new ArrayList<Map<String,Object>>(recordResults.size());
			// Ñ­»·¼Ç¼
			List<ExerciseExtendRecordData> lstRecords = null;
			for(ExciseExtendReqData recordResult:recordResults){
				
				lstRecords = recordResult.getItems();
				
				if(lstRecords.isEmpty()){
					continue;
				}
				
				// Ìá½»½á¹û
				returnMap = exerciseExtendService.doOperExerciseFaultRecordData(null, recordResult);
				
				resultList.add(returnMap);
			}
			
			resultMap.put("success", true);
			resultMap.put("attrs", resultList);
			resultMap.put("msg", "Ìá½»³É¹¦");
		} catch (Exception e) {
			resultMap.put("msg", "Ìύʧ°Ü");
			log.error(e);
		}
		
		return resultMap; 
	}
	
	/**
	 * APP2.0: Ìá½»Êղر¾µÄ¼Ç¼µ½DB
	 * URL:    /exercise/Extend/submitFavorData
	 * 
	 * @param records  json×Ö·û´®
	 * @return
	 */
	@RequestMapping(value = "submitFavorData", method = RequestMethod.POST)
	public @ResponseBody Result doSubmitExerFavorRecord(
			@RequestParam(value = "records") String records,
			@RequestParam(value="subjectId", required = false) String subjectId)  {
		
		Result result = new Result(false);
		try {
			ObjectMapper mapper = new ObjectMapper();
			// ×°»»jsonµ½¶ÔÏó
			ExciseExtendReqData recordResult = mapper.readValue(records, ExciseExtendReqData.class);
			List<ExerciseExtendRecordData> lstRecords = recordResult.getItems();
			
			if(lstRecords.isEmpty()){
				return result; 
			}
			
			// Ìá½»½á¹û
			Map<String,Object> resultMap = exerciseExtendService.doOperExerciseFavorRecordData(null, recordResult);
			result.setResult(true);
			result.setData(resultMap);
			
		} catch (Exception e) {
			result = new Result(false);
			log.error(e);
		}
		
		return result; 
	}
	
	
	/**
	 * APP2.0: Ìá½»Êղر¾µÄ¼Ç¼µ½DB
	 * URL:    /exercise/Extend/submitFavorData
	 * 
	 * @param records  json×Ö·û´®
	 * @return
	 */
	@RequestMapping(value = "submitFavorMutiData", method = RequestMethod.POST)
	public @ResponseBody Object doSubmitExerFavorMutiRecord(
			@RequestParam(value = "records") String records)  {
		
		Map<String,Object> resultMap = new HashMap<String,Object>(2);
		Map<String,Object> returnMap = null;
		resultMap.put("success", false);
		resultMap.put("attrs", null);
		List<Map<String,Object>> resultList = null;
		try {
			
			ObjectMapper mapper = new ObjectMapper();
			
			// ×°»»jsonµ½¶ÔÏó
			ExciseExtendReqListData recordData = mapper.readValue(records, ExciseExtendReqListData.class);
			
			//String subjectId = recordData.getSubjectId();
			List<ExciseExtendReqData> recordResults = recordData.getDatas();
			resultList = new ArrayList<Map<String,Object>>(recordResults.size());
			
			// Ñ­»·¼Ç¼
			List<ExerciseExtendRecordData> lstRecords = null;
			for(ExciseExtendReqData recordResult:recordResults){
				
				lstRecords = recordResult.getItems();
				
				if(lstRecords.isEmpty()){
					continue;
				}
				
				// Ìá½»½á¹û
				returnMap = exerciseExtendService.doOperExerciseFavorRecordData(null, recordResult);
				
				resultList.add(returnMap);
			}
			resultMap.put("success", true);
			resultMap.put("attrs", resultList);
			resultMap.put("msg", "Ìá½»³É¹¦");
			
		} catch (Exception e) {
			log.error(e);
		}
		
		return resultMap; 
	}
	
	/**
	 * »ñµÃ¶àÌ×Ìâ´ð°¸
	 * @param groupId ¸ñʽ"111,222,333...."
	 * @return
	 */
	@RequestMapping(value = "getExtendAnswers", method = RequestMethod.GET)
	public @ResponseBody List<ExerItemResponseData> getExtendAnswersData(
			@RequestParam(value = "groupId") String groupId,
			@RequestParam(value = "exerciseType") String exerciseType)  {
			
			String[] groupIds = groupId.split(",");
			
			if(groupIds.length<1){
				return null;
			}
			
			List<ExerItemResponseData> resultDataLst = new ArrayList<ExerItemResponseData>(groupIds.length);
			
			
			for(String exerGroupId:groupIds){
				try{
					
					if(Constants.EXERCISE_TYPE_FAULT.equals(exerciseType)){// ´íÌâ±¾
						
						// ²éѯ½á¹û
						resultDataLst.add(exerciseExtendService.queryExerciseFaultAnswerData(exerGroupId));
						
					}else if(Constants.EXERCISE_TYPE_FAVORT.equals(exerciseType)){// ÊÕ²Ø
						// ²éѯ½á¹û
						resultDataLst.add(exerciseExtendService.queryExerciseFavorAnswerData(exerGroupId));
					}else{
						return null;
					}
					
				}catch(Exception e){
					
					log.error("»ñµÃ¶àÌ×Ìâ´ð°¸getExtendAnswers½á¹ûʧ°Ü£¬groupId="+exerGroupId,e);
				}
			}
			
			return resultDataLst;
	}
	
	
	/**
	 * APP2.0: Ìá½»Á·Ï°´ð°¸
	 * URL:    /exercise/Extend/exerExtendAnswers
	 * 
	 * ÇëÇóÊý¾Ý= answers={
			    "exerciseGroupId": ×éid, 
			    "exerciseRecordId": ¼Ç¼id, 
			    "exerciseExtendId": null, 
			    "currTitleNum": "µ±Ç°ÌâºÅ", 
			    "status": ״̬,
			    "type": Á·Ï°ÀàÐÍ,// ÕûÐÍ
			    "doCount": Á·Ï°ÀàÐÍ,
			    "correctCount": ÕýÈ·¸öÊý, 
			    "allCount":ÌâÄ¿×ÜÊý,
			    "items": [
			        {
			            "exerciseId": "Á·Ï°id", 
			            "type": Á·Ï°ÀàÐÍ,// ÕûÊýÐÍ
			            "answer": "Ñ¡Ôñ´ð°¸", 
			            "correct": ÊÇ·ñÕýÈ·(0:´íÎó 1£ºÕýÈ· 2:δ֪)
			        }, 
			        {
			            "exerciseId": "Á·Ï°id", 
			            "type": Á·Ï°ÀàÐÍ, 
			            "answer": "Ñ¡Ôñ´ð°¸", 
			            "correct": ÊÇ·ñÕýÈ·(0:´íÎó 1£ºÕýÈ· 2:δ֪)
			        }
			    ]
			}
			
		·µ»ØÊý¾Ý=	{"success":true,//true:³É¹¦ false:ʧ°Ü
				"attrs":{"exerciseRecordId":Á·Ï°¼Ç¼id,
						"updateTime":ÐÞ¸Äʱ¼ä
			     },
				"msg":"Ìá½»³É¹¦",//½á¹ûÐÅÏ¢
		}
	 * 
	 * @param answers 
	 * @return
	 */
	@RequestMapping(value = "exerExtendAnswers", method = RequestMethod.POST)
	public @ResponseBody Result doSubmitExerExtendAnswer(
			@RequestParam(value = "answers")  String answers)  {
		// Óû§±¾´Î×öÌâÌá½»µÄÊý¾Ý
		Result result = new Result(false);
		String initExerciseRecordId = "";
		try {
			ObjectMapper mapper = new ObjectMapper();
			// ×°»»jsonµ½¶ÔÏó
			ExerciseSubmitAnswerData answerResult = mapper.readValue(answers, ExerciseSubmitAnswerData.class);
			
			// 1.---------¼Ç¼Ìá½»µÄÊý¾ÝÈÕÖ¾
			// ¼Ç¼id
			initExerciseRecordId = answerResult.getExerciseRecordId();
			
			if(answerResult.getItems().isEmpty() 
					&& !ExerciseRecord.STATUS_SUBMIT.equals(answerResult.getStatus()) 
					&& answerResult.getSubmitType() != 1){// Ìύ״̬
				
				exerciseExtendService.doSaveExerciseDataSubmitLog(answers,
						initExerciseRecordId, ExerciseDataSubmitLog.TYPE_SUBMIT_EXTEND_ANSWER,
						ExerciseDataSubmitLog.STATUS_FAILED,"/exercise/Extend/exerExtendAnswers");
				
				return result;
			}
			
			// 2.Ìá½»´ð°¸
			result = exerciseExtendService.doSubmitExerciseAnswerData(answerResult);
			
			int status = 0;
			if(result.isSuccess()){
				status = ExerciseDataSubmitLog.STATUS_SUCCESS;
			}else{
				status = ExerciseDataSubmitLog.STATUS_FAILED;
			}
			
			// ¼Ç¼Ìá½»µÄÊý¾ÝÈÕÖ¾
			String exerciseDataLogId = exerciseExtendService.doSaveExerciseDataSubmitLog(answers,
					initExerciseRecordId, ExerciseDataSubmitLog.TYPE_SUBMIT_EXTEND_ANSWER, 
					status,"/exercise/Extend/exerExtendAnswers");
			
			if(StringUtils.isBlank(initExerciseRecordId) 
					&& result.getData("exerciseRecordId") != null){// Ϊ¿Õ ˵Ã÷µÚÒ»´ÎÌá½»  ¸üÐÂÈÕÖ¾¼Ç¼id
				exerciseExtendService.doUpdateExerciseDataSubmitLog(exerciseDataLogId, 
						String.valueOf(result.getData("exerciseRecordId")));
				
			}
			
		} catch (Exception e) {
			result = new Result(false);
			log.error(e);
			
			// ¼Ç¼Ìá½»µÄÊý¾ÝÈÕÖ¾
			exerciseExtendService.doSaveExerciseDataSubmitLog(answers,
					initExerciseRecordId, ExerciseDataSubmitLog.TYPE_SUBMIT_EXTEND_ANSWER,
					ExerciseDataSubmitLog.STATUS_FAILED,"/exercise/Extend/exerExtendAnswers");
		}
		
		return result;
	}
	
	
	/**
	 * APP2.0: Ìá½»Á·Ï°´ð°¸
	 * URL:    /exercise/Extend/exerExtendMutiAnswers
	 * 
	 * ÇëÇóÊý¾Ý= answers=[{
			    "exerciseGroupId": ×éid, 
			    "exerciseRecordId": ¼Ç¼id, 
			    "exerciseExtendId": null, 
			    "currTitleNum": "µ±Ç°ÌâºÅ", 
			    "status": ״̬,
			    "type": Á·Ï°ÀàÐÍ,// ÕûÐÍ
			    "doCount": Á·Ï°ÀàÐÍ,
			    "correctCount": ÕýÈ·¸öÊý, 
			    "allCount":ÌâÄ¿×ÜÊý,
			    "items": [
			        {
			            "exerciseId": "Á·Ï°id", 
			            "type": Á·Ï°ÀàÐÍ,// ÕûÊýÐÍ
			            "answer": "Ñ¡Ôñ´ð°¸", 
			            "correct": ÊÇ·ñÕýÈ·(0:´íÎó 1£ºÕýÈ· 2:δ֪)
			        }, 
			        {
			            "exerciseId": "Á·Ï°id", 
			            "type": Á·Ï°ÀàÐÍ, 
			            "answer": "Ñ¡Ôñ´ð°¸", 
			            "correct": ÊÇ·ñÕýÈ·(0:´íÎó 1£ºÕýÈ· 2:δ֪)
			        }
			    ]
			}]
			
		·µ»ØÊý¾Ý=	{"success":true,//true:³É¹¦ false:ʧ°Ü
				"attrs":{"exerciseRecordId":Á·Ï°¼Ç¼id,
						"updateTime":ÐÞ¸Äʱ¼ä
			     },
				"msg":"Ìá½»³É¹¦",//½á¹ûÐÅÏ¢
		}
	 * 
	 * @param answers 
	 * @return
	 */
	@RequestMapping(value = "exerExtendMutiAnswers", method = RequestMethod.POST)
	public @ResponseBody Object doSubmitExerExtendMutiAnswer(
			@RequestParam(value = "answers")  String answers)  {
		// Óû§±¾´Î×öÌâÌá½»µÄÊý¾Ý
		Map<String,Object> resultMap = new HashMap<String,Object>(2);
		resultMap.put("success", false);
		resultMap.put("attrs", null);
		try {
			ObjectMapper mapper = new ObjectMapper();
			// ×°»»jsonµ½¶ÔÏó
			ExerciseSubmitAnswerDataList answerDataList = mapper.readValue(answers, ExerciseSubmitAnswerDataList.class);
			
			// Ìá½»´ð°¸
			resultMap = exerciseExtendService.doSubmitMutiExerciseAnswerData(answerDataList);
			
		} catch (Exception e) {
			log.error(e);
			resultMap.put("msg", "Ìá½»Á·Ï°´ð°¸ÇëÇóÒì³£");
			
			exerciseExtendService.doSaveExerciseDataSubmitLog(answers,
					"exerExtendMutiAnswers", ExerciseDataSubmitLog.TYPE_SUBMIT_EXTEND_ANSWER, 
					ExerciseDataSubmitLog.STATUS_FAILED, "/exercise/Extend/exerExtendMutiAnswers");
		}
		
		return resultMap;
	}
	
	/**
	 * APP2.0:  app¶ËÖØпªÊ¼×öÌâ ¸üÐÂ״̬
	 * URL:    /exercise/Extend/updateNewExerRecordNew
	 * 
	 * @param groupId Ï°Ìâ×éID  Èç¹ûΪAllʱ£¬±íʾȫ²¿´íÌâ
	 * @return
	 */
	@RequestMapping(value = "updateNewExerRecordNew", method = RequestMethod.GET)
	public @ResponseBody Result doUpdateExerItemNumber(
			@RequestParam(value = "groupId")  String groupId,// Ï°Ìâ×éID  Èç¹ûΪAllʱ£¬±íʾȫ²¿´íÌ⡢ȫ²¿ÊÕ²Ø
			@RequestParam(value = "exerciseType")  String exerciseType)  {
		
		Map<String,Object> map = null;
		Result result = new Result(true, "״̬¸üгɹ¦");
		if(Constants.EXERCISE_TYPE_FAULT.equals(exerciseType)){// ´íÌâ±¾
			
			 map = exerciseExtendService.doUpdateFaultExerRecordNew(groupId);
			
		}else if(Constants.EXERCISE_TYPE_FAVORT.equals(exerciseType)){// ÊÕ²Ø
			
			map = exerciseExtendService.doUpdateFavortExerRecordNew(groupId);
		}else{
			
			result = new Result(false, "exerciseType´«Öµ´íÎó£ºexerciseType="+exerciseType);
		}
		
		result.setData(map);
		
		return result;
	} 
	
	/**
	 * APP2.0: ¸üÐÂÁ·Ï°×÷ÒµÌâºÅ app¶ËÖØпªÊ¼×öÌâ
	 * URL:    /exercise/Extend/updateExerciseRecord
	 * 
	 * @param groupId         Ï°Ìâ×éID
	 * @return
	 */
	@RequestMapping(value = "updateExerciseRecord", method = RequestMethod.GET)
	public @ResponseBody Result doUpdateExerciseRecord(
			@RequestParam(value = "groupId")  String groupId,// all ±íʾȫ²¿´íÎó»òÊÕ²Ø
			@RequestParam(value = "exerciseType")  String exerciseType,
			@RequestParam(value = "exerciseRecordId") String exerciseRecordId,
			@RequestParam(value = "currTitleNum", required = false) String currTitleNum)  {
		
		
		Result result = new Result(true, "״̬¸üгɹ¦");
		
		if(StringUtils.isBlank(exerciseRecordId) && !"All".equals(groupId)){
			return new Result(false, "¸üÐÂʧ°Ü£¬exerciseRecordIdΪ¿Õ");
		}

		if(Constants.EXERCISE_TYPE_FAULT.equals(exerciseType)){// ´íÌâ±¾
			
			if("All".equals(groupId)){// È«²¿´íÌâ
				return exerciseExtendService.doUpdateExerciseFaultBook(currTitleNum);
			}
			
			ExerciseFaultRecord record = commonDAO.read(ExerciseFaultRecord.class, exerciseRecordId);
			record.setTitleMaxNumber(currTitleNum);
			
			result = exerciseExtendService.doUpdateExerciseFaultRecord(record);
			
		}else if(Constants.EXERCISE_TYPE_FAVORT.equals(exerciseType)){// ÊÕ²Ø
			
			if("All".equals(groupId)){// È«²¿ÊÕ²Ø
				return exerciseExtendService.doUpdateExerciseFavorBook(currTitleNum);
			}
			
			ExerciseFavoriteRecord record = commonDAO.read(ExerciseFavoriteRecord.class, exerciseRecordId);
			record.setTitleMaxNumber(currTitleNum);
			
			result = exerciseExtendService.doUpdateExerciseFavorRecord(record);
		}else{
			
			result = new Result(false, "exerciseType´«Öµ´íÎó£ºexerciseType="+exerciseType);
		}
		
		return result;
	}

	/**
	 * APP2.0: ²éѯ´íÌâ ÊղرʼǸöÊý
	 * URL:    /exercise/Extend/queryExerCount
	 * @return ¼üÖµ¶Ô£ºiFavor ÊղظöÊý   iFault ´íÎó¸öÊý
	 */
	@RequestMapping(value = "exerBookInfo", method = RequestMethod.GET)
	public @ResponseBody Result queryExtendListCount(
			@RequestParam(value = "exerciseType")  String exerciseType)  {
		
		Map<String, Object> map = null;
		Result result = new Result(false);
		if(Constants.EXERCISE_TYPE_FAULT.equals(exerciseType)){// ´íÌâ±¾
			
			map = exerciseExtendService.queryExerFaultInfo();
			
		}else if(Constants.EXERCISE_TYPE_FAVORT.equals(exerciseType)){// ÊÕ²Ø
			
			map = exerciseExtendService.queryExerFavorInfo();
		}else{
			
			result = new Result(false, "exerciseType´«Öµ´íÎó£ºexerciseType="+exerciseType);
		}
		
		result = new Result(true, "²éѯ³É¹¦");
		result.setData(map);
		
		return result; 
	}

	/**
	 * APP2.0: ÌâÄ¿´ð°¸·ÖÎö
	 * URL:    /exercise/Extend/itemstatisics
	 * 
	 * 
	 * 
	 * @param groupId         Ï°Ìâ×éID
	 * @return
	 */
	@RequestMapping(value = "itemStatisics", method = RequestMethod.GET)
	public @ResponseBody List<Map<String, Object>> doQueryExerciseItemStatisics(
			@RequestParam(value = "exerciseType")  String exerciseType)  {
		
		// ²éѯ½á¹û
		List<Map<String, Object>> resultLst = exerciseExtendService.queryExerciseItemStatisics(exerciseType);
		
		return resultLst;
	} 
	
	/**
	 * ´íÌâͳ¼Æ½Ó¿Ú
	 * URL:    /exercise/Extend/faultStatis
	 * 
	 * @return
	 */
	@RequestMapping(value = "faultStatis", method = RequestMethod.GET)
	public @ResponseBody Result doCalcFaultStatisInfo()  {
		
		return exerciseExtendService.doCalcExerFaultStatisticsByDay();
	} 
	
	/**
	 *µÃµ½ ´íÌâͳ¼ÆÐÅÏ¢
	 * URL:    /exercise/Extend/faultStatis
	 * 
	 * type :week ×î½üÒ»ÖÜ   month:×î½üÒ»Ô  year£º×î½üÒ»Äê
	 * @return
	 */
	@RequestMapping(value = "getfaultStatis", method = RequestMethod.GET)
	public @ResponseBody List<Map<String,Object>> doGetFaultStatisInfo(
			@RequestParam(value = "type")  String type )  {
		
		return exerciseExtendService.doGetFaultStatisInfo(type);
	} 
	
	/**-----------------------------------------APP  V2.0 ½Ó¿Ú end----------------------------------------------------------- */
	
	@RequestMapping(value = "initFaultStatisData", method = RequestMethod.GET)
	public @ResponseBody Result doInitExerRecentRecord()  {
		
		return exerciseExtendService.doInitFaultStatisData();
	}
	
	
	/*@RequestMapping(value = "initExerRecentRecord", method = RequestMethod.GET)
	public @ResponseBody Result doInitExerRecentRecord()  {
		
		return exerciseExtendService.doInitExerRecentRecord();
	}
	
	@RequestMapping(value = "initFaultRecord", method = RequestMethod.GET)
	public @ResponseBody Result doInitExerOldGroup()  {
		
		return exerciseExtendService.doInitFaultRecord();
	}
	
	@RequestMapping(value = "initFaultItem", method = RequestMethod.GET)
	public @ResponseBody Result doInitFaultItem()  {
		
		// 2.
		String sql2="select f,re.exerciseGroupId"
				+" from ExerciseFault f,ExerciseGroupItemRe re"
				+" where f.exerciseItemId=re.exerciseItemId"
				+" and (f.faultRecordId is null or f.faultRecordId='') order by f.exerciseFaultId";
		
		List<Object[]> lstData2 =commonDAO.findwithRawResult(sql2, new ArrayList<Object>());
		
		if(lstData2.isEmpty()){//Å×Òì³£»Ø¹ö
			return new Result(false,"´íÌâÊý¾ÝΪ¿Õ2222");
		}
		
		String hql_existRecord = "from ExerciseFaultRecord where  resumeBookId=? and exerciseGroupId=? ";
		ExerciseFault fault=null;
		ExerciseFault newFault=null;
		String exerciseFaultId="";
		List<ExerciseFaultRecord> lstRecord = null;
		int i=0;
		for(Object[] objs:lstData2){
			fault = (ExerciseFault)objs[0];
			if(fault.getExerciseFaultId().equals(exerciseFaultId)){
				newFault = new ExerciseFault();
				BeanUtils.copyProperties(fault, newFault);
				newFault.setExerciseFaultId(null);
				
				lstRecord = commonDAO.find(hql_existRecord, CollectionUtils.newList(newFault.getResumeBookId(),String.valueOf(objs[1])), ExerciseFaultRecord.class);
				if(lstRecord.isEmpty()){
					continue;
				}
				
				newFault.setFaultRecordId(lstRecord.get(0).getFaultRecordId());
				TraceUtils.setUpdateTrace(newFault);
				exerciseExtendService.doSavetoDB(newFault);
			}else{
				lstRecord = commonDAO.find(hql_existRecord, CollectionUtils.newList(fault.getResumeBookId(),String.valueOf(objs[1])), ExerciseFaultRecord.class);
				if(lstRecord.isEmpty()){
					continue;
				}
				
				fault.setFaultRecordId(lstRecord.get(0).getFaultRecordId());
				TraceUtils.setUpdateTrace(fault);
				exerciseExtendService.doSavetoDB(fault);
			}
			
			exerciseFaultId=fault.getExerciseFaultId();
			i++;
		}
		
		return new Result(true, "¸üÐÂExerciseFaultÌõÊý£º"+i);
	}
	
	
	
	@RequestMapping(value = "initFavorRecord", method = RequestMethod.GET)
	public @ResponseBody Result doInitFavorRecord()  {
		
		return exerciseExtendService.doInitFavorRecord();
	}
	

	@RequestMapping(value = "initFavorItem", method = RequestMethod.GET)
	public @ResponseBody Result doInitFavorItem()  {
		
		String sql2="select f,re.exerciseGroupId"
				+" from ExerciseFavorite f,ExerciseGroupItemRe re"
				+" where f.exerciseItemId=re.exerciseItemId"
				+" and (f.favoriteRecordId is null or f.favoriteRecordId = '') order by f.exerciseFavoriteId";
		
		List<Object[]> lstData2 =commonDAO.findwithRawResult(sql2, new ArrayList<Object>());
		
		if(lstData2.isEmpty()){//Å×Òì³£»Ø¹ö
			return new Result(false,"ÊÕ²ØÊý¾ÝΪ¿Õ2222");
		}
		
		String hql_existRecord = "from ExerciseFavoriteRecord where  favoriteBookId=? and exerciseGroupId=? ";
		List<ExerciseFavoriteRecord> lstRecord = null;
		ExerciseFavorite favor=null;
		ExerciseFavorite newFavor=null;
		String exerciseFavoriteId="";
		int i=0;
		for(Object[] objs:lstData2){
			favor = (ExerciseFavorite)objs[0];
			if(favor.getExerciseFavoriteId().equals(exerciseFavoriteId)){
				
				newFavor = new ExerciseFavorite();
				BeanUtils.copyProperties(favor, newFavor);
				newFavor.setExerciseFavoriteId(null);
				
				lstRecord = commonDAO.find(hql_existRecord, CollectionUtils.newList(newFavor.getFavoriteBookId(),String.valueOf(objs[1])), ExerciseFavoriteRecord.class);
				if(lstRecord.isEmpty()){
					continue;
				}
				
				newFavor.setFavoriteRecordId(lstRecord.get(0).getFavoriteRecordId());
				TraceUtils.setUpdateTrace(newFavor);
				exerciseExtendService.doSavetoDB(newFavor);
			}else{
				lstRecord = commonDAO.find(hql_existRecord, CollectionUtils.newList(favor.getFavoriteBookId(),String.valueOf(objs[1])), ExerciseFavoriteRecord.class);
				if(lstRecord.isEmpty()){
					continue;
				}
				
				favor.setFavoriteRecordId(lstRecord.get(0).getFavoriteRecordId());
				TraceUtils.setUpdateTrace(favor);
				
				exerciseExtendService.doSavetoDB(favor);
			}
			
			i++;
		}
		
		return new Result(true,"|¸üÐÂExerciseFavoriteÌõÊý£º"+i);
	}
	
	@SuppressWarnings("unchecked")
	@RequestMapping(value = "updateAnswerU", method = RequestMethod.GET)
	public @ResponseBody Result doUpdateAnswerU()  {
		

		int count = commonDAO.findCount("select count(1) from ExerciseItemAnswerU where correct>1", Collections.EMPTY_LIST);
		
		Pager page = new Pager();
		
		int pageSize = 50;
		
		int maxPage = count/pageSize + (count%pageSize>0?1:0);
		
		page.setPageSize(pageSize);
		page.setTotalCount(count);
		int j=0;
		String hql2;
		for(int i=1;i<=maxPage;i++){
			page.setPageNum(i);
			List<ExerciseItemAnswerU> lstAnswerU = commonDAO.findList("from ExerciseItemAnswerU where correct>1", page, Collections.EMPTY_LIST, ExerciseItemAnswerU.class);
			for(ExerciseItemAnswerU answer:lstAnswerU){
				hql2 = "select answer from ExerciseItem where (answer is not null and answer != '') and exerciseId=? and deleteFlag is false ";
				
				List<Object[]> lstData2 =commonDAO.findwithRawResult(hql2, CollectionUtils.newList(answer.getExerciseItemId()));
				
				if(lstData2.isEmpty()){
					continue;
				}
				
				if(!answer.getAnswer().equals(String.valueOf(lstData2.get(0)))
						&& answer.getCorrect() != 0){
					answer.setCorrect((byte)0);
					TraceUtils.setUpdateTrace(answer);
					exerciseExtendService.doSavetoDB(answer);
					
					j++;
				}
				
				if(answer.getAnswer().equals(String.valueOf(lstData2.get(0)))
						&& answer.getCorrect() != 1){
					answer.setCorrect((byte)1);
					TraceUtils.setUpdateTrace(answer);
					exerciseExtendService.doSavetoDB(answer);
					
					j++;
				}
				
			}
		}
		
		return new Result(true,"|¸üÐÂExerciseItemAnswerUÌõÊý£º"+j);
	}*/
}