package org.apache.maven.plugin;
   
   /* ====================================================================
    *   Licensed to the Apache Software Foundation (ASF) under one or more
    *   contributor license agreements.  See the NOTICE file distributed with
    *   this work for additional information regarding copyright ownership.
    *   The ASF licenses this file to You 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.
   * ====================================================================
   */
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Properties;
  import java.util.StringTokenizer;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.maven.MavenException;
  import org.apache.maven.MavenSession;
  import org.codehaus.plexus.util.StringUtils;
  
  /**
   * Plugin cache management.
   *
   * @author <a href="mailto:brett@apache.org">Brett Porter</a>
   */
  final class PluginCacheManager
      implements PluginDefinitionHandler
  {
      /** Log. */
      private static final Log LOGGER = LogFactory.getLog( PluginCacheManager.class );
  
      /** Maven session LOGGER */
      private static final Log sessionLog = LogFactory.getLog( MavenSession.class );
  
      /** Plug-in cache lock. */
      public static final String LOCK_CACHE = "lock.cache";
  
      /** Plug-in cache valid. */
      public static final String VALID_CACHE = "valid.cache";
  
      /** Artifact ID to Plug-in cache */
      public static final String ARTIFACT_ID_CACHE = "artifactIdToPlugin.cache";
  
      /** Plug-in cache */
      public static final String PLUGINS_CACHE = "plugins.cache";
  
      /** Goal cache */
      public static final String GOALS_CACHE = "goals.cache";
  
      /** call backs cache */
      public static final String CALLBACKS_CACHE = "callbacks.cache";
  
      /** Taglibs cache */
      public static final String DYNAMIC_TAGLIBS_CACHE = "dynatag.cache";
  
      /** Plugin -&gt; dynatag dependencies. */
      public static final String PLUGIN_DYNATAG_DEPS_CACHE = "plugin-dynatag-deps.cache";
  
      /** Dirty flag. */
      private boolean dirty = true;
  
      /**
       * The artifact id cache contains plugin name to artifact ID mappings.
       * @todo just for getPluginContext - should not be loading multiple versions, and hence using artifact ID instead of name everywhere...
       */
      private Properties artifactIdCache = new Properties();
  
      /**
       * The goals caches contains a mapping of goal names to a description for the
       * goal and any prerequisite goals.
       */
      private Properties goalCache = new Properties();
  
      /**
       * The plugin cache contains a mapping of goal names to plugin names.
       */
      private Properties pluginCache = new Properties();
  
      /**
       * Dyanamic tag libraries that are created within plugin.jelly scripts using
      * the jelly:define tags. So we might have something like the following:
      * <pre>
      * &lt;define:taglib uri="aptdoc"&gt;
      *   &lt;define:jellybean
      *     name="convert"
      *     className="org.apache.maven.aptdoc.AptToXdocConverter"
      *     method="doExecute"
      *   /&gt;
      * &lt;/define:taglib&gt;
      * </pre>
      * What will end up in the dynamic-taglibs.cache file is something like
      * the following:
      *
      * aptdoc=maven-aptdoc-1.0-SNAPSHOT
      */
     private Properties dynaTagLibCache = new Properties();
 
     /**
      * This is list of registered preGoals and postGoals in the various plugins. For
      * example the antlr plugin has preGoal set on java:compile goal to make sure that
      * that antlr can generate the requested sources before java:compile executes. In
      * this case we have something like the following registered in the callbacks.cache
      * file:
      *
      * java\:compile.pre=maven-antlr-plugin[1.1-SNAPSHOT;1.2]
      *
      * Note that ":" is a key termination character to the Properties class so we
      * escape it to be identified as a ":" character.
      */
     private Properties callbackCache = new Properties();
 
     /**
      * Plugin dependencies on dyna tags. So, for example, the junit plugin
      * depends on the 'doc' dynatag which provides the mechanism to perform
      * a JSL transformation.
      */
     private Properties pluginDynaTagDepsCache = new Properties();
 
     /** Default constructor. */
     public PluginCacheManager()
     {
     }
 
     void checkLockFile( File lockFile )
     {
         for ( int i = 1; i <= 10; i++ )
         {
             if ( lockFile.exists() )
             {
                 LOGGER.info( "Lock file " + lockFile + " exists, waiting... " + i + " of 10" );
                 try
                 {
                     Thread.sleep( 1000 );
                 }
                 catch ( InterruptedException e )
                 {
                     // do nothing
                 }
             }
             else
             {
                 break;
             }
         }
         if ( lockFile.exists() )
         {
             LOGGER.warn( "Lock file still exists: ignoring" );
             lockFile.delete();
         }
     }
 
     void saveCache( File directory )
         throws IOException
     {
         if ( !dirty )
         {
             return;
         }
 
         directory.mkdirs();
 
         File lockFile = new File( directory, LOCK_CACHE );
         checkLockFile( lockFile );
 
         LOGGER.debug( "Locking " + lockFile );
         if ( !lockFile.getParentFile().exists() )
         {
             lockFile.getParentFile().mkdirs();
         }
         lockFile.createNewFile();
 
         try
         {
             if ( LOGGER.isDebugEnabled() )
             {
                 LOGGER.debug( "Saving caches to " + directory.getAbsolutePath() );
             }
 
             File f = new File( directory, VALID_CACHE );
             f.delete();
             storeProperties( pluginCache, new File( directory, PLUGINS_CACHE ), "plugins cache" );
             storeProperties( goalCache, new File( directory, GOALS_CACHE ), "goals cache" );
             storeProperties( callbackCache, new File( directory, CALLBACKS_CACHE ), "callbacks cache" );
             storeProperties( dynaTagLibCache, new File( directory, DYNAMIC_TAGLIBS_CACHE ), "taglibs cache" );
             storeProperties( pluginDynaTagDepsCache, new File( directory, PLUGIN_DYNATAG_DEPS_CACHE ),
                              "plugin deps cache" );
             storeProperties( artifactIdCache, new File( directory, ARTIFACT_ID_CACHE ), "artifact ID to plugin mapping" );
             f.createNewFile();
             dirty = false;
         }
         finally
         {
             LOGGER.debug( "Unlocking " + lockFile );
             lockFile.delete();
         }
     }
 
     /**
      * Write the given properties to the given file in the unpacked dir
      * @param properties the properties object to store
      * @param header the header for the written properties
      * @throws FileNotFoundException when the unpacked plugin directory can't be found
      * @throws IOException if there is a problem storing properties
      */
     private void storeProperties( Properties properties, File file, String header )
         throws FileNotFoundException, IOException
     {
         FileOutputStream stream = new FileOutputStream( file );
         properties.store( stream, header );
         stream.close();
     }
 
     /**
      * @return a loaded properties file from disk or a new one if there are any problems
      * @param file the file within the unpacked plugins dir to load
      */
     private Properties loadProperties( File file )
         throws IOException
     {
         Properties properties = new Properties();
         FileInputStream stream = null;
         try
         {
             stream = new FileInputStream( file );
             properties.load( stream );
         }
         finally
         {
             if ( stream != null )
             {
                 try
                 {
                     stream.close();
                 }
                 catch ( IOException e )
                 {
                     // Nothing to do
                 }
             }
         }
         return properties;
     }
 
     /**
      *  Load on-disk cache information, if possible.
      */
     void loadCache( File directory )
     {
         File lockFile = new File( directory, LOCK_CACHE );
         checkLockFile( lockFile );
 
         File f = new File( directory, VALID_CACHE );
         if ( !f.exists() )
         {
             LOGGER.info( "Plugin cache will be regenerated" );
             return;
         }
         LOGGER.debug( "Loading plugin cache" );
         try
         {
             pluginCache = loadProperties( new File( directory, PLUGINS_CACHE ) );
             goalCache = loadProperties( new File( directory, GOALS_CACHE ) );
             callbackCache = loadProperties( new File( directory, CALLBACKS_CACHE ) );
             dynaTagLibCache = loadProperties( new File( directory, DYNAMIC_TAGLIBS_CACHE ) );
             pluginDynaTagDepsCache = loadProperties( new File( directory, PLUGIN_DYNATAG_DEPS_CACHE ) );
             artifactIdCache = loadProperties( new File( directory, ARTIFACT_ID_CACHE ) );
         }
         catch ( IOException e )
         {
             LOGGER.warn( "Clearing cache due to exception loading part of cache" );
             LOGGER.debug( "Exception", e );
             clearCache();
         }
         dirty = false;
     }
 
     /**
      * Manipulate a csv property string.
      *
      * @param properties
      * @param key
      * @param newEntry
      */
     private void appendCsvProperty( Properties properties, String key, String newEntry )
     {
         String csvProperty = properties.getProperty( key );
 
         if ( csvProperty == null )
         {
             properties.setProperty( key, newEntry );
         }
         else
         {
             StringTokenizer st = new StringTokenizer( csvProperty, "," );
 
             while ( st.hasMoreTokens() )
             {
                 if ( st.nextToken().equals( newEntry ) )
                 {
                     return;
                 }
             }
             // not already there so append and return
             properties.setProperty( key, csvProperty + ',' + newEntry );
         }
     }
 
     public void addPluginDynaTagDep( JellyScriptHousing housing, String uri )
     {
         appendCsvProperty( pluginDynaTagDepsCache, housing.getName(), uri );
         dirty = true;
     }
 
     public void removePluginDynaTagDep( JellyScriptHousing housing, String uri )
     {
         String prop = (String) pluginDynaTagDepsCache.get( housing.getName() );
         int tl = uri.length();
 
         if ( prop.indexOf( "," ) < 0 )
         {
             pluginDynaTagDepsCache.remove( housing.getName() );
         }
         else
         {
             int i = prop.indexOf( uri + "," );
             if ( i == 0 )
             {
                 // First
                 prop = prop.substring( tl + 1 );
             }
             else if ( i > 0 )
             {
                 // Middle
                 prop = prop.substring( 0, i ) + prop.substring( i + tl + 1 );
             }
             else
             {
                 // The last entry
                 prop = prop.substring( 0, prop.length() - tl - 1 );
             }
             if ( LOGGER.isDebugEnabled() )
             {
                 LOGGER.debug( "Caching Taglib Dependency --> " + prop );
             }
             pluginDynaTagDepsCache.put( housing.getName(), prop );
         }
         dirty = true;
     }
 
     void registerPlugin( String name, JellyScriptHousing housing )
         throws MavenException
     {
         artifactIdCache.put( name, housing.getProject().getArtifactId() );
     }
 
     public void addPostGoal( String name, JellyScriptHousing housing )
     {
         appendCsvProperty( callbackCache, name + ".post", housing.getName() );
         dirty = true;
     }
 
     public void addPreGoal( String name, JellyScriptHousing housing )
     {
         appendCsvProperty( callbackCache, name + ".pre", housing.getName() );
         dirty = true;
     }
 
     public void addGoal( String name, String prereqs, String description, JellyScriptHousing housing )
     {
         String goalProperty = description + ">";
 
         if ( prereqs != null )
         {
             goalProperty += StringUtils.deleteWhitespace( prereqs );
         }
 
         goalCache.setProperty( name, goalProperty );
         pluginCache.setProperty( name, housing.getName() );
         dirty = true;
     }
 
     public void addDynaTagLib( String tagLibUri, JellyScriptHousing housing )
     {
         dynaTagLibCache.setProperty( tagLibUri, housing.getName() );
         dirty = true;
     }
 
     /**
      * Invalidate cache information for a single plugin.
      *
      * @param pluginName The name of the plugin to invalid cache entries.
      */
     void invalidateCache( String pluginName )
     {
         LOGGER.debug( "Invalidating plugin " + pluginName );
         for ( Iterator i = dynaTagLibCache.keySet().iterator(); i.hasNext(); )
         {
             String uri = (String) i.next();
 
             if ( dynaTagLibCache.getProperty( uri ).equals( pluginName ) )
             {
                 sessionLog.debug( "removing dynataglib cache entry for uri " + uri );
                 i.remove();
             }
         }
         for ( Iterator i = callbackCache.keySet().iterator(); i.hasNext(); )
         {
             String callbackName = (String) i.next();
             String goalName = callbackName.endsWith( ".pre" ) ? callbackName.substring( 0, callbackName.length() - 4 )
                                                              : callbackName.substring( 0, callbackName.length() - 5 );
 
             // This may be null as you can define pre/postGoals on goals that don't (yet) exist
             String callbackPlugin = pluginCache.getProperty( goalName );
             String callbacks = callbackCache.getProperty( callbackName );
             if ( pluginName.equals( callbackPlugin ) )
             {
                 sessionLog
                     .debug( "removing callback cache entry for goal " + callbackName + " (goal in source plugin)" );
                 i.remove();
             }
             else if ( pluginName.equals( callbacks ) )
             {
                 sessionLog
                     .debug( "removing callback cache entry for goal " + callbackName + " (lone callback removed)" );
                 i.remove();
             }
             else
             {
                 StringTokenizer tok = new StringTokenizer( callbacks, "," );
                 StringBuffer newCallback = new StringBuffer();
                 boolean changed = false;
                 while ( tok.hasMoreTokens() )
                 {
                     String name = tok.nextToken();
                     if ( name.equals( pluginName ) )
                     {
                         changed = true;
                     }
                     else
                     {
                         if ( newCallback.length() > 0 )
                         {
                             newCallback.append( "," );
                         }
                         newCallback.append( name );
                     }
                 }
                 if ( changed )
                 {
                     callbacks = newCallback.toString();
                     sessionLog.debug( "removing callback cache value for goal " + callbackName
                         + " (other callbacks remain: " + callbacks + ")" );
                     callbackCache.setProperty( callbackName, callbacks );
                 }
             }
         }
         for ( Iterator i = goalCache.keySet().iterator(); i.hasNext(); )
         {
             String eachGoal = (String) i.next();
 
             if ( pluginCache.getProperty( eachGoal ).equals( pluginName ) )
             {
                 sessionLog.debug( "removing goal and plugin cache entry for goal " + eachGoal );
                 i.remove();
                 pluginCache.remove( eachGoal );
             }
         }
         if ( pluginDynaTagDepsCache.containsKey( pluginName ) )
         {
             sessionLog.debug( "removing dynatag dependency cache entry" );
             pluginDynaTagDepsCache.remove( pluginName );
         }
         if ( artifactIdCache.containsKey( pluginName ) )
         {
             sessionLog.debug( "removing artifactId cache entry" );
             artifactIdCache.remove( pluginName );
         }
 
         dirty = true;
     }
 
     private JellyScriptHousing loadHousing( String pluginName, PluginManager manager, Map pluginDirs, String desc )
         throws IOException
     {
         File dir = (File) pluginDirs.get( pluginName );
         if ( dir == null )
         {
             sessionLog.warn( "plugin " + pluginName + " is cached (" + desc + ") but no longer present" );
             return null;
         }
 
         JellyScriptHousing housing = manager.loadPluginHousing( pluginName, dir );
         if ( housing == null )
         {
             sessionLog.error( "plugin " + pluginName + " is cached (" + desc + ") but no longer valid" );
             return null;
         }
         return housing;
     }
 
     private void clearCache()
     {
         pluginCache.clear();
         callbackCache.clear();
         goalCache.clear();
         dynaTagLibCache.clear();
         pluginDynaTagDepsCache.clear();
         artifactIdCache.clear();
     }
 
     /**
      * @param mapper
      */
     boolean mapPlugins( GoalToJellyScriptHousingMapper mapper, PluginManager manager, Map pluginDirs )
         throws IOException
     {
         // Must invalidate bad ones first to keep iterators and cache consistent
         for ( Iterator i = pluginDynaTagDepsCache.keySet().iterator(); i.hasNext(); )
         {
             String pluginName = (String) i.next();
             JellyScriptHousing housing = loadHousing( pluginName, manager, pluginDirs, "dynatag dep" );
             if ( housing == null )
             {
                 clearCache();
                 return false;
             }
         }
         for ( Iterator i = pluginCache.keySet().iterator(); i.hasNext(); )
         {
             String goalName = (String) i.next();
             String pluginName = pluginCache.getProperty( goalName );
             JellyScriptHousing housing = loadHousing( pluginName, manager, pluginDirs, "goal" );
             if ( housing == null )
             {
                 clearCache();
                 return false;
             }
         }
         for ( Iterator i = artifactIdCache.keySet().iterator(); i.hasNext(); )
         {
             String pluginName = (String) i.next();
             JellyScriptHousing housing = loadHousing( pluginName, manager, pluginDirs, "artifactId" );
             if ( housing == null )
             {
                 clearCache();
                 return false;
             }
         }
 
         Map preGoals = new HashMap();
         Map postGoals = new HashMap();
         for ( Iterator i = callbackCache.keySet().iterator(); i.hasNext(); )
         {
             String callbackName = (String) i.next();
             boolean isPreGoal = callbackName.endsWith( ".pre" );
             String goalName = isPreGoal ? callbackName.substring( 0, callbackName.length() - 4 ) : callbackName
                 .substring( 0, callbackName.length() - 5 );
             String pluginNames = callbackCache.getProperty( callbackName );
             StringTokenizer tok = new StringTokenizer( pluginNames, "," );
             List housings = new ArrayList();
             if ( isPreGoal )
             {
                 preGoals.put( goalName, housings );
             }
             else
             {
                 postGoals.put( goalName, housings );
             }
             while ( tok.hasMoreTokens() )
             {
                 String pluginName = tok.nextToken();
                 JellyScriptHousing housing = loadHousing( pluginName, manager, pluginDirs, "callbacks" );
                 if ( housing != null )
                 {
                     housings.add( housing );
                 }
                 else
                 {
                     clearCache();
                     return false;
                 }
             }
         }
 
         for ( Iterator i = dynaTagLibCache.keySet().iterator(); i.hasNext(); )
         {
             String uri = (String) i.next();
             String pluginName = dynaTagLibCache.getProperty( uri );
             JellyScriptHousing housing = loadHousing( pluginName, manager, pluginDirs, "dynataglib" );
             if ( housing == null )
             {
                 clearCache();
                 return false;
             }
         }
 
         // Now map the clean set of plugins
         for ( Iterator i = preGoals.keySet().iterator(); i.hasNext(); )
         {
             String goalName = (String) i.next();
             List housings = (List) preGoals.get( goalName );
             for ( Iterator j = housings.iterator(); j.hasNext(); )
             {
                 JellyScriptHousing housing = (JellyScriptHousing) j.next();
                 mapper.addPreGoal( goalName, housing );
             }
         }
         for ( Iterator i = postGoals.keySet().iterator(); i.hasNext(); )
         {
             String goalName = (String) i.next();
             List housings = (List) postGoals.get( goalName );
             for ( Iterator j = housings.iterator(); j.hasNext(); )
             {
                 JellyScriptHousing housing = (JellyScriptHousing) j.next();
                 mapper.addPostGoal( goalName, housing );
             }
         }
 
         for ( Iterator i = pluginDynaTagDepsCache.keySet().iterator(); i.hasNext(); )
         {
             String pluginName = (String) i.next();
             JellyScriptHousing housing = manager.loadPluginHousing( pluginName, (File) pluginDirs.get( pluginName ) );
             String csv = pluginDynaTagDepsCache.getProperty( pluginName );
             StringTokenizer tok = new StringTokenizer( csv, "," );
             while ( tok.hasMoreTokens() )
             {
                 String uri = tok.nextToken();
                 mapper.addPluginDynaTagDep( housing, uri );
             }
         }
 
         for ( Iterator i = pluginCache.keySet().iterator(); i.hasNext(); )
         {
             String goalName = (String) i.next();
             String pluginName = pluginCache.getProperty( goalName );
             JellyScriptHousing housing = manager.loadPluginHousing( pluginName, (File) pluginDirs.get( pluginName ) );
             String goal = goalCache.getProperty( goalName );
             int index = goal.indexOf( ">" );
             String description = null;
             if ( index > 0 )
             {
                 description = goal.substring( 0, index );
             }
             String prereqs = goal.substring( index + 1 );
 
             mapper.addGoal( goalName, prereqs, description, housing );
         }
 
         for ( Iterator i = dynaTagLibCache.keySet().iterator(); i.hasNext(); )
         {
             String uri = (String) i.next();
             String pluginName = dynaTagLibCache.getProperty( uri );
             JellyScriptHousing housing = manager.loadPluginHousing( pluginName, (File) pluginDirs.get( pluginName ) );
             mapper.addDynaTagLib( uri, housing );
         }
 
         for ( Iterator i = artifactIdCache.keySet().iterator(); i.hasNext(); )
         {
             String pluginName = (String) i.next();
             JellyScriptHousing housing = manager.loadPluginHousing( pluginName, (File) pluginDirs.get( pluginName ) );
             manager.mapArtifactIdToPluginHousing( artifactIdCache.getProperty( pluginName ), housing );
         }
         return true;
     }
 
     /* (non-Javadoc)
      * @see org.apache.maven.plugin.PluginDefintionHandler#setDefaultGoalName(java.lang.String)
      */
     public void setDefaultGoalName( String defaultGoalName )
     {
         // this method intentionally left blank
     }
 
     /**
      * @return Properties
      */
     Properties getPluginCache()
     {
         return pluginCache;
     }
 
     /**
      * @return Properties
      */
     public Properties getGoalCache()
     {
         return goalCache;
     }
 
     /**
      * @return Returns the callbackCache.
      */
     Properties getCallbackCache()
     {
         return callbackCache;
     }
 
     /**
      * @return Returns the dynaTagLibCache.
      */
     Properties getDynaTagLibCache()
     {
         return dynaTagLibCache;
     }
 
     /**
      * @return Returns the pluginDynaTagDepsCache.
      */
     Properties getPluginDynaTagDepsCache()
     {
         return pluginDynaTagDepsCache;
     }
 
 }