/*
    * Copyright 2017 The Netty Project
    *
    * The Netty Project licenses this file to you under the Apache License,
    * version 2.0 (the "License"); you may not use this file except in compliance
    * with the License. You may obtain a copy of the License at:
    *
    *   https://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
   * License for the specific language governing permissions and limitations
   * under the License.
   */
  package io.netty.channel;
  
  import io.netty.util.concurrent.Future;
  import io.netty.util.concurrent.GenericFutureListener;
  import io.netty.util.internal.PromiseNotificationUtil;
  import io.netty.util.internal.UnstableApi;
  import io.netty.util.internal.logging.InternalLogger;
  import io.netty.util.internal.logging.InternalLoggerFactory;
  
  import java.util.concurrent.ExecutionException;
  import java.util.concurrent.TimeUnit;
  import java.util.concurrent.TimeoutException;
  
  import static io.netty.util.internal.ObjectUtil.checkNotNull;
  
  @UnstableApi
  public final class DelegatingChannelPromiseNotifier implements ChannelPromise, ChannelFutureListener {
      private static final InternalLogger logger =
              InternalLoggerFactory.getInstance(DelegatingChannelPromiseNotifier.class);
      private final ChannelPromise delegate;
      private final boolean logNotifyFailure;
  
      public DelegatingChannelPromiseNotifier(ChannelPromise delegate) {
          this(delegate, !(delegate instanceof VoidChannelPromise));
      }
  
      public DelegatingChannelPromiseNotifier(ChannelPromise delegate, boolean logNotifyFailure) {
          this.delegate = checkNotNull(delegate, "delegate");
          this.logNotifyFailure = logNotifyFailure;
      }
  
      @Override
      public void operationComplete(ChannelFuture future) throws Exception {
          InternalLogger internalLogger = logNotifyFailure ? logger : null;
          if (future.isSuccess()) {
              Void result = future.get();
              PromiseNotificationUtil.trySuccess(delegate, result, internalLogger);
          } else if (future.isCancelled()) {
              PromiseNotificationUtil.tryCancel(delegate, internalLogger);
          } else {
              Throwable cause = future.cause();
              PromiseNotificationUtil.tryFailure(delegate, cause, internalLogger);
          }
      }
  
      @Override
      public Channel channel() {
          return delegate.channel();
      }
  
      @Override
      public ChannelPromise setSuccess(Void result) {
          delegate.setSuccess(result);
          return this;
      }
  
      @Override
      public ChannelPromise setSuccess() {
          delegate.setSuccess();
          return this;
      }
  
      @Override
      public boolean trySuccess() {
          return delegate.trySuccess();
      }
  
      @Override
      public boolean trySuccess(Void result) {
          return delegate.trySuccess(result);
      }
  
      @Override
      public ChannelPromise setFailure(Throwable cause) {
          delegate.setFailure(cause);
          return this;
      }
  
      @Override
      public ChannelPromise addListener(GenericFutureListener<? extends Future<? super Void>> listener) {
          delegate.addListener(listener);
          return this;
      }
  
     @Override
     public ChannelPromise addListeners(GenericFutureListener<? extends Future<? super Void>>... listeners) {
         delegate.addListeners(listeners);
         return this;
     }
 
     @Override
     public ChannelPromise removeListener(GenericFutureListener<? extends Future<? super Void>> listener) {
         delegate.removeListener(listener);
         return this;
     }
 
     @Override
     public ChannelPromise removeListeners(GenericFutureListener<? extends Future<? super Void>>... listeners) {
         delegate.removeListeners(listeners);
         return this;
     }
 
     @Override
     public boolean tryFailure(Throwable cause) {
         return delegate.tryFailure(cause);
     }
 
     @Override
     public boolean setUncancellable() {
         return delegate.setUncancellable();
     }
 
     @Override
     public ChannelPromise await() throws InterruptedException {
         delegate.await();
         return this;
     }
 
     @Override
     public ChannelPromise awaitUninterruptibly() {
         delegate.awaitUninterruptibly();
         return this;
     }
 
     @Override
     public boolean isVoid() {
         return delegate.isVoid();
     }
 
     @Override
     public ChannelPromise unvoid() {
         return isVoid() ? new DelegatingChannelPromiseNotifier(delegate.unvoid()) : this;
     }
 
     @Override
     public boolean await(long timeout, TimeUnit unit) throws InterruptedException {
         return delegate.await(timeout, unit);
     }
 
     @Override
     public boolean await(long timeoutMillis) throws InterruptedException {
         return delegate.await(timeoutMillis);
     }
 
     @Override
     public boolean awaitUninterruptibly(long timeout, TimeUnit unit) {
         return delegate.awaitUninterruptibly(timeout, unit);
     }
 
     @Override
     public boolean awaitUninterruptibly(long timeoutMillis) {
         return delegate.awaitUninterruptibly(timeoutMillis);
     }
 
     @Override
     public Void getNow() {
         return delegate.getNow();
     }
 
     @Override
     public boolean cancel(boolean mayInterruptIfRunning) {
         return delegate.cancel(mayInterruptIfRunning);
     }
 
     @Override
     public boolean isCancelled() {
         return delegate.isCancelled();
     }
 
     @Override
     public boolean isDone() {
         return delegate.isDone();
     }
 
     @Override
     public Void get() throws InterruptedException, ExecutionException {
         return delegate.get();
     }
 
     @Override
     public Void get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
         return delegate.get(timeout, unit);
     }
 
     @Override
     public ChannelPromise sync() throws InterruptedException {
         delegate.sync();
         return this;
     }
 
     @Override
     public ChannelPromise syncUninterruptibly() {
         delegate.syncUninterruptibly();
         return this;
     }
 
     @Override
     public boolean isSuccess() {
         return delegate.isSuccess();
     }
 
     @Override
     public boolean isCancellable() {
         return delegate.isCancellable();
     }
 
     @Override
     public Throwable cause() {
         return delegate.cause();
     }
 }