/**
    * This file Copyright (c) 2014-2015 Magnolia International
    * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
    *
    *
    * This file is dual-licensed under both the Magnolia
    * Network Agreement and the GNU General Public License.
    * You may elect to use one or the other of these licenses.
    *
   * This file is distributed in the hope that it will be
   * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
   * implied warranty of MERCHANTABILITY or FITNESS FOR A
   * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
   * Redistribution, except as permitted by whichever of the GPL
   * or MNA you select, is prohibited.
   *
   * 1. For the GPL license (GPL), you can redistribute and/or
   * modify this file under the terms of the GNU General
   * Public License, Version 3, as published by the Free Software
   * Foundation.  You should have received a copy of the GNU
   * General Public License, Version 3 along with this program;
   * if not, write to the Free Software Foundation, Inc., 51
   * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * 2. For the Magnolia Network Agreement (MNA), this file
   * and the accompanying materials are made available under the
   * terms of the MNA which accompanies this distribution, and
   * is available at http://www.magnolia-cms.com/mna.html
   *
   * Any modifications to this file must keep this entire header
   * intact.
   *
   */
  package info.magnolia.config.source.jcr;
  
  import info.magnolia.cms.util.ExceptionUtil;
  import info.magnolia.config.NamedDefinition;
  import info.magnolia.config.registry.DefinitionMetadata;
  import info.magnolia.config.registry.DefinitionMetadataBuilder;
  import info.magnolia.config.registry.DefinitionProvider;
  import info.magnolia.config.registry.DefinitionProviderBuilder;
  import info.magnolia.config.registry.DefinitionRawView;
  import info.magnolia.config.registry.Registry;
  import info.magnolia.config.source.ConfigurationSource;
  import info.magnolia.config.source.ConfigurationSourceType;
  import info.magnolia.config.source.ConfigurationSourceTypes;
  import info.magnolia.jcr.node2bean.Node2BeanException;
  import info.magnolia.jcr.node2bean.Node2BeanProcessor;
  import info.magnolia.jcr.node2bean.TransformationState;
  import info.magnolia.jcr.node2bean.TypeDescriptor;
  import info.magnolia.jcr.node2bean.TypeMapping;
  import info.magnolia.jcr.node2bean.impl.Node2BeanTransformerImpl;
  import info.magnolia.jcr.node2bean.impl.PreConfiguredBeanUtils;
  import info.magnolia.jcr.predicate.NodeTypePredicate;
  import info.magnolia.jcr.util.NodeTypes;
  import info.magnolia.jcr.util.NodeUtil;
  import info.magnolia.jcr.util.NodeVisitor;
  import info.magnolia.module.ModuleRegistry;
  import info.magnolia.objectfactory.ComponentProvider;
  import info.magnolia.objectfactory.Components;
  
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  import javax.jcr.Node;
  import javax.jcr.RepositoryException;
  
  import org.apache.commons.lang3.StringUtils;
  import org.apache.jackrabbit.commons.predicate.Predicate;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Configuration source for JCR configuration.
   *
   * @param <T> type the source will provide
   */
  public class JcrConfigurationSource<T> implements ConfigurationSource {
  
      private static final Logger log = LoggerFactory.getLogger(JcrConfigurationSource.class);
  
      private final Registry<T> registry;
      private final String pathInModule;
      private final Predicate nodeFilter;
      private final Node2BeanProcessor node2BeanProcessor;
      private Set<DefinitionMetadata> registeredIds = new HashSet<>();
      private final RegistryBasedObservingManager observingManager;
  
      public JcrConfigurationSource(Registry<T> registry, String pathInModule, Predicate nodeFilter,
                                    Node2BeanProcessor node2BeanProcessor, ModuleRegistry moduleRegistry) throws IOException {
          this.registry = registry;
          this.pathInModule = pathInModule;
         this.nodeFilter = nodeFilter;
         this.node2BeanProcessor = node2BeanProcessor;
 
         this.observingManager = new RegistryBasedObservingManager(pathInModule, moduleRegistry, this);
     }
 
     @Override
     public ConfigurationSourceType type() {
         return ConfigurationSourceTypes.jcr;
     }
 
     @Override
     public void start() {
         this.observingManager.start();
     }
 
     protected void reload(List<Node> nodes) throws RepositoryException {
         final List<DefinitionProvider<T>> providers = new ArrayList<>();
 
         for (Node node : nodes) {
             collectProvidersFor(providers, node);
         }
 
         this.registeredIds = registry.unregisterAndRegister(registeredIds, providers);
     }
 
     protected void collectProvidersFor(final List<DefinitionProvider<T>> providers, Node node) throws RepositoryException {
         NodeUtil.visit(node, new NodeVisitor() {
             @Override
             public void visit(Node parent) throws RepositoryException {
                 for (Node configNode : NodeUtil.getNodes(parent, NodeTypes.ContentNode.NAME)) {
                     if (checkNode(configNode)) {
                         DefinitionProvider<T> provider = newProvider(configNode);
                         if (provider != null) {
                             providers.add(provider);
                         }
                     }
                 }
             }
         }, new NodeTypePredicate(NodeTypes.Content.NAME, false));
     }
 
     /**
      * Returns true if the given node should be used to load a definition from it.
      */
     protected boolean checkNode(Node node) {
         return nodeFilter.evaluate(node);
     }
 
     protected DefinitionProvider<T> newProvider(Node configNode) throws RepositoryException {
         String nodePath = configNode.getPath();
 
         final DefinitionProviderBuilder<T> builder = DefinitionProviderBuilder.newBuilder();
         final DefinitionMetadataBuilder metadataBuilder = createMetadata(configNode);
         builder.metadata(metadataBuilder);
 
         try {
             // Transform into the actual bean
             MapPopulatingN2BTransformer transformer = new MapPopulatingN2BTransformer();
             @SuppressWarnings("unchecked")
             final T bean = (T) node2BeanProcessor.toBean(configNode, true, transformer, Components.getComponentProvider());
             builder.definition(bean);
 
             // Override metadata name if needed
             if (bean instanceof NamedDefinition) {
                 final String definitionName = ((NamedDefinition) bean).getName();
                 if (definitionName != null) {
                     // Definition's name has priority
                     metadataBuilder.name(definitionName);
                 }
             }
 
             // TODO raw view should be attached to builder before attempting any bean transformation
             builder.rawView(transformer.getRawView().getSubRawView());
 
         } catch (Throwable t) {
             // Here we're catching any exception, from node2BeanTransformer down to underlying potential errors (e.g. NoClassDefFoundError)
             builder.addErrorMessage(ExceptionUtil.exceptionToWords(t));
             log.warn("Problem while registering {} from {}: {}", getRegistry().type(), nodePath, ExceptionUtil.exceptionToWords(t), t);
         }
 
         DefinitionProvider<T> provider = builder.build();
         return provider;
     }
 
     protected DefinitionMetadataBuilder createMetadata(Node configNode) throws RepositoryException {
         final String fallbackDefinitionName = configNode.getName();
 
         final String path = configNode.getPath();
         final String[] pathElements = path.split("/");
         final String moduleName = pathElements[2];
         final String relPath = StringUtils.removeStart(path, "/modules/" + moduleName + "/" + pathInModule + "/");
 
         return registry.newMetadataBuilder()
                 .type(getRegistry().type())
                 .name(fallbackDefinitionName)
                 .module(moduleName)
                 .location(path)
                 .relativeLocation(relPath);
     }
 
     protected Registry<T> getRegistry() {
         return registry;
     }
 
     /**
      * Simple implementation of {@link DefinitionRawView}.
      */
     private static class DefinitionRawViewImpl implements DefinitionRawView {
 
         private List<Property> properties;
 
         public DefinitionRawViewImpl(List<Property> properties) {
             this.properties = properties;
         }
 
         @Override
         public List<Property> properties() {
             return properties;
         }
     }
 
     /**
      * Populates a {@link DefinitionRawView} along with normal N2B transformation.
      *
      * @see #newProvider(javax.jcr.Node)
      */
     private class MapPopulatingN2BTransformer extends Node2BeanTransformerImpl {
 
         private Map<String, DefinitionRawView.Property> populatedProperties = new HashMap<>();
 
         private DefinitionRawView.Property rawView;
 
         public MapPopulatingN2BTransformer() {
             super(new PreConfiguredBeanUtils());
         }
 
         @Override
         protected TypeDescriptor onResolveType(TypeMapping mapping, TransformationState state, TypeDescriptor resolvedType, ComponentProvider componentProvider) {
             if (resolvedType == null && state.getLevel() == 1) {
                 return mapping.getTypeDescriptor(getRegistry().type().baseClass());
             }
             return resolvedType;
         }
 
         @Override
         public void initBean(TransformationState state, Map values) throws Node2BeanException {
             // Invoked almost at the end of N2B transformation
             super.initBean(state, values);
             // Create a new level of resulting map
             final List<DefinitionRawView.Property> properties = new LinkedList<>();
             try {
                 final Iterator<Map.Entry<String, Object>> it = values.entrySet().iterator();
 
                 while (it.hasNext()) {
                     final Map.Entry<String, Object> entry = it.next();
                     // Replace the concrete objects with their tracked map representations
                     if (this.populatedProperties.containsKey(entry.getKey())) {
                         properties.add(this.populatedProperties.remove(entry.getKey()));
                     } else {
                         properties.add(DefinitionRawView.Property.simple(entry.getKey(), String.valueOf(entry.getValue())));
                     }
                 }
 
                 // Append erased class property
                 if (state.getCurrentNode().hasProperty("class")) {
                     properties.add(DefinitionRawView.Property.simple("class", state.getCurrentNode().getProperty("class").getString()));
                 }
 
                 String name = state.getCurrentNode().getName();
                 if (state.getCurrentType().isCollection() || state.getCurrentType().isMap() || state.getCurrentType().isArray()) {
                     rawView = DefinitionRawView.Property.collection(name, properties);
                 } else {
                     rawView = DefinitionRawView.Property.subBean(name, new DefinitionRawViewImpl(properties));
                 }
                 // Track current object map representation
                 this.populatedProperties.put(name, rawView);
 
             } catch (RepositoryException e) {
 
             }
         }
 
         // Use this method to get the resulting map after transform
         public DefinitionRawView.Property getRawView() {
             return rawView;
         }
     }
 }