/*
    *  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.jtella;
  
  import java.io.IOException;
  import java.util.List;
  import java.util.StringTokenizer;
  
  import org.apache.log4j.Logger;
  import org.xnap.XNapFacade;
  import org.xnap.gui.AbstractPreferencesDialog;
  import org.xnap.gui.XNapFrame;
  import org.xnap.gui.event.AbstractPreferencesDialogListener;
  import org.xnap.gui.util.IconHelper;
  import org.xnap.plugin.AbstractPlugin;
  import org.xnap.search.MediaType;
  import org.xnap.search.Search;
  import org.xnap.search.SearchFilter;
  import org.xnap.search.SearchManager;
  import org.xnap.search.SearchProvider;
  import org.xnap.util.PortRange;
  
  import com.kenmccrary.jtella.ConnectionData;
  import com.kenmccrary.jtella.GNUTellaConnection;
  
  /***
   * Provides a gnutella network plugin based on the jtella library.
   */
  public class JTellaPlugin extends AbstractPlugin implements SearchProvider
  {
  
      //--- Constant(s) ---
      
      //--- Data Field(s) ---
  
      private static Logger logger = Logger.getLogger(JTellaPlugin.class);
      private static JTellaPlugin singleton;
  
      private JTellaPreferences jtellaPrefs;
      private GNUTellaConnection connection;
      private JTellaPanel jpJTella;
      private PreferencesDialogListener pdl;
  
      private boolean started = false;
  
      //--- Constructor(s) ---
  
      public JTellaPlugin()
      {
      }
  
      //--- Method(s) ---
  
      public static JTellaPlugin getInstance()
      {
  		return singleton;
      }
  
  	public static JTellaPreferences getPreferences()
  	{
  		return singleton.jtellaPrefs;
  	}
      
      /***
       * Returns the network connection.
       */
      public GNUTellaConnection getConnection()
      {
  		return connection;
      }
  
      /***
       * Returns the name of the plugin.
  	 *
  	 * @see SearchProvider#getName()
       */
      public String getName()
      {
  		return getInfo().getName();
      }
  
      /***
      * Returns all supported search media types.
      */
     public MediaType[] getSupportedMediaTypes()
     {
 		return new MediaType[] { SearchManager.MEDIA_ANYTHING };
     }
 
     /***
      * Creates and returns a {@link JTellaSearch} object.
      */
     public Search search(SearchFilter filter)
     {
 		return new JTellaSearch(filter);
     }
 
     /***
      * Starts the plugin.
      */
     public void start() 
     {
 		singleton = this;
 
 		jtellaPrefs = new JTellaPreferences();
 
 		//System.setProperty("JTella.Debug", "true");
 		createConnection();
 
 		// auto start
 		if (getPreferences().getAutoConnect()) {
 			startConnection();
 		}
     }
 
     /***
      * Starts the GUI of the plugin.
      */
     public void startGUI()
     {
 		jpJTella = new JTellaPanel();
 		XNapFrame.getInstance().insertTab
 			(getName(), IconHelper.getListIcon("socket.png"), jpJTella);
 		
 		pdl = new PreferencesDialogListener();
 		XNapFacade.addPluginPreferencesDialogListener(pdl);
     }
 
     /***
      * Stops the plugin. Disposes all singletons.
      */
     public void stop()
     {
 		stopConnection(false);
 		SearchManager.getInstance().remove(JTellaPlugin.getInstance());
 
 		connection = null;
 
 		jtellaPrefs = null;
 
 		singleton = null;
     }
 
     /***
      * Stops the GUI of the plugin.
      */
     public void stopGUI()
     {
 		pdl.dispose();
 		XNapFacade.removePluginPreferencesDialogListener(pdl);
 		pdl = null;
 
 		// stop update timer
 		jpJTella.setConnected(false);
 
 		XNapFrame.getInstance().removeTab(jpJTella);
 		jpJTella = null;
     }
 
     /***
      * Creates a new connection.
      */
     public void createConnection()
     {
 		ConnectionData data = new ConnectionData();
 		PortRange range
 			= new PortRange(JTellaPlugin.getPreferences().getLocalPortRange());
 		data.setIncomingPort(range.getRandom(6348));
 		data.setVendorCode
 			("XNap " + JTellaPlugin.getInstance().getInfo().getVersion());
 
 		try {
 			connection = new GNUTellaConnection(data);
 		}
 		catch (IOException e) {
 		}
     }
 
     public boolean isStarted()
     {
 		return started;
     }
 
     /***
      * Starts the network connection.
      */
     public void startConnection()
     {
 		connection.start();
 
 		// add host caches
 		String[] hostCaches = JTellaPlugin.getPreferences().getHostCaches();
 		for (int i = 0; i < hostCaches.length; i++) {
 			StringTokenizer t = new StringTokenizer(hostCaches[i], ":");
 			try {
 				String host = t.nextToken();
 				int port = Integer.parseInt(t.nextToken());
 				connection.addHostCacheServant(host, port);
 			}
 			catch (Exception e) {
 				logger.debug("could not add host cache", e);
 			}
 		}
 
 		started = true;
 		SearchManager.getInstance().add(this);
 
 		if (jpJTella != null) {
 			jpJTella.setConnected(true);
 		}
     }
 
     /***
      * Stops the connection.
      *
      * @param createNew if true, a new connection will be created
      * @see #createConnection()
      */
     private void stopConnection(boolean createNew)
     {
 		connection.stop();
 		SearchManager.getInstance().remove(this);
 		started = false;
 
 		if (createNew) {
 			createConnection();
 		}
 
 		if (jpJTella != null) {
 			jpJTella.setConnected(false);
 		}
     }
 
     /***
      * Stops the connection and creates a new one.
      *
      * @see #createConnection(boolean)
      */
     public void stopConnection()
     {
 		stopConnection(true);
     }
 
     // --- Inner Class(es) ---
 
     private class PreferencesDialogListener 
 		extends AbstractPreferencesDialogListener
     {
 
 		public void addPanels(AbstractPreferencesDialog dialog, List panels) 
 		{
 			JTellaPreferencesPanel jpp = new JTellaPreferencesPanel();
 			panels.add(jpp);
 			panels.add(dialog.addPanel(jpp, "socket.png"));
 		}
 
     }
 
 }