/*
    *  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.gui.table;
  
  import java.util.Iterator;
  
  import org.xnap.XNap;
  import org.xnap.gui.event.SwingListListener;
  import org.xnap.gui.event.TransferManagerListener;
  import org.xnap.gui.util.SwingSynchronizedCache;
  import org.xnap.gui.util.SwingSynchronizedTask;
  import org.xnap.peer.Peer;
  import org.xnap.transfer.AbstractTransferManager;
  import org.xnap.transfer.*;
  import org.xnap.transfer.TransferContainer;
  import org.xnap.transfer.Upload;
  import org.xnap.util.Progress;
  import org.xnap.util.Scheduler;
  
  /***
   * The model for the upload and download table.
   *
   * @see xnap.gui.TransferPanel
   */
  public class TransferTableModel extends DefaultColumnTreeTableModel
      implements SwingListListener {
      
      //--- Constant(s) ---
      
      /***
       * The table update interval.
       */
      public static final int UPDATE_INTERVAL = 1 * 1000;
  
      //--- Data field(s) ---
  
      private TransferManagerListener listener;
  	private boolean printActiveBold;
  
      //--- Constructor(s) ---
  
      public TransferTableModel
  		(AbstractTransferManager queue, boolean printActiveBold)
      {
  		this.printActiveBold = printActiveBold;
  
  		Column columns[] = new Column[] {
  			new Column("icon", XNap.tr("Filename"), TreeTableModel.class),
  			new Column("filename", XNap.tr("Filename"), TransferWrapper.class), 
  			new Column("queuePos", XNap.tr("Queued At"), Integer.class, 
  					   new NumberCellRenderer(1)),
  			new Column("filesize", XNap.tr("Size"), Long.class, 
  					   new FilesizeCellRenderer()),
  			new Column("peer", XNap.tr("Peer"), String.class,
  					   new StringCellRenderer()),
  			new Column("client", XNap.tr("Client"), String.class),
  			new Column("status", XNap.tr("Status"), String.class, 
  					   new StringCellRenderer()),
  			new Column("segments", XNap.tr("Segments"), Segment[].class, 
  					   new SegmentCellRenderer()),
  			new Column("progress", XNap.tr("Progress"), Progress.class, 
  					   new ProgressCellRenderer()),
  			new Column("timeLeft", XNap.tr("Time Left"), Integer.class, 
  					   new TimeCellRenderer()),
  			new Column("transferred", XNap.tr("Transfered"), Long.class,
  					   new FilesizeCellRenderer()),
  		};
  		addColumns(columns);
  
  		SwingSynchronizedCache cache = new SwingSynchronizedCache(this);
  		queue.addListListener(cache);
  
  		Scheduler.run(0, UPDATE_INTERVAL, new Updater());
      }
  
      //--- Method(s) ---
  
  	public void add(Transfer t)
  	{
  		if (t instanceof TransferContainer) {
  			TransferContainerTreeTableNode node 
  				= new TransferContainerTreeTableNode(this, t);
 			add(node);
 			node.addExistingChildren();
 		}
 		else {
 			add(new TransferTreeTableNode(this, t));
 		}
 	}
 
     /***
      * Invoked when transfers have been added to the queue.
      */
     public void itemsAdded(Object[] items)
     {
 		for (int i = 0; i < items.length; i++) {
 			add((Transfer)items[i]);
 		}
     }
     
     /***
      * Invoked when transfers have been removed from the queue.
      */
     public void itemsRemoved(Object[] items) 
     {
 		for (int i = 0; i < items.length; i++) {
 			remove((Transfer)items[i]);
 		}
     }
 
     public Object getValueAt(Object node, int column)
     {
 		if (node instanceof TreeTableNode) {
 			Transfer t = (Transfer)((TreeTableNode)node).getData();
 			Peer p = t.getPeer();
 	    
 			switch (column) {
 			case 0:
 				return (node instanceof LeafTreeTableNode) 
 					? (t instanceof Upload) ? t.getIcon() : null : t.getIcon();
 			case 1:
 				return new TransferWrapper(t);
 //				return printActiveBold && t.isRunning() ? 
 //					"}" + t.getFilename() 
 //					: t.getFilename();
 			case 2:
 				return new Integer(t.getQueuePosition());
 			case 3:
 				return new Long(t.getFilesize());
 			case 4:
 				return (p != null) ? p.getName() : "";
 			case 5:
 				return (p != null) ? p.getClientInfo() : "";
 			case 6:
 				return t.getStatus();
 			case 7:
 				return t.getSegments();
 			case 8:
 				Progress pr = new Progress
 					(t.getFilesize(), t.getTotalBytesTransferred());
 				pr.setRate((t.isRunning()) 
 						   ? t.getCurrentRate() 
 						   : t.getAverageRate());
 				return pr;
 			case 9:
 				return new Integer(t.getRemainingTime());
 			case 10:
 				return new Long(t.getTotalBytesTransferred());
 			}
 		}
 
 		return null;
     }
 
 	public void remove(Transfer t)
 	{
 		int index = indexOfByData(t);
 		if (index != -1) {
 			remove(index);
 		}
 	}
 
     public void setListener(TransferManagerListener listener)
     {
 		this.listener = listener;
     }
 
     private class Updater extends SwingSynchronizedTask
     {
 
 		public void runSynchronized()
 		{
 			long rate = 0;
 			int running = 0;
 			for (Iterator it = iterator(); it.hasNext();) {
 				TreeTableNode node = (TreeTableNode)it.next();
 				Transfer t = (Transfer)node.getData();
 
 				// update transfer
 				if (t.isRunning()) {
 					nodeChanged(node);
 					// only take rate of master transfer into account
 					long transferRate = t.getCurrentRate();
 					if (transferRate > 0) {
 						rate += transferRate;
 					}
 					running++;
 				}
 
 				// update children
 				for (int i = 0; i < node.getChildCount(); i++) {
 					TreeTableNode child = (TreeTableNode)node.getChildAt(i);
 					t = (Transfer)child.getData();
 
 					if (t.isRunning()) {
 						childChanged(node, i, child);
 					}
 				}
 			}
 	    
 			if (listener != null) {
 				listener.statsUpdated(running, rate);
 			}
 		}
 
     }
 
 }