// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.

#pragma once

/*! \file rx-connect_forever.hpp

    \brief  takes a connectable_observable source and calls connect during the construction of the expression.
            This means that the source starts running without any subscribers and continues running after all subscriptions have been unsubscribed.

    \return An observable that emitting the items from its source.
 */

#if !defined(RXCPP_OPERATORS_RX_CONNECT_FOREVER_HPP)
#define RXCPP_OPERATORS_RX_CONNECT_FOREVER_HPP

#include "../rx-includes.hpp"

namespace rxcpp {

namespace operators {

namespace detail {

template<class... AN>
struct connect_forever_invalid_arguments {};

template<class... AN>
struct connect_forever_invalid : public rxo::operator_base<connect_forever_invalid_arguments<AN...>> {
    using type = observable<connect_forever_invalid_arguments<AN...>, connect_forever_invalid<AN...>>;
};
template<class... AN>
using connect_forever_invalid_t = typename connect_forever_invalid<AN...>::type;

template<class T, class ConnectableObservable>
struct connect_forever : public operator_base<T>
{
    typedef rxu::decay_t<ConnectableObservable> source_type;

    source_type source;

    explicit connect_forever(source_type o)
        : source(std::move(o))
    {
        source.connect();
    }

    template<class Subscriber>
    void on_subscribe(Subscriber&& o) const {
        source.subscribe(std::forward<Subscriber>(o));
    }
};

}

/*! @copydoc rx-connect_forever.hpp
*/
template<class... AN>
auto connect_forever(AN&&... an)
->     operator_factory<connect_forever_tag, AN...> {
    return operator_factory<connect_forever_tag, AN...>(std::make_tuple(std::forward<AN>(an)...));
}

}

template<>
struct member_overload<connect_forever_tag>
{
    template<class ConnectableObservable,
        class Enabled = rxu::enable_if_all_true_type_t<
            is_connectable_observable<ConnectableObservable>>,
        class SourceValue = rxu::value_type_t<ConnectableObservable>,
        class ConnectForever = rxo::detail::connect_forever<SourceValue, rxu::decay_t<ConnectableObservable>>,
        class Value = rxu::value_type_t<ConnectForever>,
        class Result = observable<Value, ConnectForever>
        >
    static Result member(ConnectableObservable&& o) {
        return Result(ConnectForever(std::forward<ConnectableObservable>(o)));
    }

    template<class... AN>
    static operators::detail::connect_forever_invalid_t<AN...> member(AN...) {
        std::terminate();
        return {};
        static_assert(sizeof...(AN) == 10000, "connect_forever takes no arguments");
    }
};

}

#endif