/*
 * Moonlight|3D Copyright (C) 2005 The Moonlight|3D team
 * 
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License as published by the Free
 * Software Foundation; either version 2.1 of the License, or (at your option)
 * any later version.
 * 
 * This library 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 Lesser General Public License for more
 * details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 * 
 * Created on Jan 5, 2005
 */
package ml.core.plugins;
/**
 * \package ml.core.plugins
 * 
 * This is the plugin manager. It is responsible for loading and
 * unloading all plugins at runtime.
 * 
 * This package is part of the core program.
 */

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.List;

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import ml.core.State;
import ml.core.exceptions.Exception;
import ml.core.helper.Property;
import ml.core.helper.Value;
import ml.core.preferences.PreferencesGroup;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

/**
 * The plugin manager is responsible for loading and unloading plugins 
 * in the right order.
 * 
 * @author gregor
 */
public class Manager {
	class ClassLoader extends URLClassLoader {
		public ClassLoader() {
			super(new URL[0]);
		}
		
		@Override
		public void addURL(URL url) {
			super.addURL(url);
		}
	}
	
    class PluginWrapper {
        private boolean loaded;
        private boolean unloadable;
        private Class pluginClass;
        private Plugin plugin;
        private Manager manager;
        
        public PluginWrapper(Manager manager, Class pluginClass) {
            this.manager=manager;
            this.pluginClass=pluginClass;
            unloadable=false;
        }
        
        public void instantiate() throws InstantiationException, IllegalAccessException {
            plugin=(Plugin)pluginClass.newInstance();        	
        }
        
        /**
         * checks, whether the dependencies of the plugin are actually satisfied
         * @return true, if dependencies are all satisfied, false otherwise
         */
        public boolean hasSatisfiesDependencies()
        {
            ArrayList<String> dependencies=plugin.getDependencies();
            
            if(dependencies==null) {
            		return true;
            }
            
            for(int i=0;i<dependencies.size();i++) {
                boolean foundDependency=false;
                for(int j=0;j<manager.plugins.size();j++) {
                    if(dependencies.get(i)==manager.plugins.get(j).plugin.getName()) {
                        foundDependency=true;
                    }
                }
                if(!foundDependency) {
                    return false;
                }
            }
            
            return true;
        }
        
        /**
         * checks, if the plugin can be loaded right now
         * @return true, if plugin can be loaded and initialized right now, false if there are unsatisfied 
         * dependencies or dependencies aren't loaded
         */
        public boolean isLoadable()
        {
            ArrayList<String> dependencies=plugin.getDependencies();
            
            if(dependencies==null) {
            		return true;
            }
            
            if(unloadable) {
            		return false;
            }
            
            for(int i=0;i<dependencies.size();i++) {
                boolean foundDependency=false;
                for(int j=0;j<manager.plugins.size();j++) {
                    if(dependencies.get(i)==manager.plugins.get(j).plugin.getName()) {
                        if(manager.plugins.get(j).isLoaded()) {
                            foundDependency=true;
                        } else if(manager.plugins.get(j).isUnloadable()) {
                        		markUnloadable();
                        		return false;
                        }
                    }
                }
                if(!foundDependency) {
                    return false;
                }
            }
            
            return true;
        }
        
        public boolean isUnloadable() {
        		return unloadable;
        }
        
        public void markUnloadable() {
        		unloadable=true;
        }
        
        /**
         * checks, wether there are other plugins running which are depending on this one
         * @return true, if there is at least one other plugin running which depends on this one
         */
        public boolean hasRuntimeDependencies()
        {
            for(int i=0;i<manager.plugins.size();i++) {
                if(manager.plugins.get(i).isLoaded()) {
                    ArrayList<String> dependencies=manager.plugins.get(i).plugin.getDependencies();
                    if(dependencies==null) {
                    		continue;
                    }
                    for(int j=0;j<dependencies.size();j++) {
                        if(dependencies.get(j)==plugin.getName()) {
                            return true;
                        }
                    }
                }
            }
            
            return false;
        }

        public boolean isLoaded()
        {
            return loaded;
        }
        
        public void load() throws java.lang.Throwable
        {
            plugin.load();
            loaded=true;
        }
        
        public void unload() throws java.lang.Throwable
        {
            plugin.unload();
            loaded=false;
        }
    }
    
    private ArrayList<PluginWrapper> plugins;
    private ClassLoader classLoader;
    
    public Manager()
    {  
        plugins=new ArrayList<PluginWrapper>();
        classLoader=new ClassLoader();
        
        // build a preferences group with the additional plugin paths
        PreferencesGroup pluginPreferences=new PreferencesGroup();
        pluginPreferences.setName("Plugins");
        Property paths=new Property(pluginPreferences);
        paths.setName("paths");
        paths.setType(Value.Type.StringArray);
        try {
			paths.setMaxSize(0);
		} catch (Exception e) {
			// this cannot happen here
			e.printStackTrace();
		}
        
        State.getInstance().getPreferencesManager().getCurrentPreferences().addPreferencesGroup(pluginPreferences);
    }
    
    /**
     * tries to load a plugin from a given class name
     * @param className the name of the class to load as a plugin
     * @throws Exception 
     */
    void getPlugin(String className) throws Exception
    {
        try {
            Class pluginClass=classLoader.loadClass(className);
            plugins.add(new PluginWrapper(this,pluginClass));
        } catch (ClassNotFoundException e) {
            throw new Exception("failed to load plugin " + className,e);
        }
    }
    
    private void addToClasspath(String path) {
   		State.getInstance().logger().info("adding to classpath: " + path);
    	try {
			classLoader.addURL(new URL("file:" + path));
		} catch (MalformedURLException e) {
			// TODO handle exception more appropriately
			e.printStackTrace();
		}
	}
    
    void parsePluginList(File file) throws Exception
    {
        try {
            Document pluginListDoc=DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(file.toURI().toString());
            Element root=pluginListDoc.getDocumentElement();
            NodeList classpathList, pluginList;
            
            State.getInstance().logger().info("loading plugins from " + file.toURI().toString());
            
            classpathList=root.getElementsByTagName("classpath");
            for(int i=0;i<classpathList.getLength();i++) {
            		Element classpath=(Element) classpathList.item(i);
            		String path=classpath.getAttributes().getNamedItem("location").getNodeValue();
            		addToClasspath(file.getParentFile().getCanonicalPath() + System.getProperty("file.separator") + path);
            }
            pluginList=root.getElementsByTagName("plugin");
            
            for(int i=0;i<pluginList.getLength();i++) {
                Node node=pluginList.item(i);
                
                Node attributeNode=node.getAttributes().getNamedItem("className");
                
                if(attributeNode==null) {
                    // log this
                    ml.core.State.getInstance().logger().info("no className attribute in plugin");
                    continue;
                }
                
                String pluginClassName=attributeNode.getNodeValue();
                try {
                    getPlugin(pluginClassName);
                } catch (Exception e) {
                    // log plugin load failure
                    ml.core.State.getInstance().logger().info("unable to load plugin " + pluginClassName + ", reason:");
                    ml.core.State.getInstance().logger().info(e.getFullText());
                }
            }
        } catch (ParserConfigurationException e) {
            throw new ml.core.exceptions.Exception("unable to parse plugin list XML file " + file.getAbsolutePath(),e);
        } catch (SAXException e) {
            throw new ml.core.exceptions.Exception("unable to parse plugin list XML file " + file.getAbsolutePath(),e);
        } catch (IOException e) {
            throw new ml.core.exceptions.Exception("unable to parse plugin list XML file " + file.getAbsolutePath(),e);
        }    
    }
    
    void scanPluginDirectory(File pluginDirectory) throws Exception {
        File[] pluginFiles=pluginDirectory.listFiles();
        
        if(pluginFiles==null) {
       		State.getInstance().logger().warning("no files found in directory " + pluginDirectory.getAbsolutePath());
            return;
        }
        
        for(int i=0;i<pluginFiles.length;i++) {
            if(pluginFiles[i].isDirectory()) {
                scanPluginDirectory(pluginFiles[i]);
            }
            if(!pluginFiles[i].getName().endsWith(".pluginlist")) {
            		continue;
            }
            parsePluginList(pluginFiles[i]);
        }
    }

	void scanPluginDirectory() throws Exception {
        // scan startup script directory/directories
        File pluginDirectory=new File(State.getInstance().getInstallationDirectory() + File.separator + "plugins");
        scanPluginDirectory(pluginDirectory);
        
        /* Try to check other user-supplied plugin paths.
         * NOTE: The "current" preferences set is not fully loaded at this stage.
         * So we need to resort to the saved user preferences which are loaded by now.
         */
        // check if preferences group exists (it won't be present during first startup)
        if(State.getInstance().getPreferencesManager().getUserPreferences().getGroupByName("Plugins")==null) {
        	return;
        }
        Property paths=State.getInstance().getPreferencesManager().getUserPreferences().getGroupByName("Plugins").getProperty("paths");
        for(int i=0;i<paths.getSize();i++) {
        	String path=paths.getArrayStringValue(i);
        	pluginDirectory=new File(path);
        	scanPluginDirectory(pluginDirectory);
        }
    }
	
	void instantiatePlugins() {
		for(int i=0;i<plugins.size();i++) {
			PluginWrapper wrapper=plugins.get(i);
			boolean instantiateable=false;
			try {
				wrapper.instantiate();
				instantiateable=true;
	        } catch (InstantiationException e) {
	        	e.printStackTrace();
	        } catch (IllegalAccessException e) {
	        	e.printStackTrace();
			}
	        if(!instantiateable) {
                // log this
                ml.core.State.getInstance().logger().info("removing plugin " + plugins.get(i).plugin.getName() + " because Plugin class instance creation failed");
                plugins.remove(i);
                i--; // decrement counter because of index shift caused by remove
	        }
		}
	}
    
    /**
     * remove those plugins from the plugin list which have unsatisfied dependencies
     *
     */
    void kickUnsatisfiedDependencies()
    {
        boolean dependenciesSatisfied=false;
        
        while(!dependenciesSatisfied) {
            dependenciesSatisfied=true;
            
            for(int i=0;i<plugins.size();i++) {
                if(!plugins.get(i).hasSatisfiesDependencies()) {
                    // log this
                    ml.core.State.getInstance().logger().info("removing plugin " + plugins.get(i).plugin.getName() + " because of unsatisfied dependencies");
//                    System.out.println("removing plugin " + plugins.get(i).plugin.getName() + " because of unsatisfied dependencies");
                    plugins.remove(i);
                    i--; // decrement counter because of index shift caused by remove
                    dependenciesSatisfied=false;
                }
            }
        }
    }
    
    /**
     * actually fires the plugins up one after another
     * @throws Exception
     */

    void initializePlugins()
    {
        boolean pluginsSkipped=true;
        
        while(pluginsSkipped) {
            pluginsSkipped=false;
            for(int i=0;i<plugins.size();i++) {
                if(!plugins.get(i).isLoaded()) {
                    if(plugins.get(i).isLoadable()) {
                        // log this
                        ml.core.State.getInstance().logger().info("loading plugin " + plugins.get(i).plugin.getName());
                        try {
                        		plugins.get(i).load();
                        } catch(Exception e) {
                            ml.core.State.getInstance().logger().info("unable to initialise plugin " + plugins.get(i).plugin.getName() + ", reason:");
                            ml.core.State.getInstance().logger().info(e.getFullText());
                            plugins.get(i).markUnloadable();
                        } catch(Throwable e) {
                            ml.core.State.getInstance().logger().info("unable to initialise plugin " + plugins.get(i).plugin.getName() + ", reason:");
                            ml.core.State.getInstance().logger().info(e.getMessage());
                            plugins.get(i).markUnloadable();
                        }
                    } else if(!plugins.get(i).isUnloadable()){
                        pluginsSkipped=true;
                    }
                }
            }
        }
    }
    
    /**
     * tries to actually initialise the plugins
     * @throws Exception 
     *
     */
    public void loadPlugins() throws Exception
    {
        try {
//            parsePluginList();
        	scanPluginDirectory();
        	instantiatePlugins();
            kickUnsatisfiedDependencies();
            initializePlugins();
        } catch(java.lang.Throwable e) {
            throw new Exception("aborting plugin loading due to an exception which occured in that process",e);
        }
    }
    
    public void unloadPlugins() throws Exception
    {
        try {
            boolean pluginsSkipped=true;
            while(pluginsSkipped) {
                pluginsSkipped=false;
                for(int i=0;i<plugins.size();i++) {
                    if(plugins.get(i).hasRuntimeDependencies()) {
                        pluginsSkipped=true;
                    } else {
                        if(plugins.get(i).isLoaded()) {
                            ml.core.State.getInstance().logger().info("unloading plugin " + plugins.get(i).plugin.getName());
                            plugins.get(i).unload();
                        }
                    }
                }
            }
        } catch (java.lang.Throwable e) {
            throw new Exception("aborting plugin unloading due to an exception which occured in that in that process",e);
        }
    }
    
    public List<String> getPluginList()
    {
        ArrayList<String> pluginList=new ArrayList<String>();
        
        for(int i=0;i<plugins.size();i++) {
            pluginList.add(plugins.get(i).plugin.getName());
        }
        
        return pluginList;
    }
}