/**
 *    Copyright 2011 meltmedia
 *
 *    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 org.xchain.framework.scanner;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.WeakHashMap;
import java.net.URL;

import org.xchain.framework.lifecycle.LifecycleClass;
import org.xchain.framework.lifecycle.LifecycleAccessor;
import org.apache.commons.collections.map.LRUMap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * The lifecycle scanner provides utilities for scanning the class loader of an xcahins application.
 *
 * @author Christian Trimble
 * @author Josh Kennedy
 * @author John Trimble
 */
@LifecycleClass(uri="http://www.xchain.org/scanner")
public class ScannerLifecycle
{
  /*
   * Flag to turn on/off memoization of ScannerLifecycle.scanNode().
   */
  private static final boolean MEMOIZE_SCAN_NODE = true;
  private static Logger log = LoggerFactory.getLogger(ScannerLifecycle.class);

  private static ScannerLifecycle instance = new ScannerLifecycle();
  private Map<ClassLoader, Map<RootUrlLocator, ScanNode>> cache;
  

  @LifecycleAccessor
  public static ScannerLifecycle getInstance()
  {
    return instance;
  }

  private Map<String, ProtocolScanner> protocolMap = new HashMap<String, ProtocolScanner>();

  public ScannerLifecycle()
  {
    protocolMap.put("file", new FileProtocolScanner());
    protocolMap.put("jar", new JarProtocolScanner());

    // define the vfszip, vfsfile, and vfsmemory protocols if the jboss virtual file system classes are on the classpath.
    if( isVfsDefined() ) {
      protocolMap.put("vfszip", new VfsProtocolScanner());
      protocolMap.put("vfsfile", new VfsProtocolScanner());
      protocolMap.put("vfsmemory", new VfsProtocolScanner());
    }
    if( isZipDefined() ) {
      protocolMap.put("zip", new ZipProtocolScanner());
    }
    if( isBundleDefined() ) {
      protocolMap.put("bundle", new BundleProtocolScanner());
      protocolMap.put("bundleresource", new BundleProtocolScanner());
    }
    
    if( MEMOIZE_SCAN_NODE ) {
      cache = Collections.synchronizedMap(new WeakHashMap<ClassLoader, Map<RootUrlLocator,ScanNode>>());
    }
  }

  /**
   * Returns the root scan node.  Using this node, all of the nodes on the
   * classpath can be visited.
   */
  public ScanNode scanNode()
    throws Exception
  {
    return scanNode( Thread.currentThread().getContextClassLoader(), new MarkerResourceLocator("META-INF/xchain.xml") );
  }

  /**
   * <p>Scans the root urls found by the locator and returns the root scan node for those roots.</p>
   */
  public ScanNode scanNode( RootUrlLocator locator )
    throws Exception
  {
    return scanNode( Thread.currentThread().getContextClassLoader(), locator );
  }

  public ScanNode scanNode( ClassLoader classLoader, RootUrlLocator locator )
    throws Exception
  {
    if( MEMOIZE_SCAN_NODE ) {
      ScanNode cachedScanNode = getCached(classLoader, locator);
      if( cachedScanNode != null ) {
        log.debug("Using cached ScanNode instance '{}' for ClassLoader '{}' and RootUrlLocator '{}'.", new Object[] {cachedScanNode, classLoader, locator});
        return cachedScanNode;
      }
    }
    
    ScanNode rootScanNode = new ScanNode();
    Set<URL> roots = locator.findRoots(Thread.currentThread().getContextClassLoader());

    for( URL root : roots ) {
      // find the protocol scanner for this root url.
      String protocol = root.getProtocol();
      ProtocolScanner scanner = protocolMap.get(protocol);
      if( scanner == null ) {
        if( log.isDebugEnabled() ) {
          log.debug("Could not scan protocol "+protocol+" of url "+root+", because a scanner for this protocol is not defined.");
        }
        continue;
      }
      scanner.scan(rootScanNode, root);
    }
    
    if( MEMOIZE_SCAN_NODE ) {
      putCached(classLoader, locator, rootScanNode);
    }
    return rootScanNode;
  }
  
  /**
   * Clears internal cache of ScanNode instances.
   */
  public void clearCache() {
    if( MEMOIZE_SCAN_NODE )
      this.cache.clear();
  }
  
  /*
   * Returns the cached ScanNode instance mapped by the (classLoader, locator) tuple.
   */
  private ScanNode getCached( ClassLoader classLoader, RootUrlLocator locator ) {
    Map<RootUrlLocator, ScanNode> locatorScanNodeMap = cache.get(classLoader);
    if( locatorScanNodeMap != null )
      return locatorScanNodeMap.get(locator);
    return null;
  }
  
  /*
   * Maps a (ClassLoader,RootUrlLocator) tuple to a ScanNode instance to cache.
   */
  private void putCached( ClassLoader classLoader, RootUrlLocator locator, ScanNode scanNode ) {
    Map<RootUrlLocator, ScanNode> locatorScanNodeMap = this.cache.get(classLoader);
    if( locatorScanNodeMap == null ) {
      locatorScanNodeMap = Collections.synchronizedMap(new LRUMap(20));
      this.cache.put(classLoader, locatorScanNodeMap);
    }
    locatorScanNodeMap.put(locator, scanNode);
  }

  private boolean isVfsDefined() {
    try {
      Thread.currentThread().getContextClassLoader().loadClass("org.jboss.virtual.VirtualFile");
      // ASSERT: the virtual file class loaded, so we are on jboss 5.
      return true;
    }
    catch( Exception e ) {
      return false;
    }
  }

  private boolean isZipDefined() {
    try {
      Thread.currentThread().getContextClassLoader().loadClass("weblogic.utils.zip.ZipURLConnection");
      return true;
    }
    catch( Exception e ) {
      return false;
    }
  }

  private boolean isBundleDefined() {
    try {
      Thread.currentThread().getContextClassLoader().loadClass("org.osgi.framework.Bundle");
      return true;
    }
    catch( Exception e ) {
      return false;
    }
  }
}