/*
    * Copyright 2004-2005 Alvaro Gonzalez de Paz (kortsoft)
    *
    * Licensed under the Apache License, Version 2.0 (the "License")
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *     http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package kortsoft.kmx.deployer;
  
  import java.io.File;
  import java.io.FilenameFilter;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  
  /***
   * KmxDameon responsability is to check modified or new components to be deployed.
   * It must be assigned the directories to check (in the future it could check 
   * other sources) with the method <code>setWatchDirectories(List<File>)</code>.
   * Takes the modified or new components and selects a Deployer taken within:
   * <ul>
   *   <li>Default Deployers (directory and jar)</li>
   *   <li>Extra Deployers (based on a <code>FilenameFilter</code>)</li>
   * </ul>
   * <p>
   * These <em>Extra</em> deployers must be assigned with the method
   * <code>addExtraDeployer(Class<? extends Deployer>,FilenameFilter)</code>.
   * </p>
   * <a href="KmxDaemon.java.html"> <b><i>View Source </i> </b> </a>
   * 
   * @author Alvaro
   * @version $Revision: 1.2 $
   * 
   * @todo Refactor Deployer selection and invocation to a "DeployerManager"
   * 
   */
  public class KmxDaemon implements KmxDaemonInterface, KmxDaemonMBean {
  
      private Map<File, Class< ? extends Deployer>> deployersCache = new HashMap<File, Class< ? extends Deployer>>();
  
      private Map<FilenameFilter, Class< ? extends Deployer>> extraDeployers = new HashMap<FilenameFilter, Class< ? extends Deployer>>();
  
      private List<File> watchDirectories;
  
      private Map<File,Long> lastLoading;;
      
      private ClassLoader baseClassLoader;
  
      /***
       * Check modifications in a directory. New files and modified
       * files/directories are returned as a List <File>. It is passed a Map with
       * the timestamp of the file/directory last load, so it can be compared with
       * the modification timestamp.
       * 
       * @param directory
       * @param lastLoadings
       * @return
       * 
       * @todo Implement
       */
      protected List<File> checkDirectoryChanges(File directory,
              Map<File, Long> lastLoadings) {
          long now=System.currentTimeMillis();
          List<File> toLoadFiles = new ArrayList<File>();
          String[] fileNames = directory.list();
          for (int i = 0; i < fileNames.length; i++) {
              String fileName = fileNames[i];
              File checkedFile = new File(directory, fileName);
              Long lastLoading = lastLoadings.get(checkedFile);
              long lastModified = checkedFile.lastModified();
              if (lastLoading == null) // New File!
                  toLoadFiles.add(checkedFile);
              else if (lastLoading <= checkedFile.lastModified())
                  // Modified File!
                  toLoadFiles.add(checkedFile);
              lastLoadings.put(checkedFile, now);
          }
          return toLoadFiles;
      }
  
      /***
       * Loads an instance of a Deployer suitable for the specified file. First
       * seek for the deployer class in a caché if it has been loaded previously
       * (now it is a reload). If it doesn't find the file in the caché, look for
       * a deployer for that type of file (both in advanced Deployer and in
       * default deployes).
      * 
      * @param jarFile
      * @return
      */
     protected Deployer loadDeployer(File element)
             throws DeployerCreationException {
         Class< ? extends Deployer> deployerClass = null;
         if (!deployersCache.containsKey(element)) {
             deployerClass = checkDeployerType(element);
             if (deployerClass == null)
                 deployerClass = checkDefaultDeployerType(element);
             deployersCache.put(element, deployerClass);
         } else
             deployerClass = deployersCache.get(element);
         try {
             Deployer deployer = deployerClass.newInstance();
             deployer.setParent(getBaseClassLoader());
             return deployer;
         } catch (InstantiationException e) {
             throw new DeployerCreationException(e);
         } catch (IllegalAccessException e) {
             throw new DeployerCreationException(e);
         }
 
     }
 
     /***
      * @param element
      * @return
      */
     private Class< ? extends Deployer> checkDefaultDeployerType(File element) {
         if (element.isDirectory())
             return ComponentDirDeployer.class;
         if (element.getName().toLowerCase().endsWith(".jar"))
             return JarDeployer.class;
         else
             return SimpleFileDeployer.class;
     }
 
     /***
      * @param element
      * @return
      */
     private Class< ? extends Deployer> checkDeployerType(File element) {
         Set<FilenameFilter> filters = extraDeployers.keySet();
         for (FilenameFilter filter : filters) {
             if (filter.accept(element.getParentFile(), element.getName()))
                 return extraDeployers.get(filter);
         }
         return null;
     }
 
 
     /***
      * @param name
      * @param filter
      */
     public void addExtraDeployer(Class< ? extends Deployer> deployerType,
             FilenameFilter filter) {
         this.extraDeployers.put(filter, deployerType);
     }
 
     /***
      * @param watchDirectories
      */
     public void setWatchDirectories(List<File> watchDirectories) {
         synchronized (watchDirectories) {
             this.watchDirectories = watchDirectories;
         }
     }
 
     /***
      * Executes one iteration of loading.
      * 
      */
     public void runDaemon() {       
         List<File> auxDirectories=new ArrayList<File>();
         synchronized (watchDirectories){
            if (watchDirectories==null || (watchDirectories.size()==0)) 
                return;
            for (File f : watchDirectories)
                auxDirectories.add(f);
        }
        if (lastLoading==null)
            lastLoading=new HashMap<File,Long>();
        for (File directory : auxDirectories){
            List<File> toLoads=checkDirectoryChanges(directory,lastLoading);
            for (File toLoad : toLoads){
                try {
                    Deployer deployer = loadDeployer(toLoad);
                    deployer.deployElement(toLoad);
                } catch (DeployerCreationException e) {
                    error("Error creating deployer for File "
                            + toLoad.getName());
                }
            }
        }               
     }
 
     /***
      * @param string
      */
     private void error(String string) {
        Logger.getLogger(this.getClass().getName()).log(Level.FINE,string);        
     }
     /***
      * @return Returns the watchDirectories.
      */
     public List<File> getWatchDirectories() {
         return watchDirectories;
     }
     /***
      * @return Returns the baseClassLoader.
      */
     public ClassLoader getBaseClassLoader() {
         return baseClassLoader;
     }
     /***
      * @param baseClassLoader The baseClassLoader to set.
      */
     public void setBaseClassLoader(ClassLoader baseClassLoader) {
         this.baseClassLoader = baseClassLoader;
     }
 }