/*
 * Arquitectura del un sistema extensible a base de plug-ins.
 * Curso: Ingeniería de Software
 * 
 */
package mx.uam.ingsoft.pluginadmin;

import mx.uam.ingsoft.comun.Plugin;
import mx.uam.ingsoft.comun.PluginInfo;
import mx.uam.ingsoft.comun.AdministradorPlugins;
import mx.uam.ingsoft.comun.ArquitecturaException;

import java.net.URL;
import java.net.URLClassLoader;
import java.net.URLConnection;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.jar.JarFile;
import java.util.jar.JarInputStream;
import java.util.jar.Manifest;
import java.util.zip.ZipEntry;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;

/**
 * Esta clase implementa la interfase de administración de plugins.
 *
 * @version 0.1.1 Jan 27, 2005 
 * @author Humberto Cervantes
 */
public class AdministradorPluginsImpl implements AdministradorPlugins
{
    private Map m_registroPlugins = new HashMap();
    private File m_directorioPlugins;
    
    /**
     * El Administrador de plugins recibe un directorio a partir del
     * cual crea la lista inicial de plugins
     * 
     * @param directorio un directorio existente
     */
    public AdministradorPluginsImpl(File directorio) throws ArquitecturaException
    {
    	if(directorio == null)
    	{
    		throw new ArquitecturaException("AdministradorPluginsImpl: directorio es nulo!");
    	}
    	
        m_directorioPlugins = directorio;
        
        if(directorio.isDirectory() == true)
        {
            // Agrega todos los plugins del directorio        
            File archivos[] = directorio.listFiles();
            
            // Para cada archivo
            for (int i = 0;i<archivos.length;i++)
            {
                // Si no es un directorio
                if(archivos[i].isDirectory() == false && archivos[i].getName().endsWith(".jar"))
                {
                    try
                    {
                        // Carga el plugin
                        cargaPlugin(archivos[i].toURL(),false);
                    }
                    catch(Exception ex) // Hubo algun error?
                    {
                        System.out.println("AdministradorPlugins.AdministradorPlugins(): Error al cargar plugin");
                        ex.printStackTrace();
                    }
                }
            }
        }
        else
        {
            System.out.println("AdministradorPlugins.AdministradorPlugins(): Error "+directorio+" no es un directorio");
        }
    }
    
    /**
     * Este metodo añade una entrada al registro de plugins
     * 
     * @param p_info Información del plugin
     */
    private void registraPlugin(PluginInfo p_info)
    {
        // Checa si ya está registrado?
        if(m_registroPlugins.containsKey(p_info.getNombre()))
        {
            System.out.println("AdministradorPlugin.registraPlugin: Ese plugin ya está registrado");
        }
        
        // Añade el plugin al registro
        m_registroPlugins.put(p_info.getNombre(),p_info);
    }

    /**
     * Este metodo carga un plug-in a partir de un URL
     * 
     * @param url el emplazamiento del plugin
     * @return una instancia de Plugin o null si fallo el cargado
     */
    private PluginInfo cargaPlugin(URL url, boolean recienInstalado)
    {
    	//System.out.println("Cargando desde:"+url);
        try
        {
        	
        	// Flujo de entrada a partir del url
        	//JarInputStream	jis = new JarInputStream(url.openStream());
        	JarFile jarFile = new JarFile(url.getFile());
        	
            // Obtiene el manifest
            Manifest mf = jarFile.getManifest();

            // Obtiene nombre del plugin (obligatorio)
            String nombre = mf.getMainAttributes().getValue("Nombre-Plugin");
            
            // Obtiene la clase principal del plugin (obligatoria)
            String nom_clase = mf.getMainAttributes().getValue("Clase-Plugin");
 
            // Obtiene el nombre del autor (opcional)
            String autor = mf.getMainAttributes().getValue("Autor-Plugin");
            if(autor == null)
            {
            	System.out.println("AdministradorPlugin.cargaPlugin: No se encontro atributo Autor-Plugin, usando Anonimo");
            	autor = "Anonimo";
            }

            // Obtiene la version del plugin (opcional)
            String version = mf.getMainAttributes().getValue("Version-Plugin");
            if(version == null)
            {
            	System.out.println("AdministradorPlugin.cargaPlugin: No se encontro atributo Version-Plugin, usando 0.0.0");
            	autor = "0.0.0";
            }
            
            // Obtiene la clase principal del plugin
            String activo = mf.getMainAttributes().getValue("Inicia-Activo");
            boolean iniciaActivo = false;
            if(activo != null)
            {
            	if(activo.equals("true"))
            	{
            		iniciaActivo = true;
            	}
            }
            else
            {
            	System.out.println("AdministradorPlugin.cargaPlugin: No se encontro atributo Inicia-Activo del plugin, usando false");
            }

            // Checa si se trata verdaderamente de un plugin o un jar cualquiera
            if(nombre == null)
            {
            	System.out.println("AdministradorPlugin.cargaPlugin: El archivo "+url+" no es un plugin ya que no se encontro el atributo Nombre-Plugin");
            	return null;
            }
            	
            if(nom_clase == null)
            {
                System.out.println("AdministradorPlugin.cargaPlugin: El archivo "+url+" no es un plugin ya que no se encontro el atributo Clase-Plugin");
                return null;
            }            
            
            // Ya está registrado?
            if(m_registroPlugins.containsKey(nombre))
            {
                System.out.println("AdministradorPlugin.cargaPlugin: Ese plugin ya esta cargado");
                return (PluginInfo) m_registroPlugins.get(nombre);
            }

            
            File libDir = null;
            boolean creoLibDir = false;
            
            libDir = new File(m_directorioPlugins,nombre.replace(' ','_')+"_lib");
            
            // Si es primera instalacion creamos directorio para librerias
            if(libDir.exists() == false)
            {
            	libDir.mkdir();
            	creoLibDir = true;
            }            
            

            // Lista de los jars contenidos en este jar (librerias)
            ArrayList libURLS = new ArrayList();
            
            Enumeration enumeration = jarFile.entries();
            
            while(enumeration.hasMoreElements())
            {
            	ZipEntry entry = (ZipEntry) enumeration.nextElement();
            	if(entry.getName().endsWith(".jar") == true)
       			{
            		//innerJarList.add(entry.getName());
            		
            		// Si apenas se creo el directorio de librerias, hay que copiar las librarias ahi
            		if(creoLibDir == true)
            		{
            			InputStream is = jarFile.getInputStream(entry);
                        // Abre archivo local en el directorio de plugins
            			FileOutputStream fos = new FileOutputStream(libDir.getCanonicalPath()+"/"+entry.getName());

                        // Copia plugin
                        int oneChar, count=0;
                        while ((oneChar=is.read()) != -1)
                        {
                           fos.write(oneChar);
                           count++;
                        }

                        // Cierra archivos
                        is.close();
                        fos.close();

            		}
            		
            		File f = new File(libDir.getCanonicalPath()+"/"+entry.getName());
            		libURLS.add(f.toURL());
       			}
            }
            
            libURLS.add(url);

            
           	URL urls []=(URL [])libURLS.toArray(new URL[libURLS.size()]);
            
            // Crea un cargador de clases via URL
            PluginClassLoader cargador = new PluginClassLoader(urls);
            
            // Carga la clase principal del plugin
            Class clase = cargador.loadClass(nom_clase);
            
            // Crea una nueva instancia del plugin
            Plugin plugin = (Plugin) clase.newInstance();
            
            // Crea un objeto tipo PluginInfo
            PluginInfo p_info = new PluginInfo(nombre, nom_clase, autor, version, plugin, url.getFile(), iniciaActivo);
            
            // Registra el plugin
            this.registraPlugin(p_info);
            
            return p_info;
        }
        catch(Exception ex)
        {
            System.out.println("Plugin.cargaPlugin(): Falla al cargar el plugin desde URL="+url);
            ex.printStackTrace();
            return null;
        }
    }
    
    /**
     * Regresa un arreglo de cadenas con los nombres de los plugins
     * 
     * @return arreglo de cadenas con los nombres de los plugins
     */
    public String[] getListaPlugins()
    {        
        return (String [])m_registroPlugins.keySet().toArray(new String[m_registroPlugins.keySet().size()]);
    }
    
    /**
     * Obtiene una representación de un plugin a partir del nombre
     * 
     * @param nombre
     * @return
     */
    public PluginInfo getPlugin(String nombre)
    {
        return (PluginInfo) m_registroPlugins.get(nombre);
    }
    
    /**
     * Instala un plugin a partir de un URL dentro del directorio
     * parte del este codigo viene de:
     * http://www.javaworld.com/javaworld/javatips/jw-javatip19.html
     * 
     * @param url
     * @return
     */
    public PluginInfo instalaPlugin(String s_url)
    {
        // Vamos a copiar el plugin a partir del URL
        try
        {
            URL url = new URL(s_url);
            //Abre conexion al URL            
            URLConnection urlC = url.openConnection();
            
            InputStream is = url.openStream();            
            FileOutputStream fos=null;

            String localFile=null;

            // Vamos a obtener el nombre del archivo
            // separando los / del URL
            // el ultimo token sera el nombre del archivo           
            StringTokenizer st=new StringTokenizer(url.getFile(), "/");
            while (st.hasMoreTokens())
            {                
                localFile=st.nextToken();
            }

            // Abre archivo local en el directorio de plugins
            fos = new FileOutputStream(m_directorioPlugins.getCanonicalPath()+"/"+localFile);

            // Copia plugin
            int oneChar, count=0;
            while ((oneChar=is.read()) != -1)
            {
               fos.write(oneChar);
               count++;
            }

            // Cierra archivos
            is.close();
            fos.close();
            
            // Ya que fue copiado cargamos el plug-in desde el directorio local
            // OJO: aqui hay un problema grave: si se usa file:/ funciona en windows pero no
            // en Linux, sin embargo, si se usa file:// funciona en linux pero no en windows            
            URL p_url;
			try
			{
				// Primero intentamos abrir como si estuvieramos en windows
				p_url = new URL("file:/"+m_directorioPlugins.getCanonicalPath()+"/"+localFile);
				
				// La linea siguiente lanza un UnknownHostException si estamos en Linux
				JarInputStream	jis = new JarInputStream(p_url.openStream());
			}
			catch(UnknownHostException uhex)
			{
				//Probablemente estamos en Linux
				p_url = new URL("file://"+m_directorioPlugins.getCanonicalPath()+"/"+localFile);
			}
			
            PluginInfo p_info = cargaPlugin(p_url,true);
            
            if(p_info != null)
            {
                System.out.println("Instalacion del plugin desde:"+s_url+" exitosa.");
            }
            else
            {
            	// Borra el plugin del cache
            	System.out.println("Falla al instalar plugin desde:"+s_url+"... Borrando del cache.");
            	File temp = new File(p_url.getFile());
            	temp.delete();
            }
            
            return p_info;
        }

        catch (Exception ex)
        {
            ex.printStackTrace();
            return null;
        }
    }
        

    /**
     * Retira el plugin y lo borra del directorio
     * 
     * @param pInfo PluginInfo correspondiente al plugin
     * @return true si se retiro correctamente el plugin 
     */
    public boolean retiraPlugin(PluginInfo pInfo)
    {
        // Desactiva plugin antes de retirar
        pInfo.desactiva();
        
        // Retira el plugin de la lista
        m_registroPlugins.remove(pInfo.getNombre());
        
        // obtiene nombre de archivo
        String nomarchivo = pInfo.getArchivo();
        
        // Borra el directorio de librerias
        borraDirectorio(new File(m_directorioPlugins,pInfo.getNombre().replace(' ','_')+"_lib"));
        
        // crea archivo a partir de nombre y lo borra
        File archivo = new File(nomarchivo);
        
        return archivo.delete();        
    }

    /**
     * Borra directorio
     * 
     * @param directorio
     * @return true si se borro exitosamente, false de lo contrario
     */
    private boolean borraDirectorio(File directorio)
    {
    	if( directorio.exists() ) 
    	{
    		File[] files = directorio.listFiles();
    	    for(int i=0; i<files.length; i++) 
    	    {
    	    	if(files[i].isDirectory()) 
    	        {
    	    		borraDirectorio(files[i]);
    	        }
    	        else 
    	        {
    	            files[i].delete();
    	        }
    	    }    	   
    	    return( directorio.delete() );
    	}
    	return false;
    }
    
    public void activaPlugin(PluginInfo pInfo)
    {
    	pInfo.activa();
    }
    
    public void desactivaPlugin(PluginInfo pInfo)
    {
    	pInfo.desactiva();
    }    
    
    /**
     * Este cargador de clases permite crear un cargador de clases individual
     * para cada plug-in de tal forma que las clases proveidas por el plugin
     * quedan totalmente aisladas de las de los otros plugins. Asi dos plugins
     * pueden contener exactamente la misma clase y ejecutarse de manera simultanea.
     * 
     * Este cargador de clases debe sin embargo delegar al cargador de clases
     * principal la busqueda de clases comunes a los plugins y a la aplicacion.
     * 
     * En esta aplicación se supone que las clases comunes se encuentran dentro
     * del package de la interfaz Plugin. De otra forma se tendria un ClassCastException
     * a cada vez. 
     * 
     * @author humberto
     */
    class PluginClassLoader extends URLClassLoader
	{
       	PluginClassLoader(URL urls[])
		{
       		// Crea URL class loader sin padre
    		super(urls,null);
		}

    	
    	public Class findClass(String name) throws ClassNotFoundException 
    	{
    		// Esta en el package comun?
    		if(name.startsWith(Plugin.class.getPackage().getName()))
    		{
    			return AdministradorPluginsImpl.class.getClassLoader().loadClass(name);
    		}
    		else
    		{
    			return super.findClass(name);
    		}
		}
	}
}