// 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 <atomic>

#include <vector>

#include "tbb/queuing_mutex.h"

#include "tbb/spin_mutex.h"

#include "tbb/task_group.h"

#include "react/common/Containers.h"

#include "react/common/SourceIdSet.h"

#include "react/common/Types.h"

#include "react/detail/EngineBase.h"

#include "react/detail/ReactiveDomain.h"

/***************************************/ REACT_IMPL_BEGIN /**************************************/

namespace sourceset {

class Node;

using std::atomic;

using std::vector;

using tbb::task_group;

using tbb::queuing_mutex;

using tbb::spin_mutex;

///////////////////////////////////////////////////////////////////////////////////////////////////

/// Turn

///////////////////////////////////////////////////////////////////////////////////////////////////

class Turn : public TurnBase

{

public:

using SourceIdSetT = SourceIdSet<ObjectId>;

Turn(TurnIdT id, TurnFlagsT flags);

void AddSourceId(ObjectId id);

SourceIdSetT& Sources() { return sources_; }

private:

SourceIdSetT sources_;

};

///////////////////////////////////////////////////////////////////////////////////////////////////

/// Node

///////////////////////////////////////////////////////////////////////////////////////////////////

class Node : public IReactiveNode

{

public:

using SourceIdSetT = Turn::SourceIdSetT;

using NudgeMutexT = queuing_mutex;

using ShiftMutexT = spin_mutex;

Node();

void AddSourceId(ObjectId id);

void AttachSuccessor(Node& node);

void DetachSuccessor(Node& node);

void DynamicAttachTo(Node& parent, Turn& turn);

void DynamicDetachFrom(Node& parent, Turn& turn);

void Destroy();

void Pulse(Turn& turn, bool updated);

bool IsDependency(Turn& turn);

bool CheckCurrentTurn(Turn& turn);

void Nudge(Turn& turn, bool update, bool invalidate);

void CheckForCycles(ObjectId startId) const;

private:

enum

{

kFlag_Visited = 1 << 0,

kFlag_Updated = 1 << 1,

kFlag_Invaliated = 1 << 2

};

NodeVector<Node> predecessors_;

NodeVector<Node> successors_;

SourceIdSetT sources_;

uint curTurnId_;

short tickThreshold_;

uchar flags_;

NudgeMutexT nudgeMutex_;

ShiftMutexT shiftMutex_;

void invalidateSources();

};

///////////////////////////////////////////////////////////////////////////////////////////////////

/// EngineBase

///////////////////////////////////////////////////////////////////////////////////////////////////

template <typename TTurn>

class EngineBase : public IReactiveEngine<Node,TTurn>

{

public:

void OnNodeCreate(Node& node);

void OnNodeAttach(Node& node, Node& parent);

void OnNodeDetach(Node& node, Node& parent);

void OnNodeDestroy(Node& node);

void OnTurnInputChange(Node& node, TTurn& turn);

void OnTurnPropagate(TTurn& turn);

void OnNodePulse(Node& node, TTurn& turn);

void OnNodeIdlePulse(Node& node, TTurn& turn);

void OnDynamicNodeAttach(Node& node, Node& parent, TTurn& turn);

void OnDynamicNodeDetach(Node& node, Node& parent, TTurn& turn);

private:

vector<Node*> changedInputs_;

};

class BasicEngine : public EngineBase<Turn> {};

class QueuingEngine : public DefaultQueuingEngine<EngineBase,Turn> {};

} // ~namespace sourceset

/****************************************/ REACT_IMPL_END /***************************************/

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

struct parallel;

struct parallel_queue;

template <typename TMode>

class SourceSetEngine;

template <> class SourceSetEngine<parallel> : public REACT_IMPL::sourceset::BasicEngine {};

template <> class SourceSetEngine<parallel_queue> : public REACT_IMPL::sourceset::QueuingEngine {};

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

/***************************************/ REACT_IMPL_BEGIN /**************************************/

template <typename> struct EnableParallelUpdating;

template <> struct EnableParallelUpdating<SourceSetEngine<parallel>> : std::true_type {};

template <> struct EnableParallelUpdating<SourceSetEngine<parallel_queue>> : std::true_type {};

/****************************************/ REACT_IMPL_END /***************************************/