/**
    * This file Copyright (c) 2014-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.form.field.transformer.multi;
  
  import info.magnolia.jcr.util.NodeTypes;
  import info.magnolia.jcr.util.NodeUtil;
  import info.magnolia.ui.api.i18n.I18NAuthoringSupport;
  import info.magnolia.ui.form.field.definition.ConfiguredFieldDefinition;
  import info.magnolia.ui.form.field.definition.MultiValueFieldDefinition;
  import info.magnolia.ui.vaadin.integration.jcr.AbstractJcrNodeAdapter;
  import info.magnolia.ui.vaadin.integration.jcr.JcrNewNodeAdapter;
  import info.magnolia.ui.vaadin.integration.jcr.JcrNodeAdapter;
  
  import java.util.Collections;
  import java.util.List;
  
  import javax.jcr.Node;
  import javax.jcr.RepositoryException;
  
  import org.apache.commons.beanutils.BeanUtils;
  import org.apache.commons.beanutils.PropertyUtils;
  import org.apache.commons.lang3.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import com.vaadin.v7.data.Item;
  import com.vaadin.v7.data.util.PropertysetItem;
  
  /**
   * This delegating {@link info.magnolia.ui.form.field.transformer.Transformer Transformer} is dedicated to the {@link info.magnolia.ui.form.field.MultiField MultiField};
   * it considers entries as child nodes of a sub-node (named after the field) and delegates property handling to their respective sub-fields.
   * <p>
   * The storage strategy is that of the {@link info.magnolia.ui.form.field.transformer.multi.MultiValueSubChildrenNodePropertiesTransformer MultiValueSubChildrenNodePropertiesTransformer}:
   * <ul>
   * <li>rootItem (relatedFormItem)
   * <ul>
   * <li>childNode (single child node for MultiField entries)<br>
   * <ul>
   * <li>0 (first entry of the MultiField)<br>
   * <li>1 (second entry of the MultiField)<br>
   * <li>...
   * </ul>
   * </ul>
   * </ul>
   */
  public class DelegatingMultiValueSubnodeTransformer extends DelegatingMultiValueFieldTransformer {
  
      private static final Logger log = LoggerFactory.getLogger(DelegatingMultiValueSubnodeTransformer.class);
  
      private JcrNodeAdapter childNode;
  
      public DelegatingMultiValueSubnodeTransformer(Item relatedFormItem, ConfiguredFieldDefinition definition, Class<PropertysetItem> type, I18NAuthoringSupport i18NAuthoringSupport) {
          super(relatedFormItem, definition, type, i18NAuthoringSupport);
          detectsChildNodeType((MultiValueFieldDefinition) definition);
      }
  
      /**
       * Overridden to keep only the digit part in child-node names.
       */
      @Override
      protected String getSubItemBaseName() {
          return "";
      }
  
      /**
       * Overridden to get an intermediate child node where the multiple nodes are stored, rather than directly under the root node.
       * <p>
       * The child node is created if it doesn't exist, and is named after the multi-value field definition.
      */
     @Override
     protected JcrNodeAdapter getRootItem() {
         if (childNode == null) {
             JcrNodeAdapter rootItem = super.getRootItem();
             Node rootJcrItem = rootItem.getJcrItem();
             try {
                 final String childNodeName = getChildNodeName();
                 if (rootJcrItem.hasNode(childNodeName)) {
                     final AbstractJcrNodeAdapter alreadyExistingChildItem = rootItem.getChild(childNodeName);
                     if (alreadyExistingChildItem instanceof JcrNodeAdapter) { //don't lose children items by creating a new item when item already exists (happens when switching language)
                         childNode = (JcrNodeAdapter) alreadyExistingChildItem;
                     } else {
                         childNode = new JcrNodeAdapter(rootJcrItem.getNode(childNodeName));
                     }
                 } else if (rootItem.getChildren().containsKey(childNodeName)) {
                     // Initialize an intermediate child node when the child item has been created already but hasn't been persisted yet.
                     Object childItem = rootItem.getChildren().get(childNodeName);
                     if (childItem instanceof JcrNodeAdapter) {
                         childNode = (JcrNodeAdapter) childItem;
                     }
                 } else {
                     childNode = new JcrNewNodeAdapter(rootJcrItem, NodeTypes.ContentNode.NAME, childNodeName);
                 }
                 rootItem.addChild(childNode);
             } catch (RepositoryException e) {
                 log.warn(String.format("Could not determine whether form item '%s' had a child node named '%s'", rootJcrItem, definition.getName()), e);
             }
         }
         return childNode;
     }
 
     @Override
     protected List<Node> getStoredChildNodes(JcrNodeAdapter parent) {
         try {
             if (!(parent instanceof JcrNewNodeAdapter) && parent.getJcrItem().hasNodes()) {
                 return NodeUtil.asList(NodeUtil.getNodes(parent.getJcrItem(), childNodeType));
             }
         } catch (RepositoryException re) {
             log.warn("Not able to access the Child Nodes of the following Node Identifier {}", parent.getItemId(), re);
         }
         return Collections.emptyList();
     }
 
     protected String getChildNodeName() {
         return definition.getName();
     }
 
     private void detectsChildNodeType(MultiValueFieldDefinition definition) {
         try {
             if (definition.getField() != null && PropertyUtils.isReadable(definition.getField(), "nodeType")) {
                 childNodeType = StringUtils.defaultIfBlank(BeanUtils.getProperty(definition.getField(), "nodeType"), childNodeType);
             }
         } catch (Exception ex) {
             log.error("Can't read nodeType property from the definition");
         }
     }
 }