/**
    * 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.map2bean.Map2BeanTransformer;
  import info.magnolia.config.registry.Registry;
  import info.magnolia.config.source.AbstractConfigurationSourceBuilder;
  import info.magnolia.resourceloader.ResourceOrigin;
  
  import java.io.IOException;
  import java.util.regex.Pattern;
  import java.util.regex.PatternSyntaxException;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Builder for {@link info.magnolia.config.source.yaml.YamlConfigurationSource} instances.
   */
  public class YamlConfigurationSourceBuilder extends AbstractConfigurationSourceBuilder {
  
      private static final Logger log = LoggerFactory.getLogger(YamlConfigurationSourceBuilder.class);
  
      /**
       * Regex format for config files according to Magnolia module conventions.
       * Mind the %s part of the regex, which should be replaced with the expected definition type.
       * @see #moduleConventionsFormatFor(Registry)
       */
      private static final String MODULE_CONVENTIONS_FORMAT = "^/(?<module>[a-zA-Z0-9-_]+)/(?<deftype>%s)/(?<relPath>.*/)?(?<name>[a-zA-Z0-9-_\\.]+)\\.yaml$";
  
      private final ResourceOrigin origin;
      private final YamlReader yamlReader;
      private final Map2BeanTransformer map2BeanTransformer;
      private String pathPattern;
  
      public YamlConfigurationSourceBuilder(ResourceOrigin origin, Map2BeanTransformer map2BeanTransformer, YamlReader yamlReader) {
          this.origin = origin;
          this.map2BeanTransformer = map2BeanTransformer;
          this.yamlReader = yamlReader;
      }
  
      public YamlConfigurationSourceBuilder withPattern(String pathPattern) {
          this.pathPattern = pathPattern;
          return this;
      }
  
      @Override
      public void bindTo(Registry<?> registry) {
          final Pattern pathPattern = validatePathPattern(this.pathPattern);
          if (registry == null) {
              throw new NullPointerException("Must pass a registry instance");
          }
  
          try {
              final YamlConfigurationSource<?> yamlConfigurationSource = new YamlConfigurationSource<>(origin, map2BeanTransformer, registry, pathPattern, yamlReader);
              yamlConfigurationSource.start();
          } catch (IOException e) {
              throw new RuntimeException(e);
          }
      }
  
      public void bindWithDefaults(Registry registry) {
          if (pathPattern != null) {
              throw new IllegalStateException(this + " is already partially configured, don't use bindWithDefaults().");
          }
          withPattern(moduleConventionsFormatFor(registry)).bindTo(registry);
      }
  
     protected Pattern validatePathPattern(String regex) {
         if (pathPattern == null) {
             throw new IllegalStateException(this + " is incomplete.");
         }
         try {
             final Pattern pattern = Pattern.compile(regex);
             // Ideally, we'd validate the pattern contains 1 group.
             return pattern;
         } catch (PatternSyntaxException e) {
             log.warn("Pattern {} is invalid: {}", regex, e.getMessage());
             return Pattern.compile("$^");
         }
     }
 
     // TODO Move this (and the regex pattern) to a component that exposes this and more conventions-wrapping objects (e.g Predicate<Path>)
     protected String moduleConventionsFormatFor(Registry registry) {
         final String pluralTypeName = pluralTypeNameOf(registry);
         return String.format(MODULE_CONVENTIONS_FORMAT, pluralTypeName);
     }
 
 }