package wjhk.jupload2.upload;
   
   import java.util.concurrent.BlockingQueue;
   
   import wjhk.jupload2.exception.JUploadException;
   import wjhk.jupload2.policies.UploadPolicy;
   
   /**
    * @author etienne_sf
   */
  public class PacketConstructionThread extends Thread {
  
      /** The current upload policy. */
      UploadPolicy uploadPolicy = null;
  
      /** The thread which globally manages the upload */
      FileUploadManagerThread fileUploadManagerThread = null;
  
      /**
       * The queue where each prepared file are stored, for further processing. This class picks files here, and post them
       * to the packetQueue.
       */
      BlockingQueue<UploadFileData> preparedFileQueue = null;
  
      /**
       * The queue where each prepared file will be stored, for further processing
       */
      BlockingQueue<UploadFilePacket> packetQueue = null;
  
      /**
       * The packet this instance is working on.
       */
      UploadFilePacket packetInProgress = null;
  
      /**
       * Indicates when the last file has been received. The last file is the poisonned
       */
      boolean lastFileReceived = false;
  
      PacketConstructionThread(BlockingQueue<UploadFileData> preparedFileQueue,
              BlockingQueue<UploadFilePacket> packetQueue, FileUploadManagerThread fileUploadManagerThread,
              UploadPolicy uploadPolicy) {
          // A thread name is very useful, when debugging...
          super("PacketConstructionThread");
  
          this.preparedFileQueue = preparedFileQueue;
          this.packetQueue = packetQueue;
          this.fileUploadManagerThread = fileUploadManagerThread;
          this.uploadPolicy = uploadPolicy;
  
          // Let's construct the first packet...
          this.packetInProgress = new UploadFilePacket(this.uploadPolicy);
      }
  
      /**
       * The actual command to generate packets.
       * 
       * @see java.lang.Thread#run()
       */
      @Override
      final public void run() {
          int nbFiles = 0;
          this.uploadPolicy.displayDebug("Start of PacketConstructionThread", 80);
          try { // catch (JUploadException e)
  
              // We loop, and wait for the 'poisonned' UploadFileData to finish.
              try {
                  while (!lastFileReceived && !this.fileUploadManagerThread.isUploadFinished()) {
                      UploadFileData ufd = preparedFileQueue.take();
                      receiveNewFile(ufd);
                      nbFiles += 1;
                  }
  
                  this.uploadPolicy.displayDebug("PacketConstructionThread: end of loop, the thread is about to finish",
                          30);
  
                  // We may have some file left to send...
                  if (this.packetInProgress.size() > 0) {
                      this.uploadPolicy.displayDebug("Last file received: the current packet is not empty, we send it",
                              30);
                      sendCurrentPacket();
                  }
              } catch (InterruptedException e) {
                  this.uploadPolicy.displayWarn("packetConstructionThread received InterruptedException, exiting");
              }
  
              // In standard mode, we should have no more file to manage. The
              // following test is meaningful only if the FilePreparationThread
              // has been finished before (otherwise, other files could enter the
              // queue after this test)
              if (!this.preparedFileQueue.isEmpty()) {
                  if (!this.fileUploadManagerThread.isUploadFinished()) {
                      // Hum, hum. This should not happen.
                      this.uploadPolicy.displayWarn("The preparedFileQueue is not empty, at the end of "
                              + this.getClass().getName());
                  }
                  // This can happen, if we are interrupted while working. Let's
                  // empty this.
                  this.uploadPolicy
                         .displayDebug(
                                 "The PacketConstructionThread is about to finish, but the preparedFileQueue is not empty. Let's clear it.",
                                 30);
                 while (!this.preparedFileQueue.isEmpty()) {
                     this.preparedFileQueue.poll();
                 }
             }
         } catch (JUploadException e) {
             this.fileUploadManagerThread.setUploadException(e);
         } finally {
             // To properly finish the job, we send a 'poisonned' packet, so that
             // the FileUploadThread knows it's finished.
             try {
                 this.packetQueue.put(new UploadFilePacketPoisonned(this.uploadPolicy));
             } catch (InterruptedException e) {
                 this.uploadPolicy
                         .displayWarn("packetConstructionThread received InterruptedException (while checking if packetQueue is empty), exiting");
             }
         }
         this.uploadPolicy.displayDebug("End of PacketConstructionThread (" + nbFiles
                 + " files have been taken from the queue, including the 'poisoned' one)", 10);
     }
 
     /**
      * Called when a new file is received
      * 
      * @param uploadFileData
      * @throws JUploadException
      * @throws InterruptedException
      */
     private void receiveNewFile(UploadFileData uploadFileData) throws JUploadException, InterruptedException {
         // Are we finished ?
         if (uploadFileData.isPoisonned()) {
             lastFileReceived = true;
             this.uploadPolicy.displayDebug(
                     "Poisonned UploadFileData received, PacketContructionThread will exit normally", 50);
         } else {
             // We try to add the file to the current packet. If it doesn't work,
             // this packet is probably full. We sent it, and add the packet to
             // the new one.
             if (!this.packetInProgress.add(uploadFileData)) {
                 // The packet was refused. We send the current one, and retry.
                 this.uploadPolicy.displayDebug(
                         "The file can't be added to the current packet. Let's send this packet first.", 80);
                 sendCurrentPacket();
                 if (!this.packetInProgress.add(uploadFileData)) {
                     throw new JUploadException("Could not add file to packet! (filename: "
                             + uploadFileData.getFileName() + ")");
                 }
             }
 
             // If the current packet is finished, we send it immediatly.
             if (this.packetInProgress.isFull()) {
                 sendCurrentPacket();
             }
         }
     }
 
     private void sendCurrentPacket() throws InterruptedException {
         if (this.packetInProgress == null) {
             throw new java.lang.AssertionError(this.getClass().getName()
                     + ".sendCurrentPacket(): this.packetInProgress may not be null");
         } else if (this.packetInProgress.size() == 0) {
             throw new java.lang.AssertionError(this.getClass().getName()
                     + ".sendCurrentPacket(): this.packetInProgress.size() may not be 0");
         }
         // If a packet is ready, we post it into the relevant queue.
         this.packetQueue.put(packetInProgress);
 
         // And we start a new one.
         this.packetInProgress = new UploadFilePacket(this.uploadPolicy);
     }
 }