/**
    * 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.*;
  
  import info.magnolia.ui.field.EditorPropertyDefinition;
  import info.magnolia.ui.field.FieldDefinition;
  import info.magnolia.ui.field.ValueBoundProperty;
  import info.magnolia.ui.framework.layout.FieldLayoutDefinition;
  import info.magnolia.ui.framework.layout.FieldLayoutProducer;
  import info.magnolia.ui.framework.layout.LayoutDefinition;
  
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.LinkedHashMap;
  import java.util.List;
  import java.util.Locale;
  import java.util.Map;
  import java.util.Optional;
  import java.util.function.Function;
  import java.util.stream.Stream;
  
  import javax.inject.Inject;
  
  import com.vaadin.data.Binder;
  import com.vaadin.data.BinderValidationStatus;
  import com.vaadin.ui.Component;
  import com.vaadin.ui.ComponentContainer;
  import com.vaadin.ui.HasComponents;
  
  import lombok.AllArgsConstructor;
  import lombok.Getter;
  
  /**
   * Builds a locale-aware form view. It first creates one {@link Binder} per {@link Locale},
   * then binds form components accordingly and finally creates one layout for each available locale.
   * @param <T> item type.
   *
   * @see FormPresenter
   */
  public class FormView<T> implements EditorView<T>, ItemEditor {
  
      private final List<SubEditorReference<T>> subEditors = new ArrayList<>();
      private final LocaleContext localeContext;
  
      private final FormDefinition<T> formDefinition;
      private final FormPresenter<T> formPresenter;
      private Component layout;
  
      @Inject
      public FormView(FormDefinition<T> formDefinition, LocaleContext localeContext) {
  
          this.formDefinition = formDefinition;
          this.localeContext = localeContext;
  
          this.formPresenter = create(FormPresenter.class, formDefinition, localeContext.getDefault());
          this.createComplexProperties();
  
          if (!localeContext.current().value().isPresent()) {
              displayLocalisedVersion(localeContext.getDefault());
          }
  
          localeContext.current().observe(optionalLocale -> optionalLocale.ifPresent(this::displayLocalisedVersion));
      }
  
      private void createComplexProperties() {
          formDefinition.getSubFormDefinitions().forEach(def -> {
             ComplexPropertyDefinition<T> asComplexPropertyDef = def;
             ItemProviderStrategy<T, T> subFormProviderStrategy = this.create(asComplexPropertyDef.getItemProvider(), def);
             Map<Locale, EditorView<T>> localisedRepresentations = new HashMap<>();
             // in case complex property is localised, keep separate "single-language" representations
             // each of which can be bound to different child items
             if (asComplexPropertyDef.isI18n()) {
                 localeContext.availableLocales().nullableValue().forEach(locale -> {
                     LocaleContext childLocaleContext = LocaleContext.of(locale);
                     EditorView<T> subForm = createSubEditor(asComplexPropertyDef, childLocaleContext, subFormProviderStrategy);
                     localisedRepresentations.put(locale, subForm);
                 });
             } else {
                 // in case complex property is not localised - there is no need to keep localised representations, one is enough,
                 // just propagate the locale context inside into it.
                 localisedRepresentations.put(localeContext.getDefault(), createSubEditor(asComplexPropertyDef, this.localeContext, subFormProviderStrategy));
             }
 
             this.subEditors.add(new SubEditorReference<>(localisedRepresentations, subFormProviderStrategy, asComplexPropertyDef));
         });
     }
 
     private EditorView<T> createSubEditor(ComplexPropertyDefinition<T> definition, LocaleContext localeContext, Object... args) {
         EditorView<T> subEditor = this.create(definition.getEditorDefinition(), localeContext, args);
         String caption = definition.getLabel();
         if (definition.isI18n() && this.localeContext.getAvailableLocales().count() > 1) {
             subEditor.bindInstance(LocaleContext.class, localeContext);
             caption = String.format("%s (%s)", caption, localeContext.getDefault().toString());
         }
         subEditor.asVaadinComponent().addStyleName(definition.getStyleName());
         subEditor.asVaadinComponent().setCaption(caption);
         return subEditor;
     }
 
     @Override
     public <V> Optional<V> getPropertyValue(String propertyName) {
         return this.getPropertyValue(propertyName, localeContext.getCurrent());
     }
 
     @Override
     public void populate(T item) {
         formPresenter.bind(item);
         subEditors.forEach(ref -> {
             ItemProviderStrategy<T, T> itemProviderStrategy = ref.itemProviderStrategy;
             ref.representations.forEach((locale, subForm) -> itemProviderStrategy.read(item, locale).ifPresent(subForm::populate));
         });
     }
 
     @Override
     public void write(T localisedItemSources) {
         formPresenter.writeBindings(localisedItemSources);
         subEditors.forEach(ref -> {
             ItemProviderStrategy<T, T> itemProviderStrategy = ref.itemProviderStrategy;
             ref.representations.forEach((locale, subForm) -> itemProviderStrategy.read(localisedItemSources, locale).ifPresent(subForm::write));
         });
     }
 
     @Override
     public void applyDefaults() {
         this.formPresenter.applyDefaults();
         this.subEditors.stream()
                 .map(ref -> ref.getRepresentations().get(localeContext.getDefault()))
                 .forEach(EditorView::applyDefaults);
     }
 
     private void displayLocalisedVersion(Locale locale) {
         formPresenter.getBoundFields(locale).ifPresent(boundFields -> {
             Component old = this.layout;
             this.layout = computeLayout(boundFields);
             HasComponents parent = old != null ? old.getParent() : null;
             if (parent instanceof ComponentContainer) {
                 this.layout.addStyleNames(old.getStyleName());
                 ((ComponentContainer) parent).replaceComponent(old, this.layout);
             }
         });
     }
 
     /**
      * Validates this forms and all its sub-forms recursively.
      * @return a list of {@link BinderValidationStatus}
      */
     @Override
     public List<BinderValidationStatus<?>> validate() {
         final Stream<BinderValidationStatus<T>> fieldValidationResults = formPresenter.validateBoundProperties();
 
         final Stream<BinderValidationStatus<?>> subFormValidationResults = subEditors.stream()
                 .flatMap(subEditorReference -> subEditorReference.representations.values().stream())
                 .flatMap(childForm -> childForm.validate().stream());
 
         return Stream.concat(fieldValidationResults, subFormValidationResults).collect(toList());
     }
 
     @Override
     public <V> Optional<V> getPropertyValue(String propertyName, Locale locale) {
         return this.formPresenter.getBoundPropertyValue(propertyName, locale);
     }
 
     @Override
     public Stream<String> getPropertyNames() {
         return formDefinition.getProperties().stream().map(EditorPropertyDefinition::getName);
     }
 
     private Component computeLayout(Map<FieldDefinition<T>, Component> boundFields) {
 
         FieldLayoutDefinition<?> layoutDefinition = formDefinition.getLayout();
         @SuppressWarnings("unchecked")
         FieldLayoutProducer<LayoutDefinition> producer = getComponentProvider().newInstance(layoutDefinition.getImplementationClass());
 
         Map<String, Component> fieldComponents = new LinkedHashMap<>();
         subEditors.forEach(subForm -> {
             Locale targetLocale = subForm.definition.isI18n() ? localeContext.getCurrent() : localeContext.getDefault();
             fieldComponents.put(subForm.definition.getName(), subForm.representations.get(targetLocale).asVaadinComponent());
         });
 
         boundFields.forEach((def, component) -> fieldComponents.put(def.getName(), component));
         Map<EditorPropertyDefinition, Component> orderedComponents = this.formDefinition.getProperties().stream().collect(
                 toMap(Function.identity(),
                       def -> fieldComponents.get(def.getName()),
                       (f, s) -> s, LinkedHashMap::new));
 
         return producer.createLayout(layoutDefinition, orderedComponents);
     }
 
     @Override
     public Component asVaadinComponent() {
         return this.layout;
     }
 
     @Getter
     @AllArgsConstructor
     private static class SubEditorReference<T> {
         private Map<Locale, EditorView<T>> representations;
         private ItemProviderStrategy<T, T> itemProviderStrategy;
         private ComplexPropertyDefinition<T> definition;
     }
 }