/**
    * This file Copyright (c) 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.ui.framework.app.contenttypes;
  
  import static info.magnolia.config.registry.DefinitionProvider.Problem.severe;
  import static info.magnolia.ui.form.field.factory.LinkFieldFactory.SELF_APP_REFERENCE;
  import static java.util.stream.Collectors.toList;
  import static org.apache.commons.lang3.StringUtils.EMPTY;
  
  import info.magnolia.cms.util.SimpleFreemarkerHelper;
  import info.magnolia.config.maputil.ConfigurationMapOverlay;
  import info.magnolia.config.maputil.ToMap;
  import info.magnolia.config.registry.DefinitionProvider;
  import info.magnolia.config.source.yaml.YamlReader;
  import info.magnolia.config.source.yaml.construct.MgnlYamlConstruct;
  import info.magnolia.config.source.yaml.dependency.DefinitionDependency;
  import info.magnolia.jcr.util.NodeTypes;
  import info.magnolia.resourceloader.Resource;
  import info.magnolia.resourceloader.ResourceOrigin;
  import info.magnolia.types.ContentTypeDefinition;
  import info.magnolia.types.ContentTypeRegistry;
  import info.magnolia.types.model.ConfiguredPropertyDefinition;
  import info.magnolia.types.model.ModelDefinition;
  import info.magnolia.types.model.PropertyDefinition;
  import info.magnolia.types.model.SubModelDefinition;
  import info.magnolia.types.model.jcr.ConfiguredJcrModelDefinition;
  import info.magnolia.types.model.jcr.JcrModelDefinition;
  import info.magnolia.ui.api.app.AppDescriptor;
  import info.magnolia.ui.contentapp.contenttypes.ContentTypeAppDescriptor;
  import info.magnolia.ui.api.app.registry.AppDescriptorRegistry;
  import info.magnolia.ui.vaadin.integration.jcr.ModelConstants;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.Reader;
  import java.io.StringReader;
  import java.io.StringWriter;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Optional;
  import java.util.function.Consumer;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import javax.inject.Inject;
  
  import org.apache.commons.collections4.CollectionUtils;
  import org.apache.commons.io.IOUtils;
  import org.apache.commons.lang3.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.yaml.snakeyaml.nodes.Node;
  
  import com.google.common.collect.ImmutableMap;
  
  /**
   * Snake YAML construct which takes over the YAML processing of
   * a content app and injects the boilerplate configuration resolved
   * from a content type definition and templates. Bound to the
   * tag <strong>!content-type:{type-name}</strong>.
   */
  public class AppWithContentType extends MgnlYamlConstruct {
  
      public static final String TAG_PREFIX = "!content-type";
     public static final String CONTENT_TYPE_REFERENCE_PREFIX = "reference:";
     private static final Logger log = LoggerFactory.getLogger(AppWithContentType.class);
     private static final Pattern CONTENT_TYPE_PATTERN = Pattern.compile("^!content-type:(?<type>.+)$");
     private static final String APP_TEMPLATE_PATH = "/contenttypes/appTemplate.yaml";
     private static final Map<String, String> FIELD_TYPE_MAPPING = ImmutableMap.of(
             "date", "date",
             "richtext", "richText",
             "boolean", "checkbox");
 
     private final ContentTypeRegistry contentTypeRegistry;
     private final AppDescriptorRegistry appDescriptorRegistry;
     private final SimpleFreemarkerHelper freemarkerHelper;
     private final YamlReader yamlReader;
 
     private ContentTypeDefinition relatedContentType;
     private Map<String, List<String>> dependencyMatrix;
     private Map<String, Object> baseData;
 
     private static final String NAME_FIELD_NAME = "name";
 
     @Inject
     public AppWithContentType(ContentTypeRegistry contentTypeRegistry, AppDescriptorRegistry appDescriptorRegistry, YamlReader yamlReader, Consumer<DefinitionProvider.Problem> problemCollector) {
         super(problemCollector);
         this.contentTypeRegistry = contentTypeRegistry;
         this.appDescriptorRegistry = appDescriptorRegistry;
         this.yamlReader = yamlReader;
         this.freemarkerHelper = new SimpleFreemarkerHelper(getClass(), false);
     }
 
     /**
      * @deprecated since 6.1 - use {@link #AppWithContentType(ContentTypeRegistry, AppDescriptorRegistry, YamlReader, Consumer)} instead.
      */
     @Deprecated
     public AppWithContentType(ContentTypeRegistry contentTypeRegistry, AppDescriptorRegistry appDescriptorRegistry, YamlReader yamlReader, ResourceOrigin resourceOrigin) {
         this(contentTypeRegistry, appDescriptorRegistry, yamlReader, problem -> {
         });
     }
 
     @Override
     public Object construct(Node node) {
         baseData = ToMap.toMap(getConstructor().getConstructByNodeType(node).construct(node));
 
         Matcher contentTypeMatcher = CONTENT_TYPE_PATTERN.matcher(node.getTag().getValue());
         if (!contentTypeMatcher.matches()) {
             throw new IllegalStateException("Content-type reference is passed incorrectly! " + node.getTag().getValue());
         }
 
         // Add dependency to content-type definition
         String contentTypeName = contentTypeMatcher.group("type");
 
         final DefinitionDependency dependency = DefinitionDependency.resolve()
                 .withRegistry(contentTypeRegistry)
                 .withDefinitionReference(contentTypeName)
                 .withProblemCollector(this::reportProblem)
                 .build();
 
         getConstructor().getDependencyAggregator().addDependency(dependency);
 
         Optional<DefinitionProvider<ContentTypeDefinition>> provider = getContentTypeDefinitionProvider(contentTypeName);
         if (!provider.isPresent()) {
             reportProblem(
                     severe()
                             .withType(DefinitionProvider.Problem.DefaultTypes.REFERENCES)
                             .withTitle("Content type reference problem.")
                             .withDetails(String.format("Content type {%s} is not registered or the content type name is misspelled.", contentTypeName))
                             .build()
             );
             return Collections.emptyMap();
         }
 
         relatedContentType = provider.get().get();
         dependencyMatrix = buildDependencyMatrix(relatedContentType.getModel());
         Map<String, Object> data = new HashMap<>();
         data.put("contentType", relatedContentType);
         data.put("appfn", this);
         Map<String, Object> contentApp = resolveYamlTemplate(APP_TEMPLATE_PATH, yamlReader, data);
         return ConfigurationMapOverlay
                 .of(contentApp)
                 .by(baseData)
                 .at("/")
                 .overlay();
     }
 
     public String getSubAppLabel() {
         return StringUtils.defaultIfEmpty((String) baseData.get("label"), getAppName(relatedContentType.getName()));
     }
 
     public PropertyDefinition getNameField() {
         if (!(relatedContentType.getModel() instanceof ConfiguredJcrModelDefinition)) {
             return null;
         }
         ConfiguredJcrModelDefinition model = (ConfiguredJcrModelDefinition) relatedContentType.getModel();
         if (model.getProperties()
                 .stream()
                 .anyMatch(p -> p.getName().equals(NAME_FIELD_NAME) || p.getName().equals(ModelConstants.JCR_NAME))) {
             return null;
         }
         ConfiguredPropertyDefinition nameProperty = new ConfiguredPropertyDefinition();
         nameProperty.setName(NAME_FIELD_NAME);
         nameProperty.setRequired(true);
         return nameProperty;
     }
 
     public String getAppName(String contentType) {
         if (StringUtils.equalsIgnoreCase(relatedContentType.getName(), contentType)) {
             return StringUtils.defaultIfEmpty((String) baseData.get("name"), relatedContentType.getName());
         }
 
         return appDescriptorRegistry.getAllProviders().stream()
                 .filter(DefinitionProvider::isValid)
                 .map(DefinitionProvider::get)
                 .filter(ContentTypeAppDescriptor.class::isInstance)
                 .map(ContentTypeAppDescriptor.class::cast)
                 .filter(appDescriptor -> StringUtils.equalsIgnoreCase(contentType, appDescriptor.getContentType()))
                 .findFirst()
                 .map(AppDescriptor::getName)
                 .orElse(EMPTY);
     }
 
     public String getLinkFieldAppName(String ref) {
         String contentType = StringUtils.removeStart(ref, CONTENT_TYPE_REFERENCE_PREFIX);
         if (StringUtils.equalsIgnoreCase(relatedContentType.getName(), contentType)) {
             return StringUtils.defaultIfEmpty((String) baseData.get("name"), SELF_APP_REFERENCE);
         }
         // compute a lazy reference to the content-type, let LinkFieldFactory resolve actual app name at runtime
         return CONTENT_TYPE_REFERENCE_PREFIX + contentType;
     }
 
     public String getSubAppNodeType() {
         if (relatedContentType.getModel() != null && relatedContentType.getModel() instanceof JcrModelDefinition) {
             return StringUtils.defaultIfBlank(((JcrModelDefinition) relatedContentType.getModel()).getNodeType(), NodeTypes.Content.NAME);
         }
         return NodeTypes.Content.NAME;
     }
 
     public String inferFieldType(String propertyType) {
         propertyType = propertyType.toLowerCase();
         if (FIELD_TYPE_MAPPING.containsKey(propertyType)) {
             return FIELD_TYPE_MAPPING.get(propertyType);
         }
         return "text";
     }
 
     public ModelDefinition lookupSubModelDefinition(String modelName) {
         ModelDefinition modelDefinition = relatedContentType.getModel();
         if (modelDefinition == null || CollectionUtils.isEmpty(modelDefinition.getSubModels())) {
             return null;
         }
         return modelDefinition.getSubModels().stream()
                 .filter(modelDef -> modelDef.getName().equalsIgnoreCase(modelName))
                 .findFirst().orElse(null);
     }
 
     public boolean canResolveModel(String modelName) {
         List<String> visited = new ArrayList<>();
         if (isCyclicModelReference(dependencyMatrix, modelName.toLowerCase(), modelName.toLowerCase(), visited)) {
             log.error("Detected cyclic dependencies path: {}", Arrays.toString(visited.toArray()));
             return false;
         }
         return true;
     }
 
     public String getDefaultNodeTypeOfSubModel() {
         return NodeTypes.ContentNode.NAME;
     }
 
     private Map<String, List<String>> buildDependencyMatrix(ModelDefinition modelDefinition) {
         if (modelDefinition == null || CollectionUtils.isEmpty(modelDefinition.getSubModels())) {
             return Collections.emptyMap();
         }
         Map<String, List<String>> dependencyMatrix = new HashMap<>();
         for (SubModelDefinition subModel : modelDefinition.getSubModels()) {
             if (!CollectionUtils.isEmpty(subModel.getProperties())) {
                 List<String> child = subModel.getProperties().stream()
                         .filter(property -> lookupSubModelDefinition(property.getType()) != null)
                         .map(property -> property.getType().toLowerCase())
                         .distinct()
                         .collect(toList());
                 dependencyMatrix.put(subModel.getName().toLowerCase(), child);
             }
         }
         return dependencyMatrix;
     }
 
     private boolean isCyclicModelReference(Map<String, List<String>> matrix, String start, String model, List<String> visited) {
         if (visited.contains(model) && StringUtils.equalsIgnoreCase(model, start)) {
             return true;
         }
         visited.add(model);
         for (String element : matrix.get(model)) {
             if (isCyclicModelReference(matrix, start, element, visited)) {
                 return true;
             }
         }
         visited.remove(model);
         return false;
     }
 
     public Optional<DefinitionProvider<ContentTypeDefinition>> getContentTypeDefinitionProvider(String contentTypeName) {
         return contentTypeRegistry.getAllProviders()
                 .stream()
                 .filter(provider -> StringUtils.equalsIgnoreCase(provider.get().getName(), contentTypeName))
                 .findFirst();
     }
 
     public Optional<DefinitionProvider<ContentTypeDefinition>> resolveReferenceContentTypeDefinitionProvider(String refContentType) {
         return getContentTypeDefinitionProvider(StringUtils.removeStart(refContentType, CONTENT_TYPE_REFERENCE_PREFIX));
     }
 
     private Map<String, Object> resolveYamlTemplate(String templatePath, YamlReader yamlReader, Map<String, Object> data) {
         try {
             StringWriter writer = new StringWriter();
             freemarkerHelper.render(templatePath, data, writer);
             return yamlReader.readToMap(new InMemoryFileResource(writer.toString()));
         } catch (Exception ex) {
             log.error("Can't resolve content-type YAML template: {}", ex.getMessage());
             return Collections.emptyMap();
         }
     }
 
     private class InMemoryFileResource implements Resource {
         private String content;
 
         InMemoryFileResource(String content) {
             this.content = content;
         }
 
         @Override
         public ResourceOrigin getOrigin() {
             return null;
         }
 
         @Override
         public boolean isFile() {
             return true;
         }
 
         @Override
         public boolean isDirectory() {
             return false;
         }
 
         @Override
         public boolean isEditable() {
             return false;
         }
 
         @Override
         public String getPath() {
             return null;
         }
 
         @Override
         public String getName() {
             return null;
         }
 
         @Override
         public long getLastModified() {
             return 0;
         }
 
         @Override
         public Resource getParent() {
             return null;
         }
 
         @Override
         public List<Resource> listChildren() {
             return null;
         }
 
         @Override
         public InputStream openStream() throws IOException {
             return IOUtils.toInputStream(content, "UTF-8");
         }
 
         @Override
         public Reader openReader() throws IOException {
             return new StringReader(content);
         }
     }
 }