package com.qxueyou.scc.exercise.util;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang3.StringUtils;

import com.qxueyou.scc.base.model.ITrace;
import com.qxueyou.scc.base.util.CollectionUtils;
import com.qxueyou.scc.base.util.CommonUtils;
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.ExerciseOptionStatistics;
import com.qxueyou.scc.school.model.SchEvaluate;

/**
 * Á·Ï°¹¤¾ßÀà
 * 
 * @author zhiyong
 *
 */
public class ExerciseUtils {

	/**
	 * ÖØÐÂ×é×°Á·Ï°item
	 * 
	 * @param lstItems
	 * @return
	 */
	public static void packageExerciseItem(List<ExerciseItem> lstItems, List<ExerciseItemAnswerU> lstUserAnswer,
			List<ExerciseObjectImg> lstOptionImgs) {
		for (ExerciseItem objExerciseItem : lstItems) {
			// Ñ¡Ïî
			List<ExerciseItemOption> options = objExerciseItem.getOptions();
			// Ñ¡Ïî·ÖÊý
			List<ExerciseItemScore> scores = objExerciseItem.getScores();
			ExerciseUtils.packOption(options, scores, lstOptionImgs);
			if (lstUserAnswer == null || lstUserAnswer.isEmpty()) {
				continue;
			}
			for (ExerciseItemAnswerU answerU : lstUserAnswer) {
				// »ñÓû§´ð°¸
				if (answerU.getExerciseItemId().equals(objExerciseItem.getExerciseId())) {
					objExerciseItem.setAnswer(answerU.getAnswer());
					break;
				}
			}
		}
	}

	/**
	 * ΪѡÏî×é×°·ÖÊýºÍͼƬ
	 * 
	 * @return
	 */
	private static List<ExerciseItemOption> packOption(List<ExerciseItemOption> options, List<ExerciseItemScore> scores,
			List<ExerciseObjectImg> lstOptionImgs) {
		if (options == null || options.isEmpty()) {
			return options;
		}
		if (scores == null || scores.isEmpty()) {
			return options;
		}
		for (ExerciseItemOption objExerciseItemOption : options) {
			for (ExerciseItemScore objExerciseItemScore : scores) {
				if (objExerciseItemScore.getAttribute1().equals(objExerciseItemOption.getOptionId())) {
					objExerciseItemOption.setScore((int) (Double.parseDouble(objExerciseItemScore.getScore())));
					break;
				}
			}
			// ͼƬ
			if (lstOptionImgs == null || lstOptionImgs.isEmpty()) {
				continue;
			}
			for (ExerciseObjectImg objExerciseObjectImg : lstOptionImgs) {
				if (objExerciseObjectImg.getExerciseObjectId().equals(objExerciseItemOption.getOptionId())) {
					List<ExerciseObjectImg> lstImgs = new ArrayList<>();
					lstImgs.add(objExerciseObjectImg);
					objExerciseItemOption.setImgPath(objExerciseObjectImg.getImgPath());
					objExerciseItemOption.setImgs(lstImgs);
					break;
				}
			}
		}
		return options;
	}

	/**
	 * ×é×°ÎʾíÏêϸͳ¼ÆÇé¿ö
	 * 
	 * @param lstItems
	 * @param objSchEvaluate
	 * @return
	 */
	public static Map<String, Object> packageExerciseDetail(List<ExerciseItem> lstItems, SchEvaluate objSchEvaluate) {
		Map<String, Object> mResult = new HashMap<String, Object>();
		double iTotalAverageScore = 0;
		double iTotalScore = 0;
		for (ExerciseItem objExerciseItem : lstItems) {
			// Ñ¡Ïî
			List<ExerciseItemOption> options = objExerciseItem.getOptions();
			// Ñ¡Ïî·ÖÊý
			List<ExerciseItemScore> scores = objExerciseItem.getScores();

			ExerciseUtils.packOption(options, scores, null);
			List<ExerciseItemAnswerU> exerciseItemAnswerU = objExerciseItem.getExerciseItemAnswerU();
			// ƽ¾ù·ÖÊý
			double dAverageScore = 0;
			double dUserScore = 0;
			// ÊÇ·ñ´æÔÚ´ðÌâѧԱ
			boolean hasAnswerU = exerciseItemAnswerU != null && !exerciseItemAnswerU.isEmpty();
			if (options == null || options.isEmpty()) {
				continue;
			}
			// ͳ¼Æÿ¸öÑ¡ÏîµÄÇé¿ö
			LinkedHashMap<String, Integer> mOptionsDetail = new LinkedHashMap<String, Integer>();
			LinkedHashMap<String, Integer> mOptionOrderDetail = new LinkedHashMap<String, Integer>();
			if (!hasAnswerU) {
				continue;
			}
			for (ExerciseItemAnswerU objExerciseItemAnswerU : exerciseItemAnswerU) {
				String strAnswer = objExerciseItemAnswerU.getAnswer();
				if (StringUtils.isEmpty(strAnswer)) {// Ϊ¿Õ×Ô¶¯Ìø³öÑ­»·
					break;
				}
				Map<String, Object> mResult2 = packageItemOption(objExerciseItem, strAnswer, mOptionsDetail, mOptionOrderDetail);
				objExerciseItemAnswerU.setAnswerValue((String) mResult2.get("userAnswerContent"));
				objExerciseItem.setMaxScore((Double) mResult2.get("dMaxScore"));
				dUserScore += (Double) mResult2.get("dUserScore");
			}
			// ¼ÆËãƽ¾ùÖµ
			if (hasAnswerU) {
				dAverageScore = dUserScore / exerciseItemAnswerU.size();
			}
			// ×î´óÖµ
			iTotalScore += objExerciseItem.getMaxScore();
			objExerciseItem.setOptionsDetail(mOptionsDetail);
			if(!mOptionOrderDetail.isEmpty()) {
				List<Map<String, Object>> optionsOrderDetail = new ArrayList<>();
				for (String key : mOptionOrderDetail.keySet()) { 
					optionsOrderDetail.add(CollectionUtils.newObjectMap("optionsOrder", key, "count", mOptionOrderDetail.get(key)));
				} 
				objExerciseItem.setOptionsOrderDetail(optionsOrderDetail);
			}
			objExerciseItem.setAverageScore(dAverageScore);
			iTotalAverageScore += dAverageScore;
			objExerciseItem.setScores(null);
		}
		mResult.put("iTotalAverageScore", iTotalAverageScore);
		mResult.put("iTotalScore", iTotalScore);
		mResult.put("lstExerciseItem", lstItems);
		mResult.put("objSchEvaluate", objSchEvaluate);
		return mResult;
	}

	/**
	 * ×é×°ÎʾíÏêϸͳ¼ÆÇé¿ö
	 * 
	 * @param lstItems
	 * @param objSchEvaluate
	 * @return
	 */
	public static Map<String, Object> packageUserExerciseDetail(List<ExerciseItem> result, SchEvaluate objSchEvaluate,
			List<ExerciseObjectImg> lstExerciseObjectImg) {
		Map<String, Object> mResult = new HashMap<String, Object>();
		double iTotalScore = 0;
		List<ExerciseItem> lstItems = new ArrayList<>();
		double dTotalScoreU = 0;
		String strCreator = "";
		for (ExerciseItem objExerciseItem : result) {
			lstItems.add(objExerciseItem);
			List<ExerciseItemAnswerU> lstExerciseItemAnswerU = objExerciseItem.getExerciseItemAnswerU();
			// Ñ¡Ïî
			List<ExerciseItemOption> options = objExerciseItem.getOptions();
			// Ñ¡Ïî·ÖÊý
			List<ExerciseItemScore> scores = objExerciseItem.getScores();
			// ×é×°Ñ¡ÏîºÍ·ÖÊý
			ExerciseUtils.packOption(options, scores, lstExerciseObjectImg);
			if (lstExerciseItemAnswerU == null || lstExerciseItemAnswerU.isEmpty()) {
				continue;
			}
			// Óû§´ð°¸
			String strAnswer = lstExerciseItemAnswerU.get(0).getAnswer();
			if (StringUtils.isEmpty(strAnswer)) {// Ϊ¿Õ×Ô¶¯Ìø³öÑ­»·
				break;
			}
			strCreator = lstExerciseItemAnswerU.get(0).getCreator();
			if (objExerciseItem.getType() == ExerciseItem.TYPE_ESSAY_QUESTION) {// ÎÊ´ðÌâ
				objExerciseItem.setAnswer(strAnswer);
			} else {
				if (options == null || options.isEmpty()) {
					continue;
				}
				Map<String, Object> mResult2 = packageItemOption(objExerciseItem, strAnswer,
						new LinkedHashMap<String, Integer>(), new LinkedHashMap<String, Integer>());
				objExerciseItem.setMaxScore((Double) mResult2.get("dUserScore"));
				iTotalScore += (Double) mResult2.get("dMaxScore");
				dTotalScoreU += (Double) mResult2.get("dUserScore");
				objExerciseItem.setScores(null);
				objExerciseItem.setAnswer((String) mResult2.get("userAnswerContent"));
			}
		}
		mResult.put("iTotalScore", iTotalScore);
		mResult.put("dTotalScoreU", dTotalScoreU);
		mResult.put("lstExerciseItem", lstItems);
		mResult.put("objSchEvaluate", objSchEvaluate);
		mResult.put("strUserName", strCreator);
		return mResult;
	}

	/**
	 * ÅжÏÌâÄ¿ÀàÐÍ
	 * 
	 * @param objExerciseItem
	 *            퉀	 * @param strAnswer
	 *            Óû§Ñ¡Ôñ´ð°¸
	 * @param mOptionsDetail
	 *            ͳ¼ÆÖµ
	 * @return
	 */
	public static Map<String, Object> packageItemOption(ExerciseItem objExerciseItem, String strAnswer,
			LinkedHashMap<String, Integer> mOptionsDetail, LinkedHashMap<String, Integer> mOptionOrderDetail) {
		Map<String, Object> mResult = new HashMap<String, Object>();
		// Ñ¡Ïî
		List<ExerciseItemOption> options = objExerciseItem.getOptions();
		double dMaxScore = 0;
		double dUserScore = 0;
		String[] c = "A B C D E F G H I J K L M N".split(" ");
		// ÌâÄ¿ÀàÐÍ
		int iType = objExerciseItem.getType();
		int index = 0;
		StringBuffer userAnswerContent = new StringBuffer(256);
		for (ExerciseItemOption objExerciseItemOption : options) {
			double dScore = Double.valueOf(objExerciseItemOption.getScore());
			// »ñÈ¡×î´óÖµ
			dMaxScore = iType == 2 ? dMaxScore + dScore : dScore > dMaxScore ? dScore : dMaxScore;
			if (iType == ExerciseItem.TYPE_SINGLE_SELECT
					&& strAnswer.substring(0, 1).equals(objExerciseItemOption.getOptionOrder())) {// µ¥Ñ¡A»òB»òC»òD_²¹³äxxxxxx
				dUserScore += dScore;
				userAnswerContent.append(strAnswer.length() > 2
						? objExerciseItemOption.getContent() + strAnswer.substring(1, strAnswer.length()) : // Æ´½Ó²¹³äÄÚÈÝ
						objExerciseItemOption.getContent());
				mOptionsDetail.put(ExerciseUtils.getOptionsContent(objExerciseItemOption),
						ExerciseUtils.getValue(ExerciseUtils.getOptionsContent(objExerciseItemOption), mOptionsDetail));
				mOptionOrderDetail.put(objExerciseItemOption.getOptionOrder(),mOptionsDetail.get(ExerciseUtils.getOptionsContent(objExerciseItemOption)));
			} else if (iType == ExerciseItem.TYPE_MULTI_SELECT) {// ¶àÑ¡A,B,C,D_²¹³äxxxxxx
				String[] arrAnswer = strAnswer.split("_");
				String[] strAnswerOrder = arrAnswer[0].split(",");
				for (int i = 0; i < strAnswerOrder.length; i++) {
					if (strAnswerOrder[i].equals(objExerciseItemOption.getOptionOrder())) {
						dUserScore += dScore;
						// Æ´½Ó²¹³äµÄÄÚÈÝ
						if (index == options.size() - 1) {
							userAnswerContent.append(objExerciseItemOption.getContent());
							userAnswerContent.append(arrAnswer.length > 1 && arrAnswer[1].length() > 2
									? "_" + strAnswer.substring(arrAnswer[0].length() + 1, strAnswer.length()) : "");
						} else {
							userAnswerContent.append(objExerciseItemOption.getContent()).append(';');
						}
						mOptionsDetail.put(ExerciseUtils.getOptionsContent(objExerciseItemOption), ExerciseUtils
								.getValue(ExerciseUtils.getOptionsContent(objExerciseItemOption), mOptionsDetail));
						mOptionOrderDetail.put(objExerciseItemOption.getOptionOrder(),mOptionsDetail.get(ExerciseUtils.getOptionsContent(objExerciseItemOption)));
					}
				}
			} else if (iType == ExerciseItem.TYPE_SCORE
					&& c[Integer.valueOf(strAnswer) - 1].equals(objExerciseItemOption.getOptionOrder())) {// ·ÖÖµ£¬1£¬2£¬3£¬4£¬5¿ÅÐÇ
				dUserScore += dScore;
				userAnswerContent.append(ExerciseUtils.getOptionsContent(objExerciseItemOption));// ¸ø´ð°¸ÎÄ×Ö¸³Öµ
				mOptionsDetail.put(ExerciseUtils.getOptionsContent(objExerciseItemOption),
						ExerciseUtils.getValue(ExerciseUtils.getOptionsContent(objExerciseItemOption), mOptionsDetail));
				mOptionOrderDetail.put(objExerciseItemOption.getOptionOrder(),mOptionsDetail.get(ExerciseUtils.getOptionsContent(objExerciseItemOption)));
			} else if (iType == ExerciseItem.TYPE_MEASUREMENT && index == 0) {// Á¿Öµ£¬Ö±½Ó´æ·ÖÊý
				dUserScore += Integer.valueOf(strAnswer);
				userAnswerContent.append(strAnswer).append("·Ö");
				mOptionsDetail.put(strAnswer + "·Ö",
						mOptionsDetail.get(strAnswer + "·Ö") == null ? 1 : mOptionsDetail.get(strAnswer + "·Ö") + 1);
				mOptionOrderDetail.put(strAnswer,mOptionsDetail.get(strAnswer + "·Ö"));
			}
			index++;
		}
		mResult.put("dMaxScore", dMaxScore);
		mResult.put("userAnswerContent", userAnswerContent.toString());
		mResult.put("dUserScore", dUserScore);
		return mResult;
	}

	/**
	 * »ñÈ¡Öµ
	 * 
	 * @param content
	 * @param mOptionsDetail
	 * @param Content
	 * @return
	 */
	public static Integer getValue(String content, Map<String, Integer> mOptionsDetail) {
		return mOptionsDetail.get(content) == null ? 1 : mOptionsDetail.get(content) + 1;
	}

	/**
	 * »ñÈ¡Ñ¡ÏîµÄÖµºÍ·ÖÊý
	 * 
	 * @param objExerciseItemOption
	 * @return
	 */
	public static String getOptionsContent(ExerciseItemOption objExerciseItemOption) {
		return objExerciseItemOption.getContent().concat("(").concat(String.valueOf(objExerciseItemOption.getScore()))
				.concat("·Ö)");
	}

	/**
	 * ÖØÐÂ×é×°Á·Ï°item
	 * 
	 * @param lstAllOptions
	 * @return
	 */
	public static void packageExerciseItem(Map<String, List<ExerciseItemOption>> optionsMap,
			Map<String, String> answerMap, List<ExerciseItemOption> lstAllOptions,
			Map<String, List<ExerciseObjectImg>> imgOptionMap) {
		// ÉÏÒ»´ÎÁ·Ï°id
		String lastExerciseId = "";
		ExerciseItemOption option = null;
		List<ExerciseItemOption> lstOptions = null;
		StringBuffer correctAnswers = new StringBuffer(128); // ÕýÈ·´ð°¸
		// 4.3 ÌâÄ¿Ñ¡Ïî
		for (int i = 0; i < lstAllOptions.size(); i++) {
			option = lstAllOptions.get(i);

			if (imgOptionMap != null && imgOptionMap.get(option.getOptionId()) != null) {
				option.setImgs(imgOptionMap.get(option.getOptionId()));
			}

			if (i == 0) {// µÚÒ»´Î
				lstOptions = new ArrayList<ExerciseItemOption>();
				lstOptions.add(option);

				if (option.getChecked()) {// ÕýÈ·´ð°¸
					correctAnswers.append(option.getOptionOrder()).append(',');
				}
			} else {// µÚ¶þ´Î¿ªÊ¼
				if (lastExerciseId.equals(option.getExerciseItemId())) {// Ïàͬ
					lstOptions.add(option);

					if (option.getChecked()) {// ÕýÈ·´ð°¸
						correctAnswers.append(option.getOptionOrder()).append(',');
					}
				} else {// ²»Ïàͬ
						// Ìí¼Óµ½map
					optionsMap.put(lastExerciseId, lstOptions);
					answerMap.put(lastExerciseId, correctAnswers.toString());

					correctAnswers = new StringBuffer(128);
					if (option.getChecked()) {// ÕýÈ·´ð°¸
						correctAnswers.append(option.getOptionOrder()).append(',');
					}
					lstOptions = new ArrayList<ExerciseItemOption>();
					lstOptions.add(option);
				}
			}

			if (i == lstAllOptions.size() - 1) {// ×îºóÒ»´Î
				answerMap.put(option.getExerciseItemId(), correctAnswers.toString());
				optionsMap.put(option.getExerciseItemId(), lstOptions);
			}

			// ÉÏÒ»´ÎÁ·Ï°id
			lastExerciseId = option.getExerciseItemId();
		}
	}

	/**
	 * ÖØÐÂ×é×°Á·Ï°item ÌâĿͼƬ
	 * 
	 * @param lstAllOptions
	 * @return
	 */
	public static Map<String, List<ExerciseObjectImg>> packageExerciseItemImg(List<ExerciseObjectImg> lstImgs) {
		Map<String, List<ExerciseObjectImg>> imgMap = new HashMap<String, List<ExerciseObjectImg>>();
		// ÉÏÒ»´ÎÁ·Ï°id
		String lastExerciseId = "";
		ExerciseObjectImg objImg = null;
		List<ExerciseObjectImg> lstImg = null;
		// 4.3 ÌâÄ¿Ñ¡Ïî
		for (int i = 0; i < lstImgs.size(); i++) {
			objImg = lstImgs.get(i);

			if (i == 0) {// µÚÒ»´Î
				lstImg = new ArrayList<ExerciseObjectImg>();
				lstImg.add(objImg);
			} else {// µÚ¶þ´Î¿ªÊ¼
				if (lastExerciseId.equals(objImg.getExerciseObjectId())) {// Ïàͬ
					lstImg.add(objImg);
				} else {// ²»Ïàͬ
						// Ìí¼Óµ½map
					imgMap.put(lastExerciseId, lstImg);

					lstImg = new ArrayList<ExerciseObjectImg>();
					lstImg.add(objImg);
				}
			}

			if (i == lstImgs.size() - 1) {// ×îºóÒ»´Î
				imgMap.put(objImg.getExerciseObjectId(), lstImg);
			}

			// ÉÏÒ»´ÎÁ·Ï°id
			lastExerciseId = objImg.getExerciseObjectId();
		}

		return imgMap;
	}

	/**
	 * ÖØÐÂ×é×°Á·Ï°item
	 * 
	 * @param lstAllOptions
	 * @return
	 */
	public static void packageExerciseItemScore(Map<String, List<ExerciseItemScore>> scoreMap,
			List<ExerciseItemScore> lstAllscores) {
		// ÉÏÒ»´ÎÁ·Ï°id
		String lastExerciseId = "";
		ExerciseItemScore score = null;
		List<ExerciseItemScore> lstscore = null;
		// 4.3 ÌâÄ¿Ñ¡Ïî
		for (int i = 0; i < lstAllscores.size(); i++) {
			score = lstAllscores.get(i);

			if (i == 0) {// µÚÒ»´Î
				lstscore = new ArrayList<ExerciseItemScore>();
				lstscore.add(score);
			} else {// µÚ¶þ´Î¿ªÊ¼
				if (lastExerciseId.equals(score.getExerciseItemId())) {// Ïàͬ
					lstscore.add(score);
				} else {// ²»Ïàͬ
						// Ìí¼Óµ½map
					scoreMap.put(lastExerciseId, lstscore);

					lstscore = new ArrayList<ExerciseItemScore>();
					lstscore.add(score);
				}
			}

			if (i == lstAllscores.size() - 1) {// ×îºóÒ»´Î
				scoreMap.put(score.getExerciseItemId(), lstscore);
			}

			// ÉÏÒ»´ÎÁ·Ï°id
			lastExerciseId = score.getExerciseItemId();
		}
	}

	/**
	 * ÖØÐÂ×é×°×öÌâ¼Ç¼ ExerciseItemAnswer ¡ª¡ª ³É¼¨Í³¼Æ
	 * 
	 * @param lstAllOptions
	 * @return
	 */
	public static void packageExerciseItemAnswerStatis(List<ExerciseItemAnswerU> answers,
			Map<String, Object> answerUMap) {
		// ÉÏÒ»´ÎÁ·Ï°id
		String lastExerciseId = "";
		ExerciseItemAnswerU answer = null;
		List<ExerciseItemAnswerU> lstAnswers = null;
		// ×öÌâ¼Ç¼
		for (int i = 0; i < answers.size(); i++) {
			answer = answers.get(i);

			if (i == 0) {// µÚÒ»´Î
				lstAnswers = new ArrayList<ExerciseItemAnswerU>();
				lstAnswers.add(answer);
			} else {// µÚ¶þ´Î¿ªÊ¼
				if (lastExerciseId.equals(answer.getExerciseItemId())) {// Ïàͬ
					lstAnswers.add(answer);

				} else {// ²»Ïàͬ
						// Ìí¼Óµ½map
					answerUMap.put(lastExerciseId, lstAnswers);

					lstAnswers = new ArrayList<ExerciseItemAnswerU>();
					lstAnswers.add(answer);
				}
			}

			if (i == answers.size() - 1) {// ×îºóÒ»´Î
				answerUMap.put(answer.getExerciseItemId(), lstAnswers);
			}

			// ÉÏÒ»´ÎÁ·Ï°id
			lastExerciseId = answer.getExerciseItemId();
		}
	}

	/**
	 * ÖØÐÂ×é×°ÌâÄ¿Ñ¡ÏîExerciseItemOption ¡ª¡ª ³É¼¨Í³¼Æ
	 * 
	 * @param lstAllOptions
	 * @return
	 */
	public static void packageExerciseItemOption(List<ExerciseItemOption> itemOptionLst,
			Map<String, Object> itemOptionMap) {
		// ÉÏÒ»´ÎÁ·Ï°id
		String lastExerciseId = "";
		ExerciseItemOption option = null;
		List<ExerciseItemOption> lstOptions = null;
		// ÌâÄ¿Ñ¡Ïî
		for (int i = 0; i < itemOptionLst.size(); i++) {
			option = itemOptionLst.get(i);

			if (i == 0) {// µÚÒ»´Î
				lstOptions = new ArrayList<ExerciseItemOption>();
				lstOptions.add(option);
			} else {// µÚ¶þ´Î¿ªÊ¼
				if (lastExerciseId.equals(option.getExerciseItemId())) {// Ïàͬ
					lstOptions.add(option);

				} else {// ²»Ïàͬ
						// Ìí¼Óµ½map
					itemOptionMap.put(lastExerciseId, lstOptions);

					lstOptions = new ArrayList<ExerciseItemOption>();
					lstOptions.add(option);
				}
			}

			if (i == itemOptionLst.size() - 1) {// ×îºóÒ»´Î
				itemOptionMap.put(option.getExerciseItemId(), lstOptions);
			}

			// ÉÏÒ»´ÎÁ·Ï°id
			lastExerciseId = option.getExerciseItemId();
		}
	}

	/**
	 * ÖØÐÂ×é×°ÌâÄ¿Ñ¡Ïîͳ¼ÆExerciseOptionStatistics ¡ª¡ª ³É¼¨Í³¼Æ
	 * 
	 * @param lstAllOptions
	 * @return
	 */
	public static void packageExerciseOptionStatis(List<ExerciseOptionStatistics> claOptionStatisLst,
			Map<String, Object> optionStatisMap) {
		// ÉÏÒ»´ÎÁ·Ï°id
		String lastExerciseId = "";
		ExerciseOptionStatistics optionSta = null;
		List<ExerciseOptionStatistics> lstOptionStas = null;
		// ÌâÄ¿Ñ¡Ïî
		for (int i = 0; i < claOptionStatisLst.size(); i++) {
			optionSta = claOptionStatisLst.get(i);

			if (i == 0) {// µÚÒ»´Î
				lstOptionStas = new ArrayList<ExerciseOptionStatistics>();
				lstOptionStas.add(optionSta);
			} else {// µÚ¶þ´Î¿ªÊ¼
				if (lastExerciseId.equals(optionSta.getExerciseItemId())) {// Ïàͬ
					lstOptionStas.add(optionSta);

				} else {// ²»Ïàͬ
						// Ìí¼Óµ½map
					optionStatisMap.put(lastExerciseId, lstOptionStas);

					lstOptionStas = new ArrayList<ExerciseOptionStatistics>();
					lstOptionStas.add(optionSta);
				}
			}

			if (i == claOptionStatisLst.size() - 1) {// ×îºóÒ»´Î
				optionStatisMap.put(optionSta.getExerciseItemId(), lstOptionStas);
			}

			// ÉÏÒ»´ÎÁ·Ï°id
			lastExerciseId = optionSta.getExerciseItemId();
		}
	}

	/**
	 * »ñȡת»»½á¹û
	 * 
	 * @param count
	 * @param allCount
	 * @return
	 */
	public static String getFormatValue(long count, long allCount) {
		double value = Double.valueOf(count) / Double.valueOf(allCount) * 100;

		return CommonUtils.formatDecimalFormat(value, CommonUtils.PARTEN_ONE);
	}

	/**
	 * »ñȡת»»½á¹û
	 * 
	 * @param count
	 * @param allCount
	 * @return
	 */
	public static String getFormatValue(int count, int allCount) {
		double value = Double.valueOf(count) / Double.valueOf(allCount) * 100;

		return CommonUtils.formatDecimalFormat(value, CommonUtils.PARTEN_ONE);
	}

	/**
	 * ÉèÖÃÐÂÔö¹ì¼£ÐÅÏ¢
	 * 
	 * @param trace
	 */
	public static void setCreateTrace(ITrace trace, Map<String, String> userMap) {
		trace.setCreateId(userMap.get("userId"));
		trace.setCreateTime(new Date(System.currentTimeMillis()));
		trace.setCreator(userMap.get("userName"));
		trace.setUpdateId(userMap.get("userId"));
		trace.setUpdateTime(new Date(System.currentTimeMillis()));
		trace.setUpdator(userMap.get("userName"));

	}

	/**
	 * ÉèÖøüй켣ÐÅÏ¢
	 * 
	 * @param trace
	 */
	public static void setUpdateTrace(ITrace trace, Map<String, String> userMap) {

		trace.setUpdateId(userMap.get("userId"));
		trace.setUpdateTime(new Date(System.currentTimeMillis()));
		trace.setUpdator(userMap.get("userName"));

	}

	/**
	 * ת»»ÎªBigDecimal
	 * 
	 * @param str1
	 * @param str2
	 * @return
	 */
	public static BigDecimal parseStrToBigDecimal(String str1, String str2) {

		return new BigDecimal(
				CommonUtils.formatDecimalFormat(Double.parseDouble(str1) / Double.parseDouble(str2) * 100, "#.##"));
	}
}