/**
    * 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.Objects;
  import java.util.Optional;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import io.reactivex.BackpressureStrategy;
  import io.reactivex.disposables.Disposable;
  import io.reactivex.functions.Consumer;
  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();
  
      default void set(T value) {
          set(value, false);
      }
  
      void set(T value, boolean shouldNotifyOnSameItem);
  
      void mutate(Consumer<T> mutator);
  
      default T nullableValue() {
          //TODO: Not get if that's nullable!
          return value().get();
      }
  
      /**
       * 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 set(T value, boolean shouldNotifyOnSameItem) {
             this.delegate.set(value, shouldNotifyOnSameItem);
         }
 
         @Override
         public void mutate(Consumer<T> mutator) {
             this.delegate.mutate(mutator);
         }
     }
 
     //    Flowable<Optional<T>> observe();
 
     /**
      * 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;
 
 
         Impl() {
             subject.onNext(Optional.empty());
         }
 
         public Disposable observeNullable(Consumer<T> action) {
             return subject
                     .toFlowable(BackpressureStrategy.LATEST)
                     .map(optional -> optional)
                     .subscribe(
                             optional -> {
                                 muteUpdates();
                                 try {
                                     action.accept(optional.orElse(null));
                                 } finally {
                                     unmuteUpdates();
                                 }
                             },
                             e -> log.error("Failed to dispatch context property change: {}", e.getMessage(), e));
         }
 
         @Override
         public Disposable observe(Consumer<Optional<T>> action) {
             return subject.subscribe(value -> {
                 muteUpdates();
                 try {
                     action.accept(value);
                 } finally {
                     unmuteUpdates();
                 }
             }, e -> log.error("Failed to dispatch context property change: {}", e.getMessage(), e));
 
         }
 
         @Override
         public void mutate(Consumer<T> mutator) {
             value().ifPresent(value -> {
                 try {
                     mutator.accept(value);
                 } catch (Exception e) {
                     log.error("{}", e.getMessage(), e);
                 }
                 doSet(value, true);
             });
         }
 
         @Override
         public Optional<T> value() {
             return Optional.ofNullable(this.lastValue);
         }
 
         @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;
         }
     }
 }