/**
    * 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.function.Function.identity;
  import static java.util.stream.Collectors.toList;
  import static java.util.stream.Collectors.toMap;
  
  import com.vaadin.data.*;
  import info.magnolia.objectfactory.ComponentProvider;
  import info.magnolia.ui.datasource.PropertySetFactory;
  import info.magnolia.ui.field.FieldBinder;
  import info.magnolia.ui.field.FieldDefinition;
  import info.magnolia.ui.field.ValueBoundProperty;
  import info.magnolia.ui.framework.ioc.UiComponentProvider;
  import info.magnolia.ui.framework.layout.field.FieldLayoutComponent;
  
  import java.lang.reflect.Field;
  import java.util.*;
  import java.util.function.Function;
  import java.util.stream.Stream;
  import java.util.stream.StreamSupport;
  
  import javax.inject.Inject;
  
  import com.vaadin.server.ClientConnector;
  import com.vaadin.ui.Component;
  import com.vaadin.ui.VerticalLayout;
  
  /**
   * Handles some logic on behalf of the FormView.
   * @param <T> item type.
   */
  public class FormPresenter<T> {
  
      private static final Field changedBindingsAccessor;
      private static Field converterValidatorChain;
  
      static {
          try {
              changedBindingsAccessor = Binder.class.getDeclaredField("changedBindings");
              changedBindingsAccessor.setAccessible(true);
          } catch (NoSuchFieldException e) {
              throw new RuntimeException("Failed to enable changed bindings accessor", e);
          }
      }
  
      private final PropertySetFactory<T> propertySetFactory;
      private final FormDefinition<T> formDefinition;
      private final UiComponentProvider componentProvider;
      private final LocaleContext localeContext;
      private final Locale defaultLocale;
      private final Map<Locale, Binder<T>> localisedBinders = new HashMap<>();
  
      @Inject
      public FormPresenter(PropertySetFactory<T> propertySetFactory, FormDefinition<T> formDefinition, UiComponentProvider componentProvider, LocaleContext localeContext) {
          this.propertySetFactory = propertySetFactory;
          this.formDefinition = formDefinition;
          this.componentProvider = componentProvider;
          this.defaultLocale = localeContext.getDefault();
          this.localeContext = localeContext;
          this.localeContext.getAvailableLocales().forEach(locale -> this.localisedBinders.put(locale, bindFields(locale)));
      }
  
      public FormPresenter(PropertySetFactory<T> propertySetFactory, FormDefinition<T> formDefinition, UiComponentProvider componentProvider) {
          this(propertySetFactory, formDefinition, componentProvider, LocaleContext.of(Locale.getDefault()));
      }
  
     public void bind(T item) {
         localeContext.getAvailableLocales().map(this::getBinder).forEach(binder -> binder.readBean(item));
     }
 
     public Binder<T> getBinder(Locale locale) {
         return this.localisedBinders.computeIfAbsent(locale, l -> bindFields(locale));
     }
 
     public <V> Optional<V> getBoundPropertyValue(String propertyName, Locale locale) {
         Binder<T> binder = localisedBinders.get(locale);
 
         Optional<Binder.Binding<T, ?>> binding = binder.getBinding(propertyName);
         return binding
                 .filter(b -> !b.validate().isError())
                 .map(b -> (V) b.getField().getValue());
     }
 
     public void writeBindings(T item) {
         this.localisedBinders.forEach((locale, binder) -> {
             try {
                 if (pendingForValidationAndWrite(binder, locale)) {
                     binder.writeBean(item);
                 }
             } catch (ValidationException e) {
                 throw new IllegalStateException("Failed to write form state", e);
             }
         });
     }
 
     public Stream<BinderValidationStatus<T>> validateBoundProperties() {
         Stream.Builder<BinderValidationStatus<T>> result = Stream.builder();
         localisedBinders.forEach((locale, binder) -> {
            if (pendingForValidationAndWrite(binder, locale)) {
                result.add(binder.validate());
            }
         });
         return result.build();
     }
 
     private boolean pendingForValidationAndWrite(Binder<T> binder, Locale locale) {
         return Objects.equals(locale, this.defaultLocale) || hasI18NPropertyChanges(binder);
     }
 
     public Optional<Map<FieldDefinition<T>, Component>> getBoundFields(Locale locale) {
         Map<FieldDefinition<T>, Component> result = new LinkedHashMap<>();
 
         Binder<T> binder = getBinder(locale);
 
         formDefinition.getFieldDefinitions().forEach(fieldDefinition -> {
             binder.getBinding(fieldDefinition.getName())
                     .map(Binder.Binding::getField)
                     .ifPresent(wrappedField -> result.put(fieldDefinition, (Component) wrappedField));
         });
 
         return Optional.of(result);
     }
 
     private Binder<T> createBinder(FormDefinition<T> formDefinition, Locale locale) {
         return Binder.withPropertySet(createPropertySet(formDefinition, locale));
     }
 
     private PropertySet<T> createPropertySet(FormDefinition<T> formDefinition, Locale locale) {
         return propertySetFactory.fromFormDefinition(formDefinition, locale);
     }
 
     private Binder.BindingBuilder configureBinding(FieldDefinition property, Binder.BindingBuilder bindingBuilder) {
         ComponentProvider fieldComponentProvider = componentProvider.inChildContext(property);
         FieldBinder<?> fieldBinder = (FieldBinder<?>) fieldComponentProvider.newInstance(property.getFieldBinderClass());
         return fieldBinder.configureBinding(property, bindingBuilder);
     }
 
     private Binder.BindingBuilder bindValidator(Binder.BindingBuilder bindingBuilder) {
         return bindingBuilder.withValidationStatusHandler(status -> findParent(bindingBuilder.getField(), VerticalLayout.class)
                 .flatMap(components -> StreamSupport.stream(components.spliterator(), false)
                 .filter(component ->  FieldLayoutComponent.ValidationLabel.class.isInstance(component))
                 .map(FieldLayoutComponent.ValidationLabel.class::cast)
                 .findFirst())
                 .ifPresent(validationLabel -> validationLabel.setValue(status.getMessage().orElse("")))
         );
     }
 
     public void bindProperty(Component field, FieldDefinition property, Binder<T> binder) {
         configureBinding(property, bindValidator(binder.forField((HasValue) field))).bind(property.getName());
     }
 
     private <V extends Component> Optional<V> findParent(HasValue field, Class<V> parentClass) {
         return findParent((Component) field, parentClass);
     }
 
     private <V extends Component> Optional<V> findParent(Component field, Class<V> parentClass) {
         ClientConnector connector = field;
         while (connector != null) {
             if (parentClass.isInstance(connector)) {
                 return Optional.of((V) connector);
             }
             connector = connector.getParent();
         }
         return Optional.empty();
     }
 
     private void broadcastNonLocalisedFieldChanges(Binder<T> binder, Map<Component, FieldDefinition> fields) {
 
         // whenever a value change occurs to a non-i18n field,
         // propagate the value to all the locale-specific projections (such value should be shared and
         // Vaadin is not able to do that for us, hence explicitness.
         binder.addValueChangeListener(e -> {
             Optional<FieldDefinition> fieldDefinition = findRelatedDefinition((Component) e.getSource(), fields);
             fieldDefinition.ifPresent(def -> {
                 if (!def.isI18n()) {
                     localisedBinders.values().stream()
                             .filter(b -> b != binder)
                             .forEach(b -> b.getBinding(def.getName())
                                     .ifPresent(binding -> ((HasValue) binding.getField()).setValue(e.getValue())));
                 }
             });
         });
     }
 
     /**
      * Takes list of field definitions mapped to their Vaadin components and another component that
      * is potentially a child of one of them. Looks up its parent and returns a corresponding field
      * definition.a
      */
     private Optional<FieldDefinition> findRelatedDefinition(Component component, Map<Component, FieldDefinition> parentComponentMappings) {
         while (component != null) {
             if (parentComponentMappings.containsKey(component)) {
                 return Optional.of(parentComponentMappings.get(component));
             }
             component = component.getParent();
         }
         return Optional.empty();
     }
 
     protected Binder<T> bindFields(Locale locale) {
         Map<Component, FieldDefinition> fields = this.formDefinition
                 .getFieldDefinitions()
                 .stream()
                 .map(fieldDefinition -> (FieldDefinition<?>) fieldDefinition)
                 .collect(toMap(
                         fieldDefinition ->
                                 (Component) componentProvider
                                         .inChildContext(fieldDefinition)
                                         .newInstance(fieldDefinition.getFactoryClass())
                                         .createField(),
                         identity()));
 
         Binder<T> binder = createBinder(formDefinition, locale);
         // Bind all fields
         fields.forEach((field, property) -> bindProperty(field, property, binder));
 
         binder.getFields()
                 .map(field -> (Component) field)
                 .filter(field -> fields.get(field).isI18n())
                 .forEach(component -> {
                     if (locale != null && localeContext.getAvailableLocales().count() > 1) {
                         component.setCaption(String.format("%s (%s)", component.getCaption(), locale.toString()));
                     }
                 });
 
         broadcastNonLocalisedFieldChanges(binder, fields);
 
         return binder;
     }
 
     private boolean hasI18NPropertyChanges(Binder<T> binder) {
         Collection<Binder.Binding<T, ?>> changedBindings = getChangedBindings(binder);
         return formDefinition.getFieldDefinitions().stream()
                 .filter(FieldDefinition::isI18n)
                 .map(FieldDefinition::getName)
                 .map(binder::getBinding)
                 .anyMatch(maybeBinding -> maybeBinding
                         .map(changedBindings::contains)
                         .orElse(false));
     }
 
     public Collection<Binder.Binding<T, ?>> getChangedBindings(Binder<T> binder) {
         try {
             return ((Collection<Binder.Binding<T, ?>>) changedBindingsAccessor.get(binder));
         } catch (IllegalAccessException e) {
             throw new RuntimeException("Failed to access changed bindings", e);
         }
     }
 
     public void applyDefaults() {
         Map<FieldDefinition, Object> defaultValues = this.formDefinition
                 .getFieldDefinitions().stream()
                 .filter(def -> def.getDefaultValue() != null)
                 .collect(toMap(Function.identity(), ValueBoundProperty::getDefaultValue));
 
 
         Binder<T> binder = this.localisedBinders.get(localeContext.getDefault());
         defaultValues.forEach(((fieldDefinition, value) -> {
             binder.getBinding(fieldDefinition.getName()).ifPresent(binding -> {
                 Object presentationValue = resolveConversionChain(binding).convertToPresentation(value, null);
                 ((HasValue) binding.getField()).setValue((T) presentationValue);
             });
         }));
     }
 
     private Converter resolveConversionChain(Binder.Binding binding) {
         try {
             if (converterValidatorChain == null) {
                 converterValidatorChain = binding.getClass().getDeclaredField("converterValidatorChain");
                 converterValidatorChain.setAccessible(true);
             }
 
             return (Converter) converterValidatorChain.get(binding);
         } catch (NoSuchFieldException | IllegalAccessException e) {
             throw new RuntimeException(e);
         }
     }
 }