/***
    * 
    */
   package org.telscenter.pas.steps;
   
   import java.awt.BorderLayout;
   import java.awt.Color;
   import java.awt.event.ActionEvent;
   import java.awt.event.ActionListener;
  import java.awt.event.ComponentEvent;
  import java.awt.event.ComponentListener;
  import java.awt.Dimension;
  import java.awt.FlowLayout;
  import java.awt.GridBagConstraints;
  import java.awt.GridBagLayout;
  import java.io.InputStream;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Random;
  
  import javax.swing.BorderFactory;
  import javax.swing.BoxLayout;
  import javax.swing.ButtonGroup;
  import javax.swing.ImageIcon;
  import javax.swing.JButton;
  import javax.swing.JComponent;
  import javax.swing.JLabel;
  import javax.swing.JPanel;
  import javax.swing.JRadioButton;
  import javax.swing.JScrollPane;
  import javax.swing.JTextArea;
  import javax.swing.border.CompoundBorder;
  
  import net.sf.sail.core.entity.ISock;
  
  import java.util.logging.Logger;
  
  import org.apache.commons.io.IOUtils;
  import org.telscenter.pas.beans.PasProject;
  import org.telscenter.pas.beans.PasStep;
  import org.telscenter.pas.common.ui.CommonUI;
  import org.telscenter.pas.common.ui.panel.SimpleGradientPanel;
  import org.telscenter.pas.navigation.PasProjectNavigationTaskPanel;
  import org.telscenter.pas.service.INavigationService;
  import org.telscenter.pas.service.NavigateAction;
  import org.telscenter.pas.steps.actions.LeaveStudentAssessmentAction;
  import org.telscenter.pas.steps.domain.BlockInteraction;
  import org.telscenter.pas.steps.domain.ChoiceInteraction;
  import org.telscenter.pas.steps.domain.FeedbackInline;
  import org.telscenter.pas.steps.domain.FeedbackModal;
  import org.telscenter.pas.steps.domain.ResponseDeclaration;
  import org.telscenter.pas.steps.actions.ChallengeQuestionCheckAction;
  import org.telscenter.pas.steps.domain.SimpleChoice;
  import org.telscenter.pas.ui.icons.PasCommonIconProvider;
  import org.telscenter.pas.ui.util.PasColors;
  import org.telscenter.pas.util.QTIUtils;
  import org.xhtmlrenderer.simple.XHTMLPanel;
  
  /***
   * @author aperritano
   *
   */
  public class ChallengeQuestionUI extends AssessmentUI {
  
  	/***
  	 * Logger for this class
  	 */
  	static final Logger logger = Logger
  			.getLogger(StudentAssessmentUI.class.getName());
  	
  	private static final long serialVersionUID = 1L;
  
  	protected String introductionHtml = ""; //$NON-NLS-1$
  
  	protected JButton submitQuestionsButton;
  
  	protected String QUESTION_CARD = "QUESTION_CARD"; //$NON-NLS-1$
  
  	protected String RESULT_CARD = "RESULT_CARD"; //$NON-NLS-1$
  
  	//stores the feedbacks 
  	private HashMap<String, JLabel> feedbackLabels;
  
  	//stores the radiobuttons
  	private HashMap<String, JRadioButton> radiobuttons;
  	
  	//FIX: this is hacked to disable submit checking
  	public boolean hasSubmited = true;
  
  	public boolean toLeaveStep = false;
  
  	protected JPanel submitButtonPanel;
  
  	protected LeaveStudentAssessmentAction leaveAction;
  	
  	//the check to determine the action to take according to 
  	//whether the current answer selected was correct or not
 	private JButton processAttemptButton;
 	
 	//the link via which to revisit the evidence step before proceeding with
 	//the challenge question for another attempt
 	private JButton gotoStepButton;
 
 	//holds icon for incorrect answer
 	private ImageIcon redX;
 
 	//holds label for the score
 	private JLabel scoreLabel;
 
 	//stores the inline feedback text
 	private JLabel inlineFbTextLabel;
 
 	//a radiobutton for multiple choice
 	private JRadioButton scButton;
 
 	//panel for holding all the multiple choice selections to choose answer from
 	private JPanel choicePanel; 
 	
 	private List<JRadioButton> choiceButtonList = new ArrayList<JRadioButton>();
 	
 	private static final int CHOICE_CONTENT_WIDTH = 300;
 	
 	private static final int INLINE_FEEDBACK_WIDTH = 300;
 	
 	private static final int INLINE_FEEDBACK_HEIGHT = 100;
 	//private static final Color CORRECT_INLINE_COLOR = Color.GREEN;
 
 	//private static final Color INCORRECT_INLINE_COLOR = Color.RED;
 
 	//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" };
 	
 	public ChallengeQuestionUI(Assessment assmt) {
 		super(assmt);
 	} 
 	
 	/***
 	 * 
 	 * creates and integrates all the buttons, feedback icons, score label, prompt panel, choices panel, feedback panel for showing in VLE 
 	 * the final step for the actual VLE output itself is controlled by getComponent in ChallengeQuestion.java
 	 * 
 	 * @return
 	 */
 	@Override
 	protected void initUI() {		
 		if( assessment.getAssessmentItem() == null || assessment.getAssessmentItem().getItemBody().getInteractions().size() == 0 ) {
 			this.setLayout(new FlowLayout(FlowLayout.CENTER));
 			this.setOpaque(false);
 			JLabel noLabel = new JLabel("This Note has no items.");
 			noLabel.setOpaque(false);
 			this.add(noLabel, BorderLayout.CENTER);
 			return;
 		}
 		List<BlockInteraction> interactions = assessment.getAssessmentItem().getItemBody().getInteractions();
 		radiobuttons = new HashMap<String, JRadioButton>();
 		feedbackLabels = new HashMap<String, JLabel>();
 		gotoStepButton = createGotoStepButton();
 		gotoStepButton.setVisible(false);
 		clearFeedbackInline();
 		
 		JPanel titlePanel = createTitlePanel();
 		JPanel scorePanel = createScorePanel();
 		JPanel buttonPanel = createButtonPanel();			
 		JPanel cqChoicePanel = cQ_choiceInteractionPanel(interactions, titlePanel, scorePanel, buttonPanel);
 		
 		// put them in a scrollpanel for the ca
 		JPanel scrollerPanel = createScrollerPanel(cqChoicePanel);
 
 		cardPanel.add(scrollerPanel, QUESTION_CARD);		
 
 		SimpleGradientPanel mainPanel = createSimpleGradientPanel();
 		GridBagConstraints c = createGridBagConstraint();
 		mainPanel.add(cardPanel, c);
 
 		// disable buttons if...1) no more attempts left or 2) student has
 		// answered and student got correct answer
 		Object correctAnswer = ((ChallengeQuestion)assessment).correctAnswer();
 		getCorrectFeedback(correctAnswer);
 
 		updateScoreLabelStatus();
 		mainPanel.validate();
 		
 		this.setLayout(new BorderLayout(0,0));
 		this.add(mainPanel,BorderLayout.CENTER);
 
 	}
 
 /**************************************** START OF LAYOUT ****************************************************/	
 	/***
 	 * @return c
 	 * creates the position of the component to be shown via grid bag layout
 	 */
 	private GridBagConstraints createGridBagConstraint() {
 		GridBagConstraints c = new GridBagConstraints();
 		// c.fill = GridBagConstraints.HORIZONTAL;
 		c.fill = GridBagConstraints.BOTH;
 
 		c.weightx = 1;
 		c.gridx = 0;
 		c.gridy = 0;
 	//	mainPanel.add(bannerPanel, c);
 
 		c.gridx = 0;
 		c.gridy = 0;
 		//mainPanel.add(introPanel, c);
 
 		c.weighty = 1;
 		c.gridx = 0;
 		c.gridy = 0;
 		c.fill = GridBagConstraints.BOTH;
 		return c;
 	}
 
 /******************************** ENDING OF LAYOUT ********************************************************/
 /******************************** THE MAIN PANELS **********************************************************
  * TITLE, SCORE, BUTTON, PROMPT & CHOICE, CHOICE & FEEDBACK, CHOICE INTERACTION, GRADIENT, AND SCROLLING PANELS
  */
 	/***
 	 * creates the challenge question title panel
 	 * 
 	 * 
 	 * @return titlePanel
      */
 	private JPanel createTitlePanel(){
 		String labelValue = "<html><body>" + "<p style='font-size:16;font-weight:bold;text-align:left;'>" +
 							"Challenge Question" + "</body></html>";
 		
 		JPanel titlePanel = new JPanel();
 		titlePanel.setLayout(new BorderLayout(0,0));
 		
 		titlePanel.add(new JLabel(labelValue), BorderLayout.CENTER);
 		return titlePanel;
 	}
 
 	/***
 	 * creates the challenge question score panel, with score report shown in blue text
 	 * 
 	 * 
 	 * @return scorePanel
      */
 	private JPanel createScorePanel(){
 		JPanel scorePanel = new JPanel();
 		scorePanel.setOpaque(false);
 		scoreLabel = new JLabel();
 		scoreLabel.setForeground(Color.BLUE);
 		scorePanel.add(scoreLabel, BorderLayout.CENTER);
 		return scorePanel;
 	}
 
 	/***
 	 * creates the check action button panel
 	 * 
 	 * 
 	 * @return buttonPanel
      */
 	private JPanel createButtonPanel(){
 		ChallengeQuestionCheckAction checkAction = getCQCheckAction();	
 		processAttemptButton = new JButton();
 		processAttemptButton.setAction(checkAction);
 		processAttemptButton.setEnabled(false);
 		CommonUI.makeEnhancedButton(processAttemptButton);
 		JPanel buttonPanel = new JPanel();
 		buttonPanel.add(processAttemptButton, BorderLayout.NORTH);
 		buttonPanel.setPreferredSize(new Dimension(buttonPanel.getPreferredSize().width, 20));
 		buttonPanel.setBackground(PasColors.challengeQuestionChoiceInteractionTextAreaColor);
 		return buttonPanel;
 	}
 
 	/***
 	 * gets choice and feedback panel, adds the score panel, prompt panel, and the choice & feedback panel to a single panel to return
 	 * 
 	 * @param scorePanel
 	 * @param promptPanel
 	 * @param choicePanel
 	 * @param buttonPanel
 	 * @return allPartsPanel
      */
 	private JPanel getPromptAndChoicePanel(JPanel scorePanel, JComponent promptPanel, JPanel choicePanel, JPanel buttonPanel){
 		JPanel allPartsPanel = new JPanel();
 		allPartsPanel.setLayout(new BoxLayout(allPartsPanel, BoxLayout.Y_AXIS));
 		allPartsPanel.setBackground(Color.white);
 		allPartsPanel.putClientProperty(ITEM_COMPLETED, new Boolean(false));
 		JPanel choiceAndFeedbackPanel = getChoiceAndFeedbackPanel(choicePanel, buttonPanel);	
 		allPartsPanel.setBackground(PasColors.challengeQuestionChoiceInteractionTextAreaColor);
 		allPartsPanel.add(scorePanel,BorderLayout.NORTH);
 		allPartsPanel.add(promptPanel, BorderLayout.CENTER);
 		allPartsPanel.add(choiceAndFeedbackPanel,BorderLayout.SOUTH);
 		return allPartsPanel;
 	}
 
 	/***
 	 * adds the multiple choice panel, inline feedback text label, and check action button panel to
 	 * choice and feedback panel
 	 * 
 	 * @param choicePanel
 	 * @param buttonPanel
 	 * @return choiceAndFeedbackPanel
 	 */
 	private JPanel getChoiceAndFeedbackPanel(JPanel choicePanel, JPanel buttonPanel) {
 		JPanel choiceAndFeedbackPanel = new JPanel();
 		choiceAndFeedbackPanel.setLayout(new BoxLayout(choiceAndFeedbackPanel, BoxLayout.Y_AXIS));
 		choiceAndFeedbackPanel.setPreferredSize(new Dimension(450,350));
 		choiceAndFeedbackPanel.setBackground(PasColors.challengeQuestionChoiceInteractionTextAreaColor);
 
 		JPanel inlineFbTextPanel = new JPanel();
 		inlineFbTextLabel = new JLabel();
 		inlineFbTextLabel.setPreferredSize(new Dimension(INLINE_FEEDBACK_WIDTH,INLINE_FEEDBACK_HEIGHT));
 		inlineFbTextPanel.add(inlineFbTextLabel);
 		inlineFbTextPanel.setBackground(PasColors.challengeQuestionChoiceInteractionTextAreaColor);
 		if(!inlineFbTextLabel.getText().equals("")){
 			inlineFbTextPanel.setPreferredSize(new Dimension(INLINE_FEEDBACK_WIDTH/2, INLINE_FEEDBACK_HEIGHT));
 			
 		}else{
 			inlineFbTextPanel.setPreferredSize(new Dimension(0,0));
 		}
 		choiceAndFeedbackPanel.add(choicePanel);
 		choiceAndFeedbackPanel.add(inlineFbTextPanel);
 		choiceAndFeedbackPanel.add(buttonPanel);
 	
 		return choiceAndFeedbackPanel;
 	}
 
 	/***
 	 * creates a simple gradient panel for background
 	 * 
 	 * @return mainPanel
 	 */
 	private SimpleGradientPanel createSimpleGradientPanel() {
 		SimpleGradientPanel mainPanel = new SimpleGradientPanel();
 		mainPanel.setDirection(SimpleGradientPanel.VERTICAL);
 		mainPanel.setStartColor(PasColors.compactNavBackgroundStartColor);
 		mainPanel.setEndColor(PasColors.compactNavBackgroundEndColor);
 		mainPanel.setLayout(new GridBagLayout());
 		return mainPanel;
 	}
 
 	/***
 	 * Creates all the interactions
 	 * 
 	 * @param interactions
 	 * @param titlePanel
 	 * @param scorePanel
 	 * @param buttonPanel
 	 * @return a panel with all the parts needed for this challenge question - title, prompt and multiple choices, and the check action button panel
 	 */
 	protected JPanel cQ_choiceInteractionPanel(List<BlockInteraction> interactions, JPanel titlePanel, JPanel scorePanel, JPanel buttonPanel) {
 		JPanel mainPanel = new JPanel();
 		mainPanel.setBackground(PasColors.pandaPanelBackgroundColor);
 		mainPanel.setLayout(new BorderLayout(0, 0));
 
 		JPanel tPane = new JPanel();
 		tPane.setBackground(PasColors.challengeQuestionChoiceInteractionTextAreaColor);
 		JPanel allPanel = null;
 		
 		choicePanel = new JPanel();
 		choicePanel.setLayout(new BoxLayout(choicePanel, BoxLayout.Y_AXIS));
 		choicePanel.setBackground(PasColors.challengeQuestionChoiceInteractionTextAreaColor);
 		
 		JComponent createPromptPanel=null;
 			
 		//traverses through the interactions, reorders the choices for scrambling the choices around 
 		//in the challenge question and adds the updated choice interaction to the corresponding 
 		//radio buttons and group for the multiple choice functionality, and then the panels are added
 		for (int i = 0; i < interactions.size(); i++) {
 			ChoiceInteraction<String> choiceInteraction = (ChoiceInteraction<String>) interactions
 					.get(i);
 			choiceInteraction = reOrderChoices(choiceInteraction);
 			createPromptPanel = createPromptPanel(choiceInteraction);
 			createPromptPanel.setBackground(PasColors.challengeQuestionChoiceInteractionTextAreaColor);
 		    setChoicesToButtons(choiceInteraction);
 			JPanel promptAndChoicePanel = getPromptAndChoicePanel(scorePanel, createPromptPanel, choicePanel, buttonPanel);
 			allPanel = new JPanel();
 			allPanel.setLayout(new BoxLayout(allPanel, BoxLayout.Y_AXIS));
 			allPanel.add(titlePanel);
 			allPanel.add(promptAndChoicePanel);
 			allPanel.add(gotoStepButton);
 			tPane.add(allPanel, BorderLayout.CENTER);
 		}
 		
 		mainPanel.add(tPane, BorderLayout.CENTER);
 
 		return mainPanel;
 	}
 
 	/***
 	 * Creates the scroller panel for adding the challenge question panel created
 	 * 
 	 * @param questionsPanel
 	 * @return scrollerPanel
 	 */
 
 	private JPanel createScrollerPanel(JPanel questionsPanel) {
 		JScrollPane questionScroller = new JScrollPane(questionsPanel);
 		questionScroller
 				.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
 		questionScroller
 				.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
 		questionScroller.setBorder(BorderFactory.createEmptyBorder());
 		questionScroller.getVerticalScrollBar().setValue(
 				questionScroller.getVerticalScrollBar().getMaximum());
 		questionScroller.setOpaque(false);
 		JPanel scrollerPanel = new JPanel(new BorderLayout(0, 0));
 		scrollerPanel.add(questionScroller, BorderLayout.CENTER);
 		scrollerPanel.setOpaque(true);
 		scrollerPanel.setBackground(PasColors.pandaPanelBackgroundColor);
 		return scrollerPanel;
 	}
 	
 /*********************************CLOSING OF THE PANELS ********************************************************/	
 /*********************************** BUTTON CREATION ***********************************************************
 	 * createGotoStepButton
 	 * getChoiceButton
 	 */ 	
 		/***
 		 * Creates goto step button
 		 * 
 		 * @param thisPanel
 		 * @param j
 		 * @param step
 		 * @return
 		 */
 		public JButton createGotoStepButton() {
 			PasProjectNavigationTaskPanel navigationTaskPanel = ((ChallengeQuestion) assessment).getPasProject().getPanel();
 			PasStep gotoStep = ((ChallengeQuestion) assessment).getGotoStep();
 			INavigationService navigationService = ((ChallengeQuestion) assessment).getNavigationService();
 			JButton gotoStepButton = new JButton(new NavigateAction(gotoStep, navigationService, navigationTaskPanel));
 			gotoStepButton.setHorizontalTextPosition(JLabel.LEFT);
 			gotoStepButton.setContentAreaFilled(false);
 			gotoStepButton.setFont(gotoStepButton.getFont().deriveFont(16.0f));
 			gotoStepButton.setBorder(BorderFactory.createEmptyBorder(0, 0, 8, 0));
 			gotoStepButton.setText("Go to Evidence Step");
 
 			gotoStepButton.addActionListener(new ActionListener() {
 				public void actionPerformed(ActionEvent e) { //if the link is clicked, the code below is performed
 					PasProject pasProject = ((ChallengeQuestion) assessment).getPasProject();
 					ISock<String> navigationLogSock = pasProject.getNavigationLogSock(); //retrieves the navigation log
 					if (navigationLogSock != null) {
 						//registers the navigation to the goto step into the navigation log so that the challenge question is unlocked 
 						navigationLogSock.add(pasProject.getItemLog("step_open", (((ChallengeQuestion) assessment).getGotoStep())));
 					}
 				}
 			});
 			CommonUI.makeLink(gotoStepButton);
 			return gotoStepButton;
 		}
 			
 		/***
 		 * Creates multiple choice radio button with action listener for setting student selection
 		 * 
 		 * @param studentAnswer
 		 * @param sc
 		 * @param choiceInteraction
 		 * @return button
 		 */
 		private JRadioButton getChoiceButton(String studentAnswer, SimpleChoice<String> sc, ChoiceInteraction<String> choiceInteraction){
 			JRadioButton button = new JRadioButton();
 //		 if student chose this choice before, mark as selected
 			if (studentAnswer != null
 					&& studentAnswer.equals(sc.getIdentifier())) {
 				button.setSelected(true);
 			} else {
 				button.setSelected(false);
 			}
 			button.setOpaque(false);
 			button.putClientProperty(QTIUtils.SIMPLE_CHOICE, sc);
 			button.putClientProperty(RESPONSE_ID, choiceInteraction
 					.getResponseIdentifier());
 			// ... all in one container
 
 			button.addActionListener(new ActionListener() {
 
 				public void actionPerformed(ActionEvent e) {
 					JRadioButton radioButton = (JRadioButton) e.getSource();
 
 					if (radioButton.isSelected()) {
 						SimpleChoice<String> sc = ((SimpleChoice<String>) radioButton
 								.getClientProperty(QTIUtils.SIMPLE_CHOICE));
 
 						assessment.getResponses().put(
 								(String) radioButton
 										.getClientProperty(RESPONSE_ID),
 								sc.getIdentifier());
 
 						logger.info("responses: "
 								+ assessment.getResponses().toString());
 						processAttemptButton.setEnabled(true);
 					}
 				}
 			});
 
 			return button;
 		}
 
 /********************************************************************************************************/
 /*********************************** BUTTON ACTION ***********************************************************/
 		/***
 		 * disables the 'check answer' button after an attempt has been made (until the next time the cq step is visited)
 		 * as long as one has more tries remaining or did not yet choose the correct answer
 		 * 
 		 *  
 		 * 
 		 * @return
 		 */
 				
 		public void disableProcessAttemptButton() {
 			this.processAttemptButton.setEnabled(false);
 		}
 
 		/***
 		 * Greys out SimpleChoice radio buttons
 		 * 
 		 * @param buttonIdentifier
 		 * @param isCorrect
 		 * @return
 		 */
 		
 		public void disableRadioButtons(Object buttonIdentifier, boolean isCorrect) {
 			JRadioButton rb = radiobuttons.get(buttonIdentifier);
 
 			for (JRadioButton radioButton : radiobuttons.values()) {
 				if(!radioButton.equals(rb)){
 					radioButton.setEnabled(false);
 				}else{
 					if(isCorrect){
 						rb.setIcon(greenCheck);
 					}else{
 						rb.setIcon(redX);
 					}
 				}
 			}
 		}
 
 		/*** 
 		 * selects the radio button and also sets the appropriate image icon
 		 * 
 		 * @param buttonIdentifier
 		 * @param isCorrect
 		 */
 		public void selectRadioButton(Object buttonIdentifier, boolean isCorrect) {
 			JRadioButton rb = radiobuttons.get(buttonIdentifier);
 			if (isCorrect) {
 				rb.setIcon(greenCheck);
 				rb.setForeground(new Color(0,220,0));
 			} else {
 				rb.setIcon(redX);
 				rb.setForeground(Color.RED);
 			}
 			rb.setSelected(true);
 		}
 
 		/***
 		 * Removes the icons associated with all of the radio buttons and reverts to
 		 * default
 		 * 
 		 * @return 
 		 */
 		public void clearRadioButtonIcons() {
 			for (JRadioButton radioButton : radiobuttons.values()) {
 				radioButton.setIcon(null);
 				radioButton.setForeground(Color.BLACK);
 			}
 		}
 
 /************************************* END BUTTON ACTION ***************************************************/	
 /************************************ CHOICE INTERACTIONS **************************************************/
 		/***
 		 * reorders the choices once the cq step is refreshed (revisited) as long as the correct answer was not chosen yet
 		 * updates the score board and report
 		 * clears all the inline feedbacks
 		 * disables the process attempt button until the user chooses a choice
 		 * 
 		 * @return
 		 */
 		
 		@SuppressWarnings("cast")
 		public void updateCqUI_Interactions(){
 			String correctAnswer = ((ChallengeQuestion)assessment).correctAnswer();
 			String studentAnswer = ((ChallengeQuestion)assessment).lastAnswer();
 			boolean correctAnswerChosen = correctAnswer.equals(studentAnswer);
 			int attemptNum = ((ChallengeQuestion)assessment).numStudentAttempts();
 			boolean outOfAttempts = attemptNum >= ((ChallengeQuestion)assessment).getMaxAttempts();
 			
 			updateScoreLabelStatus();
 			processAttemptButton.setEnabled(false);
 			
 			//if(!correctAnswerChosen && !outOfAttempts){
 				scoreLabel.setVisible(true);
 				this.inlineFbTextLabel.setText("");
 				clearRadioButtonIcons();
 				List<BlockInteraction> theInteractions = assessment.getAssessmentItem().getItemBody().getInteractions();
 				choiceButtonList = new ArrayList<JRadioButton>();
 
 				//traverses through the interactions, reorders the choices for scrambling the choices around 
 				//in the challenge question 
 				for (int i = 0; i < theInteractions.size(); i++) {
 					ChoiceInteraction<String> choiceInteraction = (ChoiceInteraction<String>) theInteractions.get(i);
 					choiceInteraction = reOrderChoices(choiceInteraction);
 					theInteractions.set(i, (BlockInteraction)choiceInteraction);
 					radiobuttons.clear();
 					choicePanel.removeAll();
 					inlineFbTextLabel.setText("");
 					setupChoiceButtonPanel(choiceInteraction, "", true);
 				}	
 				
 				assessment.getAssessmentItem().getItemBody().setInteractions(theInteractions);
 			}
 		//}
 		
 		/***
 		 * assigns each choice content to a radio button for displaying as part of the multiple choice button
 		 * panel
 		 * 
 		 * @return
 		 */
 		private void setupChoiceButtonPanel(ChoiceInteraction<String> ci, String answer, boolean feedbackAdjusted){
 			List<SimpleChoice<String>> theChoices = ci.getSimpleChoices();
 			ButtonGroup group = new ButtonGroup(); // this is for the radio button
 												   // functionality
 												   // (one-choice-at-a-time)
 			for (SimpleChoice<String> sc : theChoices) {
 				scButton = getChoiceButton(answer,sc,ci);			
  
 				JPanel jp = new JPanel();
 				jp.setLayout(new BoxLayout(jp, BoxLayout.Y_AXIS));
 				jp.add(scButton);
 				jp.setOpaque(false);
 				if(!feedbackAdjusted)
 					adjustFeedback(sc);
 				String theContent = sc.getContent();
 				/*
 				theContent = wrapInlineText(theContent, CHOICE_CONTENT_WIDTH);
 				sc.setContent(theContent); */
 				scButton.setText(theContent.trim());
 				scButton.setIcon(null);
 				choicePanel.add(jp, BorderLayout.NORTH);
 				radiobuttons.put(sc.getIdentifier(), scButton);				
 				choiceButtonList.add(scButton);				
 				group.add(scButton);
 			}	
 		}
 		
 		/***
 		 * Randomizes the choices
 		 * @param interaction
 		 * @return
 		 */
 		private ChoiceInteraction<String> reOrderChoices(ChoiceInteraction<String> interaction){
 			String prompt = interaction.getPrompt();
 			String promptAttrs = "<P style='font-size:20;text-align:center;'>";
 			String initHtml = "<html><body>";
 			String finalHtml = "</P></body></html>";			
 			String updatedPrompt = initHtml + promptAttrs + extractBody(prompt) + finalHtml;		
 			List<SimpleChoice<String>> choices = interaction.getSimpleChoices();
 			interaction.setPrompt(updatedPrompt);		
 			List<SimpleChoice<String>> newChoices = new ArrayList<SimpleChoice<String>>(choices.size());
 		    Random rand = new Random();
 		    while (choices.size() > 0) {
 		    	newChoices.add(choices.remove(rand.nextInt(choices.size())));
 		    }
 		
 		    interaction.setSimpleChoices(newChoices);		
 			return interaction;
 		}
 		
 
 		/***
 		 * maps the student answer to the corresponding radio button, and maps the choice content to the radio buttons as well
 		 * 
 		 * @param choiceInteraction
 		 * @return
 		 */
 		private void setChoicesToButtons(
 				ChoiceInteraction<String> choiceInteraction) {
 			choiceButtonList = new ArrayList<JRadioButton>();
 			
 			String studentAnswer = Assessment.getStudentAnswer(assessment,
 					choiceInteraction);
 
 			setupChoiceButtonPanel(choiceInteraction, studentAnswer, false);
 			choiceInteractionToChoiceButtonLists.put(choiceInteraction,
 				choiceButtonList);
 		}
 
 /*********************************************************************************************************/
 
 /**************************** SCORE STATUS **************************************************
 	* This section determines what the score status should be - correct, wrong, or out of attempts
 	* the corresponding status is shown on the score label and also stored in the reportText for 
 	* displaying in show all work
 ********************************************************************************************/
 	
 	/***
 	 * Displays a status message on the bottom of the screen Either: -- What
 	 * score the student can get -- What score the student has gotten
 	 * 
 	 * @return 
 	 */
 	public void updateScoreLabelStatus() {
 		int sNumAttempts = ((ChallengeQuestion)assessment).numStudentAttempts();
 		List<Integer> scores = ((ChallengeQuestion) assessment).getScores();		
 		String correctAnswer = ((ChallengeQuestion)assessment).correctAnswer();
 		String feedbackSize = "<p style='font-size:16;font-weight:bold;text-align:center;'>";
 		String origText = null;
 		String initHtml = "<html><body>";
 		String finalHtml = "</p></body></html>";
 		
 	//	for(int i = 1; i < scores.size(); i++){
 	//		scores.set(i,0);
 	//	}
 
 		setScoreLabel(sNumAttempts, scores, correctAnswer);
 		
 		origText = scoreLabel.getText();
 		scoreLabel.setText(initHtml + feedbackSize + origText + finalHtml);	
 		scoreLabel.setVisible(false);
 	}
 
 	/***
 	 * sets the score label outcome of the choice student selected and chose as their current answer, 
 	 * where the outcome is dependent on whether the most recent answer selected was correct,
 	 * incorrect, or the number of attempts have been reached or exceeded 
 	 * 
 	 * @param sNumAttempts
 	 * @param scores
 	 * @param correctAnswer
 	 * @return
 	 */
 	private void setScoreLabel(int sNumAttempts, List<Integer> scores,
 			String correctAnswer) {
 		String lastAnswer = ((ChallengeQuestion)assessment).lastAnswer();
 		
 		if (correctAnswer.equals(lastAnswer)){
 			int index = sNumAttempts-1;
 			String corrFeedback = indexes[index] + " try";
 			setCorrectAnswerLabel(index, corrFeedback, scores);
 			
 		} else if (sNumAttempts >= scores.size()) {
 			scoreLabel.setText("Sorry, you're out of tries.");
 		} else {
 			String attmptFeedback = indexes[sNumAttempts] + " try";
 			setWrongAnswerLabel(sNumAttempts, attmptFeedback, scores);
 		}
 		
 	}
 	
 	/***
 	 * updates the score label if the answer is wrong; if there are points, the points are shown in the label 
 	 * otherwise they are not shown
 	 * 
 	 * @param sNumAttempts
 	 * @param attmptFeedback
 	 * @param scores
 	 * @return
 	 */
 	private void setWrongAnswerLabel(int sNumAttempts, String attmptFeedback, List<Integer> scores) {
 		if(scores.get(sNumAttempts) > 0){
 			scoreLabel.setText(attmptFeedback + " for "
 				               + scores.get(sNumAttempts) + " points.");
 		}else{
 			scoreLabel.setText(attmptFeedback + ".");
 		}
 	}
 	
 	/***
 	 * updates the score label if the answer is correct; if there are points, the points are shown in the label 
 	 * otherwise they are not shown
 	 * 
 	 * @param index
 	 * @param corrFeedback
 	 * @param scores
 	 * @return
 	 */
 	private void setCorrectAnswerLabel(int index, String corrFeedback, List<Integer> scores) {			
 		if(scores.get(index) > 0){
 			scoreLabel.setText(corrFeedback + " for " + scores.get(index)
 				+ " points.");
 		}else{
 			scoreLabel.setText(corrFeedback + ".");
 		}
 	}
 
 /*********************************** ENDS SCORE STATUS **************************************************/	
 /************************************ FEEDBACK INLINE  **************************************************/
 
 	/***
 	 * set all inline feedback labels to be invisible
 	 * 
 	 * @return 
 	 */
 	public void clearFeedbackInline() {
 		if (feedbackLabels == null)
 			return;
 
 		for (JLabel label : feedbackLabels.values()) {
 			label.setVisible(false);
 		}
 	}
 	
 	/***
 	 * disables the radio buttons, shows the correct inline feedback with corresponding radio button chosen 
 	 * 
 	 * @param correctAnswer
 	 */
 	private void getCorrectFeedback(Object correctAnswer) {
 		int numStudentAttempts = ((ChallengeQuestion)assessment).numStudentAttempts();
 		int maxAttempts = ((ChallengeQuestion)assessment).getMaxAttempts();
 		String lastAnswer = ((ChallengeQuestion)assessment).lastAnswer();
 		
 		if (numStudentAttempts >= maxAttempts
 				|| lastAnswer != null && lastAnswer.equals(correctAnswer)) {
 			disableRadioButtons(correctAnswer,false);
 			displayCorrectFeedbackInline();
 			selectRadioButton(correctAnswer, true); // select w/ correct image
 			// icon
 		}
 	}
 
 	/***
 	 * shows the correct inline feedback 
 	 * 
 	 * @return
 	 */
 	public void displayCorrectFeedbackInline() {
 		String newFeedbackInline = ((ChallengeQuestion)assessment).getCorrectFeedbackInline();
 		displayInlineFeedbackLabel(newFeedbackInline);
 	}
 	
 	/***
 	 * show last attempted choice's feedback
 	 * 
 	 * precondition: there is at least one previous answer in studentSock
 	 * @return 
 	 */
 	public void displayLastFeedbackInline() {
 		String newFeedbackInline = ((ChallengeQuestion)assessment).getLastFeedbackInline(assessment);
 		displayInlineFeedbackLabel(newFeedbackInline);	
 	}
 
 
 	private void displayInlineFeedbackLabel(String newFeedbackInline){
 		if(!newFeedbackInline.equals("")){
 			inlineFbTextLabel.setText(newFeedbackInline);
 			inlineFbTextLabel.setForeground(Color.BLUE);
 			inlineFbTextLabel.setVisible(true);
 		}
 	}
 	
 	
 	/***
 	 * wraps the inline feedback, adds it to a feedback label and puts it to the list of feedbackLabels 
 	 * 
 	 * @param sc
 	 * @return 
 	 */
 
 	private void adjustFeedback(SimpleChoice<String> sc){
 		int adjustedWidth = 50;
 		String inlineFeedbackText = null;
 		FeedbackInline inlineFeedback = sc.getFeedbackInline();
 
 		if (inlineFeedback != null) {
 			inlineFeedbackText = (String) inlineFeedback
 					.getContent();			
 			inlineFeedbackText = wrapInlineText(inlineFeedbackText,adjustedWidth);
 			inlineFeedback.setContent(inlineFeedbackText);
 		}
 			JLabel fiLabel = new JLabel();
 			// save each (choice, JLabel) pair so the itempanel can
 			// be updated easily
 			feedbackLabels.put(sc.getIdentifier(), fiLabel);
 			fiLabel.setLayout(new BoxLayout(fiLabel,BoxLayout.Y_AXIS));
 			fiLabel.setBorder(BorderFactory.createEmptyBorder(0, 4, 0, 0));
 			
 	}
 	
 
 	/***
 	 * @return label
 	 */
 	protected JLabel createNoNoteTakenLabel() {
 		JLabel noNoteTakenLabel = new JLabel(Messages
 				.getString("Note.NOTE_NOT_TAKEN")); //$NON-NLS-1$
 		noNoteTakenLabel.setFont(noNoteTakenLabel.getFont().deriveFont(
 				14.0f));
 		noNoteTakenLabel.setBorder(BorderFactory.createEmptyBorder(0, 8, 0,
 				0));
 		noNoteTakenLabel.setOpaque(false);
 		return noNoteTakenLabel;
 	}
 	
 	/***
 	 * @return panel - an empty box layout panel with components to be aligned vertically
 	 */
 	protected JPanel createVerticalBoxLayoutPanel(){
 		JPanel panel = new JPanel();
 		panel.setOpaque(false);
 		panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
 		return panel;
 	}
 	
 	/***
 	 * Creates a simple, border-layout panel
 	 * @return JPanel border layout
 	 */
 	protected JPanel createBorderLayoutPanel() {
 		JPanel borderPanel = new JPanel();
 		borderPanel.setLayout(new BorderLayout(0, 0));
 		borderPanel.setOpaque(false);
 		return borderPanel;
 	}
 	
 	
 	
 	/***
 	 * @return CompoundBorder 
 	 */
 	protected CompoundBorder createCompoundBorder(){
 		return BorderFactory
 		.createCompoundBorder(BorderFactory.createEmptyBorder(
 				0, 8, 0, 0), BorderFactory.createLineBorder(
 				PasColors.noteReportLineBorderColor, 1));
 	}
 
 	/***
 	 * @param answer - creates a textarea for the answer to be stored into, 
 	 * in this case red (if not answered) 
 	 * or black (if answered)
 	 * @return answerArea
 	 */
 	protected JTextArea createAnswerArea(String answer) {
 		JTextArea answerArea = new JTextArea();
 		answerArea.setOpaque(true);
 		answerArea.setBackground(PasColors.noteReportTextAreaColor);		
 		
 		if(answer.indexOf("NOT ANSWERED") > -1){
 			answerArea.setForeground(Color.RED);
 		}else{
 			answerArea.setForeground(Color.BLACK);				
 		}
 		
 		answerArea.setText(answer);
 		answerArea.setBorder(CommonUI.createEtchedBorder());
 		answerArea.setBorder(BorderFactory.createMatteBorder(0,0,1,0,Color.BLACK));
 		return answerArea;
 	}
 /************************************END FEEDBACK INLINE  **************************************************/
 /************************************************** TEXT PROCESSING **************************************************/	
 	/***
 	 * wraps the inline text but cutting off each line to a specified width and continuing 
 	 * the remainder of the text, repeating this process until the string has been fully wrapped
 	 */	
 	public String wrapInlineText(String inlineFeedbackText, int adjustedWidth){
 		String initHtml = "<html><body>";
 		String finalHtml = "</body></html>";
 		String finalStr = "";	
 		int lastIndex = 0;
 
 		inlineFeedbackText = inlineFeedbackText.trim();
 
 		while(inlineFeedbackText.length() > adjustedWidth){
 			String substri = inlineFeedbackText.substring(0,adjustedWidth);
 			lastIndex = substri.lastIndexOf(" ");
 			finalStr = finalStr + substri.substring(0,lastIndex) + "\n";
 			inlineFeedbackText = inlineFeedbackText.substring((int)lastIndex, inlineFeedbackText.length());
 
 		}
 		return initHtml + finalStr + inlineFeedbackText.substring(0,inlineFeedbackText.length()) + finalHtml;		
 	}
 
 	/***
 	 * extracts everything between the body tags
 	 * 
 	 * @param prompt
 	 * @return extractedBody 
 	 */	
 
 	private 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;
 	}
 	
 
 	
 /***********************************************END TEXT PROCESSING **************************************************/
 /*********************************************************************************************************************/
 /***********************************************GETTERS AND SETTERS **************************************************/
 
 	/***
 	 * @return the check action for the check action button, the logic of which proceeds to 
 	 * ChallengeQuestionCheckAction
 	 */
 	protected ChallengeQuestionCheckAction getCQCheckAction() {
 		ChallengeQuestionCheckAction checkAction = new ChallengeQuestionCheckAction(
 				assessment.getAssessmentItem(), assessment.getResponses(),
 				assessment.getResponseDeclarationToSocks(),
 				(ChallengeQuestion) assessment);
 		return checkAction;
 	}
 	
 	/***
 	 * @return the gotoStepButton
 	 */
 	public JButton getGotoStepButton() {
 		return gotoStepButton;
 	}
 
 	/***
 	 * @param gotoStepButton the gotoStepButton to set
 	 */
 	public void setGotoStepButton(JButton gotoStepButton) {
 		this.gotoStepButton = gotoStepButton;
 	}
 	
 /************************************************************************************************************************/
 
 }