/*
    *  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.plugin.overnet.net;
  
  import java.awt.event.ActionEvent;
  import java.util.*;
  
  import javax.swing.Action;
  import javax.swing.JOptionPane;
  import javax.swing.AbstractAction;
  import javax.swing.Icon;
  
  import org.apache.log4j.Logger;
  import org.xnap.XNap;
  import org.xnap.gui.*;
  import org.xnap.gui.action.AbstractDownloadAction;
  import org.xnap.peer.Peer;
  import org.xnap.plugin.Plugin;
  import org.xnap.plugin.overnet.OvernetPlugin;
  import org.xnap.plugin.overnet.net.msg.client.DownloadLinkMessage;
  import org.xnap.plugin.overnet.net.msg.core.SearchResultMessage;
  import org.xnap.search.AbstractSearchResult;
  import org.xnap.search.AbstractSearchResultContainer;
  import org.xnap.search.SearchResult;
  import org.xnap.search.SearchResultContainer;
  import org.xnap.util.Formatter;
  import org.xnap.gui.util.*;
  
  public class OvernetSearchResult extends AbstractSearchResult
  {
  	//--- Constant(s) ---
  
  	//--- Data field(s) ---
  
  	private String filename;
  	private int filesize;
  	private byte[] hash;
  	private int availability;
  
      private static Logger logger = Logger.getLogger(OvernetSearchResult.class);
  	
  	//--- Constructor(s) ---
  
      public OvernetSearchResult(SearchResultMessage sm)
  	{
  		filename = sm.filename;
  		filesize = sm.filesize;
  		hash = sm.hash;
  		availability = sm.availability;
  
  		put(XNap.tr("Filesize"), Formatter.formatSize(sm.filesize));
  		put(XNap.tr("Hash"), hashToString(sm.hash));
  		put(XNap.tr("Availability"), new Integer(sm.availability));
  		put(XNap.tr("Bitrate"), new Integer(sm.bitrate));
  		put(XNap.tr("Artist"), sm.artist);
  		put(XNap.tr("Title"), sm.title);
  		put(XNap.tr("Album"), sm.album);
  		put(XNap.tr("Length"), sm.length);
  		put(XNap.tr("Codec"), sm.codec);
  		put(XNap.tr("File Format"), sm.format);
  	}
  
      //--- Method(s) ---
  
  	public boolean canGroup(SearchResult result)
  	{
  		if (result instanceof OvernetSearchResult) {
  			OvernetSearchResult os = (OvernetSearchResult)result;
  			return Arrays.equals(hash, os.hash);
  		}
  		return false;
  	}
  
  	public SearchResultContainer createContainer()
  	{
  		return new OvernetSearchResultContainer(this);
  	}
  
  	public Action[] getActions()
  	{
  		return new Action[] { new OvernetDownloadAction(),
  							  new OvernetDownloadAsAction()
 		};
 	}
 
 	public int getAvailability()
 	{
 		return availability;
 	}
 
 	public int getSourcesCount()
 	{
 		return availability;
 	}
 
 	public String getFilename()
     {
 		return filename;
     }
 
 	public long getFilesize()
     {
 		return filesize;
     }
 
 	public Object getHash()
 	{
 		return hashToString(hash);
 	}
 
 	public Icon getIcon()
     {
 		return OvernetPlugin.ICON_16;
     }
 
 	public Plugin getPlugin()
     {
 		return OvernetPlugin.getInstance();
     }
 
 	public Peer getPeer()
     {
 		return null;
     }
 
 	/***
 	 * Converts a byte array to a string representation using base 16 and
 	 * capital letters.
 	 *
 	 * @param hash the array to convert
 	 * @return a string of length <code>2 * hash.length</code>
 	 */
 	private String hashToString(byte[] hash)
 	{
 		char[] digits = new char[] { '0', '1', '2', '3', '4', '5', '6', '7',
 									 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
 		StringBuffer sb = new StringBuffer(2 * hash.length);
 		for (int i = 0; i < hash.length; i++) {
 			sb.append(digits[(hash[i] & 0xF0) >> 4]);;
 			sb.append(digits[(hash[i] & 0x0F)]);
 		}
 		return sb.toString();
 	}
 
 	private class OvernetSearchResultContainer 
 		extends AbstractSearchResultContainer
 	{
 		private OvernetSearchResult os;
 
 		public OvernetSearchResultContainer(OvernetSearchResult os)
 		{
 			this.os = os;
 		}
 
 		/***
 		 * Discards search results having the same file name, they don't
 		 * provide any new information to the user.  
 		 */
 		public boolean add(SearchResult result)
 		{
 			for (Iterator i = iterator(); i.hasNext();) {
 				SearchResult sr = (SearchResult)i.next();
 				if (sr.getFilename().equals(result.getFilename())) {
 					return false;
 				}
 			}
 			return super.add(result);
 		}
 
 		public Action[] getActions()
 		{
 			return new Action[] { new OvernetDownloadAction(),
 								  new OvernetDownloadAsAction()
 			};
 		}
 	}
 
 	private class OvernetDownloadAction extends AbstractDownloadAction
 	{
 		public void actionPerformed(ActionEvent e)
 		{
 			DownloadLinkMessage dm = 
 				new DownloadLinkMessage(hash, filesize, filename);
 			OvernetCore.send(dm);
 			FocusManager.setFocusTo("transfer", e);
 		}
 	}
 	
 	private class OvernetDownloadAsAction extends AbstractAction
 	{
 		public OvernetDownloadAsAction()
 		{
 			putValue(Action.NAME, XNap.tr("Download as") + "...");
 			putValue(IconHelper.XNAP_ICON, "down.png");
 		}
 		
 		public void actionPerformed(ActionEvent e)
 		{
 			String name = JOptionPane.showInputDialog
 				(XNapFrame.getInstance(),
 				 XNap.tr("Save Download As:"),
 				 filename);
 
 			if (name != null) {
 				DownloadLinkMessage dm = 
 					new DownloadLinkMessage(hash, filesize, name);
 				OvernetCore.send(dm);
 				FocusManager.setFocusTo("transfer", e);
 			}
 		}
 	}
 	
 }