/*
    * Copyright 2007 Joachim Grueneis
    *
    * 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.exolab.castor.xml.util.resolvers;
  
  import java.net.URL;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.castor.mapping.BindingType;
  import org.castor.mapping.MappingUnmarshaller;
  import org.exolab.castor.mapping.ClassDescriptor;
  import org.exolab.castor.mapping.Mapping;
  import org.exolab.castor.mapping.MappingException;
  import org.exolab.castor.mapping.MappingLoader;
  import org.exolab.castor.xml.ResolverException;
  import org.exolab.castor.xml.XMLConstants;
  
  /**
   * Tries to load the package mapping file for the given package.
   * <br/>
   * If the mapping file is available and could be loaded properly the
   * descriptors listed in it are added to the description class cache
   * of the configuration.
   * <br/>
   * To disable loading of pacakge mapping files just don't use this
   * command.
   * <br/>
   * If a mapping file is not available for the given package this method
   * will not load any descriptors and not throw any exceptions.<br/>
   * The class loader specified in the configuration is used.
   * <br/>
   * The mapping file - if available - is loaded using the
   * <code>MappingLoader</code>.<br/>
   * <br/>
   * Further calls to this command with the same package name will not be
   * processed.
   * 
   * @author <a href="mailto:jgrueneis AT gmail DOT com">Joachim Grueneis</a>
   * @author <a href="mailto:stevendolg AT gxm DOT at">Steven Dolg</a>
   * @version $Revision$ $Date$
   * @since 1.2
   */
  public class ByPackageMapping extends AbstractResolverPackageCommand {
  	private static final Log LOG = LogFactory.getLog(ByPackageMapping.class);
      
      private List<String> _loadedPackages = new ArrayList<String>();
  
      /**
       * No specific stuff needed.
       */
  	public ByPackageMapping() {
          super();
  	}
  
      /**
       * Loads a package mapping file for the given package name using the
       * provided ClassLoader.
       *
       * @param packageName The name of the package to load the mapping file for.
       * @return The loaded Mapping or <code>null</code> if no mapping file
       *         is available for the given package.
       * @throws MappingException
       */
      private Mapping loadMapping(final String packageName, final ClassLoader classLoader)
      throws MappingException {
          URL url = classLoader.getResource(ResolveHelpers.getQualifiedFileName(
                  XMLConstants.PKG_MAPPING_FILE, packageName));
          if (url == null) { return null; }
          try {
              Mapping mapping = new Mapping(classLoader);
              mapping.loadMapping(url);
              return mapping;
          } catch (java.io.IOException ioex) {
              throw new MappingException(ioex);
          }
      }
  
      /**
       * {@inheritDoc}
       */
      protected Map<String, ClassDescriptor> internalResolve(final String packageName, final ClassLoader classLoader,
              final Map properties) throws ResolverException {
         
         Map<String, ClassDescriptor> results = new HashMap<String, ClassDescriptor>();
         if (!isEmptyPackageName(packageName) && _loadedPackages.contains(packageName)) {
             if (LOG.isDebugEnabled()) {
                 LOG.debug("Package: " + packageName + " has already been loaded.");
             }
             return results;
         }
         
         if (!isEmptyPackageName(packageName)) {
             _loadedPackages.add(packageName);
         }
         try {
             final Mapping mapping = this.loadMapping(packageName, classLoader);
             if (mapping != null) {
                 MappingUnmarshaller unmarshaller = new MappingUnmarshaller();
                 // TODO: Joachim 2007-09-07 the InternalContext should be set into the unmarshaller!
                 MappingLoader mappingLoader = unmarshaller.getMappingLoader(mapping, BindingType.XML);
                 for (ClassDescriptor classDescriptor : mappingLoader.getDescriptors()) {
                     if (LOG.isDebugEnabled()) {
                         LOG.debug("Found descriptor: " + classDescriptor);
                     }
                     results.put(classDescriptor.getJavaClass().getName(), classDescriptor);
                 }
             }
         } catch (MappingException e) {
             if (LOG.isDebugEnabled()) {
                 LOG.debug("Ignored exception: " + e + " while loading mapping for package: "
                         + packageName);
             }
         }
         return results;
     }
 }