/*
    *  Copyright 2007 Tacos.
    * 
    *  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.
   *  under the License.
   */
  package net.sf.tacos.resolvers;
  
  import org.apache.commons.logging.Log;
  import org.apache.hivemind.ApplicationRuntimeException;
  import org.apache.hivemind.Location;
  import org.apache.hivemind.Resource;
  import org.apache.hivemind.impl.DefaultClassResolver;
  import org.apache.hivemind.impl.LocationImpl;
  import org.apache.hivemind.util.ClasspathResource;
  import org.apache.hivemind.util.Defense;
  import org.apache.tapestry.INamespace;
  import org.apache.tapestry.IRequestCycle;
  import org.apache.tapestry.resolver.AbstractSpecificationResolver;
  import org.apache.tapestry.resolver.ComponentSpecificationResolver;
  import org.apache.tapestry.services.ClassFinder;
  import org.apache.tapestry.spec.ComponentSpecification;
  import org.apache.tapestry.spec.IComponentSpecification;
  
  /**
   * An AbstractSpecificationResolver similar to tapestry's. Contains additional 
   * logic that can loads tapestry templates from the classpath.
   * 
   * @author Howard Lewis Ship
   * @author Andreas Andreou, amplafi.com
   */
  
  public class ClasspathComponentSpecResolver extends
          AbstractSpecificationResolver implements ComponentSpecificationResolver {
  
      /** Set by container. */
      private Log log;
  
      /** Set by resolve(). */
      private String type;
  
      private ClassFinder classFinder;
  
      protected void reset() {
          type = null;
          super.reset();
      }
  
      /**
       * Passed the namespace of a container (to resolve the type in) and the type
       * to resolve, performs the processing. A "bare type" (without a library
       * prefix) may be in the containerNamespace, or the framework namespace (a
       * search occurs in that order).
       * 
       * @param cycle
       *            current request cycle
       * @param containerNamespace
       *            namespace that may contain a library referenced in the type
       * @param componentType
       *            the component specification to find, either a simple name, or
       *            prefixed with a library id (defined for the container
       *            namespace)
       * @see #getNamespace()
       * @see #getSpecification()
       */
  
      public void resolve(IRequestCycle cycle, INamespace containerNamespace,
              String componentType, Location location) {
          Defense.notNull(componentType, "type");
  
          int colonx = componentType.indexOf(':');
  
          if (colonx > 0) {
              String libraryId = componentType.substring(0, colonx);
              String simpleType = componentType.substring(colonx + 1);
  
              resolve(cycle, containerNamespace, libraryId, simpleType, location);
          } else {
              resolve(cycle, containerNamespace, null, componentType, location);
          }
      }
  
      /**
       * Like #resolve(org.apache.tapestry.IRequestCycle,
       * org.apache.tapestry.INamespace, java.lang.String,
       * org.apache.tapestry.ILocation), but used when the type has already been
       * parsed into a library id and a simple type.
       * 
       * @param cycle
      *            current request cycle
      * @param containerNamespace
      *            namespace that may contain a library referenced in the type
      * @param libraryId
      *            the library id within the container namespace, or null
      * @param componentType
      *            the component specification to find as a simple name (without
      *            a library prefix)
      * @param location
      *            of reference to be resolved
      * @throws ApplicationRuntimeException
      *             if the type cannot be resolved
      */
 
     public void resolve(IRequestCycle cycle, INamespace containerNamespace,
             String libraryId, String componentType, Location location) {
         reset();
         this.type = componentType;
 
         INamespace namespace = findNamespaceForId(containerNamespace, libraryId);
 
         setNamespace(namespace);
 
         if (namespace.containsComponentType(type)) {
             setSpecification(namespace.getComponentSpecification(type));
             return;
         }
 
         IComponentSpecification spec = searchForComponent(cycle);
 
         // If not found after search, check to see if it's in
         // the framework instead.
         if (spec == null) {
             spec = doCustomSearch(cycle);
         }
 
         if (spec == null) {
             throw new ApplicationRuntimeException("no Such Component Type:" + this.type,
                     location, null);
         }
 
         setSpecification(spec);
 
         // Install it into the namespace, to short-circuit any future search.
         install();
     }
 
     /**
      * Override to add custom behavior to component resolution - will be the last
      * resolve logic to be executed.
      * @param cycle
      * @return
      */
     protected IComponentSpecification doCustomSearch(IRequestCycle cycle) {
         return null;
     }
 
     private IComponentSpecification searchForComponent(IRequestCycle cycle) {
         INamespace namespace = getNamespace();
 
         // if (_log.isDebugEnabled())
         // _log.debug(ImplMessages.resolvingComponent(_type, namespace));
 
         String expectedName = type + ".jwc";
         Resource namespaceLocation = namespace.getSpecificationLocation();
 
         // Look for appropriate file in same folder as the library (or
         // application) specification.
 
         IComponentSpecification result = check(namespaceLocation.getRelativeResource(expectedName));
 
         if (result != null) {
             return result;
         }
         if (namespace.isApplicationNamespace()) {
 
             // The application namespace gets some extra searching.
 
             result = check(getWebInfAppLocation().getRelativeResource(
                     expectedName));
 
             if (result == null) {
                 result = check(getWebInfLocation().getRelativeResource(
                         expectedName));
             }
             if (result == null) {
                 result = check(getContextRoot()
                         .getRelativeResource(expectedName));
             }
             if (result != null) {
                 return result;
             }
         }
 
         result = searchForComponentClass(namespace, type);
 
         if (result != null) {
             return result;
         }
 
         // Not in the library or app spec; does it match a component
         // provided by the Framework?
 
         INamespace framework = getSpecificationSource().getFrameworkNamespace();
 
         if (framework.containsComponentType(type)) {
             return framework.getComponentSpecification(type);
         }
         return getDelegate()
                 .findComponentSpecification(cycle, namespace, type);
     }
 
     IComponentSpecification searchForComponentClass(INamespace namespace,
             String componentType) {
         String packages = namespace
                 .getPropertyValue("org.apache.tapestry.component-class-packages");
 
         String className = componentType.replace('/', '.');
 
         Class componentClass = classFinder.findClass(packages, className);
 
         if (componentClass == null) {
             return null;
         }
         Resource componentResource = null;
         Resource namespaceResource = namespace.getSpecificationLocation();
 
         String fullPath = componentClass.getName().replace('.', '/');
         ClasspathResource html = new ClasspathResource(
                 new DefaultClassResolver(), fullPath + ".html");
 
         // first check near the class, if the html is there then that's where
         // the (fictional) jwc should be - need exploded wars for this
 
         if (html.getResourceURL() != null && namespace.isApplicationNamespace()) {
             componentResource = new ClasspathResource(
                     new DefaultClassResolver(), fullPath + ".jwc");
         } else {
             componentResource = namespaceResource.getRelativeResource(componentType
                     + ".jwc");
         }
 
         Location location = new LocationImpl(componentResource);
 
         IComponentSpecification spec = new ComponentSpecification();
         spec.setLocation(location);
         spec.setSpecificationLocation(componentResource);
         spec.setComponentClassName(componentClass.getName());
 
         return spec;
     }
 
     private IComponentSpecification check(Resource resource) {
         if (log.isDebugEnabled()) {
             log.debug("Checking: " + resource);
         }
         if (resource.getResourceURL() == null) {
             return null;
         }
         return getSpecificationSource().getComponentSpecification(resource);
     }
 
     private void install() {
         INamespace namespace = getNamespace();
         IComponentSpecification specification = getSpecification();
 
         // if (_log.isDebugEnabled())
         // _log.debug(ImplMessages.installingComponent(_type, namespace,
         // specification));
 
         namespace.installComponentSpecification(type, specification);
     }
 
     public String getType() {
         return type;
     }
 
     public void setLog(Log log) {
         this.log = log;
     }
 
     public void setClassFinder(ClassFinder classFinder) {
         this.classFinder = classFinder;
     }
 
 }