/*
    *  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;
  
  import java.awt.event.KeyEvent;
  import java.io.File;
  import java.io.IOException;
  import java.util.List;
  import javax.help.HelpSet;
  import javax.swing.Action;
  import javax.swing.Icon;
  import javax.swing.JComponent;
  import javax.swing.JMenu;
  import org.apache.log4j.Logger;
  import org.xnap.XNap;
  import org.xnap.XNapFacade;
  import org.xnap.action.AbstractXNapAction;
  import org.xnap.event.StateEvent;
  import org.xnap.event.StateListener;
  import org.xnap.gui.AbstractPreferencesDialog;
  import org.xnap.gui.DefaultPrefsWizardDialog;
  import org.xnap.gui.StatusBar;
  import org.xnap.gui.XNapFrame;
  import org.xnap.gui.action.FocusAction;
  import org.xnap.gui.component.XNapMenu;
  import org.xnap.gui.component.XNapMenuItem;
  import org.xnap.gui.event.AbstractPreferencesDialogListener;
  import org.xnap.gui.shortcut.ActionShortcut;
  import org.xnap.gui.shortcut.ShortcutManager;
  import org.xnap.gui.util.GUIHelper;
  import org.xnap.gui.util.IconHelper;
  import org.xnap.plugin.AbstractPlugin;
  import org.xnap.plugin.overnet.gui.OvernetPanel;
  import org.xnap.plugin.overnet.gui.OvernetPreferencesPanel;
  import org.xnap.plugin.overnet.gui.OvernetStatusPanel;
  import org.xnap.plugin.overnet.gui.action.ConnectAction;
  import org.xnap.plugin.overnet.gui.action.DisconnectAction;
  import org.xnap.plugin.overnet.gui.action.DownloadLinkAction;
  import org.xnap.plugin.overnet.net.DownloadTable;
  import org.xnap.plugin.overnet.net.OvernetCore;
  import org.xnap.plugin.overnet.net.OvernetSearch;
  import org.xnap.plugin.overnet.net.UploadTable;
  import org.xnap.plugin.overnet.net.msg.MessageHandler;
  import org.xnap.plugin.overnet.net.msg.client.StopMessage;
  import org.xnap.plugin.overnet.util.OvernetPreferences;
  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.State;
  import org.xnap.util.VersionParser;
  
  /***
   * Provides a plugin that can control an overnet core.
   *
   * <p>OvernetPlugin follows the singleton pattern.
   */
  public class OvernetPlugin extends AbstractPlugin
  	implements SearchProvider, StateListener
  {
      
      //--- Constant(s) ---
  
  	public static final String ICON_FILENAME = "toolbar-overnet-logo.png";
  				  
  	public static final Icon ICON_16 = IconHelper.getIcon(ICON_FILENAME, 16, 
  														  false);
  				  
  	public static final String NEW_COMMANDLINE_VERSION = "overnet0.51.2";
  				  
  	public static final String OLD_COMMANDLINE_OPTION = "-";
  
  	public static final String NEW_COMMANDLINE_OPTION = "-g";
  
  	/***
  	 * The plugin's instance.
  	 */
  	private static OvernetPlugin instance = null;
  	/***
  	 * Handles Messagelisteners.
  	 */
 	private MessageHandler messageHandler;
 	/***
 	 * Used plugin-internally to map status messages to the corresponding
 	 * uploads.
 	 */
 	private UploadTable uploadTable;
 	/***
 	 * Used plugin-internally to map status messages to the corresponding
 	 * downloads.
 	 */
 	private DownloadTable downloadTable;
 	/***
 	 * Holds the connection to the core. Does all the sending and receiving of
 	 * messages.
 	 */
 	private OvernetCore core;
 	/***
 	 * Holds the core process if the core was started from within the plugin.
 	 */
 	private Process coreProcess = null;
 	/***
 	 * Is notified when the preferences dialog becomes visible and adds the
 	 * plugin's dialog.
 	 */
 	private PreferencesDialogListener listener;
 	/***
 	 * Menu plugged into XNap's plugins menu.
 	 */
 	private JMenu jmOvernet;
 	/***
 	 * The overnet gui panel.
 	 */
 	private OvernetPanel jpOvernet;
 	/***
 	 * The overnet status panel.
 	 */
 	private OvernetStatusPanel spOvernet;
 	/***
 	 * Overnet's manual helpset. Not used yet.
 	 */
 	private HelpSet hs;
 	/***
 	 * The shortcut for switching to the overnet panel.
 	 */
 	private ActionShortcut focusShortcut;
 
 	private static Logger logger = Logger.getLogger(OvernetPlugin.class);
 
     //--- Constructor(s) ---
 
     public OvernetPlugin()
     {
     }
 
     //--- Method(s) ---
 
 	public OvernetCore getCore()
 	{
 		return core;
 	}
 
     public static OvernetPlugin getInstance()
     {
 		return instance;
     }
 	
 	public String getName()
 	{
 		return getInfo().getName();
 	}
 
     public void start()
     {
 		instance = this;
 		messageHandler = new MessageHandler();
 		downloadTable = new DownloadTable();
 		uploadTable = new UploadTable();
 
 		OvernetPreferences.getInstance();
 
 		core = new OvernetCore(messageHandler);
 		core.addStateListener(this);
 
 		startCoreConnection();
     }
 
     public void startGUI()
     {
 		listener = new PreferencesDialogListener();
 		XNapFacade.addPluginPreferencesDialogListener(listener);
 
 		initializeMenu();
 		XNapFrame.getInstance().getMainMenuBar().addPluginMenu(jmOvernet);
 
 		jpOvernet = new OvernetPanel();
 		jpOvernet.setName("overnet");
 		XNapFrame.getInstance().insertTab
 			(getName(), IconHelper.getListIcon(ICON_FILENAME), jpOvernet);
 
 		spOvernet = new OvernetStatusPanel();
 		core.addStateListener(spOvernet);
 		StatusBar.getInstance().addComponent(spOvernet);
 
 		// register shortcut
 		FocusAction fa = new FocusAction();
 		fa.putValue(Action.NAME, XNap.tr("Overnet"));
 		fa.putValue(Action.SHORT_DESCRIPTION, 
 						XNap.tr("Switches to Overnet panel"));
 		fa.putValue(Action.ACTION_COMMAND_KEY, "overnet");
 		fa.putValue(IconHelper.XNAP_ICON, ICON_FILENAME);
 		fa.putValue(AbstractXNapAction.DEFAULT_KEYSTROKE,
 						GUIHelper.getMenuKeyStroke(KeyEvent.VK_O));
 		focusShortcut = ShortcutManager.getInstance().add
 			(fa, (JComponent)XNapFrame.getInstance().getContentPane(), 
 			 OvernetPreferences.getInstance());
 
 		/* show prefs panel in dialog when plugin is started for the first
            time.  */
 		if (!OvernetPreferences.getInstance().getBoolean("seenStartupWizard")) {
 			DefaultPrefsWizardDialog dfd 
 				= new DefaultPrefsWizardDialog(OvernetPreferences.getInstance(),
 											   "seenStartupWizard");
 			dfd.addPanel(new OvernetPreferencesPanel());
 			dfd.pack();
 			dfd.show(XNapFrame.getInstance());
 		}
 
 		//  hs = HelpManager.loadHelpSet("overnet-manual");
 //  		HelpManager.add(hs);
     }
 
 	/***
 	 * Starts a core process if the core command is specified in the
 	 * preferences.
 	 */
 	private void startCoreConnection()
 	{
 		OvernetPreferences prefs = OvernetPreferences.getInstance();
 		String command = prefs.getCoreCommand();
 
 		if (prefs.getStartCore() && command.length() > 0) {
 			String[] args = new String[] 
 				{ command, 
 				  prefs.getUseCustomCommandLineOption() ? 
 				  prefs.getCommandLineOption()
 				  : getCommandLineOptions(command) };
 			try {
 				logger.debug("launching core " + command + " " + args[1]);
 				coreProcess = Runtime.getRuntime().exec
 					(args, null, (new File(command)).getParentFile());
 			}
 			catch (IOException ie) {
 				logger.debug("Could not launch core", ie);
 			}
 		}
 
 		// connect to core after 5 seconds delay if it was just launched
 		core.connect(prefs.getStartCore() ? 5 * 1000 : 0);
 	}
 
 	public static String getCommandLineOptions(String command)
 	{
 		String core = new File(command).getName();
 		return VersionParser.compare(core, NEW_COMMANDLINE_VERSION) < 0 ?
 			OLD_COMMANDLINE_OPTION : NEW_COMMANDLINE_OPTION;
 	}
 
 	/***
 	 * Closes the core connection and kills the core process if it was started
 	 * from within the plugin.
 	 */
 	private void stopCoreConnection()
 	{
 		if (coreProcess != null) {
 			if (core.getState() == State.CONNECTED) {
 				OvernetCore.send(new StopMessage());
 			}
 			core.stop();
 			coreProcess.destroy();
 			coreProcess = null;
 		}
 		else {
 			core.stop();
 		}
 
 		core.removeStateListener(this);
 		core = null;
 	}
 
     private void initializeMenu()
     {
 		jmOvernet = new XNapMenu(getName());
 		jmOvernet.setIcon(IconHelper.getMenuIcon(ICON_FILENAME));
 		jmOvernet.add(new XNapMenuItem(new ConnectAction()));
 		jmOvernet.add(new XNapMenuItem(new DisconnectAction()));
 		jmOvernet.addSeparator();
 		jmOvernet.add(new XNapMenuItem(new DownloadLinkAction()));
     }
 
 	public static MessageHandler getMessageHandler()
 	{
 		return instance.messageHandler;
 	}
 
 	/***
 	 * Implements the {@link StateListener} interface.
 	 */
 	public void stateChanged(StateEvent event)
 	{
 		if (core.getState() == State.DISCONNECTED) {
 			disposeTransfers();
 		}
 	}
 
 	private void disposeTransfers()
 	{
 		downloadTable.dispose();
 		uploadTable.dispose();
 	}
 
     public void stop()
     {
 		stopCoreConnection();
 
 		disposeTransfers();
 		// downloadTable = null;
 // 		uploadTable = null;
 // 		messageHandler = null;
 		
 		OvernetPreferences.disposeInstance();
 		// we can not cleanly unload the plugin...
 		//singleton = null;
     }
 
     public void stopGUI()
     {
 		listener.dispose();
 		XNapFacade.removePluginPreferencesDialogListener(listener);
 		listener = null;
 
 		XNapFrame.getInstance().getMainMenuBar().removePluginMenu(jmOvernet);
 		jmOvernet = null;
 
 		XNapFrame.getInstance().removeTab(jpOvernet);
 		jpOvernet.dispose();
 		jpOvernet = null;
 		
 		StatusBar.getInstance().removeComponent(spOvernet);
 		core.removeStateListener(spOvernet);
 		spOvernet = null;
 
 		ShortcutManager.getInstance().remove
 			(focusShortcut, (JComponent)XNapFrame.getInstance().getContentPane());
 
 		//  HelpManager.remove(hs);
 //  		hs = null;
     }
 
 	public MediaType[] getSupportedMediaTypes()
 	{
 		return new MediaType[] { SearchManager.MEDIA_ANYTHING };
     }
 
 	public Search search(SearchFilter filter)
 	{
 		return new OvernetSearch(filter);
 	}
 
     // --- Inner Class(es) ---
 
 	private class PreferencesDialogListener
 		extends AbstractPreferencesDialogListener
 	{
 		public void addPanels(AbstractPreferencesDialog dialog, List panels)
 		{
 			OvernetPreferencesPanel opp = new OvernetPreferencesPanel();
 			panels.add(opp);
 			panels.add(dialog.addPanel(opp, ICON_FILENAME));
 		}
 	}
 }