/*
    *  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;
  
  import java.awt.event.ActionEvent;
  import java.awt.event.KeyEvent;
  import java.io.File;
  
  import javax.swing.AbstractAction;
  import javax.swing.Action;
  import javax.swing.JMenu;
  import javax.swing.JPopupMenu;
  import javax.swing.JScrollPane;
  import javax.swing.KeyStroke;
  import javax.swing.tree.TreePath;
  
  import org.xnap.gui.action.*;
  import org.xnap.gui.shortcut.*;
  import org.xnap.gui.component.XNapMenuItem;
  import org.xnap.gui.event.DoubleClickListener;
  import org.xnap.gui.event.PopupListener;
  import org.xnap.gui.menu.OpenFileWithMenu;
  import org.xnap.gui.menu.PeerMenu;
  import org.xnap.gui.menu.TransferMenu;
  import org.xnap.gui.table.FilteredTransferTableModel;
  import org.xnap.gui.table.JTreeTable;
  import org.xnap.gui.table.TransferTableModel;
  import org.xnap.gui.table.TreeTableNode;
  import org.xnap.gui.tree.TransferTreeCellRenderer;
  import org.xnap.gui.util.GUIHelper;
  import org.xnap.peer.Peer;
  import org.xnap.transfer.AbstractTransferManager;
  import org.xnap.transfer.Transfer;
  import org.xnap.transfer.action.AbstractDeleteAction;
  import org.xnap.util.Preferences;
  
  public class TransferManagerPanel extends JScrollPane 
      implements FileProvider, PeerProvider, TransferProvider
  {
      
      //--- Data field(s) ---
  
      private JTreeTable jtt;
      private TransferTableModel ttm;
      private TransferMenu jmPopup;
  	private AbstractTransferManager manager; 
  
  	private Action openFileAction = new OpenFileAction(this);
  
      //--- Constructor(s) ---
  
      public TransferManagerPanel(AbstractTransferManager manager, String table,
  								boolean filtered) 
      {
          initialize(manager, table, filtered);
      }
  
      //--- Method(s) ---
  
      private void initialize(AbstractTransferManager manager, String table,
  							boolean filtered) 
      {
  		this.manager = manager;
  
  		// popup
  		JMenu jmPopup = new TransferMenu(this);
  		jmPopup.add(new XNapMenuItem(openFileAction));
  		jmPopup.add(new OpenFileWithMenu(this));
  		jmPopup.addSeparator();
  		jmPopup.add(new PeerMenu(this));
  
  
  		ttm = (filtered) 
  			? new FilteredTransferTableModel(manager)
  			: new TransferTableModel(manager, true);
  		jtt = ttm.createTreeTable(Preferences.getInstance(), table);
  		jtt.getTree().setCellRenderer
  			(new TransferTreeCellRenderer(ttm, !filtered));
  		DoubleClickListener.install(jtt, new DoubleClickAction());
  		GUIHelper.bindKey(jtt, KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, 0),
  						  new DeleteAction(), false);
  
 		// shortcuts
 		ShortcutManager.getInstance().add(openFileAction, jtt);
 
 		// add existing transfers
 		Transfer[] transfers = manager.getTransfers();
 		for (int i = 0; i < transfers.length; i++) {
 			ttm.add(transfers[i]);
 		}
 
 		PopupListener pl = new PopupListener(jmPopup.getPopupMenu());
 		jtt.addMouseListener(pl);
 
 		setViewportView(jtt);
 //  		if (filtered) {
 //  			setBorder(GUIHelper.createEmptyBorder());
 //  			jtt.getTableHeader().setBorder(GUIHelper.createEtchedBorder());
 //  		}
     }
 
     /***
      * Implements FileProvider.
      */
     public File[] getFiles()
     {
 		return TransferPanel.getFiles(this);
     }
 
 	public AbstractTransferManager getManager()
 	{
 		return manager;
 	}
 
     /***
      * Implements PeerProvider.
      */
     public Peer[] getPeers()
     {
 		return TransferPanel.getPeers(this);
     }
 
     public JPopupMenu getPopup()
     {
 		return jmPopup.getPopupMenu();
     }
 
     public TransferTableModel getTransferTableModel()
     {
 		return ttm;
     }
 
     public JTreeTable getTreeTable()
     {
 		return jtt;
     }
 
     /***
      * Returns the currently selected transfer.
      */
     public Transfer getSelectedTransfer()
     {
 		TreePath path = jtt.getTree().getSelectionPath();
 		if (path != null) {
 			TreeTableNode node 
 				= (TreeTableNode)path.getLastPathComponent();
 			return (Transfer)node.getData();
 		}
 		return null;
     }
 
     /***
      * Returns the currently selected transfers.
      *
      * @return null, if nothing is selected
      */
     public Transfer[] getTransfers()
     {
 		TreePath[] paths = jtt.getTree().getSelectionPaths();
 		if (paths != null) {
 			Transfer[] results = new Transfer[paths.length];
 			for (int i = 0; i < results.length; i++) {
 				TreeTableNode node 
 					= (TreeTableNode)paths[i].getLastPathComponent();
 				results[i] = (Transfer)node.getData();
 			}
 			return results;
 		}
 		return null;
     }
 
 	private class DeleteAction extends AbstractAction
 	{
 
         public void actionPerformed(ActionEvent event) 
 		{
 			Transfer[] transfers = getTransfers();
 			if (transfers != null) {
 				for (int i = 0; i < transfers.length; i++) {
 					ActionHelper.perform(transfers[i].getActions(), event,
 										 AbstractDeleteAction.class);
 				}
 			}
 		}
 
 	}
 
 	private class DoubleClickAction extends AbstractAction
 	{
 
         public void actionPerformed(ActionEvent event) 
 		{
 			Transfer transfer = getSelectedTransfer();
 			if (transfer != null) {
 				if (transfer.isDone()) {
 					openFileAction.actionPerformed(event);
 				}
 				else {
 					Action[] actions = transfer.getActions();
 					if (actions != null && actions.length > 0
 						&& actions[0].isEnabled()) {
 						actions[0].actionPerformed(event);
 					}
 				}
 			}
 		}
 
 	}
 
 }