/* ======================================================================
The Bodington System Software License, Version 1.0
  
Copyright (c) 2001 The University of Leeds.  All rights reserved.
  
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:

1.  Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.

2.  Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.

3.  The end-user documentation included with the redistribution, if any,
must include the following acknowledgement:  "This product includes
software developed by the University of Leeds
(http://www.bodington.org/)."  Alternately, this acknowledgement may
appear in the software itself, if and wherever such third-party
acknowledgements normally appear.

4.  The names "Bodington", "Nathan Bodington", "Bodington System",
"Bodington Open Source Project", and "The University of Leeds" must not be
used to endorse or promote products derived from this software without
prior written permission. For written permission, please contact
d.gardner@leeds.ac.uk.

5.  The name "Bodington" may not appear in the name of products derived
from this software without prior written permission of the University of
Leeds.

THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO,  TITLE,  THE IMPLIED WARRANTIES 
OF QUALITY  AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO 
EVENT SHALL THE UNIVERSITY OF LEEDS OR ITS CONTRIBUTORS BE LIABLE FOR 
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 
GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
POSSIBILITY OF SUCH DAMAGE.
=========================================================

This software was originally created by the University of Leeds and may contain voluntary 
contributions from others.  For more information on the Bodington Open Source Project, please 
see http://bodington.org/

====================================================================== */

package org.bodington.assessment;

import java.sql.*;
import java.util.Hashtable;
import java.util.Enumeration;
import java.util.Vector;
import java.math.BigDecimal;
import java.math.BigInteger;

import org.bodington.server.*;
import org.bodington.assessment.*;
import org.bodington.server.resources.UploadedFileSummary;
import org.bodington.server.resources.UploadedFile;
import org.bodington.server.realm.User;
import org.bodington.server.realm.Permission;
import org.bodington.server.events.*;
import org.bodington.database.*;
import org.bodington.text.BigString;


public class PigeonHoleSessionImpl 
	extends org.bodington.server.SingleResourceSession 
	implements org.bodington.assessment.PigeonHoleSession
	{
	int max_ordinal=0;
	boolean transfer_in_progress;
	
	
	
	public PigeonHoleSessionImpl()
		{
		super();
		transfer_in_progress=false;
		}
	
	

	public PigeonHole getPigeonHole()
		throws BuildingServerException
		{
		PigeonHole phole = PigeonHole.findPigeonHole( getResource().getResourceId() );
		return phole;
		}
		
    public Enumeration analyse(String where_clause, PigeonHoleAnalysis analysis)
    	{
	    // This method is derived from interface org.bodington.assessment.PigeonHoleSession
        // to do: code goes here
        return null;
    	}



    public Vector getPigeonHoleQuestionIds()
    	throws BuildingServerException
    	{
		Vector list = new Vector();
		
		PigeonHoleQuestion question;
		Enumeration enumeration = PigeonHoleQuestion.findPigeonHoleQuestions( "resource_id = " + getResource().getResourceId().toString(), "ordinal" );
		while ( enumeration.hasMoreElements() )
			{
			question = (PigeonHoleQuestion)enumeration.nextElement();
			list.addElement( question.getPigeonHoleQuestionId() ); 
			if ( question.getOrdinal() > max_ordinal )
				max_ordinal = question.getOrdinal();
			}
		
		return list;
    	}
	
    public Hashtable getPigeonHoleQuestions()
    	throws BuildingServerException
    	{
		Hashtable table = new Hashtable();
		
		PigeonHoleQuestion question;
		Enumeration enumeration = PigeonHoleQuestion.findPigeonHoleQuestions( "resource_id = " + getResource().getResourceId().toString() );
		while ( enumeration.hasMoreElements() )
			{
			question = (PigeonHoleQuestion)enumeration.nextElement();
			table.put( question.getPigeonHoleQuestionId(), question );
			if ( question.getOrdinal() > max_ordinal )
				max_ordinal = question.getOrdinal();
			}
		
		return table;
	    }

	public Vector getPigeonHoleQuestionsInOrder()
		throws BuildingServerException
		{
		Vector list = new Vector();
		
		PigeonHoleQuestion question;
		Enumeration enumeration = PigeonHoleQuestion.findPigeonHoleQuestions( "resource_id = " + getResource().getResourceId().toString(), "ordinal" );
		while ( enumeration.hasMoreElements() )
			{
			question = (PigeonHoleQuestion)enumeration.nextElement();
			list.addElement( question ); 
			if ( question.getOrdinal() > max_ordinal )
				max_ordinal = question.getOrdinal();
			}
		
		return list;
		}
	
    public Enumeration getResultsByUser()
    {
        // This method is derived from interface org.bodington.assessment.PigeonHoleSession
        // to do: code goes here
        return null;
    }

    public Hashtable getStrings() throws BuildingServerException
    	{
		Hashtable table = getPigeonHoleQuestions();
		
		PigeonHoleQuestion question;
		BigString big_string;
		PrimaryKey id;
		Enumeration enumeration = table.elements();
		while ( enumeration.hasMoreElements() )
			{
			question = (PigeonHoleQuestion)enumeration.nextElement();
			id = question.getNotesBigStringId();
			big_string = BigString.findBigString( id );
			table.put( id, big_string.getString() );
			}
			
		return table;
	    }

    public void setDates(Timestamp open, Timestamp deadline, Timestamp penalty)
    	throws BuildingServerException
    	{
		PigeonHole paper = PigeonHole.findPigeonHole( getResource().getResourceId() );
		if ( paper == null )
			throw new BuildingServerException( "Can't find pigeon hole." );
		paper.setDateOpen( open );
		paper.setDateDeadline( deadline );
		paper.setDatePenalty( penalty );
		paper.save();
    	}

    public void setMaximumMark( int m ) throws BuildingServerException
    	{
		PigeonHole paper = PigeonHole.findPigeonHole( getResource().getResourceId() );
		if ( paper == null )
			throw new BuildingServerException( "Can't find pigeon hole." );
		paper.setMaximumMark( m );
		paper.save();
    	}

	public PigeonHoleQuestion createQuestion()
		throws BuildingServerException
		{
		PigeonHoleQuestion question = new PigeonHoleQuestion();
		
		question.setResourceId( getResource().getResourceId() );
		question.setNotes( "Notes for marker here." );
		question.setOrdinal( max_ordinal+100 );
		question.setAvailable( 1 );
		question.setWeight( new BigDecimal( "1.0" ) );
		question.save();
		
		return question;
		}
	
	public void removeQuestion( PrimaryKey id )
		throws BuildingServerException
		{
		PigeonHoleQuestion question =  PigeonHoleQuestion.findPigeonHoleQuestion( id );
		if ( question == null )
			throw new BuildingServerException( "Question not found." );

		if ( !question.getResourceId().equals( getResource().getResourceId() ) )
			throw new BuildingServerException( "Question doesn't belong in this MCQ paper." );

		question.delete();
		}
	
	public void changeQuestion( PrimaryKey id, PigeonHoleQuestion model )
		throws BuildingServerException
		{
		PigeonHoleQuestion question =  PigeonHoleQuestion.findPigeonHoleQuestion( id );
		if ( question == null )
			throw new BuildingServerException( "Question not found." );

		if ( !question.getResourceId().equals( getResource().getResourceId() ) )
			throw new BuildingServerException( "Question doesn't belong in this MCQ paper." );

		question.setOrdinal( model.getOrdinal() );
		question.setAvailable( model.getAvailable() );
		question.setWeight( model.getWeight() );
		question.save();

		if ( question.getOrdinal() > max_ordinal )
			max_ordinal = question.getOrdinal();
		}
	
	public void changeQuestionText( PrimaryKey qid, PrimaryKey tid, String new_text )
		throws BuildingServerException
		{
		PigeonHoleQuestion question =  PigeonHoleQuestion.findPigeonHoleQuestion( qid );
		if ( question == null )
			throw new BuildingServerException( "Question not found." );
			
		if ( !question.getResourceId().equals( getResource().getResourceId() ) )
			throw new BuildingServerException( "Question doesn't belong in this MCQ paper." );

		boolean found = false;
		found = tid.equals( question.getNotesBigStringId() );

		if ( !found )
			throw new BuildingServerException( "Can't identify qhich part of question to edit." );

		BigString big = BigString.findBigString( tid );
		big.setString( new_text );
		big.save();
		}
	
	public boolean canUpload() throws BuildingServerException
		{
		return canUpload( null, new StringBuffer() );
		}
		
	/**
	 * Work out if an upload can be made.
	 * Currently is does several checks, the main one being that the users has 
	 * upload permission.
	 * @param uid The primary key of the user to check. If <code>null</code> check
	 * the current user.
	 * @param message The StringBuffer to output any messages to.
	 * @return <code>true</code> if the user can upload a file.
	 */
	private boolean canUpload( PrimaryKey uid, StringBuffer message ) throws BuildingServerException
		{
		PigeonHole ph = getPigeonHole();
		PigeonHoleEntry entry;
		User user;
		
		if ( uid==null )
			{
			user = (User)BuildingContext.getContext().getUser();
			entry = getPigeonHoleEntry();
			}
		else
			{
			user = User.findUser( uid );
			entry = getPigeonHoleEntry( uid );
			}
		
		if ( user == null )
			{
			message.append( "it wasn't possible to find a record of the user in the user directory." );
			return false;
			}
		
		if ( !getResource().checkPermission( user, Permission.UPLOAD ) )
			{
			if ( uid == null )
				message.append( "you havn't been granted the upload access right." );
			else
				message.append( "the user hasn't been granted the upload access right." );
			return false;
			}
			
		if ( entry == null )
			{
			entry = new PigeonHoleEntry();
			entry.setStatus( PigeonHoleEntry.STATUS_UPLOAD_BY_DATE );
			}
			
		java.util.Date now					=new java.util.Date();
		java.util.Date now_minus_24_hours	=new java.util.Date( now.getTime()-(24L*60L*60L*1000L) );
		
		switch ( entry.getStatus() )
			{
			case PigeonHoleEntry.STATUS_UPLOAD_BY_DATE:
				if ( ph.getDateOpen() !=null && ph.getDateOpen().after( now ) )
					{
					message.append( " the pigeon hole is not yet available for use " );
					return false;
					}
				
				if ( ph.getDateDeadline() == null )
					return true;
				if ( ph.getDateDeadline().after( now ) )
					return true;
				if ( ph.getDatePenalty() == null )
					{
					message.append( " the deadline for uploading to this pigeon hole has passed and uploading files after the deadline is not allowed " );
					return false;
					}
				if ( ph.getDatePenalty().before( now ) )
					{
					message.append( " the penalty period deadline for uploading to this pigeon hole has passed " );
					return false;
					}
				// at this point we know that "now" lies between deadline and penalty
				// allowing them to upload depends on whether and when they previously
				// uploaded a file.

				//  if user has never uploaded a file let them do so now
				if ( entry.getUploadedFileId() == null )
					return true;

				// if user uploaded before deadline they can't change it
				if ( entry.getWhenSaved().before( ph.getDateDeadline() ) )
					{
					message.append( " a file was uploaded before the deadline and one can't change a file now the deadline has passed " );
					return false;
					}

				// if user uploaded during the penalty period but more than
				// 24 hours ago they can't change it.
				if ( entry.getWhenSaved().before( now_minus_24_hours ) )
					{
					message.append( " a file was uploaded during the penalty period but more than 24 hours ago " );
					return false;
					}

				// if we reached here then the user must have uploaded within the
				// last 24 hours and they can replace their work now and get another
				// 24 hours.
				return true;

			case PigeonHoleEntry.STATUS_UPLOAD_CHANGEABLE:
				return true;

			case PigeonHoleEntry.STATUS_UPLOAD_LOCKED:
			case PigeonHoleEntry.STATUS_UPLOAD_PROCESSED:
			case PigeonHoleEntry.STATUS_UPLOAD_MARKED:
			case PigeonHoleEntry.STATUS_UPLOAD_RETURNED:
				message.append( " the manager of this pigeon hole has locked your file " );
				return false;			

			default:
				message.append( " a technical problem has been detected " );
				return false;			
			}
		}
		
	public boolean canUpload( PrimaryKey user_id ) throws BuildingServerException
		{
		return canUpload( user_id, new StringBuffer() );
		}
	
	public boolean canSeeMark() throws BuildingServerException
		{
		return canSeeMark( null );
		}
		
	public boolean canSeeMark( PrimaryKey uid ) throws BuildingServerException
		{
		PigeonHole paper = getPigeonHole();
		PigeonHoleEntry entry;
		if ( uid==null )
			entry = getPigeonHoleEntry();
		else
			entry = getPigeonHoleEntry( uid );
		
		if ( entry == null )
			return false;
			
		return entry.getStatus() == PigeonHoleEntry.STATUS_UPLOAD_RETURNED;
		}
		
	
	public String denyUploadMessage() throws BuildingServerException
		{
		StringBuffer message = new StringBuffer();
		canUpload( null, message );
		return message.toString();
		}
		
	public String denyUploadMessage( PrimaryKey user_id ) throws BuildingServerException
		{
		StringBuffer message = new StringBuffer();
		canUpload( user_id, message );
		return message.toString();
		}
	
	public PigeonHoleEntry transferFileForAssessment( String current_pathname, String file_name, String mime_type )
		throws BuildingServerException
		{
		// forces uppload to sub directory named after user id
		// only allows one file per user.  (Fixes file name?)
		User user = (User)BuildingContext.getContext().getUser();
		PrimaryKey uid = user.getUserId();
		PigeonHoleEntry entry;
		UploadedFileSummary uf;

		if ( !canUpload() )
			throw new BuildingServerException( "You are not allowed to upload a file at this time." );
	
		try
			{
			synchronized ( this )
				{
				if ( transfer_in_progress )
					throw new BuildingServerException( "The system is currently receiving a file from you and you can't send another until it has finished." );
				transfer_in_progress = true;
				}
				
			entry = getPigeonHoleEntry();
			if ( entry == null )
				{
				entry = new PigeonHoleEntry();
				entry.setResourceId( getResource().getResourceId() );
				entry.setUserId( uid );
				entry.setFeedback( "" );
				entry.setComments( "" );
				}

			if ( entry.getUploadedFileId() !=null )
				{
				UploadedFile old_uf = UploadedFile.findUploadedFile( entry.getUploadedFileId() );
				if ( old_uf != null )
					old_uf.setDeleted( true );
				}
			
			uf = getUploadedFileSession().transferFile( current_pathname, uid.toString() + "/" + file_name, mime_type );
			
			entry.setUploadedFileId( uf.getUploadedFileId() );
			entry.setWhenSaved( uf.getUpdatedTime() );
			entry.save();
			
	    	UserFileEvent event = new UserFileEvent(UserFileEvent.EVENT_UPLOAD,
                getResource(), uf);
			event.save();
			}
		finally
			{
			transfer_in_progress = false;
			}

		return entry;
		}

	public PigeonHoleEntry recordStatus( PrimaryKey entry_id, int status )
		throws BuildingServerException
		{
		PigeonHoleEntry entry = PigeonHoleEntry.findPigeonHoleEntry( entry_id );
		if ( entry==null )
			throw new BuildingServerException( "Can't find entry." );
			
		entry.setStatus( status );
		entry.save();
		
		return entry;
		}

	public PigeonHoleEntry recordMarks( PrimaryKey entry_id, PrimaryKey[] pigeonhole_question_ids, int[] marks, String feedback, String comments )
		throws BuildingServerException
		{
		PigeonHole ph = getPigeonHole();
		Hashtable responses = getPigeonHoleResponses( entry_id );
		PigeonHoleEntry entry = PigeonHoleEntry.findPigeonHoleEntry( entry_id );
		PigeonHoleResponse response;
		Hashtable questions = getPigeonHoleQuestions();
		PigeonHoleQuestion question;
		
		double total_mark=0.0;
		double total_weight=0.0;
		boolean incomplete=false;
		
		for ( int i=0; i<pigeonhole_question_ids.length; i++ )
			{
			question = (PigeonHoleQuestion)questions.get( pigeonhole_question_ids[i] );
			response = (PigeonHoleResponse)responses.get( pigeonhole_question_ids[i] );
			if ( response == null )
				{
				response = new PigeonHoleResponse();
				response.setPigeonHoleEntryId( entry_id );
				response.setPigeonHoleQuestionId( pigeonhole_question_ids[i] );
				}
			if ( marks[i]<0 )
				{
				response.setMark( null );
				incomplete=true;
				}
			else
				{
				response.setMark( new Integer( marks[i] ) );
				total_mark += question.getWeight().doubleValue() * (double)marks[i] / (double)question.getAvailable();
				total_weight += question.getWeight().doubleValue();
				}
			response.save();
			}
		
		if ( incomplete )
			entry.setMark( null );
		else
			entry.setMark( new Integer( (int)Math.round((double)ph.getMaximumMark() * total_mark/total_weight )) );
		
		entry.setStatus( PigeonHoleEntry.STATUS_UPLOAD_PROCESSED );
		entry.setWhenMarked( new Timestamp( System.currentTimeMillis() ) );
		User user = (User)BuildingContext.getContext().getUser();
		entry.setMarkerUserId( user.getUserId() );
		entry.setFeedback( feedback );
		entry.setComments( comments );
		entry.save();
		
		return entry;
		}
		
	public PigeonHoleEntry recordAdjustedMark( PrimaryKey entry_id, int adjusted_mark, String feedback, String comments )
		throws BuildingServerException
		{
		PigeonHole tq = getPigeonHole();
		PigeonHoleEntry entry = PigeonHoleEntry.findPigeonHoleEntry( entry_id );
		
		entry.setAdjustedMark( new Integer( adjusted_mark ) );
		entry.setFeedback( feedback );
		entry.setComments( comments );
		entry.save();
		
		return entry;
		}


	public PigeonHoleEntry getPigeonHoleEntry()
		throws BuildingServerException
		{
		User user = (User)BuildingContext.getContext().getUser();
		return getPigeonHoleEntry( user.getUserId() );
		}
		
	public PigeonHoleEntry getPigeonHoleEntry( PrimaryKey uid )
		throws BuildingServerException
		{
		PigeonHoleEntry entry = 
			PigeonHoleEntry.findPigeonHoleEntry( 
				"resource_id = " + getResource().getResourceId() + " AND user_id = " + uid );
		
		return entry;
		}
		
	public Hashtable getPigeonHoleEntries() throws BuildingServerException
		{
		Hashtable table = new Hashtable();
		PigeonHoleEntry entry;
		
		Enumeration enumeration= 
			PigeonHoleEntry.findPigeonHoleEntries( "resource_id = " + getResource().getResourceId() );
		
		while ( enumeration.hasMoreElements() )
			{
			entry = (PigeonHoleEntry)enumeration.nextElement();
			table.put( entry.getUserId(), entry );
			}

		return table;
		}
		
		
	public Vector getPigeonHoleUsers() throws BuildingServerException
		{
		Vector users= new Vector();
		
		Enumeration enumeration = 
			User.findUsers(
				"user_id IN (SELECT user_id FROM pigeonhole_entries WHERE resource_id = " +
				getResource().getResourceId() +
				")",
				"surname, initials" );
		
		while ( enumeration.hasMoreElements() )
			{
			users.addElement( enumeration.nextElement() );
			}
		
		return users;
		}


	public Hashtable getPigeonHoleResponses( PrimaryKey entryid )
		throws BuildingServerException
		{
		Hashtable table = new Hashtable();
		PigeonHoleResponse response;
		
		Enumeration enumeration = PigeonHoleResponse.findPigeonHoleResponses( "pigeonhole_entry_id = " + entryid );
		while ( enumeration.hasMoreElements() )
			{
			response = (PigeonHoleResponse)enumeration.nextElement();
			table.put( response.getPigeonHoleQuestionId(), response );
			}
		
		return table;
		}

	}