/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program 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 for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#pragma once

/** \file
 * \ingroup fn
 *
 * A multi-function network (`MFNetwork`) allows you to connect multiple multi-functions. The
 * `MFNetworkEvaluator` is a multi-function that wraps an entire network into a new multi-function
 * (which can be used in another network and so on).
 *
 * A MFNetwork is a graph data structure with two kinds of nodes:
 * - MFFunctionNode: Represents a multi-function. Its input and output sockets correspond to
 *       parameters of the referenced multi-function.
 * - MFDummyNode: Does not reference a multi-function. Instead it just has sockets that can be
 *       used to represent node group inputs and outputs.
 *
 * Links represent data flow. Unlinked input sockets have no value. In order to execute a function
 * node, all its inputs have to be connected to something.
 *
 * Links are only allowed between sockets with the exact same MFDataType. There are no implicit
 * conversions.
 *
 * Every input and output parameter of a multi-function corresponds to exactly one input or output
 * socket respectively. A multiple parameter belongs to exactly one input AND one output socket.
 *
 * There is an .to_dot() method that generates a graph in dot format for debugging purposes.
 */

#include "FN_multi_function.hh"

#include "BLI_vector_set.hh"

namespace blender::fn {

class MFNode;
class MFFunctionNode;
class MFDummyNode;
class MFSocket;
class MFInputSocket;
class MFOutputSocket;
class MFNetwork;

class MFNode : NonCopyable, NonMovable {
 protected:
  MFNetwork *network_;
  Span<MFInputSocket *> inputs_;
  Span<MFOutputSocket *> outputs_;
  bool is_dummy_;
  int id_;

  friend MFNetwork;

 public:
  StringRefNull name() const;

  int id() const;

  MFNetwork &network();
  const MFNetwork &network() const;

  bool is_dummy() const;
  bool is_function() const;

  MFDummyNode &as_dummy();
  const MFDummyNode &as_dummy() const;

  MFFunctionNode &as_function();
  const MFFunctionNode &as_function() const;

  MFInputSocket &input(int index);
  const MFInputSocket &input(int index) const;

  MFOutputSocket &output(int index);
  const MFOutputSocket &output(int index) const;

  Span<MFInputSocket *> inputs();
  Span<const MFInputSocket *> inputs() const;

  Span<MFOutputSocket *> outputs();
  Span<const MFOutputSocket *> outputs() const;

  bool has_unlinked_inputs() const;

 private:
  void destruct_sockets();
};

class MFFunctionNode : public MFNode {
 private:
  const MultiFunction *function_;
  Span<int> input_param_indices_;
  Span<int> output_param_indices_;

  friend MFNetwork;

 public:
  StringRefNull name() const;

  const MultiFunction &function() const;

  const MFInputSocket &input_for_param(int param_index) const;
  const MFOutputSocket &output_for_param(int param_index) const;
};

class MFDummyNode : public MFNode {
 protected:
  StringRefNull name_;
  MutableSpan<StringRefNull> input_names_;
  MutableSpan<StringRefNull> output_names_;

  friend MFNetwork;

 public:
  StringRefNull name() const;

  Span<StringRefNull> input_names() const;
  Span<StringRefNull> output_names() const;
};

class MFSocket : NonCopyable, NonMovable {
 protected:
  MFNode *node_;
  bool is_output_;
  int index_;
  MFDataType data_type_;
  int id_;
  StringRefNull name_;

  friend MFNetwork;

 public:
  StringRefNull name() const;

  int id() const;
  int index() const;

  const MFDataType &data_type() const;

  MFNode &node();
  const MFNode &node() const;

  bool is_input() const;
  bool is_output() const;

  MFInputSocket &as_input();
  const MFInputSocket &as_input() const;

  MFOutputSocket &as_output();
  const MFOutputSocket &as_output() const;
};

class MFInputSocket : public MFSocket {
 private:
  MFOutputSocket *origin_;

  friend MFNetwork;

 public:
  MFOutputSocket *origin();
  const MFOutputSocket *origin() const;
};

class MFOutputSocket : public MFSocket {
 private:
  Vector<MFInputSocket *, 1> targets_;

  friend MFNetwork;

 public:
  Span<MFInputSocket *> targets();
  Span<const MFInputSocket *> targets() const;
};

class MFNetwork : NonCopyable, NonMovable {
 private:
  LinearAllocator<> allocator_;

  VectorSet<MFFunctionNode *> function_nodes_;
  VectorSet<MFDummyNode *> dummy_nodes_;

  Vector<MFNode *> node_or_null_by_id_;
  Vector<MFSocket *> socket_or_null_by_id_;

 public:
  MFNetwork() = default;
  ~MFNetwork();

  MFFunctionNode &add_function(const MultiFunction &function);
  MFDummyNode &add_dummy(StringRef name,
                         Span<MFDataType> input_types,
                         Span<MFDataType> output_types,
                         Span<StringRef> input_names,
                         Span<StringRef> output_names);
  void add_link(MFOutputSocket &from, MFInputSocket &to);

  MFOutputSocket &add_input(StringRef name, MFDataType data_type);
  MFInputSocket &add_output(StringRef name, MFDataType data_type);

  void relink(MFOutputSocket &old_output, MFOutputSocket &new_output);

  void remove(MFNode &node);
  void remove(Span<MFNode *> nodes);

  int socket_id_amount() const;
  int node_id_amount() const;

  Span<MFDummyNode *> dummy_nodes();
  Span<MFFunctionNode *> function_nodes();

  MFNode *node_or_null_by_id(int id);
  const MFNode *node_or_null_by_id(int id) const;

  MFSocket *socket_or_null_by_id(int id);
  const MFSocket *socket_or_null_by_id(int id) const;

  void find_dependencies(Span<const MFInputSocket *> sockets,
                         VectorSet<const MFOutputSocket *> &r_dummy_sockets,
                         VectorSet<const MFInputSocket *> &r_unlinked_inputs) const;

  bool have_dummy_or_unlinked_dependencies(Span<const MFInputSocket *> sockets) const;

  std::string to_dot(Span<const MFNode *> marked_nodes = {}) const;
};

/* --------------------------------------------------------------------
 * MFNode inline methods.
 */

inline StringRefNull MFNode::name() const
{
  if (is_dummy_) {
    return this->as_dummy().name();
  }
  else {
    return this->as_function().name();
  }
}

inline int MFNode::id() const
{
  return id_;
}

inline MFNetwork &MFNode::network()
{
  return *network_;
}

inline const MFNetwork &MFNode::network() const
{
  return *network_;
}

inline bool MFNode::is_dummy() const
{
  return is_dummy_;
}

inline bool MFNode::is_function() const
{
  return !is_dummy_;
}

inline MFDummyNode &MFNode::as_dummy()
{
  BLI_assert(is_dummy_);
  return static_cast<MFDummyNode &>(*this);
}

inline const MFDummyNode &MFNode::as_dummy() const
{
  BLI_assert(is_dummy_);
  return static_cast<const MFDummyNode &>(*this);
}

inline MFFunctionNode &MFNode::as_function()
{
  BLI_assert(!is_dummy_);
  return static_cast<MFFunctionNode &>(*this);
}

inline const MFFunctionNode &MFNode::as_function() const
{
  BLI_assert(!is_dummy_);
  return static_cast<const MFFunctionNode &>(*this);
}

inline MFInputSocket &MFNode::input(int index)
{
  return *inputs_[index];
}

inline const MFInputSocket &MFNode::input(int index) const
{
  return *inputs_[index];
}

inline MFOutputSocket &MFNode::output(int index)
{
  return *outputs_[index];
}

inline const MFOutputSocket &MFNode::output(int index) const
{
  return *outputs_[index];
}

inline Span<MFInputSocket *> MFNode::inputs()
{
  return inputs_;
}

inline Span<const MFInputSocket *> MFNode::inputs() const
{
  return inputs_;
}

inline Span<MFOutputSocket *> MFNode::outputs()
{
  return outputs_;
}

inline Span<const MFOutputSocket *> MFNode::outputs() const
{
  return outputs_;
}

inline bool MFNode::has_unlinked_inputs() const
{
  for (const MFInputSocket *socket : inputs_) {
    if (socket->origin() == nullptr) {
      return true;
    }
  }
  return false;
}

/* --------------------------------------------------------------------
 * MFFunctionNode inline methods.
 */

inline StringRefNull MFFunctionNode::name() const
{
  return function_->name();
}

inline const MultiFunction &MFFunctionNode::function() const
{
  return *function_;
}

inline const MFInputSocket &MFFunctionNode::input_for_param(int param_index) const
{
  return this->input(input_param_indices_.first_index(param_index));
}

inline const MFOutputSocket &MFFunctionNode::output_for_param(int param_index) const
{
  return this->output(output_param_indices_.first_index(param_index));
}

/* --------------------------------------------------------------------
 * MFDummyNode inline methods.
 */

inline StringRefNull MFDummyNode::name() const
{
  return name_;
}

inline Span<StringRefNull> MFDummyNode::input_names() const
{
  return input_names_;
}

inline Span<StringRefNull> MFDummyNode::output_names() const
{
  return output_names_;
}

/* --------------------------------------------------------------------
 * MFSocket inline methods.
 */

inline StringRefNull MFSocket::name() const
{
  return name_;
}

inline int MFSocket::id() const
{
  return id_;
}

inline int MFSocket::index() const
{
  return index_;
}

inline const MFDataType &MFSocket::data_type() const
{
  return data_type_;
}

inline MFNode &MFSocket::node()
{
  return *node_;
}

inline const MFNode &MFSocket::node() const
{
  return *node_;
}

inline bool MFSocket::is_input() const
{
  return !is_output_;
}

inline bool MFSocket::is_output() const
{
  return is_output_;
}

inline MFInputSocket &MFSocket::as_input()
{
  BLI_assert(this->is_input());
  return static_cast<MFInputSocket &>(*this);
}

inline const MFInputSocket &MFSocket::as_input() const
{
  BLI_assert(this->is_input());
  return static_cast<const MFInputSocket &>(*this);
}

inline MFOutputSocket &MFSocket::as_output()
{
  BLI_assert(this->is_output());
  return static_cast<MFOutputSocket &>(*this);
}

inline const MFOutputSocket &MFSocket::as_output() const
{
  BLI_assert(this->is_output());
  return static_cast<const MFOutputSocket &>(*this);
}

/* --------------------------------------------------------------------
 * MFInputSocket inline methods.
 */

inline MFOutputSocket *MFInputSocket::origin()
{
  return origin_;
}

inline const MFOutputSocket *MFInputSocket::origin() const
{
  return origin_;
}

/* --------------------------------------------------------------------
 * MFOutputSocket inline methods.
 */

inline Span<MFInputSocket *> MFOutputSocket::targets()
{
  return targets_;
}

inline Span<const MFInputSocket *> MFOutputSocket::targets() const
{
  return targets_;
}

/* --------------------------------------------------------------------
 * MFNetwork inline methods.
 */

inline Span<MFDummyNode *> MFNetwork::dummy_nodes()
{
  return dummy_nodes_;
}

inline Span<MFFunctionNode *> MFNetwork::function_nodes()
{
  return function_nodes_;
}

inline MFNode *MFNetwork::node_or_null_by_id(int id)
{
  return node_or_null_by_id_[id];
}

inline const MFNode *MFNetwork::node_or_null_by_id(int id) const
{
  return node_or_null_by_id_[id];
}

inline MFSocket *MFNetwork::socket_or_null_by_id(int id)
{
  return socket_or_null_by_id_[id];
}

inline const MFSocket *MFNetwork::socket_or_null_by_id(int id) const
{
  return socket_or_null_by_id_[id];
}

inline int MFNetwork::socket_id_amount() const
{
  return socket_or_null_by_id_.size();
}

inline int MFNetwork::node_id_amount() const
{
  return node_or_null_by_id_.size();
}

}  // namespace blender::fn