/*
    * Created on Apr 27, 2005, Copyright UC Regents
    */
   package org.telscenter.pas.steps;
   
   import java.awt.BorderLayout;
   import java.awt.Color;
   import java.awt.Component;
   import java.io.IOException;
  import java.io.StringReader;
  import java.util.ArrayList;
  import java.util.Date;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  import javax.swing.BorderFactory;
  import javax.swing.JComponent;
  import javax.swing.JLabel;
  import javax.swing.JPanel;
  import javax.swing.JTextArea;
  import javax.swing.border.CompoundBorder;
  
  import net.sf.sail.core.entity.ISock;
  import net.sf.sail.core.entity.ISockEntry;
  
  import org.telscenter.pas.beans.IWorkReporter;
  import org.telscenter.pas.beans.PasProject;
  import org.telscenter.pas.beans.PasStep;
  import org.telscenter.pas.service.INavigationService;
  import org.telscenter.pas.steps.actions.ChallengeQuestionCheckAction;
  import org.telscenter.pas.steps.domain.BlockInteraction;
  import org.telscenter.pas.steps.domain.ChoiceInteraction;
  import org.telscenter.pas.steps.domain.ResponseDeclaration;
  import org.telscenter.pas.steps.domain.SimpleChoice;
  import org.telscenter.pas.ui.pdf.PDFUtil;
  import org.telscenter.pas.ui.util.PasColors;
  
  import com.lowagie.text.Element;
  import com.lowagie.text.Font;
  import com.lowagie.text.Paragraph;
  import com.lowagie.text.html.simpleparser.HTMLWorker;
  import com.lowagie.text.html.simpleparser.StyleSheet;
  import com.lowagie.text.pdf.PdfPCell;
  import com.lowagie.text.pdf.PdfPTable;
  
  /***
   * Implement of the Pas step type, <i>ChallengeQuestion</i>.
   * 
   * @author Jerry Cheung
   * @author Hiroki Terashima
   * @author turadg
   */
  public class ChallengeQuestion extends Assessment {
  	/***
  	 * Logger for this class
  	 */
  	private static final Logger logger = Logger
  			.getLogger(ChallengeQuestion.class.getName());
  
  	// index of the gotostep within the same activity as this challenge question
  	private int gotoStepIndex;
  
  	// step to display if the student gets the question wrong
  	private PasStep gotoStep;
  
  	// keeps track of the scores used to assign points, where the length of the
  	// scores array corresponds to the number of attempts the user is allotted
  	// for the challenge question and each successive index is the value
  	// assigned
  	// for that particular try
  	private List<Integer> scores = new ArrayList<Integer>();
  
  	// keeps track of whether the scoring mode is quantitative, qualitative, or
  	// off
  	private String scoringMode;
  
  	// current number of attempts is found by looking at the size of the
  	// student's sock
  	private int maxAttempts;
  
  	// keeps track of the parts of each step
  	private List<JPanel> stepParts = new ArrayList<JPanel>();
  
  	// holds set of values for the attempt prefixes for reporting (e.g. 1st
  	// attempt, 2nd attempt, etc)
  	public static final String indexes[] = { "1st", "2nd", "3rd", "4th", "5th",
  			"6th", "7th", "8th", "9th", "10th" };
  
  	// the challenge question interface for getting the gotostep button, etc.
  	private ChallengeQuestionUI cqUI;
  
  	// the service required to navigate to the appropriate steps in the
  	// navigation panel when clicked on
  	private INavigationService navigationService;
  
 	// required to get access to the PasProjectNavigationTaskPanel, activities,
 	// process the gotostep, etc.
 	private PasProject pasProject;
 
 	// keeps track of whether the choices are to be reordered or not when cq is
 	// revisited after visiting goto step
 	private String choiceOrdering;
 
 	// empty constructor for challenge question
 	public ChallengeQuestion() {
 	}
 
 	// confirms that the step type is a challenge question
 	@Override
 	public String getType() {
 		return "Challenge Question";
 	}
 
 	/***
 	 * The entry method to CQ. This method gets called when the step is visited
 	 * If the evidence step has not been visited before visiting this CQ step,
 	 * display a message to go back to the step
 	 * 
 	 * @return visual representation of the Challenge Question
 	 */
 	@Override
 	public Component getComponent() {
 		if (cqUI == null)
 			cqUI = new ChallengeQuestionUI(this);
 
 		cqUI.getGotoStepButton().setVisible(false);
 
 		// If student has answered CQ at least once, either of the following has
 		// occurred:
 		// (1) last choice correct
 		// (2) last choice incorrect
 		// (3) ran out of attempts
 		// here, only cases (1) and (3) are considered because the CQ is no
 		// longer needed to be tried
 		// and the final result is shown.
 		ISock<String> lastAnswerSock = getLastAnswerSock();
 		if (lastAnswerSock != null && !lastAnswerSock.isEmpty()) {
 			if (isStudentAnswerCorrect(lastAnswerSock)
 					|| (numStudentAttempts() >= scores.size())) {
 				ChallengeQuestionCheckAction cqAction = cqUI.getCQCheckAction();
 				cqAction.doCheckAndUpdate();
 				return cqUI;
 			}
 		}
 
 		// check to see if student has visited the evidence step at all, or
 		// since the last visit to the CQ step
 		// if so, a panel should be returned with a message asking the student
 		// to review the evidence step again
 		// before looking at the CQ once more.
 		JPanel panel = panelToReviewEvidencePage();
 		if (panel != null)
 			return panel;
 
 		// the last student answer was incorrect, so the choices are reordered
 		// and the updated set of choice interaction
 		// values are shown to the user.
 		cqUI.updateCqUI_Interactions();
 		return cqUI;
 	}
 
 	/***
 	 * This method determines whether the goto step (i.e. evidence step) for
 	 * this challenge question has been visited at all, or has been visited
 	 * since the last visit to that CQ step. If either of these has not
 	 * occurred, a message will be displayed in the VLE asking the user to
 	 * review the evidence step again before seeing the CQ again.
 	 * 
 	 * @return panel
 	 */
 	private JPanel panelToReviewEvidencePage() {
 		JPanel panel = null;
 
 		// Display a message to the student to go back to the evidence step
 		if (!isGotoStepEverVisited()) {
 			panel = new JPanel();
 			panel
 					.add(new JLabel(
 							"Please review earlier evidence steps in this project before starting this Challenge Question."));
 			return panel;
 		}
 
 		// if last answer exists and is incorrect, check to see if student has
 		// visited
 		// the gotostep before coming back to this step
 		ISock<String> lastAnswerSock = getLastAnswerSock();
 		if (lastAnswerSock != null && !lastAnswerSock.isEmpty()
 				&& !isStudentAnswerCorrect(lastAnswerSock)) {
 			if (!isGotoStepVisitedSinceLastWrongAnswer()) {
 				// Display a message to the student to go back to the evidence
 				// step
 				panel = new JPanel();
 				panel
 						.add(new JLabel(
 								"Please review the evidence page before trying this Challenge Question."));
 				return panel;
 			}
 		}
 		return null;
 
 	}
 
 	
 
 	
 
 	/***
 	 * Returns a PDF-version of the report
 	 * 
 	 * @see org.telscenter.pas.steps.ChallengeQuestion#getReportForLearnerPDF()
 	 */
 	public PdfPCell getReportForLearnerPDF(boolean withAnnotations) {
 		if (logger.isLoggable(Level.CONFIG)) {
 			logger.config("start"); //$NON-NLS-1$
 		}
 
 		int defaultFont = Font.TIMES_ROMAN;
 		PdfPTable table = PDFUtil.createStepTitle(this.getTitle());
 		PdfPTable questionAnswerTable = new PdfPTable(1);
 
 		List<ResponseDeclaration> reponseDeclarations = assessmentItem
 				.getResponseDeclarations();
 
 		if (reponseDeclarations.isEmpty()) {
 			PdfPCell noNoteTaken = new PdfPCell(new Paragraph(Messages
 					.getString("Note.NOTE_NOT_TAKEN"))); //$NON-NLS-1$
 			// table.addCell(noNoteTaken);
 		} else {
 			PdfPCell questionAnswerTableCell = null;
 			Font font = new Font(defaultFont, 14, Font.NORMAL);
 			font.setColor(PasColors.showAllWorkTextColor);
 			for (ResponseDeclaration rd : reponseDeclarations) {
 				BlockInteraction bi = getInteractionByResponseDeclaration(rd);
 				String prompt = null;
 				String answer = null;
 
 				if (bi == null) {
 					prompt = null;
 				} else {
 					prompt = bi.getPrompt();
 				}// if
 
 				PdfPCell noteQuestionCell = null;
 				if (prompt == null) {
 					prompt = Messages.getString("Note.ERROR_PROMPT_NOT_FOUND"); //$NON-NLS-1$
 
 					noteQuestionCell = new PdfPCell(new Paragraph(prompt, font));
 					noteQuestionCell.setBorderWidthBottom(0.0f);
 					noteQuestionCell.setGrayFill(0.8f);
 				} else {
 					//					
 					StringReader stringReader = new StringReader(prompt);
 					List<Element> p = null;
 					try {
 						StyleSheet st = new StyleSheet();
 						st.loadTagStyle("body", "face", "Times New Roman");
 						// st.loadTagStyle("body", "encoding", "Identity-H");
 						st.loadTagStyle("body", "font-size", "6,0");
 
 						p = HTMLWorker.parseToList(stringReader, st);
 
 					} catch (IOException e) {
 						e.printStackTrace();
 					}// try
 
 					stringReader.close();
 
 					noteQuestionCell = new PdfPCell();
 					for (Element e : p) {
 						noteQuestionCell.addElement(e);
 					}
 
 					noteQuestionCell.setBorderWidthBottom(0.0f);
 					noteQuestionCell.setGrayFill(0.8f);
 
 					// PdfPCell noteQuestionCell = new PdfPCell(new
 					// Paragraph(p.get(index),
 					// font));
 					// noteQuestionCell.setBorderWidthBottom(0.0f);
 					// noteQuestionCell.setGrayFill(0.8f);
 					// prompt = prompt.replaceAll(CommonUI.HTML_REGEX, "");
 					// //$NON-NLS-1$
 				}
 
 				// if (prompt == null) {
 				// prompt = Messages.getString("Note.ERROR_PROMPT_NOT_FOUND");
 				// //$NON-NLS-1$
 				// } else {
 				//					
 				//					
 
 				// try {
 				//						
 				// StringExtractor ext = new StringExtractor(prompt);
 				// prompt = ext.extractStrings(true);
 				// } catch (ParserException e) {
 				// // TODO Auto-generated catch block
 				// e.printStackTrace();
 				// }
 				// prompt = prompt.replaceAll(CommonUI.HTML_REGEX, "");
 				// prompt = prompt.trim();
 				// prompt = prompt.replaceAll(CommonUI.HTML_REGEX, "");
 				// //$NON-NLS-1$
 				// }
 				// PdfPCell noteQuestionCell = new PdfPCell(new
 				// Paragraph(prompt,
 				// font));
 				// noteQuestionCell.setBorderWidthBottom(0.0f);
 				// noteQuestionCell.setGrayFill(0.8f);
 
 				if (bi == null) {
 					answer = null;
 				} else {
 					answer = lastAnswer(this.getResponseDeclarationToSocks(),
 							rd);
 				}// if
 
 				if (answer == null) {
 					answer = Messages.getString("Note.NOT_ANSWERED"); //$NON-NLS-1$					
 				} else if (bi instanceof ChoiceInteraction) {
 					ChoiceInteraction<String> ci = (ChoiceInteraction<String>) bi;
 
 					List<SimpleChoice<String>> simpleChoices = ci.getSimpleChoices();
 					for (SimpleChoice<String> choice : simpleChoices) {
 						if (choice.getIdentifier().equals(answer)) {
 							answer = choice.getContent();
 						}
 					}
 				}
 
 				PdfPCell noteAnswerCell = new PdfPCell(new Paragraph(answer,
 						font));
 				noteAnswerCell.setBorderWidthTop(0.0f);
 
 				questionAnswerTable.addCell(noteQuestionCell);
 				questionAnswerTable.addCell(noteAnswerCell);
 
 				questionAnswerTableCell = new PdfPCell(questionAnswerTable);
 				questionAnswerTableCell.setPaddingLeft(9.0f);
 				questionAnswerTableCell.setBorderWidth(0.0f);
 
 			}// for
 			table.addCell(questionAnswerTableCell);
 		}
 		PdfPCell mainCell = new PdfPCell(table);
 		// PdfPCell mainCell = new PdfPCell();
 		mainCell.setBorder(0);
 
 		if (logger.isLoggable(Level.CONFIG)) {
 			logger.config("end"); //$NON-NLS-1$
 		}
 
 		// PdfPCell mainCell = new PdfPCell();
 		return mainCell;
 
 		// TODO Auto-generated method stub
 		// return super.getReportForLearnerPDF();
 	}
 
 	/*** *********************************************************************************** */
 	/***
 	 * ******************************* GOTO EVIDENCE STEP
 	 * **********************************************************
 	 */
 	/***
 	 * Checks if gotoStep has ever been visited
 	 * 
 	 * @return true iff the gotoStep has ever been visited (at least once)
 	 *         before visiting this Challenge Question step
 	 */
 	public boolean isGotoStepEverVisited() {
 		if (getLastGotoStepVisitedSockEntry() == null) {
 			return false;
 		}
 		return true;
 	}
 
 	/***
 	 * Checks if gotoStep has ever been visited
 	 * 
 	 * @return true iff the gotoStep has ever been visited (at least once)
 	 *         before visiting this Challenge Question step
 	 */
 	public ISockEntry<String> getLastGotoStepVisitedSockEntry() {
 		ISock<String> navigationLogSock = getPasProject()
 				.getNavigationLogSock();
 		ISockEntry<String> lastGotoStepVisitSockEntry = null;
 		// now check if the gotoStep has been visited yet
 		if (navigationLogSock != null) {
 			Object gotoStepElement = getPasProject().getItemLog("step_open",
 					getGotoStep());
 			Iterator<ISockEntry<String>> iter = navigationLogSock
 					.entryIterator();
 			while (iter.hasNext()) {// make sure to go thru all of the iter to
 									// get the LAST visit log
 				ISockEntry<String> logElement = iter.next();
 				if (logElement.getValue().equals(gotoStepElement)) {
 					lastGotoStepVisitSockEntry = logElement;
 				}
 			}
 		}
 		return lastGotoStepVisitSockEntry;
 	}
 
 	/***
 	 * Checks if gotoStep has been visited between the last time this step was
 	 * visited and now This must only be called if the last answer was wrong
 	 * 
 	 * @return true iff the gotoStep has been visited (at least once) between
 	 *         the last time this ChallengeQuestion step was visited until now
 	 */
 	public boolean isGotoStepVisitedSinceLastWrongAnswer() {
 
 		ISock<String> lastWrongAnswerSock = getLastAnswerSock();
 		Iterator<ISockEntry<String>> entryIterator = lastWrongAnswerSock.entryIterator();
 		ISockEntry<String> lastSockEntry = null;
 		while (entryIterator.hasNext()) {
 			lastSockEntry = entryIterator.next();
 		}
 		Date lastWrongAnswerEntryDate = lastSockEntry.getDate();
 
 		ISockEntry<String> lastGotoStepVisitSockEntry = getLastGotoStepVisitedSockEntry();
 		if (lastGotoStepVisitSockEntry == null) {
 			return false;
 		}
 
 		Date lastGotoStepVisitDate = lastGotoStepVisitSockEntry.getDate();
 
 		return lastWrongAnswerEntryDate.before(lastGotoStepVisitDate);
 	}
 
 	/***
 	 * ******************************* END GOTO EVIDENCE STEP
 	 * ******************************************************
 	 */
 
 	/***
 	 * ************************************** ANSWER
 	 * ******************************************
 	 */
 
 	/***
 	 * @return number of attempts that the student has made
 	 */
 	public int numStudentAttempts() {
 
 		ResponseDeclaration rd = assessmentItem.getResponseDeclarations()
 				.get(0);
 		ISock<String> studentSock = this.getResponseDeclarationToSocks().get(rd);
 		if (studentSock == null) {
 			logger.severe("no sock available for rim declaration " + rd
 					+ "\n  so defaulting to ZERO for numStudentAttempts()");
 			return 0;
 		}
 		return studentSock.size();
 	}
 
 	/***
 	 * @param rd
 	 * @param bi
 	 * @return answer - either stored in socks or whatever is retrieved from
 	 *         choice interaction
 	 */
 	protected String getAnswer(ResponseDeclaration rd, BlockInteraction bi) {
 		String answer = lastAnswer(this.getResponseDeclarationToSocks(), rd);
 		if (answer == null) {
 			answer = Messages.getString("Note.NOT_ANSWERED"); //$NON-NLS-1$
 
 		} else if (bi instanceof ChoiceInteraction) {
 			ChoiceInteraction<String> ci = (ChoiceInteraction<String>) bi;
 			String scoreReport = this.getScoreReport();
 			if (scoreReport != null) {
 				answer = scoreReport;
 			} else {
 				List<SimpleChoice<String>> simpleChoices = ci.getSimpleChoices();
 				for (SimpleChoice<String> sc : simpleChoices) {
 					if (sc.getIdentifier().equals(answer)) {
 						answer = sc.getContent();
 					}
 				}
 			}
 		}
 		return answer;
 	}
 
 	/***
 	 * TODO: refactor into utils along w/ lastAnswer
 	 * 
 	 * retrieves correct answer based on the inline feedback
 	 * 
 	 * @return corrAnswer
 	 */
 	public String correctAnswer() {
 		ResponseDeclaration rd = assessmentItem.getResponseDeclarations()
 				.get(0);
 		return rd.getCorrectResponses().get(0);
 	}
 
 	/***
 	 * retrieves last answer based on the data from student sock
 	 * 
 	 */
 	public String lastAnswer() {
 		ResponseDeclaration rd = assessmentItem.getResponseDeclarations()
 				.get(0);
 		ISock<String> sock = this.getResponseDeclarationToSocks().get(rd);
 
 		if (sock == null) {
 			String errMsg = "no sock available for rim declaration " + rd
 					+ "\n  so returning null for lastAnswer()";
 			logger.severe(errMsg);
 			return null;
 		}
 
 		if (sock.isEmpty())
 			return null;
 
 		return sock.peek();
 	}
 
 	/***
 	 * @param rd
 	 * @return sock last answer from sock
 	 */
 	public ISock<String> getLastAnswerSock() {
 		ResponseDeclaration rd = getAssessmentItem().getResponseDeclarations()
 				.get(0);
 		ISock<String> sock = getResponseDeclarationToSocks().get(rd);
 
 		if (sock == null) {
 			String errMsg = "no sock available for rim declaration " + rd
 					+ "\n  so returning null for lastAnswer()";
 			logger.severe(errMsg);
 			return null;
 		}
 
 		if (sock.isEmpty())
 			return null;
 
 		return sock;
 	}
 
 	/***
 	 * Checks if student's answer in the provided sock is correct
 	 * 
 	 * @param studentAnswerSock
 	 *            the Sock containing the student's answer
 	 * @return true iff the first item in the sock contains a correct answer
 	 *         response
 	 */
 	public boolean isStudentAnswerCorrect(ISock<String> studentAnswerSock) {
 		String studentAnswer = studentAnswerSock.peek();
 		Object correctAnswer = correctAnswer();
 		return correctAnswer.equals(studentAnswer);
 	}
 
 	/***
 	 * ************************** ENDS ANSWER SECTION
 	 * ************************************************
 	 */
 	/*** *********************************************************************************************** */
 
 	/****************************************************************************
 	 * SETTERS AND GETTERS - ACCESSOR METHODS ********************
 	 * 
 	 * Methods: - getInteractionByResponseDeclaration - setCurrentStepPart,
 	 * getStepParts - setScoringMode, getScoringMode - setScores, getScores -
 	 * setGotoStepIndex, getGotoStepIndex - setGotoStep, getGotoStep -
 	 * setScoreReport, getScoreReport - setMaxAttempts, getMaxAttempts -
 	 * setCqUI, getCqUI - setNavigationService, getNavigationService -
 	 * getPasProject, setPasProject - getChoiceOrdering, setChoiceOrdering -
 	 * getCorrectFeedbackInline - getFeedbackContentFromChoices -
 	 * getLastFeedbackInline
 	 **************************************************************************/
 
 	/***
 	 * @param rd
 	 * @return
 	 */
 	protected BlockInteraction getInteractionByResponseDeclaration(
 			ResponseDeclaration rd) {
 		BlockInteraction bi = Assessment.getInteractionByResponseDeclaration(
 				getAssessmentItem().getItemBody().getInteractions(), rd);
 		return bi;
 	}
 
 	/***
 	 * @return stepParts
 	 */
 	public List<JPanel> getStepParts() {
 		return this.stepParts;
 	}
 
 	/***
 	 * @param currentPart
 	 *            adds the current step part to the list of steps' parts
 	 */
 	private void setCurrentStepPart(JPanel currentPart) {
 		List<JPanel> stepParts = this.stepParts;
 		stepParts.add(currentPart);
 		this.stepParts = stepParts;
 	}
 
 	/***
 	 * @return scoringMode
 	 */
 	public String getScoringMode() {
 		return scoringMode;
 	}
 
 	/***
 	 * @param scoringMode
 	 *            how the scoring is done - quantitative, qualitative, or off
 	 */
 	public void setScoringMode(String scoringMode) {
 		this.scoringMode = scoringMode;
 	}
 
 	/***
 	 * @return the scores
 	 */
 	public List<Integer> getScores() {
 		return scores;
 	}
 
 	/***
 	 * @param scores
 	 *            the scores to set
 	 */
 	public void setScores(List<Integer> scores) {
 		logger.info("setScores");
 		if (scores == null)
 			throw new NullPointerException("null 'scores' argument'");
 		this.scores = scores;
 	}
 
 	/***
 	 * @return the gotoStepIndex
 	 */
 	public int getGotoStepIndex() {
 		return gotoStepIndex;
 	}
 
 	/***
 	 * @param gotoStepIndex
 	 *            the gotoStepIndex to set
 	 */
 	public void setGotoStepIndex(int gotoStepIndex) {
 		this.gotoStepIndex = gotoStepIndex;
 	}
 
 	/***
 	 * @return the gotoStep
 	 */
 	public PasStep getGotoStep() {
 		return gotoStep;
 	}
 
 	/***
 	 * @param gotoStep
 	 *            the step to go to when reviewing evidence
 	 */
 	public void setGotoStep(PasStep gotoStep) {
 		if (gotoStep == null)
 			throw new NullPointerException("null 'gotoStep' argument'");
 		this.gotoStep = gotoStep;
 	}
 
 	/***
 	 * @return scoreReport
 	 */
 	public String getScoreReport() {
 		Object correctAnswer = correctAnswer();
 		String reportText = null;
 		String lastAnswer = lastAnswer();
 		int sNumAttempts = numStudentAttempts();
 
 		if (correctAnswer.equals(lastAnswer)) {
 			reportText = getCorrectAnswerReport(sNumAttempts, scores, indexes);
 		} else if (sNumAttempts >= scores.size()) {
 			reportText = "Out of tries. 0 points.";
 		} else {
 			reportText = getWrongAnswerReport(sNumAttempts, scores, indexes);
 		}
 
 		if (reportText == null) {
 			String errMsg = "no score report available "
 					+ "\n  so returning null";
 			logger.severe(errMsg);
 			return null;
 		}
 
 		return reportText;
 	}
 
 	/***
 	 * provides scorereport to be shown for correct answer by stating how many
 	 * attempts (tries) have been made and how many points have been earned
 	 * 
 	 * 
 	 * @param sNumAttempts
 	 * @param scores
 	 * @param initHtml
 	 * @return reportText
 	 */
 	protected String getCorrectAnswerReport(int sNumAttempts,
 			List<Integer> scores, String[] indexes) {
 		String reportText = null;
 		int index = sNumAttempts - 1;
 		String corrFeedback = indexes[index] + " try";
 
 		if (scores.get(index) > 0) {
 			reportText = corrFeedback + " earned you " + scores.get(index)
 					+ " points.";
 		} else {
 			reportText = "Correct on " + corrFeedback + ".";
 		}
 		return reportText;
 	}
 
 	/***
 	 * provides scorereport to be shown for wrong answer by stating how many
 	 * attempts (tries) have been made and how many possible points are
 	 * attainable (0 if that score attempt has a score of 0)
 	 * 
 	 * @param sNumAttempts
 	 * @param scores
 	 * @param initHtml
 	 * @param attmptFeedback
 	 * @return reportText
 	 */
 	private String getWrongAnswerReport(int sNumAttempts, List<Integer> scores,
 			String[] indexes) {
 		String reportText = null;
 		if (scores.get(sNumAttempts) > 0) {
 			// student hasn't gotten the question right, but can try again.
 			reportText = indexes[sNumAttempts] + " try for "
 					+ scores.get(sNumAttempts) + " points.";
 		} else {
 			reportText = indexes[sNumAttempts] + " try.";
 		}
 		return reportText;
 	}
 
 	/***
 	 * @return the indexes of the attempts
 	 */
 	public String[] getAttemptIndexes() {
 		return indexes;
 	}
 
 	/***
 	 * @return the maxAttempts
 	 */
 	public int getMaxAttempts() {
 		return maxAttempts;
 	}
 
 	/***
 	 * @param maxAttempts
 	 *            the maxAttempts to set
 	 */
 	public void setMaxAttempts(int maxAttempts) {
 		this.maxAttempts = maxAttempts;
 	}
 
 	/***
 	 * @return the cqUI
 	 */
 	public ChallengeQuestionUI getCqUI() {
 		return this.cqUI;
 	}
 
 	/***
 	 * @param cqUI
 	 *            the cqUI to set
 	 */
 	public void setCqUI(ChallengeQuestionUI cqUI) {
 		this.cqUI = cqUI;
 	}
 
 	/***
 	 * @param navigationService
 	 *            navigation service for being able to retrieve, visit, and
 	 *            update steps in the navigation task panel
 	 */
 	public void setNavigationService(INavigationService navigationService) {
 		this.navigationService = navigationService;
 
 	}
 
 	/***
 	 * @return the navigationService
 	 */
 	public INavigationService getNavigationService() {
 		return this.navigationService;
 	}
 
 	/***
 	 * @return the pasProject
 	 */
 	public PasProject getPasProject() {
 		return this.pasProject;
 	}
 
 	/***
 	 * @param pasProject
 	 *            the pasProject to set
 	 */
 	public void setPasProject(PasProject pasProject) {
 		this.pasProject = pasProject;
 	}
 
 	/***
 	 * @param choiceOrdering -
 	 *            sets the variable for whether to reorder choices or not
 	 */
 	public void setChoiceOrdering(String choiceOrdering) {
 		this.choiceOrdering = choiceOrdering;
 	}
 
 	/***
 	 * @return choiceOrdering
 	 */
 	public String getChoiceOrdering() {
 		return this.choiceOrdering;
 	}
 
 	/***
 	 * returns the inline feedback if the chosen answer is the correct one
 	 * 
 	 * @return newFeedbackInline
 	 */
 	public String getCorrectFeedbackInline() {
 		List<BlockInteraction> theInteractions = assessmentItem.getItemBody()
 				.getInteractions();
 		ChoiceInteraction<String> interaction = (ChoiceInteraction<String>) theInteractions
 				.get(0);
 		List<SimpleChoice<String>> choices = interaction.getSimpleChoices();
 		String newFeedbackInline = getFeedbackContentFromChoices(choices);
 
 		return newFeedbackInline;
 	}
 
 	/***
 	 * returns the inline feedback from the choices, choosing the one for the
 	 * correct answer if the number of points for this attempt is greater than
 	 * 0, the feedback would include saying that "you answered on the nth try
 	 * for x points" where n is the number of attempts the user has made, and x
 	 * is the number of points allotted for that attempt on a particular
 	 * question, otherwise the part about the points is not included.
 	 * 
 	 * @return newFeedbackInline
 	 */
 	protected String getFeedbackContentFromChoices(List<SimpleChoice<String>> choices) {
 		String newFeedbackInline = "";
 
 		for (int i = 0; i < choices.size(); i++) {
 			String followupMessage = "You answered on the ";
 			int numTry = numStudentAttempts();
 			if (numTry == 0)
 				break;
 			List<Integer> scores = getScores();
 			String correctAnswer = correctAnswer();
 			if ((choices.get(i).getIdentifier()).equals(correctAnswer)) {
 				String origFeedbackInline = extractBody(choices.get(i)
 						.getFeedbackInline().getContent().toString());
 				if (scores.get(numTry - 1) > 0) {
 					newFeedbackInline = "<html><body>" + origFeedbackInline
 							+ followupMessage + indexes[numTry - 1]
 							+ " try for " + scores.get(numTry - 1) + " points."
 							+ "</body></html>";
 				} else {
 					newFeedbackInline = "<html><body>" + origFeedbackInline
 							+ followupMessage + indexes[numTry - 1]
 							+ " try.</body></html>";
 				}
 			}
 
 		}
 		return newFeedbackInline;
 	}
 
 	/***
 	 * returns the inline feedback for the last answer chosen
 	 * 
 	 * @return newFeedbackInline
 	 */
 	public String getLastFeedbackInline(Assessment assessment) {
 		// TODO Auto-generated method stub
 
 		ResponseDeclaration rd = assessmentItem.getResponseDeclarations()
 				.get(0);
 		String lastAnswer = Assessment.lastAnswer(assessment
 				.getResponseDeclarationToSocks(), rd);
 		List<BlockInteraction> theInteractions = assessmentItem.getItemBody()
 				.getInteractions();
 		ChoiceInteraction<String> interaction = (ChoiceInteraction<String>) theInteractions
 				.get(0);
 		List<SimpleChoice<String>> choices = interaction.getSimpleChoices();
 		String newFeedbackInline = "";
 
 		if (lastAnswer == null) {
 			throw new IllegalStateException(
 					"displayLastFeedbackInline() called while no lastAnswer() available");
 		}
 		for (int i = 0; i < choices.size(); i++) {
 			String followupMessage = "Click the evidence button below and review the earlier evidence. Then return to this Challenge Question for a ";
 			String finalFollowupMessage = "Sorry, you're out of tries. Move on to the next step.";
 			int numTry = numStudentAttempts();
 
 			if ((choices.get(i).getIdentifier()).equals(lastAnswer)) {
 				String origFeedbackInline = extractBody(choices.get(i)
 						.getFeedbackInline().getContent().toString());
 				if (numTry >= getMaxAttempts()) {
 					newFeedbackInline = "<html><body>" + origFeedbackInline
 							+ finalFollowupMessage + "</body></html>";
 				} else {
 					newFeedbackInline = "<html><body>" + origFeedbackInline
 							+ followupMessage + indexes[numTry] + " try."
 							+ "</body></html>";
 				}
 			}
 		}
 		return newFeedbackInline;
 	}
 
 	/***
 	 * @param responseDeclarations
 	 * @param iterator
 	 * @param filteredPrompt
 	 * @param bi
 	 */
 	private void setBiPrompt(List<ResponseDeclaration> responseDeclarations,
 			int iterator, BlockInteraction bi) {
 		String oldPrompt = bi.getPrompt();
 		int index = oldPrompt.indexOf("Part");
 		int index2 = oldPrompt.indexOf("Partner");
 		String filteredPrompt = extractBody(oldPrompt);
 
 		if (responseDeclarations.size() > 1) {
 			if ((index < 0) || (index == index2)) {
 				bi.setPrompt("<html><body> Part " + iterator + " : "
 						+ filteredPrompt + "</body></html>");
 			} else {
 				bi
 						.setPrompt("<html><body>" + filteredPrompt
 								+ "</body></html>");
 			}
 		} else {
 			bi.setPrompt("<html><body>" + filteredPrompt + "</body></html>");
 		}
 	}
 
 	/***
 	 * Extracts the text in between the <body>...</body>
 	 */
 	@Override
 	protected String extractBody(String prompt) {
 		int start = prompt.indexOf("<body>");
 		int end = prompt.indexOf("</body>");
 
 		String extractedBody = "";
 
 		if (start != -1 && end != -1) {
 			extractedBody = prompt.substring(start + 6, end);
 			return extractedBody;
 		}
 		return prompt;
 	}
 
 	/***
 	 * @see org.telscenter.pas.beans.IWorkReporter#getEntityToPromptMap()
 	 */
 	public Map<String, String> getEntityToPromptMap() {
 		Map<String, String> rimToPromptMap = new HashMap<String, String>();
 		List<ResponseDeclaration> responseDeclarations = assessmentItem
 		    .getResponseDeclarations();
 		for (ResponseDeclaration responseDeclaration : responseDeclarations) {
 			String rimname = responseDeclaration.getRim().getName();
 			BlockInteraction bi = getInteractionByResponseDeclaration(responseDeclaration);
 			String prompt = bi.getPrompt();
 
 			rimToPromptMap.put(rimname, prompt);
 		}
 		return rimToPromptMap;
 	}
 
 
 }