/**
    * 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.yaml;
  
  import info.magnolia.config.registry.DefinitionMetadataBuilder;
  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.resourceloader.Resource;
  import info.magnolia.resourceloader.ResourceOrigin;
  import info.magnolia.resourceloader.ResourceVisitor;
  import info.magnolia.resourceloader.util.Functions;
  import info.magnolia.resourceloader.util.PredicatedResourceVisitor;
  import info.magnolia.resourceloader.util.VoidFunction;
  
  import java.io.IOException;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Configuration source for any text-resource based configuration files.
   *
   * @param <T> type the source will provide
   */
  public abstract class AbstractFileResourceConfigurationSource<T> implements ConfigurationSource {
  
      private static final Logger log = LoggerFactory.getLogger(AbstractFileResourceConfigurationSource.class);
  
      private final ResourceOrigin origin;
      private final Pattern pathPattern;
      private final Registry<T> registry;
      private final PathToMetadataInferrer pathToMetadataInferrer;
  
      /**
       * @param pathPattern a regular expression pattern used to determine whether a file should be considered by the source or not. If the pattern contains a group, it will be used to determine the name of the given object, if not explicitly configured.
       */
      public AbstractFileResourceConfigurationSource(ResourceOrigin origin, Registry<T> registry, Pattern pathPattern) throws IOException {
          this.origin = origin;
          this.registry = registry;
          this.pathPattern = pathPattern;
          this.pathToMetadataInferrer = new RegexBasedPathToMetadataInferrer(this.pathPattern);
      }
  
      @Override
      public ConfigurationSourceType type() {
          return ConfigurationSourceTypes.file;
      }
  
      @Override
      public void start() throws IOException {
          log.info("Setting up {} to load {} definitions from resources", getClass().getSimpleName(), getRootType().getSimpleName());
          final LoadAndRegisterFunction loadAndRegisterFunction = new LoadAndRegisterFunction();
          final ResourceVisitor visitor = PredicatedResourceVisitor.onAllMatchingFiles(Functions.pathMatches(pathPattern), loadAndRegisterFunction);
          origin.traverseWith(visitor);
          origin.watchForChanges(visitor);
      }
  
      // TODO either we pass only Resource, or String and InputStream
      public abstract void loadAndRegister(Resource resource);
  
      protected Registry<T> getRegistry() {
          return registry;
      }
  
     protected final Class<T> getRootType() {
         return registry.type().baseClass();
     }
 
     protected DefinitionMetadataBuilder createMetadata(Resource resource) {
         final DefinitionMetadataBuilder metadataBuilder = registry.newMetadataBuilder()
                 .type(getRegistry().type())
                         //.source(this??)
                 .location(resource.getPath()); // TO BE CHANGED BY WHATEVER MORE MEANINGFUL LOCATION WE'RE ABOUT TO HAVE
 
         return pathToMetadataInferrer.populateFrom(metadataBuilder, resource);
     }
 
     private class LoadAndRegisterFunction extends VoidFunction<Resource> {
         @Override
         public void doWith(Resource resource) {
             // TODO Temp/generics this
             //if (!(resource instanceof FileSystemResource)) {
             //    throw new IllegalStateException("GAAAH");
             //}
             if (resource.isDirectory()) {
                 log.debug("Ignoring event on directory {}", resource);
                 return;
             }
 
             final Matcher matcher = pathPattern.matcher(resource.getPath());
             if (!matcher.matches()) { // TODO this is currently here because FS observation triggers events for all files regardless of pattern. Find better place.
                 log.debug("Ignoring event on {} (no match for {})", resource, pathPattern);
                 return;
             }
 
             log.debug("Loading {} ({})", resource, resource.getPath());
             loadAndRegister(resource);
         }
     }
 }