//
   // $Id$
   //
   // jupload - A file upload applet.
   //
   // Copyright 2010 The JUpload Team
   //
   // Created: 27 janv. 2010
   // Creator: etienne_sf
  // Last modified: $Date$
  //
  // This program is free software; you can redistribute it and/or modify
  // it under the terms of the GNU General Public License as published by
  // the Free Software Foundation; either version 2 of the License, or
  // (at your option) any later version.
  //
  // This program is distributed in the hope that it will be useful,
  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  // GNU General Public License for more details.
  //
  // You should have received a copy of the GNU General Public License
  // along with this program; if not, write to the Free Software
  // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  
  package wjhk.jupload2.upload;
  
  import java.util.ArrayList;
  
  import wjhk.jupload2.policies.UploadPolicy;
  
  /**
   * This file contains a packet of files, which will be sent in one request to
   * the server.
   * 
   * @author etienne_sf
   */
  @SuppressWarnings("serial")
  public class UploadFilePacket extends ArrayList<UploadFileData> {
  
      /**
       * The uploadPolicy, useful to get the max number of files and max packet
       * size ... and perhaps other parameters in the future.
       */
      UploadPolicy uploadPolicy = null;
  
      /**
       * The sum of the size of all files in the packet.
       */
      long nbBytes = 0;
  
      /** The maximum number of bytes in one packet to the server */
      long maxNbBytes = -1;
  
      /** The maximum number of files in one packet to the server */
      long maxNbFiles = -1;
  
      /**
       * The standard constructor.
       * 
       * @param uploadPolicy
       */
      UploadFilePacket(UploadPolicy uploadPolicy) {
          // nbFilesPerRequest may be very very big. Let's have a more realistic
          // value, in this case (to avoid outOfMemoryError)
          super(Math.min(uploadPolicy.getNbFilesPerRequest(), uploadPolicy
                  .getContext().getUploadPanel().getFilePanel().getFilesLength()));
          this.uploadPolicy = uploadPolicy;
          this.maxNbBytes = this.uploadPolicy.getMaxChunkSize();
          this.maxNbFiles = Math.min(uploadPolicy.getNbFilesPerRequest(),
                  uploadPolicy.getContext().getUploadPanel().getFilePanel()
                          .getFilesLength());
      }
  
      /**
       * Checks if this packet can accept this file, according to the current
       * {@link UploadPolicy}.
       * 
       * @param uploadFileData
       * @return True if the file can be added, false otherwise.
       */
      public synchronized boolean canAdd(UploadFileData uploadFileData) {
          // Here is the list of conditions. This code could be smalled. But I
          // want it to be clear.
          if (size() == 0) {
              return true;
          } else if (size() == this.maxNbFiles) {
              // The packet is already full of files
              return false;
          } else if (this.nbBytes + uploadFileData.getUploadLength() > maxNbBytes) {
              // The packet would be too big
              return false;
          } else {
              // No reason to refuse this packet ...
              return true;
          }
      }
  
      /**
      * Indicates whether it is possible to add a file or not, to this packet,
      * according to the current upload policy.
      * 
      * @return true if the packet is full, that is: no file can be added to this
      *         packet.
      */
     public synchronized boolean isFull() {
         return (size() == this.maxNbFiles) || (this.nbBytes >= maxNbBytes);
     }
 
     /**
      * @param uploadFileData The file to add to the packet
      * @return true if the collection changed, that is: if the file was actually
      *         added. false if the Collection didn't change, that is: the packet
      *         is full, or th file is already there.
      */
     public synchronized boolean add(UploadFileData uploadFileData) {
         if (!canAdd(uploadFileData)) {
             return false;
         } else if (!super.add(uploadFileData)) {
             return false;
         } else {
             // The file was correctly added.
             nbBytes += uploadFileData.getUploadLength();
             ;
             return true;
         }
     }
 
     /**
      * @return the poisonned status. Returns always false, as this instance is a
      *         true one. false indicates the 'End Of Queue' marker in the
      *         preparedFileQueue, which is not the case here
      * @see UploadFileDataPoisonned
      */
     public boolean isPoisonned() {
         return false;
     }
 
     // ////////////////////////////////////////////////////////////////////////////
     // Some ArrayList methods are prohibited here
     // ////////////////////////////////////////////////////////////////////////////
     /**
      * Prohibited !
      * 
      * @see ArrayList#remove(int)
      */
     public UploadFileData remove(int index) {
         throw new java.lang.UnsupportedOperationException(
                 "Removing a file from an UploadFilePacket is prohibited");
     }
 
     /**
      * Prohibited !
      * 
      * @see ArrayList#remove(Object)
      */
     public boolean remove(Object o) {
         throw new java.lang.UnsupportedOperationException(
                 "Removing a file from an UploadFilePacket is prohibited");
     }
 
     /**
      * Prohibited !
      * 
      * @see ArrayList#removeRange(int, int)
      */
     protected void removeRange(int fromIndex, int toIndex) {
         throw new java.lang.UnsupportedOperationException(
                 "Removing a file from an UploadFilePacket is prohibited");
     }
 }