/**
    * 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.editor;
  
  import static java.util.stream.Collectors.toList;
  
  import info.magnolia.i18nsystem.SimpleTranslator;
  import info.magnolia.icons.MagnoliaIcons;
  import info.magnolia.ui.contentapp.Datasource;
  import info.magnolia.ui.framework.WithImplementation;
  import info.magnolia.ui.theme.ResurfaceTheme;
  
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.LinkedHashMap;
  import java.util.List;
  import java.util.Locale;
  import java.util.Map;
  import java.util.concurrent.CompletableFuture;
  import java.util.stream.Stream;
  
  import javax.inject.Inject;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import com.vaadin.data.BinderValidationStatus;
  import com.vaadin.ui.AbstractOrderedLayout;
  import com.vaadin.ui.Alignment;
  import com.vaadin.ui.Button;
  import com.vaadin.ui.Component;
  import com.vaadin.ui.HorizontalLayout;
  import com.vaadin.ui.Notification;
  import com.vaadin.ui.VerticalLayout;
  
  import lombok.EqualsAndHashCode;
  import lombok.Getter;
  import lombok.Setter;
  
  /**
   * Editor view which hosts a number of similar child editors.
   *
   * @param <T>
   *     item type.
   */
  public class MultiFormView<T> implements EditorView<T> {
  
      private static final Logger log = LoggerFactory.getLogger(MultiFormView.class);
  
      private final MultiFormDefinition<T> definition;
      private final SimpleTranslator i18n;
      private final Locale locale;
      private final Datasource<T> datasource;
      private final MultiFormState state = new MultiFormState();
  
      private VerticalLayout rootLayout = new VerticalLayout();
  
      @Inject
      public MultiFormView(MultiFormDefinition<T> definition, SimpleTranslator i18n, LocaleContext localeContext, Datasource<T> datasource) {
          this.definition = definition;
          this.i18n = i18n;
          this.locale = localeContext.getDefault();
          this.datasource = datasource;
          this.state.entryResolution = create(definition.getEntryResolution(), this.locale);
          this.rootLayout.setSpacing(true);
          this.rootLayout.addStyleName("multi-form-view");
  
          layout();
     }
 
     @Override
     public List<BinderValidationStatus<?>> validate() {
         return getAllChildren()
                 .flatMap(view -> view.validate().stream())
                 .collect(toList());
     }
 
     @Override
     public void write(T item) {
         Map<EditorView<T>, ItemProviderStrategy<T, T>> children = state.children;
         state.removedItemAccessors.stream()
                 .map(accessor -> accessor.read(item, locale))
                 .forEach(itemToMaybeDelete ->
                         itemToMaybeDelete
                                 .ifPresent(this.datasource::remove));
 
         List<T> itemOrder = new ArrayList<>();
         state.order.forEach(subForm ->
                 children.get(subForm).read(item, locale).ifPresent(localisedItem -> {
                     itemOrder.add(localisedItem);
                     subForm.write(localisedItem);
                 }));
 
         create(this.definition.getOrderHandler(), locale).applyOrder(itemOrder);
     }
 
     @Override
     public Component asVaadinComponent() {
         return rootLayout;
     }
 
     @Override
     public void populate(T item) {
         getAllChildren().forEach(subForm -> {
            rootLayout.removeComponent(subForm.asVaadinComponent());
            subForm.destroy();
         });
 
         state.clear();
         state.entryResolution.resolveForRoot(item).forEach(propertyDefinition -> {
             if (propertyDefinition != null) {
                 EditorView<T> subForm = createSubForm(propertyDefinition);
                 addSubFormToState(subForm, propertyDefinition);
                 populate(item, subForm);
             }
         });
 
         layout();
     }
 
     private EditorView<T> createSubForm(ComplexPropertyDefinition<T> propertyDefinition) {
         final EditorView<T> subForm = create("child", propertyDefinition.getEditorDefinition());
         if (subForm.asVaadinComponent().getCaption() == null) {
             subForm.asVaadinComponent().setCaption(propertyDefinition.getLabel());
         }
         return subForm;
     }
 
     private void addSubFormToState(EditorView<T> subForm, ComplexPropertyDefinition<T> propertyDefinition) {
         ItemProviderStrategy<T, T> itemProviderStrategy = create(propertyDefinition.getItemProvider());
         state.children.put(subForm, itemProviderStrategy);
         state.order.add(subForm);
     }
 
     private void populate(T item, EditorView<T> subForm) {
         state.children.get(subForm).read(item, locale).ifPresent(subForm::populate);
     }
 
     public void layout() {
         rootLayout.removeAllComponents();
         rootLayout.setMargin(false);
         state.children.keySet().stream()
                 .map(this::wrapChildForm)
                 .forEach(this.rootLayout::addComponent);
         attachAddButton();
     }
 
     protected Component wrapChildForm(EditorView<T> subForm) {
         HorizontalLayout wrapLayout = new HorizontalLayout();
         wrapLayout.setWidth("100%");
         subForm.asVaadinComponent().addStyleName("multi-form-entry-content");
 
         HorizontalLayout buttonLayout = createButtonsLayout(subForm, wrapLayout);
         wrapLayout.addComponents(subForm.asVaadinComponent(), buttonLayout);
         wrapLayout.setExpandRatio(subForm.asVaadinComponent(), 1f);
         wrapLayout.setComponentAlignment(buttonLayout, Alignment.TOP_CENTER);
         wrapLayout.addStyleName("multi-form-entry");
 
         return wrapLayout;
     }
 
     private HorizontalLayout createButtonsLayout(EditorView<T> subForm, HorizontalLayout wrapLayout) {
         HorizontalLayout buttonLayout = new HorizontalLayout();
         buttonLayout.setSpacing(false);
 
         if (!(definition.getOrderHandler() instanceof MultiFormDefinition.OrderHandlerDefinition.Noop)) {
             buttonLayout.addComponents(
                     new Button(MagnoliaIcons.ARROW2_N, e -> onMove(wrapLayout, true)),
                     new Button(MagnoliaIcons.ARROW2_S, e -> onMove(wrapLayout, false))
             );
         }
         if (definition.isCanRemoveItems()) {
             buttonLayout.addComponent(new Button(MagnoliaIcons.TRASH, e -> onDelete(subForm)));
         }
 
         buttonLayout.forEach(button -> button.addStyleName(ResurfaceTheme.BUTTON_ICON));
         return buttonLayout;
     }
 
     protected void attachAddButton() {
         Button addButton = new Button(this.i18n.translate("buttons.add"));
         addButton.addStyleName("add-multi-form-entry-button");
         addButton.addClickListener(e -> {
             state.entryResolution.pick().thenAccept(propertyDefinition -> {
                 if (propertyDefinition != null) {
                     EditorView<T> subForm = createSubForm(propertyDefinition);
                     addSubFormToState(subForm, propertyDefinition);
                     rootLayout.addComponent(wrapChildForm(subForm), rootLayout.getComponentCount() - 1);
                 }
             }).exceptionally(ex -> {
                 log.warn("Failed to create a multi field entry", ex);
                 Notification.show("Failed to create multi field entry");
                 return null;
             });
         });
 
         rootLayout.addComponent(addButton);
     }
 
     private Stream<EditorView<T>> getAllChildren() {
         return state.children.keySet().stream();
     }
 
     private void onMove(AbstractOrderedLayout movedLayout, boolean moveUp) {
         int currentPosition = rootLayout.getComponentIndex(movedLayout);
         int newPosition = moveUp ? currentPosition - 1 : currentPosition + 1;
 
         if (currentPosition == 0 && moveUp) {
             return;
         }
 
         if (newPosition >= rootLayout.getComponentCount() - 1) {
             return;
         }
 
         Collections.swap(state.order, currentPosition, newPosition);
         rootLayout.replaceComponent(rootLayout.getComponent(currentPosition), rootLayout.getComponent(newPosition));
     }
 
     private void onDelete(EditorView<T> subForm) {
         rootLayout.removeComponent(subForm.asVaadinComponent().getParent());
 
         state.removedItemAccessors.add(state.children.get(subForm));
         state.children.remove(subForm);
         state.order.remove(subForm);
     }
 
     class MultiFormState {
         Map<EditorView<T>, ItemProviderStrategy<T, T>> children = new LinkedHashMap<>();
         List<ItemProviderStrategy<T, T>> removedItemAccessors = new ArrayList<>();
         List<EditorView<T>> order = new ArrayList<>();
         EntryResolution<T> entryResolution;
 
         void clear() {
             children.clear();
             removedItemAccessors.clear();
             order.clear();
         }
     }
 
     /**
      * Multi-form entry resolution strategy.
      *
      * @param <T>
      */
     public interface EntryResolution<T> {
 
         Stream<ComplexPropertyDefinition<T>> resolveForRoot(T rootDatasource);
 
         CompletableFuture<ComplexPropertyDefinition<T>> pick();
 
         @Getter
         @Setter
         @EqualsAndHashCode
         class Definition<T> implements WithImplementation<EntryResolution<T>> {
             private Class<? extends EntryResolution<T>> implementationClass;
         }
     }
 }