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, "#.##"));
	}
}