/**
    * This file Copyright (c) 2017-2018 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.construct;
  
  import static info.magnolia.config.source.yaml.dependency.YamlDependencyResoutionProblemType.DEPENDENCY_RESOLUTION;
  
  import info.magnolia.config.maputil.ConfigurationMapOverlay;
  import info.magnolia.config.maputil.ToMap;
  import info.magnolia.config.registry.DefinitionProvider.Problem;
  import info.magnolia.config.source.yaml.YamlReader;
  import info.magnolia.config.source.yaml.dependency.YamlFileDependency;
  import info.magnolia.resourceloader.ResourceOrigin;
  
  import java.util.Map;
  import java.util.function.Consumer;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import org.apache.commons.lang3.StringUtils;
  import org.yaml.snakeyaml.nodes.Node;
  import org.yaml.snakeyaml.nodes.ScalarNode;
  
  /**
   * Adds support of the yaml resource inclusion with the following syntax: <b>!include:&lt;resource_path.yaml&gt;</b>. Unlike the
   * {@link IncludeYamlFile} construct this one allows us to also override the nodes and properties of the included file
   * making the inclusion process significantly more flexible.
   */
  public final class IncludeFileYamlWithModificationPossibility extends MgnlYamlConstruct {
  
      public static final String TAG_PREFIX = "!include:";
  
      private static final Pattern INCLUSION_MATCHER = Pattern.compile("^!include:(?<path>[0-9a-zA-Z_/-]+.yaml)$");
  
      private final YamlReader yamlReader;
      private final ResourceOrigin<?> resourceOrigin;
  
      public IncludeFileYamlWithModificationPossibility(YamlReader yamlReader, ResourceOrigin<?> resourceOrigin, Consumer<Problem> problemCollector) {
          super(problemCollector);
          this.yamlReader = yamlReader;
          this.resourceOrigin = resourceOrigin;
      }
  
      @Override
      public Object construct(Node node) {
          final Map<String, Object> baseData = ToMap.toMap(getConstructor().getConstructByNodeType(node).construct(node));
  
          if (node instanceof ScalarNode) {
              final String scalarValue = ((ScalarNode) node).getValue();
              if (StringUtils.isNotBlank(scalarValue)) {
                  reportProblem(
                          Problem.minor()
                                  .withType(DEPENDENCY_RESOLUTION)
                                  .withTitle("Redundant inclusion syntax used")
                                  .withDetails(String.format("Scalar value [%s] of node [%s] will be ignored due to !include:<resource_path> semantics",
                                          scalarValue, node.getNodeId()))
                                  .build());
              }
          }
  
          final Matcher resourcePathMatcher = INCLUSION_MATCHER.matcher(node.getTag().getValue());
          if (!resourcePathMatcher.matches()) {
              reportProblem(
                      Problem.severe()
                              .withType(DEPENDENCY_RESOLUTION)
                              .withTitle("Mis-configured YAML resource dependency")
                              .withDetails(String.format("Tag [%s] does not match the inclusion pattern !include:<yaml_resource_path>",
                                      node.getTag().getValue()))
                              .build());
             return baseData;
         }
 
         final String path = resourcePathMatcher.group("path");
         final YamlFileDependency dependency = new YamlFileDependency(resourceOrigin, path, yamlReader, getConstructor().getDependencyAggregator(), this::reportProblem);
 
         if (!dependency.exists()) {
             reportProblem(
                     Problem.major()
                             .withType(DEPENDENCY_RESOLUTION)
                             .withTitle("Missing YAML resource dependency")
                             .withDetails(String.format("Resource dependency at [%s] does not exist", path))
                             .build());
         }
 
         getConstructor().getDependencyAggregator().addDependency(dependency);
 
         return ConfigurationMapOverlay
                 .of(ToMap.toMap(dependency.readData()))
                 .by(baseData)
                 .at("/")
                 .overlay();
     }
 }