/*

  *  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;

     }

 }