/*
    *  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.plugin;
  
  import java.awt.Component;
  import java.io.File;
  import java.io.IOException;
  
  import javax.swing.JOptionPane;
  
  import org.apache.log4j.Logger;
  import org.xnap.XNap;
  import org.xnap.gui.Dialogs;
  import org.xnap.gui.pkg.PackageInstallerDialog;
  import org.xnap.loader.XNapLoader;
  import org.xnap.pkg.PackageCommit;
  import org.xnap.pkg.PackageInfo;
  import org.xnap.pkg.ParseException;
  import org.xnap.pkg.UnsatisfiedDependenciesException;
  import org.xnap.pkg.XNapPackageManager;
  import org.xnap.plugin.PluginInfo;
  import org.xnap.plugin.PluginManager;
  import org.xnap.plugin.PluginVerifier;
  import org.xnap.util.FileHelper;
  import org.xnap.util.Preferences;
  import org.xnap.util.StringHelper;
  
  public class PluginInstallerDialog extends PackageInstallerDialog {
  
      //--- Constant(s) ---
  
      //--- Data field(s) ---
  	private static Logger logger = Logger.getLogger(PluginInstallerDialog.class);
  	
      //--- Constructor(s) ---
  
      privatePluginInstallerDialog(PackageInfo[] packages)/package-summary.html">ong> PluginInstallerDialog(PackageInfo[] packages) 
      {
  		super(packages);
      }
  
      //--- Method(s) ---
  
  	public void close()
  	{
  		if (!isRunning()) {
  			dispose();
  
  			PackageInfo pendingCore = null;
  
  			boolean showRestart = false;
  			boolean rewriteLoader = false;
  			PackageInfo[] infos = getInstaller().getPackageInfos();
  			for (int i = 0; i < infos.length; i++) {
  				if (infos[i].isInstalled()) {
  					if (infos[i].isPlugin()) {
  						showRestart |= addPlugin(infos[i]);
  					}
  					else if (infos[i].isPatch()) {
  						rewriteLoader |= addPatch(infos[i]);
  					}
  					else if (infos[i].isCore()) {
  						pendingCore = infos[i];
  					}
  				}
  			}
  
  			if (pendingCore != null) {
  				addBase(pendingCore);
  			}
  			else if (rewriteLoader) {
  				// PluginManager.getCoreClassPath > ~/.xnap/loader
  			}
  
  			if (showRestart) {
  				Dialogs.info(this,
  							 XNap.tr("One or more plugins could not be enabled, yet. You need to restart XNap."),
  							 XNap.tr("New Plugin Installed"));
  				Preferences.getInstance().setUpdatePluginsOnStartup(true);
  			}
  		}
  
 		// save list of packages
 		XNapPackageManager.getInstance().write();
 		PluginManager.getInstance().write();
 	}
 
 
 	private void addBase(PackageInfo p)
 	{		
 		PluginInfo info = new PluginInfo(p.getProperties());
 		if (resolve(info)) {
 			PluginManager.getInstance().add(info);
 			String[] classPath = info.getClassPath();
 			try {
 				String loaderPathText
 					= "# XNap startup classpath\n"
 					+ "Loader-Version: " + XNapLoader.VERSION + "\n"
 					+ StringHelper.toString(classPath, "\n");
 				FileHelper.writeText
 					(new File(XNapLoader.LOADER_FILENAME), loaderPathText);
 			}
 			catch (IOException e) {
 				Dialogs.error
 					(this, XNap.tr("Could not write loader information: {0}.", 
 								   e.getLocalizedMessage()));
 				return;
 			}
 			Dialogs.info
 				(this,
 				 XNap.tr("You need to restart XNap."),
 				 XNap.tr("New Base Package Installed"));
 		}
 	}
 
 	private boolean addPatch(PackageInfo p)
 	{		
 		//PluginInfo info = new PluginInfo(p.getProperties());
 		
 		// check if version matches
 		// set class path
 		// add to plugin manager
 		return true;
 	}
 
 	private boolean addPlugin(PackageInfo p)
 	{		
 		PluginInfo info = new PluginInfo(p.getProperties());
 		if (resolve(info)) {
 			if (PluginManager.getInstance().add(info)) {
 				int response = JOptionPane.showConfirmDialog
 					(this, 
 					 XNap.tr("Would you like to enable the {0} plugin?",
 							 info.getName()),
 					 XNap.tr("New Plugin Installed"),
 					 JOptionPane.YES_NO_OPTION);
 				if (response == JOptionPane.YES_OPTION) {
 					PluginHelper.enablePlugin(this, info);
 				}
 			}
 			else {
 				// the plugin was installed but already loaded
 				return true;
 			}
 		}
 		return false;
 	}
 
 	public static boolean commit(Component c)
 	{
 		try {
 			PackageCommit commit 
 				= new PackageCommit(XNapPackageManager.getInstance());
 
 			if (!commit.isEmpty()) {
 				PluginInstallerDialog 
 					dialog = new PluginInstallerDialog(commit.getInstall());
 				dialog.show(c);
 			}
 
 			return true;
 		}
 		catch (ParseException e) {
 			Dialogs.error(c, e.getLocalizedMessage());
 		}
 		catch (UnsatisfiedDependenciesException e) {
 			String message
 				= XNap.tr("Unsatisfied dependency: Missing {0}.", 
 						  e.getLocalizedMessage());
 			Dialogs.error(c, message);
 		}
 
 		return false;
 	}
 
 	public boolean resolve(PluginInfo info)
 	{
 		try {
 			info.setClassPath(PluginManager.resolveClassPath(info));
 		}
 		catch (Exception e) {
 			Dialogs.error
 				(this, XNap.tr("Error while resolving class path for {0}: {1}.",
 							   info.getName(),
 							   e.getLocalizedMessage()));
 			return false;
 		}
 
 		// FIX: disabled for now
  		//if (!validate(info)) {
  		//	return false;
  		//}
 
 		return true;
 	}
 
 	public boolean validate(PluginInfo info)
 	{
 		try {
 			PluginVerifier pv = new PluginVerifier(info);
 			if (!pv.isValid()) {
 				// someone has added/modified signed code
 				logger.error(info.getName()+" contains invalid jars!");
 				Dialogs.error(this, XNap.tr("Security Error: {0} will be disabled because it has a broken signature", info.getName()));
 				return false;
 			}
 			// plugin is valid
 			logger.info(info.getName()+(pv.isSigned()?" is signed by "+pv.getSigners():"is not signed"));
 			if (!pv.isTrustedByXNap()) {
 				logger.warn(info.getName()+" contains untrusted code!");
 				//return false;
 			}
 		}
 		catch (IOException e) {
 			logger.error("Plugin validation failed", e);
 			return false;
 		}
 
 		return true;
 	}
 
     // --- Inner Class(es) ---
 }