/**

  * Copyright 2005-2013 Dozer Project

  *

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

 import org.dozer.cache.CacheManager;

 import org.dozer.cache.DozerCacheManager;

 import org.dozer.cache.DozerCacheType;

 import org.dozer.classmap.ClassMappings;

 import org.dozer.classmap.Configuration;

 import org.dozer.classmap.MappingFileData;

 import org.dozer.config.GlobalSettings;

 import org.dozer.event.DozerEventManager;

 import org.dozer.factory.DestBeanCreator;

 import org.dozer.loader.CustomMappingsLoader;

 import org.dozer.loader.LoadMappingsResult;

 import org.dozer.loader.api.BeanMappingBuilder;

 import org.dozer.loader.xml.MappingFileReader;

 import org.dozer.loader.xml.MappingStreamReader;

 import org.dozer.loader.xml.XMLParserFactory;

 import org.dozer.metadata.DozerMappingMetadata;

 import org.dozer.metadata.MappingMetadata;

 import org.dozer.stats.GlobalStatistics;

 import org.dozer.stats.StatisticType;

 import org.dozer.stats.StatisticsInterceptor;

 import org.dozer.stats.StatisticsManager;

 import org.dozer.util.MappingValidator;

 import org.slf4j.Logger;

 import org.slf4j.LoggerFactory;

 import java.io.InputStream;

 import java.lang.reflect.Proxy;

 import java.net.URL;

 import java.util.*;

 import java.util.concurrent.CountDownLatch;

 import java.util.concurrent.atomic.AtomicBoolean;

 /**

  * Public Dozer Mapper implementation. This should be used/defined as a singleton within your application. This class

  * performs several one-time initializations and loads the custom xml mappings, so you will not want to create many

  * instances of it for performance reasons. Typically a system will only have one DozerBeanMapper instance per VM. If

  * you are using an IOC framework (i.e Spring), define the Mapper as singleton="true". If you are not using an IOC

  * framework, a DozerBeanMapperSingletonWrapper convenience class has been provided in the Dozer jar.

  * <p/>

  * It is technically possible to have multiple DozerBeanMapper instances initialized, but it will hinder internal

  * performance optimizations such as caching.

  *

  * @author tierney.matt

  * @author garsombke.franz

  * @author dmitry.buzdin

  * @author suwarnaratana.arm

  */

 public class DozerBeanMapper implements Mapper {

   private final Logger log = LoggerFactory.getLogger(DozerBeanMapper.class);

   private final StatisticsManager statsMgr = GlobalStatistics.getInstance().getStatsMgr();

   private final AtomicBoolean initializing = new AtomicBoolean(false);

   private final CountDownLatch ready = new CountDownLatch(1);

   /*

    * Accessible for custom injection

    */

   private final List<String> mappingFiles = new ArrayList<String>();

   private final List<CustomConverter> customConverters = new ArrayList<CustomConverter>();

   private final List<MappingFileData> builderMappings = new ArrayList<MappingFileData>();

   private final List<DozerEventListener> eventListeners = new ArrayList<DozerEventListener>();

   private final Map<String, CustomConverter> customConvertersWithId = new HashMap<String, CustomConverter>();

   private CustomFieldMapper customFieldMapper;

   /*

    * Not accessible for injection

    */

   private ClassMappings customMappings;

   private Configuration globalConfiguration;

   // There are no global caches. Caches are per bean mapper instance

   private final CacheManager cacheManager = new DozerCacheManager();

   private DozerEventManager eventManager;

   public DozerBeanMapper() {

     this(Collections.<String>emptyList());

   }

   public DozerBeanMapper(List<String> mappingFiles) {

     this.mappingFiles.addAll(mappingFiles);

     init();

   }

   /**

    * {@inheritDoc}

    */

   public void map(Object source, Object destination, String mapId) throws MappingException {

     getMappingProcessor().map(source, destination, mapId);

   }

   /**

    * {@inheritDoc}

    */

   public <T> T map(Object source, Class<T> destinationClass, String mapId) throws MappingException {

     return getMappingProcessor().map(source, destinationClass, mapId);

   }

   /**

    * {@inheritDoc}

    */

   public <T> T map(Object source, Class<T> destinationClass) throws MappingException {

     return getMappingProcessor().map(source, destinationClass);

   }

   /**

    * {@inheritDoc}

    */

   public void map(Object source, Object destination) throws MappingException {

     getMappingProcessor().map(source, destination);

   }

   /**

    * Returns list of provided mapping file URLs

    *

    * @return unmodifiable list of mapping files

    */

   public List<String> getMappingFiles() {

     return Collections.unmodifiableList(mappingFiles);

   }

   /**

    * Sets list of URLs for custom XML mapping files, which are loaded when mapper gets initialized.

    * It is possible to load files from file system via file: prefix. If no prefix is given mapping files are

    * loaded from classpath and can be packaged along with the application.

    *

    * @param mappingFileUrls URLs referencing custom mapping files

    * @see java.net.URL

    */

   public void setMappingFiles(List<String> mappingFileUrls) {

     checkIfInitialized();

     this.mappingFiles.clear();

     this.mappingFiles.addAll(mappingFileUrls);

   }

   public void setFactories(Map<String, BeanFactory> factories) {

     checkIfInitialized();

     DestBeanCreator.setStoredFactories(factories);

   }

   public void setCustomConverters(List<CustomConverter> customConverters) {

     checkIfInitialized();

     this.customConverters.clear();

     this.customConverters.addAll(customConverters);

   }

   public List<CustomConverter> getCustomConverters() {

     return Collections.unmodifiableList(customConverters);

   }

   public Map<String, CustomConverter> getCustomConvertersWithId() {

     return Collections.unmodifiableMap(customConvertersWithId);

   }

   private void init() {

     DozerInitializer.getInstance().init();

     log.info("Initializing a new instance of dozer bean mapper.");

     // initialize any bean mapper caches. These caches are only visible to the bean mapper instance and

     // are not shared across the VM.

     GlobalSettings globalSettings = GlobalSettings.getInstance();

     cacheManager.addCache(DozerCacheType.CONVERTER_BY_DEST_TYPE.name(), globalSettings.getConverterByDestTypeCacheMaxSize());

     cacheManager.addCache(DozerCacheType.SUPER_TYPE_CHECK.name(), globalSettings.getSuperTypesCacheMaxSize());

     // stats

     statsMgr.increment(StatisticType.MAPPER_INSTANCES_COUNT);

   }

   public void destroy() {

     DozerInitializer.getInstance().destroy();

   }

   protected Mapper getMappingProcessor() {

     initMappings();

     Mapper processor = new MappingProcessor(customMappings, globalConfiguration, cacheManager, statsMgr, customConverters,

             eventManager, getCustomFieldMapper(), customConvertersWithId);

     // If statistics are enabled, then Proxy the processor with a statistics interceptor

     if (statsMgr.isStatisticsEnabled()) {

       processor = (Mapper) Proxy.newProxyInstance(processor.getClass().getClassLoader(),

               processor.getClass().getInterfaces(),

               new StatisticsInterceptor(processor, statsMgr));

     }

     return processor;

   }

   void loadCustomMappings() {

     CustomMappingsLoader customMappingsLoader = new CustomMappingsLoader();

     List<MappingFileData> xmlMappings = loadFromFiles(mappingFiles);

     ArrayList<MappingFileData> allMappings = new ArrayList<MappingFileData>();

     allMappings.addAll(xmlMappings);

     allMappings.addAll(builderMappings);

     LoadMappingsResult loadMappingsResult = customMappingsLoader.load(allMappings);

     this.customMappings = loadMappingsResult.getCustomMappings();

     this.globalConfiguration = loadMappingsResult.getGlobalConfiguration();

   }

   private List<MappingFileData> loadFromFiles(List<String> mappingFiles) {

     MappingFileReader mappingFileReader = new MappingFileReader(XMLParserFactory.getInstance());

     List<MappingFileData> mappingFileDataList = new ArrayList<MappingFileData>();

     if (mappingFiles != null && mappingFiles.size() > 0) {

       log.info("Using the following xml files to load custom mappings for the bean mapper instance: {}", mappingFiles);

       for (String mappingFileName : mappingFiles) {

         log.info("Trying to find xml mapping file: {}", mappingFileName);

         URL url = MappingValidator.validateURL(mappingFileName);

         log.info("Using URL [" + url + "] to load custom xml mappings");

         MappingFileData mappingFileData = mappingFileReader.read(url);

         log.info("Successfully loaded custom xml mappings from URL: [{}]", url);

         mappingFileDataList.add(mappingFileData);

       }

     }

     return mappingFileDataList;

   }

   /**

    * Add mapping XML from InputStream resources for mapping not stored in

    * files (e.g. from database.) The InputStream will be read immediately to

    * internally create MappingFileData objects so that the InputStreams may be

    * closed after the call to this method.

    *

          * @param xmlStream Dozer mapping XML InputStream

          */

         public void addMapping(InputStream xmlStream) {

     checkIfInitialized();

     MappingStreamReader fileReader = new MappingStreamReader(XMLParserFactory.getInstance());

     MappingFileData mappingFileData = fileReader.read(xmlStream);

     builderMappings.add(mappingFileData);

   }

   /**

    * Adds API mapping to given mapper instance.

    *

    * @param mappingBuilder mappings to be added

    */

   public void addMapping(BeanMappingBuilder mappingBuilder) {

     checkIfInitialized();

     MappingFileData mappingFileData = mappingBuilder.build();

     builderMappings.add(mappingFileData);

   }

   public List<? extends DozerEventListener> getEventListeners() {

     return Collections.unmodifiableList(eventListeners);

   }

   public void setEventListeners(List<? extends DozerEventListener> eventListeners) {

     checkIfInitialized();

     this.eventListeners.clear();

     this.eventListeners.addAll(eventListeners);

   }

   public CustomFieldMapper getCustomFieldMapper() {

     return customFieldMapper;

   }

   public void setCustomFieldMapper(CustomFieldMapper customFieldMapper) {

     checkIfInitialized();

     this.customFieldMapper = customFieldMapper;

   }

   /**

    * The {@link org.dozer.metadata.MappingMetadata} interface can be used to query information about the current

    * mapping definitions. It provides read only access to all important classes and field

    * mapping properties. When first called, initializes all mappings if map() has not yet been called.

    *

    * @return An instance of {@line org.dozer.metadata.MappingMetadata} which serves starting point 

    * for querying mapping information. 

    */

   public MappingMetadata getMappingMetadata() {

     initMappings();

     return new DozerMappingMetadata(customMappings);

   }

   /**

    * Converters passed with this method could be further referenced in mappings via its unique id.

    * Converter instances passed that way are considered stateful and will not be initialized for each mapping.

    *

    * @param customConvertersWithId converter id to converter instance map

    */

   public void setCustomConvertersWithId(Map<String, CustomConverter> customConvertersWithId) {

     checkIfInitialized();

     this.customConvertersWithId.clear();

     this.customConvertersWithId.putAll(customConvertersWithId);

   }

   private void checkIfInitialized() {

     if (ready.getCount() == 0) {

       throw new MappingException("Dozer Bean Mapper is already initialized! Modify settings before calling map()");

     }

   }

   private void initMappings() {

     if (initializing.compareAndSet(false, true)) {

       try {

         loadCustomMappings();

         eventManager = new DozerEventManager(eventListeners);

       } catch (RuntimeException e) {

         // reset initialized state if error happens

         initializing.set(false);

         throw e;

       } finally {

         ready.countDown();

       }

     }

     try {

       ready.await();

     } catch (InterruptedException e) {

       log.error("Thread interrupted: ", e);

       // Restore the interrupted status:

       Thread.currentThread().interrupt();

     }

   }

 }