/**
    * 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;
  
  
  import java.io.Serializable;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Objects;
  import java.util.Optional;
  import java.util.function.Consumer;
  import java.util.function.UnaryOperator;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import io.reactivex.BackpressureStrategy;
  import io.reactivex.Flowable;
  import io.reactivex.disposables.Disposable;
  import io.reactivex.subjects.BehaviorSubject;
  import io.reactivex.subjects.Subject;
  
  /**
   * Observable property. Provides two flavours of observation:
   * <ul>
   * <li>null-safe, which yields optionals to the observers</li>
   * <li>nullable, which may broadcast nulls</li>
   * </ul>
   * <p>
   * Also provides the mutation capabilities in imperative and functional styles. Imperative is
   * useful when we merely want to swap one value with another, whereas the functional one can be
   * used when e.g. another element needs to be added to a collection.
   * </p>
   * @param <T> item type.
   */
  public interface ContextProperty<T> extends Serializable {
  
      Logger log = LoggerFactory.getLogger(ContextProperty.class);
  
      Disposable observeNullable(Consumer<T> action);
  
      Disposable observe(Consumer<Optional<T>> action);
  
      Optional<T> value();
  
      void interceptWith(UnaryOperator<T> valueTransformer);
  
      default void set(T value) {
          set(value, false);
      }
  
      void set(T value, boolean shouldNotifyOnSameItem);
  
      void update(UnaryOperator<T> updateOperation);
  
      void update(Consumer<T> updateOperation);
  
      default T nullableValue() {
          return value().orElse(null);
      }
  
      /**
       * A wrapper around {@link ContextProperty}.
       * @param <T> item type.
       */
      class Wrapper<T> implements ContextProperty<T> {
  
          private final ContextProperty<T> delegate;
 
         public Wrapper(ContextProperty<T> delegate) {
             this.delegate = delegate;
         }
 
         @Override
         public Disposable observeNullable(Consumer<T> action) {
             return this.delegate.observeNullable(action);
         }
 
         @Override
         public Disposable observe(Consumer<Optional<T>> action) {
             return this.delegate.observe(action);
         }
 
         @Override
         public Optional<T> value() {
             return this.delegate.value();
         }
 
         @Override
         public void interceptWith(UnaryOperator<T> valueTransformer) {
             this.delegate.interceptWith(valueTransformer);
         }
 
         @Override
         public void set(T value, boolean shouldNotifyOnSameItem) {
             this.delegate.set(value, shouldNotifyOnSameItem);
         }
 
         @Override
         public void update(UnaryOperator<T> updateOperation) {
             this.delegate.update(updateOperation);
         }
 
         @Override
         public void update(Consumer<T> updateOperation) {
             this.delegate.update(updateOperation);
         }
     }
 
     /**
      * Default implementation of {@link ContextProperty}.
      *
      * @param <T>
      *     property value type
      */
     class Impl<T> implements ContextProperty<T> {
 
         private static final Logger log = LoggerFactory.getLogger(Impl.class);
 
         private T lastValue = null;
 
         private T pendingValueUpdate = null;
 
         private Subject<Optional<T>> subject = BehaviorSubject.createDefault(Optional.empty());
 
         private boolean updatesMuted;
 
         private List<UnaryOperator<T>> valueTransformers = new ArrayList<>();
 
         Impl() {
             subject.onNext(Optional.empty());
         }
 
         public Disposable observeNullable(Consumer<T> action) {
             return asFlowable()
                     .subscribe(
                             optional -> {
                                 muteUpdates();
                                 try {
                                     action.accept(optional.orElse(null));
                                 } finally {
                                     unmuteUpdates();
                                 }
                             },
                             e -> log.error("Failed to dispatch context property change: {}", e.getMessage(), e));
         }
 
         public Flowable<Optional<T>> asFlowable() {
             return subject.toFlowable(BackpressureStrategy.LATEST).map(optionalValue -> Optional.ofNullable(applyValueTransformers(optionalValue.orElse(null))));
         }
 
         public T applyValueTransformers(T value) {
             return valueTransformers.stream().reduce(
                     value,
                     (current, mapper) -> mapper.apply(current),
                     (f, s) -> s);
         }
 
         @Override
         public Disposable observe(Consumer<Optional<T>> action) {
             return asFlowable().subscribe(value -> {
                 muteUpdates();
                 try {
                     action.accept(value);
                 } finally {
                     unmuteUpdates();
                 }
             }, e -> log.error("Failed to dispatch context property change: {}", e.getMessage(), e));
 
         }
 
         @Override
         public void update(UnaryOperator<T> updateOperation) {
             value().ifPresent(value -> {
                 try {
                     doSet(updateOperation.apply(value), true);
                 } catch (Exception e) {
                     log.error("Failed to update context property value", e);
                 }
             });
         }
 
         @Override
         public void update(Consumer<T> updateOperation) {
             update(value -> {
                     updateOperation.accept(value);
                     return value;
             });
         }
 
         @Override
         public Optional<T> value() {
             return Optional.ofNullable(applyValueTransformers(this.lastValue));
         }
 
         @Override
         public void interceptWith(UnaryOperator<T> valueTransformer) {
             this.valueTransformers.add(valueTransformer);
         }
 
         @Override
         public void set(T value, boolean shouldNotifyOnSameItem) {
             doSet(value, shouldNotifyOnSameItem);
         }
 
         public void doSet(T value, boolean shouldNotifyOnSameItem) {
             if (updatesMuted) {
                 pendingValueUpdate = value;
                 return;
             }
 
             if (!shouldNotifyOnSameItem && Objects.equals(value, this.lastValue)) {
                 return;
             }
 
             this.lastValue = value;
             muteUpdates();
             try {
                 this.subject.onNext(Optional.ofNullable(value));
             } finally {
                unmuteUpdates();
             }
         }
 
         private void muteUpdates() {
             this.updatesMuted = true;
         }
 
         private void unmuteUpdates() {
             if (pendingValueUpdate != null) {
                 doSet(pendingValueUpdate, false);
                 pendingValueUpdate = null;
             }
 
             this.updatesMuted = false;
         }
     }
 }