/*
    *  XNap - A P2P framework and client.
    *
    *  See the file AUTHORS for copyright information.
    *
    *  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.
    *
   *  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
  package org.xnap.transfer;
  
  import java.io.File;
  
  import javax.swing.Icon;
  
  import org.apache.log4j.Logger;
  import org.xnap.event.StateListener;
  import org.xnap.event.StateSupport;
  
  public abstract class AbstractTransfer implements Transfer {
  
      //--- Constant(s) ---
  
      public static final int RECALC_INTERVAL = 5000;
  
      /***
       * Wait 50 milli seconds before calculating rate for the first time.
       * Otherwise we will get fantastically high ones.
       */
      public static final int MIN_RECALC_INTERVAL = 50;
  
      /***
       * The recommended default socket timeout.
       */
      public static final int SOCKET_TIMEOUT = 30 * 1000;
  
      //--- Data field(s) ---
  
      protected static Logger logger = Logger.getLogger("xnap.net.transfer");
  
      /***
       *
       */
      private long lastBytesTransferred = 0;
      private long lastElapsedTime = 0;
      private long lastRate = 0;
  
      private long transferStartTime = -1;
      private long totalRate = -1;
  
      private StateSupport listeners = new StateSupport(this);
  
      //--- Constructor(s) ---
  
      public AbstractTransfer()
      {
      }
  
      //--- Method(s) ---
  
      public void addStateListener(StateListener listener) 
      {
          listeners.addStateListener(listener);
      }
  
  	/***
  	 * Does nothing.
  	 */
  	public void cleared()
  	{
  	}
  
      /***
       * Returns the average transfer rate.
       */
      public long getAverageRate()
      {
  		if (totalRate != -1) {
  			return totalRate;
  		}
  		else if (transferStartTime == -1) {
  			return -1;
  		}
  
  		long elapsedTime = getElapsedTime();
  		if (elapsedTime > 0) {
  			return (getBytesTransferred() * 1000) / elapsedTime;
  		}
  		else {
 			return getBytesTransferred();
 		}
     }
 
     /***
      * Returns how many bytes have been transferred since the transfer
      * was started.
      * 
      * @return number of transferred bytes
      * @see #getCurrentRate()
      */
     protected abstract long getBytesTransferred();
 
     /***
      * Returns the current download rate. Take at least a
      * RECALC_INTERVAL into account to avoid jumping values all the
      * time.
      *
      * @return byte / s 
 	 */
     public long getCurrentRate() 
     {
 		if (transferStartTime == -1) {
 			return -1;
 		}
 
 		long deltaTime = System.currentTimeMillis() - lastElapsedTime;
 		if (deltaTime > MIN_RECALC_INTERVAL) {
 			long deltaBytes = getBytesTransferred() - lastBytesTransferred;
 			if (getElapsedTime() < RECALC_INTERVAL) {
 				lastRate = (deltaBytes * 1000) / deltaTime;
 			}
 			else {
 				lastBytesTransferred += deltaBytes;
 				lastElapsedTime += deltaTime;
 
 				long t = RECALC_INTERVAL - deltaTime;
 				if (t > 0) {
 					// approximate how many bytes were transfered in the 
 					// last RECALC_INTERVAL
 					deltaBytes += (t * lastRate) / 1000;
 					deltaTime = RECALC_INTERVAL;
 				}
 				lastRate = (deltaBytes * 1000) / deltaTime;
 			}
 		}
 
 		return lastRate;
     }
 
     /***
      * Returns null.
      */
     public String getDescription()
 	{
     	return null;
     }
     
     /***
      * Returns the number of milli seconds that have passed since the 
      * transfer has been started.
      */
     public long getElapsedTime() 
     {
         return System.currentTimeMillis() - transferStartTime;
     }
 
     public String getFilename()
     {
 		File f = getFile();
 		return (f != null) ? f.getName() : "";
     }
 
     public long getFilesize()
     {
 		File f = getFile();
 		return (f != null) ? f.length() : 0;
     }
 
     /***
      * Returns null.
      */
     public Icon getIcon()
     {
 		return null;
     }
 
 	/***
 	 * Returns -1.
 	 */
 	public int getQueuePosition()
 	{
 		return -1;
 	}
 
     public int getRemainingTime()
     {
 		long rate = getAverageRate();
 		return (rate <= 0) ? -1 : 
 			(int)((getFilesize() - getBytesTransferred()) / rate);
     }
 
     public void removeStateListener(StateListener listener) 
     {
         listeners.removeStateListener(listener);
     }
 
     /***
      * Notifies all StateListeners that the state has changed.
      */
     protected void stateChanged()
     {
 		listeners.fireStateChanged();
     }
 
     public String toString()
     {
 		return getFilename() + ", " + getFilesize();
     }
 
     public Segment[] getSegments()
     {
 		return null;
     }
 
 	/***
 	 * Sub classes should invoke this method when the transfer has started.
 	 */
 	protected void transferStarted()
 	{
 		transferStartTime = System.currentTimeMillis();
 		lastElapsedTime = System.currentTimeMillis();
 		totalRate = -1;
 	}
 
 	/***
 	 * Sub classes should invoke this method when the transfer has stopped.
 	 */
 	protected void transferStopped()
 	{
 		if (getBytesTransferred() > 0) {
 		    long rate = getAverageRate();
 		    totalRate = (rate != -1) ? rate : getBytesTransferred();
 		}
 		transferStartTime = -1;
 	}
 
 }