/*
    *  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 java.util.LinkedList;
  import java.util.ListIterator;
  
  import org.xnap.XNap;
  import org.xnap.event.ListEvent;
  import org.xnap.gui.event.SwingListListener;
  import org.xnap.gui.util.SwingSynchronizedCache;
  import org.xnap.peer.Peer;
  import org.xnap.plugin.Plugin;
  import org.xnap.search.SearchFilter;
  import org.xnap.search.SearchResult;
  import org.xnap.search.SearchResultContainer;
  import org.xnap.util.FileHelper;
  import org.xnap.util.StringHelper;
  import org.xnap.util.MultiHashtable;
  
  /***
   * The model for the search table.
   *
   * @see xnap.gui.SearchResultPanel
   */
  public class SearchTableModel extends DefaultColumnTreeTableModel
      implements SwingListListener {
  
      //--- Constant(s) ---
  
      //--- Data field(s) ---
  
      private SwingSynchronizedCache cache = new SwingSynchronizedCache(this);
      private FilterHandler filter = new FilterHandler();
  
  	private MultiHashtable nodeByHash = new MultiHashtable();
  
      //--- Constructor(s) ---
  
      public SearchTableModel() 
      {
  		addColumns(createDefaultColumns());
      }
  
      //--- Method(s) ---
  
      public static Column[] createDefaultColumns()
      {
  		return new Column[] {
  			new Column("icon", XNap.tr("Filename"), TreeTableModel.class),
  			new Column("filename", XNap.tr("Filename"),
  					   SearchResultWrapper.class),
  			new Column("path", XNap.tr("Path"), String.class, 
  					   new StringCellRenderer()),
  			new Column("filesize", XNap.tr("Filesize"), Long.class, 
  					   new FilesizeCellRenderer()),
  			new Column("peer", XNap.tr("Peer"), String.class, 
  					   new StringCellRenderer()),
  			new Column(XNap.tr("Link Speed"), Integer.class, 
  					   new LinkSpeedCellRenderer()),
  			new Column("plugin", XNap.tr("Plugin"), String.class),
  			new Column("availability", XNap.tr("Availability"), Integer.class, 
  					   new AvailabilityCellRenderer()),
  			new Column("type", XNap.tr("Type"), String.class, 
  					   new StringCellRenderer()),
  			new Column("bitrate", XNap.tr("Bitrate"), Integer.class, 
  					   new NumberCellRenderer()),
  			new Column("length", XNap.tr("Length"), Integer.class,
  					   new TimeCellRenderer()),
  		};
      }
  
      public SwingSynchronizedCache getListListener()
      {
  		return cache;
      }
  
      /***
       * Invoked when search results have been received.
       */
      public void itemsAdded(Object[] items)
     {
 		for (int i = 0; i < items.length; i++) {
 			if (items[i] instanceof SearchResult) {
 				SearchResult result = (SearchResult)items[i];
 				group(result);
 			}
 			else if (items[i] instanceof TreeTableNode) {
 				if (filter.matches((TreeTableNode)items[i])) {
 					add((TreeTableNode)items[i]);
 				}
 			}
 		}
     }
 
     /***
      * Groups results.
      * 
      * @return true, if result was added to the tree
      */
     public void group(SearchResult result)
     {
 		Object key = result.getHash();
 		if (key != null) {
 			for (ListIterator i = nodeByHash.getList(key).listIterator(); 
 				 i.hasNext();) {
 				LazyTreeTableNode node = (LazyTreeTableNode)i.next();
 				SearchResult sr = (SearchResult)node.getData();
 				if (sr.canGroup(result)) {
 					if (!(sr instanceof SearchResultContainer)) {
 						// create a new container
 						SearchResultContainer c = sr.createContainer();
 
 						// add itself to container
 						c.add(sr);
 						
 						// only set container in case second result
 						// was accepted by the container, otherwise
 						// the container is discarded
 						if (c.add(result)) {
 							// set container
 							node.setData(c);
 							
 							// add original result to tree
 							TreeTableNode leaf = new LeafTreeTableNode(sr);
 							node.add(leaf);
 							
 							// add new result to tree
 							leaf = new LeafTreeTableNode(result);
 							node.add(leaf);
 						}
 					}
 					else if (((SearchResultContainer)node.getData()).
 							 add(result)) {
 						TreeTableNode leaf = new LeafTreeTableNode(result);
 						node.add(leaf);
 					}
 					return;
 				}
 			}
 		}
 
 		LazyTreeTableNode node = new LazyTreeTableNode(this, result);
 		if (key != null) {
 			nodeByHash.put(key, node);
 		}
 		filter.add(node);
 		if (filter.matches(node)) {
 			add(node);
 		}
     }
 
     /***
      * Never invoked.
      */
     public void itemsRemoved(Object[] items)
     {
     }
 
     public Object getValueAt(Object node, int column)
     {
 		if (node instanceof TreeTableNode) {
 			SearchResult sr = (SearchResult)((TreeTableNode)node).getData();
 			Peer p = sr.getPeer();
 
 			switch (column) {
 			case 0:
 				return (node instanceof LeafTreeTableNode) ? null 
 					: sr.getIcon();
 			case 1:
 				// return sr.getShortFilename();
 				return new SearchResultWrapper(sr);
 			case 2:
 				String[] path = sr.getPath();
 				return (path != null) ? StringHelper.toString(path, "/") 
   					: null;
 			case 3:
 				return new Long(sr.getFilesize());
 			case 4:
 				return (p != null) ? p.getName() : null;
 			case 5:
 				return new Integer((p != null) ? p.getLinkSpeed()  : -1);
 			case 6:
 				Plugin plugin = sr.getPlugin();
 				return (plugin != null) ? plugin.getInfo().getName() : null;
 			case 7:
 				return new AvailabilityCellRenderer.Availability
 					(sr.getAvailability(),
 					 sr.getSourcesCount());
 			case 8:
 				return FileHelper.extension(sr.getShortFilename());
 			default:
 				return sr.get(getColumnAt(column).getName());
 			}
 		}
 	
 		return null;
     }
 
     public void setFilter(SearchFilter f)
     {
 		filter.setFilter(f);
     }
 
 	/***
 	 * Invoked by {@link xnap.gui.SearchResultPanel} to set the tab title.
 	 */
 	public int size()
 	{
 		return getChildCount(getRoot());
 	}
 
     //--- Inner Class(es) ---
 
     private class FilterHandler
     {
 
 		private LinkedList data = new LinkedList();
 		private SearchFilter filter;
 
 		public void add(TreeTableNode node)
 		{
 			data.add(node);
 		}
 	
 		public Iterator iterator()
 		{
 			return data.iterator();
 		}
 
 		public boolean matches(TreeTableNode node)
 		{
 			return (filter == null 
 					|| filter.matches((SearchResult)
 									  ((TreeTableNode)node).getData()));
 		}
 
 		public void setFilter(SearchFilter filter)
 		{
 			this.filter = filter;
 			clear();
 			//  	    Runnable r = new Runnable 
 			//  		{
 			//  		    public void run()
 			//  		    {
 			//  		    }
 			//  		};
 			//  	    Thread t = new Thread("Inserter", 
 			for (Iterator i = iterator(); i.hasNext();) {
 				ListEvent event 
 					= new ListEvent(this, ListEvent.ITEM_ADDED, i.next());
 				cache.itemAdded(event);
 			}
 		}
 
     }
 
 }