//          Copyright Sebastian Jeckel 2014.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)

#pragma once

#include "react/detail/Defs.h"

#include 
#include 
#include 
#include 
#include 

#include "Signal.h"
#include "EventStream.h"
#include "react/detail/graph/ConversionNodes.h"

/*****************************************/ REACT_BEGIN /*****************************************/

///////////////////////////////////////////////////////////////////////////////////////////////////
/// Fold
///////////////////////////////////////////////////////////////////////////////////////////////////
template
<
    typename D,
    typename V,
    typename E,
    typename FIn,
    typename S = std::decay::type,
    typename F = std::decay::type
>
auto Fold(V&& init, const Events& events, FIn&& func)
    -> Signal
{
    return Signal(
        std::make_shared(
            std::forward(init), events.GetPtr(), std::forward(func)));
}

///////////////////////////////////////////////////////////////////////////////////////////////////
/// Iterate
///////////////////////////////////////////////////////////////////////////////////////////////////
template
<
    typename D,
    typename V,
    typename E,
    typename FIn,
    typename S = std::decay::type,
    typename F = std::decay::type
>
auto Iterate(V&& init, const Events& events, FIn&& func)
    -> Signal
{
    return Signal(
        std::make_shared(
            std::forward(init), events.GetPtr(), std::forward(func)));
}

///////////////////////////////////////////////////////////////////////////////////////////////////
/// Hold
///////////////////////////////////////////////////////////////////////////////////////////////////
template
<
    typename D,
    typename V,
    typename T = std::decay::type
>
auto Hold(V&& init, const Events& events)
    -> Signal
{
    return Signal(
        std::make_shared(
            std::forward(init), events.GetPtr()));
}

///////////////////////////////////////////////////////////////////////////////////////////////////
/// Snapshot
///////////////////////////////////////////////////////////////////////////////////////////////////
template
<
    typename D,
    typename S,
    typename E
>
auto Snapshot(const Signal& target, const Events& trigger)
    -> Signal
{
    return Signal(
        std::make_shared(
            target.GetPtr(), trigger.GetPtr()));
}

///////////////////////////////////////////////////////////////////////////////////////////////////
/// Monitor
///////////////////////////////////////////////////////////////////////////////////////////////////
template
<
    typename D,
    typename S
>
auto Monitor(const Signal& target)
    -> Events
{
    return Events(
        std::make_shared(
            target.GetPtr()));
}

///////////////////////////////////////////////////////////////////////////////////////////////////
/// Changed
///////////////////////////////////////////////////////////////////////////////////////////////////
template
<
    typename D,
    typename S
>
auto Changed(const Signal& target)
    -> Events
{
    return Transform(Monitor(target), [] (const S& v) { return true; });
}

///////////////////////////////////////////////////////////////////////////////////////////////////
/// ChangedTo
///////////////////////////////////////////////////////////////////////////////////////////////////
template
<
    typename D,
    typename V,
    typename S = std::decay::type
>
auto ChangedTo(const Signal& target, V&& value)
    -> Events
{
    auto transformFunc  = [=] (const S& v)    { return v == value; };
    auto filterFunc     = [=] (bool v)        { return v == true; };

    return Filter(Transform(Monitor(target), transformFunc), filterFunc);
}

///////////////////////////////////////////////////////////////////////////////////////////////////
/// Pulse
///////////////////////////////////////////////////////////////////////////////////////////////////
template
<
    typename D,
    typename S,
    typename E
>
auto Pulse(const Signal& target, const Events& trigger)
    -> Events
{
    return Events(
        std::make_shared(
            target.GetPtr(), trigger.GetPtr()));
}

///////////////////////////////////////////////////////////////////////////////////////////////////
/// Flatten
///////////////////////////////////////////////////////////////////////////////////////////////////
template
<
    typename D,
    typename TInnerValue
>
auto Flatten(const Signal& node)
    -> Events
{
    return Events(
        std::make_shared(
            node.GetPtr(), node().GetPtr()));
}

///////////////////////////////////////////////////////////////////////////////////////////////////
/// Incrementer
///////////////////////////////////////////////////////////////////////////////////////////////////
template 
struct Incrementer : public std::unary_function
{
    T operator() (T v) const { return v+1; }
};

///////////////////////////////////////////////////////////////////////////////////////////////////
/// Decrementer
///////////////////////////////////////////////////////////////////////////////////////////////////
template 
struct Decrementer : public std::unary_function
{
    T operator() (T v) const { return v-1; }
};

/******************************************/ REACT_END /******************************************/