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