/*
    * 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.awt.Container;
  import java.awt.Dimension;
  import java.awt.FlowLayout;
  import java.awt.Font;
  import java.awt.GridBagConstraints;
  import java.awt.GridBagLayout;
  import java.awt.Point;
  import java.awt.event.ActionEvent;
  import java.awt.print.PrinterException;
  import java.awt.print.PrinterJob;
  import java.text.DecimalFormat;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.logging.Logger;
  
  import javax.swing.AbstractAction;
  import javax.swing.BorderFactory;
  import javax.swing.BoxLayout;
  import javax.swing.ImageIcon;
  import javax.swing.JButton;
  import javax.swing.JComponent;
  import javax.swing.JLabel;
  import javax.swing.JPanel;
  import javax.swing.JProgressBar;
  import javax.swing.JScrollPane;
  import javax.swing.JTextArea;
  import javax.swing.JTextField;
  import javax.swing.SwingUtilities;
  import javax.swing.border.Border;
  import javax.swing.border.TitledBorder;
  
  import net.miginfocom.swing.MigLayout;
  import net.sf.sail.core.beans.Pod;
  import net.sf.sail.core.beans.service.AnnotationService;
  import net.sf.sail.core.entity.AgentSet;
  import net.sf.sail.core.entity.IAgent;
  import net.sf.sail.core.entity.IAnnotation;
  import net.sf.sail.core.entity.MismatchedAgentSetSizeException;
  import net.sf.sail.core.entity.Rim;
  import net.sf.sail.core.entity.Role;
  import net.sf.sail.core.entity.User;
  
  import org.apache.commons.lang.StringUtils;
  import org.telscenter.pas.beans.IWorkReporter;
  import org.telscenter.pas.beans.PasActivity;
  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.service.PasProjectServiceProvider;
  import org.telscenter.pas.steps.domain.AssessmentItem;
  import org.telscenter.pas.steps.domain.ResponseDeclaration;
  import org.telscenter.pas.ui.frames.PasFrame;
  import org.telscenter.pas.ui.icons.PasCommonIconProvider;
  import org.telscenter.pas.ui.pdf.actions.GeneratePDFAction;
  import org.telscenter.pas.ui.util.PasColors;
  import org.telscenter.pas.util.AnnotationUtils;
  
  //import com.lowagie.text.pdf.PdfPCell;
  
  /***
   * A generic Pas step type, used for testing and demonstration purposes.
   * This PasStep does not get initialized like the other Pas steps, 
   * so consumeService cannot be used.
   * 
   * @author turadg
   */
  public class ShowAllWorkStep extends PasStep  {
  
  	/***
  	 * 
  	 */
  	private static final String UNSCORED = "unscored";
  
  	private static final long serialVersionUID = 1L;
  	
  	PasProjectServiceProvider provider;
  	PasProject project;
  	INavigationService navigationService;
  	AnnotationService annotationService;
  	boolean visited = false;
  	private boolean withAnnotations = false;
  
  	private PasProjectNavigationTaskPanel projectNavigationTaskPanel;
  
  	private static final int STUDENTWORK_MAX_SIZE_X = 250;
  	private static final int STUDENTWORK_MAX_SIZE_Y = 150;
 	private static final int TEACHERCOMMENTS_MAX_SIZE_X = 10;
 	private static final int TEACHERCOMMENTS_MAX_SIZE_Y = 10;
 	private static final int SCORE_MAX_SIZE_X = 70;
 	private static final int SCORE_MAX_SIZE_Y = 80;
 	
 	private static final Logger logger = Logger
 	.getLogger(ShowAllWorkStep.class.getName());
 	
 	private JProgressBar percentageCompleteBar = new JProgressBar(0, 100);
 
 	private JLabel currentScoreEquationLabel = new JLabel();
 
 	private HashMap<PasStep,String> stepsToTeacherScores = new HashMap<PasStep, String>();
 	
 	private HashMap<PasStep,String> stepsToPossibleScores = new HashMap<PasStep, String>();
 	
 	
 	public ShowAllWorkStep(PasProject project, INavigationService navigationService){
 		this.project = project;
 		this.navigationService = navigationService;
 		this.annotationService = project.getAnnotationService();
 		if(annotationService != null && annotationService.isAvailable()){
 			withAnnotations = true;
 		}
 	}
 	
 	public Component getComponent() {
 		PasActivity[] activities = project.getActivities();
 		 projectNavigationTaskPanel = project.getPanel();
 		JPanel activitiesPanel = traverseActivities(activities, projectNavigationTaskPanel);		
 		final JScrollPane scrollPane = setScrollPane(activitiesPanel);
 		JPanel titleAndButtonPanel = createTitleAndButtonPanel();
 		JPanel mainShowAllWorkPanel = setMainShowAllWorkPanel(titleAndButtonPanel, scrollPane);
 		setStepTitlePanelVisited(true);
 		
 		return mainShowAllWorkPanel;
 	}
 	
 	private class PrintAllWorkAction extends AbstractAction {
 		
 		public PrintAllWorkAction(String title){
 			super(title);
 		}
 		
 		public void runAction() {
 			SwingUtilities.invokeLater(new Runnable() {
 				public void run() {
 					openPrintDialog();
 				}
 			});
 		}
 		
 		public void openPrintDialog(){
 			  PrinterJob printJob = PrinterJob.getPrinterJob();
 		//	    printJob.setPrintable(new Printable());
 			    if (printJob.printDialog())
 			      try { 
 			        printJob.print();
 			      } catch(PrinterException pe) {
 			        System.out.println("Error printing: " + pe);
 			      }
 			
 		}
 		
 		public void actionPerformed(ActionEvent e) {
 			this.runAction();
 		}
 		
 	}
 
 /******************************************************************************************/	
 /********************** TRAVERSING ACTIVITIES AND STEPS ***********************************/	
 	
 	
 	/***
 	 * goes through all the activities, grabbing the title for each activity, setting the activity title panel, and 
 	 * adding all the corresponding IWorkReporter steps with student work, teacher comments (annotations), and score, 
 	 * in each activity (assuming that the activity has at least one step), 
 	 * with each step split up into its parts. A check is initially done to see whether there are any annotations: if 
 	 * there are no annotations, only the student work is shown; otherwise, the student work, teacher comments, and scores
 	 * are shown.
 	 * 
 	 *  
 	 * @param activities
 	 * @param thisPanel
 	 * @return activitiesPanel
 	 */
 	private JPanel traverseActivities(PasActivity[] activities, PasProjectNavigationTaskPanel thisPanel) {
 		float headerFontSize = 16.0f;
 		JPanel activitiesPanel = new JPanel(new BorderLayout(0,0));
 		//activitiesPanel.setLayout(new BoxLayout(activitiesPanel, BoxLayout.Y_AXIS));
 
 		MigLayout mig = new MigLayout("insets 0 0 0 0");
 		activitiesPanel.setLayout(mig);
 		activitiesPanel.setBackground(PasColors.showReportsActivityBackgroundColor);
 		//activitiesPanel.setBackground(Color.red);
 		
 		for (int i = 0; i < activities.length; i++) {
 			PasActivity activity = activities[i];
 			JLabel actTitle = getActivityTitle(i, activity);
 			JPanel titlePanel = getActTitlePanel(actTitle);
 			
 			JPanel activityPanel = new JPanel(new BorderLayout(0,0));
 			activityPanel.setBackground(PasColors.showReportsActivityBackgroundColor);
 			
 			//activityPanel.setBackground(Color.red);
 			activityPanel.add(titlePanel, BorderLayout.NORTH);
 				
 				
 				
 				//setActivityPanel(titlePanel);
 			//JLabel myWorkLabel = new JLabel("My Work");
 //			myWorkLabel.setFont(myWorkLabel.getFont().deriveFont(Font.BOLD, headerFontSize));
 
 			if( activity.getSteps().length > 0) {
 				PasStep[] steps = activity.getSteps();
 				JPanel stepsPanel = new JPanel();
 				
 				MigLayout mig1 = new MigLayout("insets 0 0 0 0");
 				stepsPanel.setLayout(mig1);
 				
 				if (withAnnotations) {
 					//stepsPanel.setLayout(new BoxLayout(stepsPanel, BoxLayout.Y_AXIS));
 					//stepsPanel.add(myWorkLabel, BorderLayout.WEST);
 					stepsPanel = traverseSteps(thisPanel, steps);
 				} else {
 					//stepsPanel.setLayout(new BoxLayout(stepsPanel, BoxLayout.Y_AXIS));
 					//stepsPanel.add(myWorkLabel, BorderLayout.WEST);
 					
 					int iterator = 0;
 
 					for (final PasStep step: steps) {
 						if (step instanceof IWorkReporter) {
 							JButton stepTitle = createStepTitleButton(thisPanel, iterator, step);
 							JPanel stepTitlePanel = new JPanel(new BorderLayout(0,0));
 							stepTitlePanel.add(CommonUI.makeLink(stepTitle),BorderLayout.WEST);
 							stepTitlePanel.setBackground(PasColors.showReportsActivityBackgroundColor);
 							stepsPanel.add(stepTitlePanel,"wrap");
 							
 							NavigateAction navigateAction = null;
 							JPanel reportForLearner;
 							
 							//assessment is special
 							if( step instanceof StudentAssessment || step instanceof Note) {
 								navigateAction = new NavigateAction(step, navigationService,projectNavigationTaskPanel);
 								reportForLearner = ((IWorkReporter) step).getReportForLearner(navigateAction);
 							} else {
 								reportForLearner = ((IWorkReporter) step).getReportForLearner();
 							}
 							
 							stepsPanel.add(reportForLearner,"wrap");
 							stepsPanel.setBackground(PasColors.showReportsActivityBackgroundColor);
 							
 						}
 						iterator++;
 				}
 					
 				}
 				
 				activityPanel.add(stepsPanel,BorderLayout.WEST);
 				activitiesPanel.add(activityPanel,"wrap");					
 			}	
 		}
 		
 		//process scores
 		
 		//create progressbar
 		if(withAnnotations) {
 		
 			int numberOfGradedSteps = 0;
 			int totalTeacherScore = 0;
 			int totalPossibleScore = 0;
 			for (Map.Entry<PasStep, String> entries : stepsToTeacherScores.entrySet()) {
 				
 				PasStep pasStep = entries.getKey();
 				String score = entries.getValue();
 				
 				if( !score.equals(UNSCORED)) {
 					 numberOfGradedSteps++;
 					
 					if( StringUtils.isNumeric(score)) {
 						totalTeacherScore = totalTeacherScore + new Integer(score).intValue();
 						
 						String possibleScore = stepsToPossibleScores.get(pasStep);
 						
 						totalPossibleScore = totalPossibleScore + new Integer(possibleScore).intValue();
 					}
 				}
 			}// for
 			
 			
 			String pattern = "###";
 			DecimalFormat myFormatter = new DecimalFormat(pattern);
 			
 			int numberGradableSteps = stepsToPossibleScores.keySet().size();
 			
 			//compute raw score percent
 			double percentGrade = (((double)totalTeacherScore)/((double)totalPossibleScore)) * 100;
 			
 			String perValue = myFormatter.format(percentGrade);
 			
 			
 			//compute raw score
 			currentScoreEquationLabel.setText(totalTeacherScore+"/"+totalPossibleScore+" = " + perValue+ "%");
 			currentScoreEquationLabel.revalidate();
 
 			
 			
 			//compute percentage completed
 			if( numberGradableSteps != 0 ) {
 				
 				double percentCompleted = (((double)numberOfGradedSteps)/((double)numberGradableSteps)) * 100;
 				
 				
 				String value = myFormatter.format(percentCompleted);
 				
 				percentageCompleteBar.setValue(new Integer(value));
 			}
 			//
 			
 			
 		}// if
 		
 		return activitiesPanel;
 	}
 
 	/***
 	 * visits all the steps in the current activity, checking to see that if a step is an instance of 
 	 * IWorkReporter, initialize its step parts listing, and creates a step panel to return, including the
 	 * step title and corresponding parts (with student answers)
 	 *  
 	 * @param thisPanel
 	 * @param steps
 	 * @return stepsPanel
 	 */
 	private JPanel traverseSteps(PasProjectNavigationTaskPanel thisPanel, PasStep[] steps) {
 		JPanel stepsPanel = new JPanel();
 		MigLayout mig = new MigLayout( "insets 0 0 0 0");
 		stepsPanel.setLayout(mig);
 		stepsPanel.setBackground(PasColors.showReportsActivityBackgroundColor);
 		//stepsPanel.setLayout(new BoxLayout(stepsPanel, BoxLayout.Y_AXIS));
 		
 		for (int j = 0; j < steps.length; j++) {
 			PasStep step = steps[j];
 			
 			if (step instanceof IWorkReporter) {
 				((IWorkReporter) step).initStepParts();
 				JButton stepTitleButton = createStepTitleButton(thisPanel, j, step);
 
 				JPanel stepTitlePanel = new JPanel(new BorderLayout(0,0));
 				stepTitlePanel.add(CommonUI.makeLink(stepTitleButton),BorderLayout.WEST);
 			    stepTitlePanel.setOpaque(false);
 				JPanel stepPanel = createStepPanel(step);
 				// stepContentPanel includes studentwork, teacher comments and score
 				
 				//stepPanel.setBorder(BorderFactory.createEtchedBorder(46));
 				stepsPanel.add(stepTitlePanel,"wrap");				
 				stepsPanel.add(stepPanel,"wrap");
 			
 				stepsPanel.setBorder(BorderFactory.createEmptyBorder(0, 8, 8, 10));
 				stepsPanel.setOpaque(true);
 				
 			}// if
 		}// for
 		
 		return stepsPanel;
 	}
 
 /******************************************************************************************/	
 /******************************************************************************************/	
 /*********************************************  TITLE PANELS ******************************/
 	/*
 	 * createTitleAndButtonPanel
 	 * getActTitlePanel
 	 * setActivityPanel
 	 * setScrollPane
 	 * setMainShowAllWorkPanel
 	 */
 	
 	/***
 	 * creates title for show all work and the corresponding function buttons, to print, save, and email 
 	 * the work for students
 	 * TODO: PDF functionality 
 	 * @return titleAndButtonPanel
 	 */
 	
 	private JPanel createTitleAndButtonPanel(){
 		float headerFontSize=28.0f;
 		JLabel showAllWorkLabel = new JLabel("SHOW ALL WORK");
 		showAllWorkLabel.setFont(showAllWorkLabel.getFont().deriveFont(Font.BOLD, headerFontSize));
 		showAllWorkLabel.setForeground(new Color(202,225,255));
 
 		SimpleGradientPanel showAllWorkPanel = createSimpleGradientPanel();
 		GridBagConstraints c = createGridBagConstraint();
 		showAllWorkPanel.add(showAllWorkLabel, c);
 		
 		JButton printAllWork = new JButton(new PrintAllWorkAction("Print All Work"));
 		printAllWork.setText("Print All Work");
 		printAllWork.setForeground(new Color(202,225,255));
 		printAllWork.setContentAreaFilled(false);		
 		printAllWork.setBorder(BorderFactory.createEmptyBorder(0, 0, 8, 0));					
 		
 		JButton saveAsPdfFile = new JButton(new GeneratePDFAction(new ImageIcon( PasCommonIconProvider.getImage("pdf.png") ), "Make PDF",project));
 		saveAsPdfFile.setText("Save As PDF File");
 		saveAsPdfFile.setForeground(new Color(202,225,255));
 		saveAsPdfFile.setContentAreaFilled(false);		
 		saveAsPdfFile.setBorder(BorderFactory.createEmptyBorder(0, 0, 8, 0));					
 
 		JButton emailPdfFile = new JButton("Email PDF File");
 		emailPdfFile.setForeground(new Color(202,225,255));	
 		emailPdfFile.setContentAreaFilled(false);		
 		emailPdfFile.setBorder(BorderFactory.createEmptyBorder(0, 0, 8, 0));					
 
 		SimpleGradientPanel buttonPanel = createSimpleGradientPanel();
 		c.gridx = 1;
 		c.gridy=0;
 		buttonPanel.add(printAllWork, c);
 		c.gridx=2;
 		buttonPanel.add(saveAsPdfFile,c);
 		c.gridx=3;
 		buttonPanel.add(emailPdfFile,c);
 		
 		PasFrame projectFrame = project.getProjectFrame();
 		String userNameMessage = "BY: ";
 		if(projectFrame != null)
 			userNameMessage = userNameMessage.concat(projectFrame.getUserNames());
 			
 		SimpleGradientPanel namePanel = new SimpleGradientPanel();
 		namePanel.add(new JLabel(userNameMessage));
 		
 		SimpleGradientPanel titleAndButtonPanel = createSimpleGradientPanel();
 		c.gridx=2;
 		c.gridy=0;
 		titleAndButtonPanel.add(showAllWorkPanel,c);
 		c.gridx=3;
 		titleAndButtonPanel.add(buttonPanel,c);
 		c.gridx=0;
 		c.gridy=1;
 		c.gridwidth = GridBagConstraints.WEST;
 		titleAndButtonPanel.add(namePanel,c);
 		return titleAndButtonPanel;		
 	}
 	
 	/***
 	 * creates a simple gradient panel for background
 	 * 
 	 * @return mainPanel
 	 */
 	private SimpleGradientPanel createSimpleGradientPanel() {
 		SimpleGradientPanel mainPanel = new SimpleGradientPanel();
 		mainPanel.setDirection(SimpleGradientPanel.VERTICAL);
 		mainPanel.setStartColor(PasColors.vleHeadingBackgroundStartColor);
 		mainPanel.setEndColor(PasColors.vleHeadingBackgroundEndColor);
 		mainPanel.setLayout(new GridBagLayout());
 		return mainPanel;
 	}
 	
 	/***
 	 * @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.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;
 	}
 	
 	
 	
 	
 
 	/***
 	 * creates a big white title panel for an activity, with the activity's title aligned to the left
 	 * 
 	 * @param actTitle
 	 * @return titlePanel
 	 */
 	private JPanel getActTitlePanel(JLabel actTitle) {
 		JPanel titlePanel = new JPanel(new BorderLayout(0,0));
 		titlePanel.add(actTitle,BorderLayout.WEST);
 		
 		//green
 		titlePanel.setBackground(new Color(69,221,106));
 		titlePanel.setBorder(BorderFactory.createLineBorder(PasColors.showReportsActivityTitleBorderColor, 1));
 		
 		JPanel wrapperPanel = new JPanel(new BorderLayout(0,0));
 		wrapperPanel.setBorder(BorderFactory.createEmptyBorder(0, 0, 5, 0));
 		wrapperPanel.add(titlePanel,BorderLayout.CENTER);
 		wrapperPanel.setBackground(PasColors.showReportsActivityBackgroundColor);
 		return wrapperPanel;
 	}
 
 	/***
 	 * creates the actual activity panel, adding the activity title panel within it
 	 * 
 	 * @param titlePanel
 	 * @return activityPanel
 	 */
 	private JPanel setActivityPanel(JPanel titlePanel) {
 		JPanel activityPanel;
 		activityPanel = new JPanel(new BorderLayout());
 		//activityPanel.setLayout(new BoxLayout(activityPanel, BoxLayout.Y_AXIS));
 		
 		activityPanel.setBackground(PasColors.showReportsActivityBackgroundColor);
 		//activityPanel.add(titlePanel.Bor);
 		return activityPanel;
 	}
 	
 	
 	/***
 	 * creates the step panel, by visiting each and every part of the step, and adding the student part,
 	 * teacher comments and score for that part before proceeding to the next part. note that the score part 
 	 * is only included once per step, and therefore is not repeatedly included after the first part. instead,
 	 * to fill up the horizontal space, a filler panel of equal size but with the background color is included.
 	 * 
 	 * @param step must be instance of IWorkReporter
 	 * @return stepPanel
 	 */
 	private JPanel createStepPanel(PasStep step){
 		assert step instanceof IWorkReporter;
 		
 		NavigateAction navigateAction = null;
 		JPanel reportForLearner;
 		
 		//assessment is special
 		if( step instanceof Assessment ) {
 			navigateAction = new NavigateAction(step, navigationService,projectNavigationTaskPanel);
 			reportForLearner = ((IWorkReporter) step).getReportForLearnerWithAnnotations(navigateAction);
 		} else {
 			reportForLearner = ((IWorkReporter) step).getReportForLearnerWithAnnotations();
 		}
 		
 		//((IWorkReporter) step).getReportForLearnerWithAnnotations();  // need to call this to populate step.currentstepparts
 		List<JPanel> theParts = ((IWorkReporter) step).getCurrentStepParts();
 		JPanel stepPanel = initStepPanel();
 	
 		if (step instanceof Note || step instanceof StudentAssessment || step instanceof ChallengeQuestion) {
 			MigLayout ml = new MigLayout("insets 0 0 0 0");
 			JPanel columnPanel = new JPanel(ml);
 			
 			JPanel teacherCommentPanel = null;
 			JPanel scorePanel = null;
 			
 			for(int i = 0; i < theParts.size(); i++){
 				JPanel studentPart = theParts.get(i);
 				
 				studentPart.setBackground(PasColors.showReportsActivityBackgroundColor);
 				studentPart.setBorder(BorderFactory.createCompoundBorder(createEmptyTitledBorder("Part " + (i+1), studentPart), BorderFactory.createLineBorder(Color.BLACK,1)));
 				
 						
 				columnPanel.add(studentPart,"wrap");
 				columnPanel.setBorder(BorderFactory.createEmptyBorder());
 				columnPanel.setOpaque(false);
 				
 				String comments = processTheAnnotations(step, i, this.project);
 //				//makes teachers comments
 				teacherCommentPanel = makeTeacherCommentPanel(comments);
 				teacherCommentPanel.setOpaque(false);
 				scorePanel = getScorePart(step, i, this.project);
 				scorePanel.setBackground(PasColors.showReportsActivityBackgroundColor);
 			}// for
 			
 //			ml = new MigLayout(
 //			"", 						//layout constraints		
 //			"[][][]",			//colum constraints
 //			"[][][]"							//row constraints
 //			);
 			MigLayout ml2 = new MigLayout("insets 0 0 0 0");
 			stepPanel.setOpaque(true);
 			stepPanel.setBackground(PasColors.showReportsActivityBackgroundColor);
 			stepPanel.setLayout(ml2);
 			stepPanel.add(columnPanel,"top gapleft 40");
 			stepPanel.add(teacherCommentPanel,"top");
 			stepPanel.add(scorePanel,"top");
 
 		} else {
 			
 			if( theParts != null ) {
 				for(int i = 0; i < theParts.size(); i++){		
 					JPanel stepPartPanel = new JPanel();
 					stepPartPanel.setLayout(new BoxLayout(stepPartPanel,BoxLayout.X_AXIS));
 					stepPartPanel.setAlignmentY(Component.TOP_ALIGNMENT);
 	
 					JPanel studentPart = getStudentPart(theParts, i);
 					studentPart.setBorder(BorderFactory.createLineBorder(Color.BLACK,1));
 					String comments = processTheAnnotations(step, i, this.project);
 					JPanel teacherCommentsPart = makeTeacherCommentPanel(comments);
 					teacherCommentsPart.setBorder(BorderFactory.createLineBorder(Color.BLACK,1));
 					JPanel scorePart = getScorePart(step, i, this.project);
 					//	scorePart.setBorder(BorderFactory.createLineBorder(Color.BLACK,1));
 					JPanel fillerPanel = new JPanel();
 					fillerPanel.setAlignmentY(Component.TOP_ALIGNMENT);				
 					fillerPanel.setBackground(PasColors.showReportsContentPanelBackgroundColor);
 					fillerPanel.setSize(SCORE_MAX_SIZE_X,  STUDENTWORK_MAX_SIZE_Y);
 					fillerPanel.setMaximumSize(new Dimension(SCORE_MAX_SIZE_X,  STUDENTWORK_MAX_SIZE_Y));
 					stepPartPanel.add(studentPart);
 					stepPartPanel.add(teacherCommentsPart);
 					if(i==0){
 						fillerPanel.add(scorePart);
 					}	
 					stepPartPanel.add(fillerPanel);
 					stepPanel.add(stepPartPanel);
 				}  // end of for each part
 			} else {
 				JLabel noAnnonationLabel = new JLabel("this step has no annotations");
 				noAnnonationLabel.setOpaque(false);
 				stepPanel.add(noAnnonationLabel);
 				// if
 			}// if
 		}
 		return stepPanel;
 	}
 
 	
 	/***
 	 * initializes the step panel, which is used for adding the corresponding step parts to 
 	 * 
 	 * @return stepPanel
 	 */
 	private JPanel initStepPanel() {
 		JPanel stepPanel = new JPanel();
 		stepPanel.setLayout(new BoxLayout(stepPanel, BoxLayout.Y_AXIS));
 		stepPanel.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0));		
 		stepPanel.add(new JLabel(" "),BorderLayout.NORTH);
 		return stepPanel;
 	}
 	
 	protected static Border createEmptyTitledBorder(String title, JComponent component) {
 		return BorderFactory.createTitledBorder(BorderFactory.createEmptyBorder(), title,TitledBorder.LEFT,TitledBorder.ABOVE_TOP,component.getFont().deriveFont(10f));
 	}
 
 	/***
 	 * returns a score panel with the score value for the corresponding step 
 	 * 
 	 * @return scorePanel;
 	 */
 	private static JPanel getScorePart(PasStep step, int rdIndex, PasProject project){
 		JPanel scorePanel = new JPanel(new FlowLayout());
 		
 		
 		scorePanel.setBorder(createEmptyTitledBorder("Score",scorePanel));
 
 		String score = processScore(step, rdIndex, project);
 		
 		if( score == null || StringUtils.trimToNull(score) == null ) {
 			score = UNSCORED;
 		}
 		
 		
 		//stepsToTeacherScores.put(step, score);
 		
 		JTextField teacherScoreField = new JTextField(score);
 		teacherScoreField.setColumns(5);
 		teacherScoreField.setHorizontalAlignment(JTextField.CENTER);
 		teacherScoreField.setEditable(false);
 		teacherScoreField.setBorder(BorderFactory.createCompoundBorder(BorderFactory.createLineBorder(PasColors.blackColor,1),BorderFactory.createEmptyBorder(1,1,1,1)));
 		
 		Integer possibleScore = ((IWorkReporter)step).getPossibleScore();
 		
 		//stepsToPossibleScores.put(step, possibleScore.toString());
 		
 		JTextField possibleScoreField = new JTextField(possibleScore.toString());
 		possibleScoreField.setHorizontalAlignment(JTextField.CENTER);
 		possibleScoreField.setColumns(5);
 		possibleScoreField.setEditable(false);
 		possibleScoreField.setBorder(BorderFactory.createCompoundBorder(BorderFactory.createLineBorder(PasColors.blackColor,1),BorderFactory.createEmptyBorder(1,1,1,1)));
 		
 		JLabel ofLabel = new JLabel("of");
 		
 		scorePanel.add(teacherScoreField);
 		scorePanel.add(ofLabel);
 		scorePanel.add(possibleScoreField);
 		scorePanel.setBackground(Color.WHITE);
 		//scorePanel.setBorder(BorderFactory.createLineBorder(PasColors.blackColor,1));
 		return scorePanel;
 	}
 	
 
 	/***
 	 * puts the entire activities panel (consisting of the activities' steps and corresponding
 	 * parts with work) into a scroll pane (after all, the entire project can easily span 
 	 * many pages work of activities and steps so a scroll pane would be necessary)
 	 * 
 	 * 
 	 * @param activitiesPanel
 	 * @return scrollPane
 	 */
 	private JScrollPane setScrollPane(JPanel activitiesPanel) {
 		final JScrollPane scrollPane = new JScrollPane(activitiesPanel,JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
 		scrollPane.setBorder(BorderFactory.createEmptyBorder());
 		scrollPane.setOpaque(false);
 
 		// workaround for scrollbar being at bottom
 		SwingUtilities.invokeLater(new Runnable() {
 			public void run() {
 				scrollPane.getViewport().setViewPosition(new Point(0,0));
 			}
 		});
 //		scrollPane.getHorizontalScrollBar().setVisible(false);
 //		scrollPane.getHorizontalScrollBar().setEnabled(false);
 		return scrollPane;
 	}
 	
 	/***
 	 * adds title and button panel (consisting of the 'show all work' and function button headings)
 	 * and the scroll pane (consisting of the corresponding activities) inside it to return
 	 *  
 	 * @param titleAndButtonPanel
 	 * @param spane
 	 * @return mainShowAllWorkPanel
 	 */
 	private JPanel setMainShowAllWorkPanel(JPanel titleAndButtonPanel, final JScrollPane spane) {
 		JPanel mainShowAllWorkPanel = new JPanel(new BorderLayout(0,0));
 		mainShowAllWorkPanel.setOpaque(false);
 		mainShowAllWorkPanel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
 		
 //		if(withAnnotations) {
 //			//SimpleGradientPanel namePanel = new SimpleGradientPanel();
 //			SimpleGradientPanel outerPanel = new SimpleGradientPanel(new BorderLayout(0,0));
 //			outerPanel.setBackground(titleAndButtonPanel.getBackground());
 //			SimpleGradientPanel progressPanel = new SimpleGradientPanel();
 //			JLabel wordsLabel = new JLabel("Project Complete: ");
 //			wordsLabel.setOpaque(false);
 //			progressPanel.add(wordsLabel);
 //			
 //	        percentageCompleteBar.setStringPainted(true);
 //	        percentageCompleteBar.setBorderPainted(true); 
 //	        percentageCompleteBar.setOpaque(false);
 //	        
 //	        progressPanel.add(percentageCompleteBar);
 //	        
 //	        JLabel currentScoreLabel = new JLabel("Current Score:");
 //	        
 //	        JPanel rawPanel = new JPanel(new FlowLayout());
 //	        
 //	        currentScoreLabel.setOpaque(false);
 //	        currentScoreEquationLabel.setOpaque(false);
 //	        
 //	        rawPanel.add(currentScoreLabel);
 //	        rawPanel.add(currentScoreEquationLabel);
 //	        rawPanel.setOpaque(false);
 //	        
 //	        progressPanel.add(rawPanel);
 //	        
 //			outerPanel.add(titleAndButtonPanel,BorderLayout.NORTH);
 //			outerPanel.add(progressPanel, BorderLayout.CENTER);
 //			
 //			mainShowAllWorkPanel.add(outerPanel,BorderLayout.NORTH);
 //			mainShowAllWorkPanel.add(spane,BorderLayout.CENTER);
 //			return mainShowAllWorkPanel;
 //		}
 		
 		
 		mainShowAllWorkPanel.add(titleAndButtonPanel,BorderLayout.NORTH);
 		mainShowAllWorkPanel.add(spane,BorderLayout.CENTER);
 		return mainShowAllWorkPanel;
 	}
 
 /******************************************************************************************/	
 /******************************************************************************************/	
 	
 	/***
 	 * sets and returns the activity title label
 	 * 
 	 * @param i
 	 * @param activity
 	 * @return actTitle
 	 */
 	private JLabel getActivityTitle(int i, PasActivity activity) {
 		float headerFontSize = 16.0f;
 		String actTitle = "";
 		if(activity.getTitle().indexOf("Activity") > -1){
 			actTitle = activity.getTitle(); 
 		}else{
 			actTitle = "Activity " + (i+1) + ": " + activity.getTitle();
 		}
 		
 		JLabel actTitleLabel = new JLabel(actTitle);
 		actTitleLabel.setFont(actTitleLabel.getFont().deriveFont(Font.BOLD, headerFontSize));
 		actTitleLabel.setBorder(BorderFactory.createEmptyBorder(2, 2, 2, 2));
 		actTitleLabel.setBackground(actTitleLabel.getBackground().brighter());
 		return actTitleLabel;
 	}
 
 	
 	/***
 	 * creates step title button 
 	 * 
 	 * @param thisPanel
 	 * @param j
 	 * @param step
 	 * @return title
 	 */
 	private JButton createStepTitleButton(PasProjectNavigationTaskPanel thisPanel, int j,
 			PasStep step) {
 		JButton title = new JButton(new NavigateAction(step, navigationService,thisPanel));
 		title.setHorizontalTextPosition(JLabel.LEFT);
 		title.setContentAreaFilled(false);
 		title.setFont(title.getFont().deriveFont(16.0f));
 		title.setBorder(BorderFactory.createEmptyBorder(0, 0, 8, 0));					
 		title.setText("Step " + (j + 1) + " : " + title.getText());
 		return title;
 	}
 	
 	
 	/***
 	 * processes and returns teacher comments (annotations) 
 	 * 
 	 * @return comments
 	 */
 	public static String processTheAnnotations(PasStep step, int rdIndex, PasProject project){
 		
 		String comments = null;
 		if (step instanceof Assessment) {
 			Assessment assmtStep = ((Assessment)step);
 			
 			List<ResponseDeclaration> responseDeclarations = assmtStep.getAssessmentItem()
 			.getResponseDeclarations();
 
 			ResponseDeclaration rd = null;
 			if(responseDeclarations !=null) {
 				rd = responseDeclarations.get(rdIndex);
 			} else {
 				rd = null;
 			}
 			comments = AnnotationUtils.processTheAnnotations(step, assmtStep.getSessionService(), assmtStep.getAgentService(), project.getAnnotationService());		
 			
 //			IAnnotation annotation;
 //			Pod pod = (Pod) step.getBeanContext();
 //
 //			User user = project.getSessionService().getUsers().iterator().next();
 //			AgentSet agentsOfUser = ((Assessment) step).agentService.getAgentsOfUser(user);
 //			AgentSet agentsOfUserInWorkgroup = 
 //				agentsOfUser.select(Role.RUN_WORKGROUP);
 //			IAgent agent=null;
 //			try {
 //				agent = agentsOfUserInWorkgroup.getSingle();
 //			} catch (MismatchedAgentSetSizeException e1) {
 //				e1.printStackTrace();
 //				//return null;
 //			}
 //			annotation = project.getAnnotationService().getAnnotation(pod, agent, "http://telscenter.org/annotation/comments");			
 //			if (annotation != null) {
 //				comments = annotation.getContents();
 			}	
 
 			
 //			if (!(step instanceof Note)) {   // for a note, we have one comment for all parts, not one comment per part
 //				AssessmentItem assessmentItem = ((Assessment)step).assessmentItem;
 //				List<ResponseDeclaration> responseDeclarations = assessmentItem
 //				.getResponseDeclarations();
 //
 //				if(responseDeclarations !=null) {
 //					ResponseDeclaration rd = responseDeclarations.get(rdIndex);
 //					if (rd != null) {
 //						Rim rim = rd.getRim();
 //
 //						if(rim!=null){
 //							try {
 //								IAnnotation rimAnnotation = project.getAnnotationService().getAnnotation(rim, agent, "http://telscenter.org/annotation/comments");
 //								if (rimAnnotation != null) {
 ////									System.out.println("Rim: " + rim.toString());
 ////									System.out.println("RimAnnotation: " + rimAnnotation);
 //									annotation = rimAnnotation;
 //									comments = annotation.getContents();
 ////									System.out.println("annotation ");
 ////									System.out.println("  source: " + annotation.getSource());
 ////									System.out.println("  contentType: " + annotation.getContentType());
 ////									System.out.println("  contents: " + annotation.getContents());
 //								}
 //							} catch(Exception e){
 //								e.printStackTrace();
 //							}
 //						}
 //					}
 //				}
 //				
 //			}
 //		}
 		
 		return comments;
 		
 	}
 	
 	/***
 	 * processes and returns teacher score (annotations) 
 	 * 
 	 * @return comments
 	 */
 	public static String processScore(PasStep step, int rdIndex, PasProject project){
 			
 			
 			String score = null;
 			if (step instanceof Assessment) {
 				Assessment assmtStep = ((Assessment)step);
 				
 				List<ResponseDeclaration> responseDeclarations = assmtStep.getAssessmentItem()
 				.getResponseDeclarations();
 
 				ResponseDeclaration rd = null;
 				if(responseDeclarations !=null) {
 					rd = responseDeclarations.get(rdIndex);
 				} else {
 					rd = null;
 				}
 				score = AnnotationUtils.processScore(step, assmtStep.getSessionService(), assmtStep.getAgentService(), project.getAnnotationService());		
 				
 			}
 //			IAnnotation scoreAnnotation;
 //			Pod pod = (Pod) step.getBeanContext();
 //
 //			User user = project.getSessionService().getUsers().iterator().next();
 //			AgentSet agentsOfUser = ((Assessment) step).agentService.getAgentsOfUser(user);
 //			AgentSet agentsOfUserInWorkgroup = 
 //				agentsOfUser.select(Role.RUN_WORKGROUP);
 //			IAgent agent=null;
 //			try {
 //				agent = agentsOfUserInWorkgroup.getSingle();
 //			} catch (MismatchedAgentSetSizeException e1) {
 //				e1.printStackTrace();
 //				//return null;
 //			}
 //
 //			scoreAnnotation = project.getAnnotationService().getAnnotation(pod, agent, "http://telscenter.org/annotation/score");
 //			if (scoreAnnotation != null) {
 //				score = scoreAnnotation.getContents();
 //			}	
 
 //			
 //			if (!(step instanceof Note)) {   // for a note, we have one comment for all parts, not one comment per part
 //				AssessmentItem assessmentItem = ((Assessment)step).assessmentItem;
 //				List<ResponseDeclaration> responseDeclarations = assessmentItem
 //				.getResponseDeclarations();
 //
 //				if(responseDeclarations !=null) {
 //					ResponseDeclaration rd = responseDeclarations.get(rdIndex);
 //					if (rd != null) {
 //						Rim rim = rd.getRim();
 //
 //						if(rim!=null){
 //							try {
 //								IAnnotation rimAnnotation = project.getAnnotationService().getAnnotation(rim, agent, "http://telscenter.org/annotation/comments");
 //								if (rimAnnotation != null) {
 ////									System.out.println("Rim: " + rim.toString());
 ////									System.out.println("RimAnnotation: " + rimAnnotation);
 //									scoreAnnotation = rimAnnotation;
 //									score = scoreAnnotation.getContents();
 ////									System.out.println("annotation ");
 ////									System.out.println("  source: " + scoreAnnotation.getSource());
 ////									System.out.println("  contentType: " + scoreAnnotation.getContentType());
 ////									System.out.println("  contents: " + scoreAnnotation.getContents());
 //								}
 //							} catch(Exception e){
 //								e.printStackTrace();
 //							}
 //						}
 //					}
 //				}
 //				
 //			}
 //		}
 		
 		return score;
 		
 	}
 	
 	
 	/***
 	 * proceeds to retrieve the current student part and set its size before returning it
 	 * 
 	 * @param theParts
 	 * @param i
 	 * @return studentPart
 	 */
 	private JPanel getStudentPart(List<JPanel> theParts, int i) {
 		JPanel studentPart = theParts.get(i); 
 		studentPart.setAlignmentY(Component.TOP_ALIGNMENT);
 		//studentPart.setBackground(Color.RED);
 		return studentPart;
 	}
 
 	/***
 	 * proceeds to set the teacher comments panel with an appropriate size before returning it
 	 * 
 	 * @param comments
 	 * @return commentPanel
 	 */
 	private JPanel makeTeacherCommentPanel(String comments) {
 		JPanel commentPanel = new JPanel(new BorderLayout(0,0));
 		
 		JTextArea textArea;
 		if( comments == null || StringUtils.trimToNull(comments) == null) {
 			textArea = new JTextArea(0,0);
 			//textArea.setPreferredSize(new Dimension(290,50));
 			comments = "  Uncommented\n\n";
 			textArea.setSize(290, textArea.getPreferredSize().height);
 			textArea.setForeground(Color.RED);
 		} else {
 			textArea = new JTextArea(0,0);
 			textArea.setSize(290, textArea.getPreferredSize().height);
 			textArea.setBackground(new Color(255,255,204));
 		}// if
 		
 		
 		textArea.setLineWrap(true);
 		textArea.setWrapStyleWord(true);
 		textArea.setEditable(false);
 		
 		textArea.setText(comments);
 		textArea.setBorder(BorderFactory.createEmptyBorder());
 		JScrollPane scrollPane = new JScrollPane(textArea);
 		scrollPane.setBorder(BorderFactory.createLineBorder(Color.black, 1));
 		commentPanel.add(scrollPane,BorderLayout.CENTER);
 		commentPanel.setBackground(Color.WHITE);
 		commentPanel.setBorder(createEmptyTitledBorder("Teacher Comments",commentPanel));
 		return commentPanel;
 	}
 
 
 	private String wrapText(String comments, double textWidth){		
 		String initHtml = "<html><body>";
 		String finalHtml = "</body></html>";
 		String finalStr = "";	
 		int lastIndex = 0;
 
 		comments.trim();
 
 		while(comments.length() > textWidth){
 			String substri = comments.substring(0,(int)textWidth);
 			lastIndex = substri.lastIndexOf(" ");
 			finalStr = finalStr + substri.substring(0,lastIndex) + "\n";
 			comments = comments.substring((int)lastIndex, comments.length());
 
 		}
 		
 		return initHtml + finalStr + comments.substring(0,comments.length()) + finalHtml;		
 	}
 
 
 	public void setServiceProvider(PasProjectServiceProvider provider){
 		this.provider = provider;
 	}
 	
 	private void setStepTitlePanelVisited(boolean isVisited){
 		this.visited = isVisited;
 	}
 	
 	public boolean getStepTitlePanelVisited(){
 		return this.visited;
 	}
 	
 	/***
 	 * gets the component by name
 	 * 
 	 * @param container
 	 * @param name
 	 * @return
 	 */
 	public static Component getByName(Container container,String name) {
 		  for (int i = 0; i < container.getComponentCount(); i++) {
 		    if (name.equals(container.getComponent(i).getName())) {
 		      return container.getComponent(i);
 		    }
 		  }
 		  return null;
 	}
 
 }