/*
    * Copyright 2005 Ralf Joachim
    *
    * 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.castor.mapping;
  
  import java.io.IOException;
  import java.util.Enumeration;
  import java.util.Iterator;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.castor.core.CoreProperties;
  import org.castor.core.util.Messages;
  import org.castor.xml.AbstractInternalContext;
  import org.castor.xml.InternalContext;
  import org.exolab.castor.mapping.Mapping;
  import org.exolab.castor.mapping.MappingException;
  import org.exolab.castor.mapping.MappingLoader;
  import org.exolab.castor.mapping.loader.AbstractMappingLoader;
  import org.exolab.castor.mapping.xml.ClassMapping;
  import org.exolab.castor.mapping.xml.FieldHandlerDef;
  import org.exolab.castor.mapping.xml.Include;
  import org.exolab.castor.mapping.xml.KeyGeneratorDef;
  import org.exolab.castor.mapping.xml.MappingRoot;
  import org.exolab.castor.util.DTDResolver;
  import org.exolab.castor.xml.ClassDescriptorResolverFactory;
  import org.exolab.castor.xml.Introspector;
  import org.exolab.castor.xml.Unmarshaller;
  import org.exolab.castor.xml.XMLClassDescriptorResolver;
  import org.exolab.castor.xml.util.ResolverStrategy;
  import org.exolab.castor.xml.util.resolvers.CastorXMLStrategy;
  import org.xml.sax.InputSource;
  import org.xml.sax.SAXException;
  
  /**
   * @author <a href="mailto:ralf DOT joachim AT syscon DOT eu">Ralf Joachim</a>
   * @version $Revision: 5951 $ $Date: 2006-04-25 16:09:10 -0600 (Tue, 25 Apr 2006) $
   */
  public final class MappingUnmarshaller {
      //--------------------------------------------------------------------------
  
      /** The <a href="http://jakarta.apache.org/commons/logging/">Jakarta Commons
       *  Logging </a> instance used for all logging. */
      private static final Log LOG = LogFactory.getLog(MappingUnmarshaller.class);
      
      /** The registry of MappingLoader's. */
      private final MappingLoaderRegistry _registry;
      
      /** The IDResolver to give to the Unmarshaller. This allows resolving "extends" and
       *  "depends" for included Mappings. */
      private final MappingUnmarshallIDResolver _idResolver;
  
      /** A flag that indicates of whether or not to allow redefinitions of class
       *  mappings. */
      private boolean _allowRedefinitions = false;
  
      /**
       * The {@link AbstractInternalContext}?holds all 'global' Castor states and access to
       * configuration.
       */
      private InternalContext _internalContext;
      
      //--------------------------------------------------------------------------
  
      /**
       * Construct a new MappingUnmarshaller.
       */
      public MappingUnmarshaller() {
          _registry = new MappingLoaderRegistry(new CoreProperties());
          _idResolver = new MappingUnmarshallIDResolver();
          AbstractInternalContext internalContext = new AbstractInternalContext() { };
          internalContext.setClassLoader(getClass().getClassLoader());
          
          XMLClassDescriptorResolver cdr = (XMLClassDescriptorResolver) ClassDescriptorResolverFactory
              .createClassDescriptorResolver(BindingType.XML);
          cdr.setInternalContext(internalContext);
          internalContext.setXMLClassDescriptorResolver(cdr);
  
          Introspector introspector = new Introspector();
          introspector.setInternalContext(internalContext);
          internalContext.setIntrospector(introspector);
          cdr.setIntrospector(introspector);
          
          ResolverStrategy resolverStrategy = new CastorXMLStrategy();
          internalContext.setResolverStrategy(resolverStrategy);
          cdr.setResolverStrategy(resolverStrategy);
  
         _internalContext = internalContext;
     }
     
     /**
      * Enables or disables the ability to allow the redefinition
      * of class mappings.
      * 
      * @param allow a boolean that when true enables redefinitions.
     **/
     public void setAllowRedefinitions(final boolean allow) {
         _allowRedefinitions = allow;
     }
 
     //--------------------------------------------------------------------------
 
     /**
      * Returns a mapping resolver for the suitable engine. The engine's
      * specific mapping loader is created and used to create engine
      * specific descriptors, returning a suitable mapping resolver.
      * The mapping resolver is cached in memory and returned in
      * subsequent method calls.
      *
      * @param mapping The mapping to load and resolve.
      * @param bindingType The binding type to read from mapping.
      * @return A mapping resolver.
      * @throws MappingException A mapping error occured preventing
      *         descriptors from being generated from the loaded mapping.
      */
     public MappingLoader getMappingLoader(final Mapping mapping,
                                           final BindingType bindingType)
     throws MappingException {
         return getMappingLoader(mapping, bindingType, null);
     }
 
     /**
      * Returns a mapping resolver for the suitable engine. The engine's
      * specific mapping loader is created and used to create engine
      * specific descriptors, returning a suitable mapping resolver.
      * The mapping resolver is cached in memory and returned in
      * subsequent method calls.
      *
      * @param mapping The mapping to load and resolve.
      * @param bindingType The binding type to read from mapping.
      * @param param Arbitrary parameter that is to be passed to resolver.loadMapping().
      * @return A mapping resolver
      * @throws MappingException A mapping error occured preventing
      *         descriptors from being generated from the loaded mapping.
      */
     public MappingLoader getMappingLoader(final Mapping mapping,
                                           final BindingType bindingType,
                                           final Object param)
     throws MappingException {
         synchronized (this) {
             Iterator iter = mapping.getMappingSources().iterator();
             while (iter.hasNext()) {
                 MappingSource source = (MappingSource) iter.next();
                 loadMappingInternal(mapping, source.getResolver(), source.getSource());
             }
 
             AbstractMappingLoader loader;
             loader = (AbstractMappingLoader) _registry.getMappingLoader(
                     "CastorXmlMapping", bindingType);
             loader.setClassLoader(mapping.getClassLoader());
             loader.setAllowRedefinitions(_allowRedefinitions);
             loader.setInternalContext(_internalContext);
             loader.loadMapping(mapping.getRoot(), param);
             return loader;
         }
     }
 
     public void loadMappingOnly(final Mapping mapping)
     throws MappingException {
         synchronized (this) {
             Iterator iter = mapping.getMappingSources().iterator();
             while (iter.hasNext()) {
                 MappingSource source = (MappingSource) iter.next();
                 loadMappingInternal(mapping, source.getResolver(), source.getSource());
             }
         }
     }
 
     //--------------------------------------------------------------------------
 
     /**
      * Internal recursive loading method. This method will load the
      * mapping document into a mapping object and load all the included
      * mapping along the way into a single collection.
      *
      * @param mapping The mapping instance.
      * @param resolver The entity resolver to use.
      * @param url The URL of the mapping file.
      * @throws IOException An error occured when reading the mapping file.
      * @throws MappingException The mapping file is invalid.
      */
     protected void loadMappingInternal(final Mapping mapping, final DTDResolver resolver,
                                        final String url)
     throws IOException, MappingException {
         try {
             InputSource source = resolver.resolveEntity(null, url);
             if (source == null) { source = new InputSource(url); }
             if (source.getSystemId() == null) { source.setSystemId(url); }
             LOG.info(Messages.format("mapping.loadingFrom", url));
             loadMappingInternal(mapping, resolver, source);
         } catch (SAXException ex) {
             throw new MappingException(ex);
         }
     }
 
     /**
      * Internal recursive loading method. This method will load the
      * mapping document into a mapping object and load all the included
      * mapping along the way into a single collection.
      *
      * @param mapping The mapping instance.
      * @param resolver The entity resolver to use. May be null.
      * @param source The input source.
      * @throws MappingException The mapping file is invalid.
      */
     private void loadMappingInternal(final Mapping mapping, final DTDResolver resolver,
                                      final InputSource source)
     throws MappingException {
         // Clear all the cached resolvers, so they can be reconstructed a
         // second time based on the new mappings loaded
         _registry.clear();
         
         Object id = source.getSystemId();
         if (id == null) { id = source.getByteStream(); }
         if (id != null) {
             //check that the mapping has already been processed
             if (mapping.processed(id)) { return; }
 
             //mark the mapping as being processed
             mapping.markAsProcessed(id);
         }
         
         MappingRoot root = mapping.getRoot();
         _idResolver.setMapping(root);
 
         try {
             // Load the specificed mapping source
             Unmarshaller unm = new Unmarshaller(MappingRoot.class);
             unm.setValidation(false);
             unm.setEntityResolver(resolver);
             unm.setClassLoader(Mapping.class.getClassLoader());
             unm.setIDResolver(_idResolver);
             unm.setUnmarshalListener(
                     new MappingUnmarshallListener(this, mapping, resolver));
 
             MappingRoot loaded = (MappingRoot) unm.unmarshal(source);
                 
             // Load all the included mapping by reference
             //-- note: this is just for processing any
             //-- includes which may have previously failed
             //-- using the IncludeListener...and to
             //-- report any potential errors.
             Enumeration includes = loaded.enumerateInclude();
             while (includes.hasMoreElements()) {
                 Include include = (Include) includes.nextElement();
                 if (!mapping.processed(include.getHref())) {
                     try {
                         loadMappingInternal(mapping, resolver, include.getHref());
                     } catch (Exception ex) {
                         throw new MappingException(ex);
                     }
                 }
             }
             
             // gather "class" tags
             Enumeration<? extends ClassMapping> classMappings = loaded.enumerateClassMapping();
             while (classMappings.hasMoreElements()) {
                 root.addClassMapping(classMappings.nextElement());
             }
 
             // gather "key-generator" tags
             Enumeration<? extends KeyGeneratorDef> keyGeneratorDefinitions = loaded.enumerateKeyGeneratorDef();
             while (keyGeneratorDefinitions.hasMoreElements()) {
                 root.addKeyGeneratorDef(keyGeneratorDefinitions.nextElement());
             }
             
             // gather "field-handler" tags
             Enumeration<? extends FieldHandlerDef> fieldHandlerDefinitions = loaded.enumerateFieldHandlerDef();
             while (fieldHandlerDefinitions.hasMoreElements()) {
                 root.addFieldHandlerDef(fieldHandlerDefinitions.nextElement());
             }
         } catch (Exception ex) {
             throw new MappingException(ex);
         }
     }
 
     /**
      * To set the internal context.
      * @param internalContext the {@link AbstractInternalContext}?to use
      */
 //    public void setInternalContext(final InternalContext internalContext) {
 //        _internalContext = internalContext;
 //    }
 
     //--------------------------------------------------------------------------
 }