/*

 * Copyright (c) 2017, 2018, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

import java.nio.ByteBuffer;

import java.util.List;

import java.util.concurrent.Flow;

/**

 * FlowTube is an I/O abstraction that allows reading from and writing to a

 * destination asynchronously.

 * This is not a {@link Flow.Processor

 * Flow.Processor<List<ByteBuffer>, List<ByteBuffer>>},

 * but rather models a publisher source and a subscriber sink in a bidirectional flow.

 * <p>

 * The {@code connectFlows} method should be called to connect the bidirectional

 * flow. A FlowTube supports handing over the same read subscription to different

 * sequential read subscribers over time. When {@code connectFlows(writePublisher,

 * readSubscriber} is called, the FlowTube will call {@code dropSubscription} on

 * its former readSubscriber, and {@code onSubscribe} on its new readSubscriber.

 */

public interface FlowTube extends

       Flow.Publisher<List<ByteBuffer>>,

       Flow.Subscriber<List<ByteBuffer>> {

    /**

     * A subscriber for reading from the bidirectional flow.

     * A TubeSubscriber is a {@code Flow.Subscriber} that can be canceled

     * by calling {@code dropSubscription()}.

     * Once {@code dropSubscription()} is called, the {@code TubeSubscriber}

     * should stop calling any method on its subscription.

     */

    static interface TubeSubscriber extends Flow.Subscriber<List<ByteBuffer>> {

        /**

         * Called when the flow is connected again, and the subscription

         * is handed over to a new subscriber.

         * Once {@code dropSubscription()} is called, the {@code TubeSubscriber}

         * should stop calling any method on its subscription.

         */

        default void dropSubscription() { }

    }

    /**

     * A publisher for writing to the bidirectional flow.

     */

    static interface TubePublisher extends Flow.Publisher<List<ByteBuffer>> {

    }

    /**

     * Connects the bidirectional flows to a write {@code Publisher} and a

     * read {@code Subscriber}. This method can be called sequentially

     * several times to switch existing publishers and subscribers to a new

     * pair of write subscriber and read publisher.

     * @param writePublisher A new publisher for writing to the bidirectional flow.

     * @param readSubscriber A new subscriber for reading from the bidirectional

     *                       flow.

     */

    default void connectFlows(TubePublisher writePublisher,

                              TubeSubscriber readSubscriber) {

        this.subscribe(readSubscriber);

        writePublisher.subscribe(this);

    }

    /**

     * Returns true if this flow was completed, either exceptionally

     * or normally (EOF reached).

     * @return true if the flow is finished

     */

    boolean isFinished();

    /**

     * Returns {@code s} if {@code s} is a {@code TubeSubscriber}, otherwise

     * wraps it in a {@code TubeSubscriber}.

     * Using the wrapper is only appropriate in the case where

     * {@code dropSubscription} doesn't need to be implemented, and the

     * {@code TubeSubscriber} is subscribed only once.

     *

     * @param s a subscriber for reading.

     * @return a {@code TubeSubscriber}: either {@code s} if {@code s} is a

     *           {@code TubeSubscriber}, otherwise a {@code TubeSubscriber}

     *           wrapper that delegates to {@code s}

     */

    static TubeSubscriber asTubeSubscriber(Flow.Subscriber<? super List<ByteBuffer>> s) {

        if (s instanceof TubeSubscriber) {

            return (TubeSubscriber) s;

        }

        return new AbstractTubeSubscriber.TubeSubscriberWrapper(s);

    }

    /**

     * Returns {@code s} if {@code s} is a {@code  TubePublisher}, otherwise

     * wraps it in a {@code  TubePublisher}.

     *

     * @param p a publisher for writing.

     * @return a {@code TubePublisher}: either {@code s} if {@code s} is a

     *           {@code  TubePublisher}, otherwise a {@code TubePublisher}

     *           wrapper that delegates to {@code s}

     */

    static TubePublisher asTubePublisher(Flow.Publisher<List<ByteBuffer>> p) {

        if (p instanceof TubePublisher) {

            return (TubePublisher) p;

        }

        return new AbstractTubePublisher.TubePublisherWrapper(p);

    }

    /**

     * Convenience abstract class for {@code TubePublisher} implementations.

     * It is not required that a {@code TubePublisher} implementation extends

     * this class.

     */

    static abstract class AbstractTubePublisher implements TubePublisher {

        static final class TubePublisherWrapper extends AbstractTubePublisher {

            final Flow.Publisher<List<ByteBuffer>> delegate;

            public TubePublisherWrapper(Flow.Publisher<List<ByteBuffer>> delegate) {

                this.delegate = delegate;

            }

            @Override

            public void subscribe(Flow.Subscriber<? super List<ByteBuffer>> subscriber) {

                delegate.subscribe(subscriber);

            }

        }

    }

    /**

     * Convenience abstract class for {@code TubeSubscriber} implementations.

     * It is not required that a {@code TubeSubscriber} implementation extends

     * this class.

     */

    static abstract class AbstractTubeSubscriber implements TubeSubscriber {

        static final class TubeSubscriberWrapper extends  AbstractTubeSubscriber {

            final Flow.Subscriber<? super List<ByteBuffer>> delegate;

            TubeSubscriberWrapper(Flow.Subscriber<? super List<ByteBuffer>> delegate) {

                this.delegate = delegate;

            }

            @Override

            public void dropSubscription() {}

            @Override

            public void onSubscribe(Flow.Subscription subscription) {

                delegate.onSubscribe(subscription);

            }

            @Override

            public void onNext(List<ByteBuffer> item) {

                delegate.onNext(item);

            }

            @Override

            public void onError(Throwable throwable) {

                delegate.onError(throwable);

            }

            @Override

            public void onComplete() {

                delegate.onComplete();

            }

        }

    }

}