package wjhk.jupload2.upload;

 import java.util.concurrent.ArrayBlockingQueue;

 import java.util.concurrent.BlockingQueue;

 import wjhk.jupload2.exception.JUploadEOFException;

 import wjhk.jupload2.exception.JUploadException;

 import wjhk.jupload2.filedata.FileData;

 import wjhk.jupload2.gui.JUploadPanel;

 import wjhk.jupload2.gui.filepanel.FilePanel;

 import wjhk.jupload2.policies.UploadPolicy;

 import wjhk.jupload2.upload.helper.ProgressBarManager;

 /**

  * This class is responsible for managing the upload. At the end of the upload, the

  * {@link JUploadPanel#updateButtonState()} is called, to refresh the button state. Its job is to: <DIR> <LI>Prepare

  * upload for the file (calls to {@link FileData#beforeUpload()} for each file in the file list. <LI>Create the thread

  * to send a packet of files. <LI>Prepare the packets, that will be red by the upload thread. <LI>Manage the end of

  * upload: trigger the call to {@link JUploadPanel#updateButtonState()} and the call to

  * {@link UploadPolicy#afterUpload(Exception, String)}. <LI>Manage the 'stop' button reaction. </DIR> This class is

  * created by {@link JUploadPanel}, when the user clicks on the upload button.

  * 

  * @author etienne_sf

  */

 public class FileUploadManagerThreadImpl extends Thread implements FileUploadManagerThread {

     /**

      * Maximum number of files that can be stored in the filePreparationQueue. It's useless to have a too big value

      * here, as, if too many files are there, it means that the file preparation process is much quicker than the file

      * upload one.

      */

     final static int FILE_PREPARATION_QUEUE_SIZE = 50;

     // /////////////////////////////////////////////////////////////////////////////////////////

     // //////////////////// Possible Status for file upload

     // /////////////////////////////////////////////////////////////////////////////////////////

     /** The current file list. */

     FilePanel filePanel = null;

     /**

      * The file preparatoin thread prepares each file for upload, and manage possible errors that can occurs at

      * preparation time.

      */

     FilePreparationThread filePreparationThread = null;

     /**

      * This thread receives each prepared files in a queue, constructs the packets of files to be sent together, and

      * posts them in another queue.

      */

     PacketConstructionThread packetConstructionThread = null;

     /**

      * The upload thread, that will wait for the next file packet to be ready, then send it.

      */

     FileUploadThread fileUploadThread = null;

     /**

      * This help controls the display of the progress bar and the status bar. It updates these bar, based on a timer.

      */

     ProgressBarManager progressBarManager;

     /**

      * Number of files that have been successfully uploaded. already been sent. The control on the upload success may be

      * done or not. It's used to properly display the progress bar.

      */

     int nbSuccessfullyUploadedFiles = 0;

     /**

      * Indicates whether the upload is finished or not. Passed to true as soon as one of these conditions becomes true:

      * <DIR> <LI>All files are uploaded (in the {@link #currentRequestIsFinished(UploadFilePacket)} method) <LI>An

      * exception occurs (in the {@link #setUploadException(JUploadException)} method) <LI>The user stops the upload (in

      * the {@link #stopUpload()} method) </DIR>

      */

     boolean uploadFinished = false;

     /**

      * If set to 'true', the thread will stop the current upload.

      * 

      * @see UploadFileData#uploadFile(java.io.OutputStream, long)

      */

     boolean stop = false;

     /** Thread Exception, if any occurred during upload. */

     JUploadException uploadException = null;

     /** A shortcut to the upload panel */

     JUploadPanel uploadPanel = null;

     /** The current upload policy. */

     UploadPolicy uploadPolicy = null;

     // ////////////////////////////////////////////////////////////////////////////

     // To follow the upload speed.

     // ////////////////////////////////////////////////////////////////////////////

     /**

      * Standard constructor of the class.

      * 

      * @param uploadPolicy

      * @throws JUploadException

      */

     public FileUploadManagerThreadImpl(UploadPolicy uploadPolicy) throws JUploadException {

         super("FileUploadManagerThreadImpl thread");

         constructor(uploadPolicy, null);

     }

     /**

      * Internal constructor. It is used by the JUnit test, to create a FileUploadManagerThreadImpl instance, based on a

      * non-active {@link FileUploadThread}.

      * 

      * @param uploadPolicy The current uploadPolicy

      * @param fileUploadThreadParam The instance of {@link FileUploadThread} that should be used. Allows execution of

      *            unit tests, based on a specific FileUploadThread, that does ... nothing.

      * @throws JUploadException

      */

     FileUploadManagerThreadImpl(UploadPolicy uploadPolicy, FileUploadThread fileUploadThreadParam)

             throws JUploadException {

         super("FileUploadManagerThreadImpl test thread");

         constructor(uploadPolicy, fileUploadThreadParam);

     }

     /**

      * Called by the class constructors, to initialize the current instance.

      * 

      * @param uploadPolicy

      * @param fileUploadThreadParam

      * @throws JUploadException

      */

     private synchronized void constructor(UploadPolicy uploadPolicy, FileUploadThread fileUploadThreadParam)

             throws JUploadException {

         // General shortcuts on the current applet.

         this.uploadPolicy = uploadPolicy;

         this.uploadPanel = uploadPolicy.getContext().getUploadPanel();

         this.filePanel = this.uploadPanel.getFilePanel();

         BlockingQueue<UploadFileData> preparedFileQueue = new ArrayBlockingQueue<UploadFileData>(

                 this.filePanel.getFilesLength());

         // If the FileUploadThread was already created, we must take the same

         // packetQueue.

         BlockingQueue<UploadFilePacket> packetQueue;

         if (fileUploadThreadParam == null) {

             packetQueue = new ArrayBlockingQueue<UploadFilePacket>(this.filePanel.getFilesLength());

         } else {

             packetQueue = fileUploadThreadParam.getPacketQueue();

         }

         // Let's create (but not start) start the file preparation thread.

         this.filePreparationThread = new FilePreparationThread(preparedFileQueue, this, this.uploadPolicy);

         // The packet tread groups files together, depending on the current

         // upload policy.

         this.packetConstructionThread = new PacketConstructionThread(preparedFileQueue, packetQueue, this,

                 this.uploadPolicy);

         // Let's start the upload thread. It will wait until the first

         // packet is ready.

         createUploadThread(packetQueue, fileUploadThreadParam);

         // We're now ready to start the bar update job.

         this.progressBarManager = new ProgressBarManager(this.uploadPolicy, this.filePreparationThread);

     }

     /**

      * @see wjhk.jupload2.upload.FileUploadManagerThread#run()

      */

     @Override

     final public void run() {

         try {

             this.uploadPolicy.displayDebug("Start of the FileUploadManagerThreadImpl", 5);

             // Let's prepare the progress bar, to display the current upload

             // stage.

             progressBarManager.uploadIsStarted();

             // Let's start the working threads.

             this.filePreparationThread.start();

             this.packetConstructionThread.start();

             this.fileUploadThread.start();

             // Let's let the current upload policy have any preparation work

             this.uploadPolicy.beforeUpload();

             // The upload is started. Let's change the button state.

             this.uploadPanel.updateButtonState();

             // The thread upload may need some information about the current

             // one, like ... knowing that upload is actually finished (no more

             // file to send).

             // So we wait for it to finish.

             while (this.fileUploadThread.isAlive() && !isUploadFinished()) {

                 try {

                     this.uploadPolicy.displayDebug("Waiting for fileUploadThread to die", 10);

                     this.fileUploadThread.join();

                 } catch (InterruptedException e) {

                     // This should not occur, and should not be a problem. Let's

                     // trace a warning info.

                     this.uploadPolicy

                             .displayWarn("An InterruptedException occured in FileUploadManagerThreadImpl.run()");

                 }

             }// while

             // If any error occurs, the prepared state of the file data may be true. We must free resources. So, to be

             // sure, we do it in all cases.

             for (FileData fd : this.uploadPanel.getFilePanel().getFiles()) {

                 if (fd.getUploadFlag() && fd.isPreparedForUpload()) {

                     fd.afterUpload();

                 }

             }// for

             // Let's restore the display.

             this.uploadPanel.updateButtonState();

             this.uploadPanel.getFilePanel().reload();

             this.uploadPolicy.getContext().showStatus("");

             this.uploadPolicy.getContext().getUploadPanel().getStatusLabel().setText("");

             // If no error occurs, we tell to the upload policy that a successful upload has been done.

             if (getUploadException() != null) {

                 this.uploadPolicy.sendDebugInformation("Error in Upload", getUploadException());

             } else if (isUploadStopped()) {

                 this.uploadPolicy.displayInfo("Upload stopped by the user. "

                         + this.nbSuccessfullyUploadedFiles

                         + " file(s) uploaded in "

                         + (int) ((System.currentTimeMillis() - this.progressBarManager.getGlobalStartTime()) / 1000)

                         + " seconds. Average upload speed: "

                         + ((this.progressBarManager.getUploadDuration() > 0) ? ((int) (this.progressBarManager

                                 .getNbUploadedBytes() / this.progressBarManager.getUploadDuration())) : 0)

                         + " (kbytes/s)");

             } else {

                 this.uploadPolicy.displayInfo("Upload finished normally. "

                         + this.nbSuccessfullyUploadedFiles

                         + " file(s) uploaded in "

                         + (int) ((System.currentTimeMillis() - this.progressBarManager.getGlobalStartTime()) / 1000)

                         + " seconds. Average upload speed: "

                         + ((this.progressBarManager.getUploadDuration() > 0) ? ((int) (this.progressBarManager

                                 .getNbUploadedBytes() / this.progressBarManager.getUploadDuration())) : 0)

                         + " (kbytes/s)");

                 // FIXME uploadDuration displayed is 0!

                 try {

                     this.uploadPolicy.afterUpload(this.getUploadException(), this.fileUploadThread.getResponseMsg());

                 } catch (JUploadException e1) {

                     this.uploadPolicy.displayErr("error in uploadPolicy.afterUpload (JUploadPanel)", e1);

                 }

             }

             // The job is finished. Let's stop the timer, and have a last

             // refresh of the bars.

             this.progressBarManager.uploadIsFinished();

             // We wait for 5 seconds, before clearing the progress bar.

             try {

                 sleep(5000);

             } catch (InterruptedException e) {

                 // Nothing to do

             }

             // The job is finished for long enough, let's clear the progression

             // bars (and any associated ressource, like the time).

             // We'll clear the progress bar, only if this thread is in control

             // of the upload, that is: if this instance is the currently

             // FileUploadManagerThread referenced in the JUpload panel.

             if (this == this.uploadPanel.getFileUploadManagerThread()) {

                 this.progressBarManager.clearBarContent();

                 this.uploadPolicy.getContext().getUploadPanel().getStatusLabel().setText("");

             }

             this.uploadPolicy.displayDebug("End of the FileUploadManagerThreadImpl", 5);

         } catch (Exception e) {

             // We need a JUploadException.

             JUploadException jue = (e instanceof JUploadException) ? (JUploadException) e : new JUploadException(e);

             setUploadException(jue);

             // And go back into a 'normal' way.

             stopUpload();

         } finally {

             // We restore the button state, just to be sure.

             this.uploadPanel.updateButtonState();

         }

         // And we die of our beautiful death ... until next upload.

     }// run

     /**

      * @see wjhk.jupload2.upload.FileUploadManagerThread#setUploadException(wjhk.jupload2.exception.JUploadException)

      */

     public synchronized void setUploadException(JUploadException uploadExceptionParam) {

         // If the user stops the upload, the socket on which the applet reads

         // the server response got closed. So we ignore this error.

         if (isUploadStopped() && uploadExceptionParam instanceof JUploadEOFException) {

             // Just ignore this error: the input stream from the server was

             // closed, but it probably occurs because the applet itself closed

             // the communicaiton.

         } else {

             // We don't override an existing exception

             if (this.uploadException != null) {

                 this.uploadPolicy

                         .displayWarn("An exception has already been set in FileUploadManagerThreadImpl. The next one is just logged.");

             } else {

                 this.uploadException = uploadExceptionParam;

             }

             String exceptionMsg = (uploadExceptionParam.getCause() == null) ? uploadExceptionParam.getMessage()

                     : uploadExceptionParam.getCause().getMessage();

             String errMsg = this.uploadPolicy.getLocalizedString("errDuringUpload") + "\n\n" + exceptionMsg;

             this.uploadPolicy.displayErr(errMsg, uploadException);

         }

     }

     /**

      * @see wjhk.jupload2.upload.FileUploadManagerThread#getUploadException()

      */

     public JUploadException getUploadException() {

         return this.uploadException;

     }

     /**

      * @see wjhk.jupload2.upload.FileUploadManagerThread#isUploadFinished()

      */

     public boolean isUploadFinished() {

         // Indicate whether or not the upload is finished. Several conditions:

         // all files are uploaded, there was an error and the user stops the

         // upload here...

         return this.uploadFinished || this.stop || this.uploadException != null;

     }

     /**

      * @see FileUploadManagerThread#isUploadStopped()

      */

     public boolean isUploadStopped() {

         return this.stop;

     }

     /**

      * @see wjhk.jupload2.upload.FileUploadManagerThread#nbBytesUploaded(long, UploadFileData)

      */

     public synchronized void nbBytesUploaded(long nbBytes, UploadFileData uploadFileData) throws JUploadException {

         this.progressBarManager.nbBytesUploaded(nbBytes, uploadFileData);

     }

     /**

      * @see wjhk.jupload2.upload.FileUploadManagerThread#setUploadStatus(wjhk.jupload2.upload.UploadFilePacket,

      *      wjhk.jupload2.upload.UploadFileData, int)

      */

     public synchronized void setUploadStatus(UploadFilePacket uploadFilePacket, UploadFileData uploadFileData,

             int uploadStatus) throws JUploadException {

         this.progressBarManager.setUploadStatus(uploadFilePacket, uploadFileData, uploadStatus);

     }

     /**

      * @see wjhk.jupload2.upload.FileUploadManagerThread#stopUpload()

      */

     public synchronized void stopUpload() {

         this.stop = true;

         // The upload is now finished ...

         this.uploadFinished = true;

         // We notify the various threads.

         if (this.filePreparationThread != null && this.filePreparationThread.isAlive()) {

             this.filePreparationThread.interrupt();

         }

         if (this.packetConstructionThread != null && this.packetConstructionThread.isAlive()) {

             this.packetConstructionThread.interrupt();

         }

         if (this.fileUploadThread != null && this.fileUploadThread.isAlive()) {

             this.fileUploadThread.interrupt();

         }

         // All 'sub-thread' is now interrupted. The upload thread can be stuck

         // while waiting for the server response. We also interrupt the current

         // thread.

         this.interrupt();

     }

     // //////////////////////////////////////////////////////////////////////////////////////////////

     // /////////////////// SYNCHRONIZATION METHODS

     // //////////////////////////////////////////////////////////////////////////////////////////////

     /**

      * @see wjhk.jupload2.upload.FileUploadManagerThread#anotherFileHasBeenSent(wjhk.jupload2.upload.UploadFilePacket,

      *      wjhk.jupload2.upload.UploadFileData)

      */

     public synchronized void anotherFileHasBeenSent(UploadFilePacket uploadFilePacket,

             UploadFileData newlyUploadedFileData) throws JUploadException {

         this.progressBarManager.anotherFileHasBeenSent(uploadFilePacket, newlyUploadedFileData);

     }

     /**

      * @see wjhk.jupload2.upload.FileUploadManagerThread#currentRequestIsFinished(wjhk.jupload2.upload.UploadFilePacket)

      */

     public synchronized void currentRequestIsFinished(UploadFilePacket uploadFilePacket) throws JUploadException {

         // We are finished with this packet. Let's display it.

         this.progressBarManager.setUploadStatus(uploadFilePacket, uploadFilePacket.get(uploadFilePacket.size() - 1),

                 FileUploadManagerThread.UPLOAD_STATUS_UPLOADED);

         // We now remove this file from the list of files to upload, to show the user that there is less and less work

         // to do.

         for (FileData fileData : uploadFilePacket) {

             this.filePanel.remove(fileData);

             this.nbSuccessfullyUploadedFiles += 1;

         }

         this.filePanel.cleanHierarchy();

         // If all files have been sent, the upload is finished.

         if (!this.uploadFinished) {

             this.uploadFinished = (this.nbSuccessfullyUploadedFiles == this.filePreparationThread.getNbFilesToSend());

         }

     }

     // //////////////////////////////////////////////////////////////////////////////////////////////

     // /////////////////// PRIVATE METHODS

     // //////////////////////////////////////////////////////////////////////////////////////////////

     /**

      * Creates the upload thread, but does not start it. IThis thread will wait until the first packet is ready.

      * 

      * @throws JUploadException

      */

     private synchronized void createUploadThread(BlockingQueue<UploadFilePacket> packetQueue,

             FileUploadThread fileUploadThreadParam) throws JUploadException {

         if (fileUploadThreadParam != null) {

             // The FileUploadThread has already been created.

             // We set the FileUploadThreadManager.

             this.fileUploadThread = fileUploadThreadParam;

             fileUploadThreadParam.setFileUploadThreadManager(this);

         } else {

             try {

                 if (this.uploadPolicy.getPostURL().substring(0, 4).equals("ftp:")) {

                     this.fileUploadThread = new FileUploadThreadFTP(this.uploadPolicy, packetQueue, this);

                 } else {

                     this.fileUploadThread = new FileUploadThreadHTTP(this.uploadPolicy, packetQueue, this);

                 }

             } catch (JUploadException e1) {

                 // Too bad !

                 this.uploadPolicy.displayErr(e1);

             }

         }

     }

 }