dot.hpp

//
// libsemigroups - C++ library for semigroups and monoids
// Copyright (C) 2023-2025 James D. Mitchell
//
// 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 3 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, see <http://www.gnu.org/licenses/>.
//
 
#ifndef LIBSEMIGROUPS_DOT_HPP_
#define LIBSEMIGROUPS_DOT_HPP_
 
#include <array>        // for array
#include <cstddef>      // for size_t
#include <map>          // for map, operator!=, __map_const_...
#include <string>       // for basic_string, operator<, oper...
#include <string_view>  // for basic_string_view
#include <utility>      // for forward, move etc
#include <vector>       // for vector
 
#include "exception.hpp"  // for LIBSEMIGROUPS_EXCEPTION
#include "libsemigroups/bipart.hpp"
#include "ranges.hpp"  // for LIBSEMIGROUPS_EXCEPTION
 
#include "detail/fmt.hpp"     // for format
#include "detail/report.hpp"  // for LIBSEMIGROUPS_EXCEPTION
 
namespace libsemigroups {
 
#ifndef LIBSEMIGROUPS_PARSED_BY_DOXYGEN
  namespace detail {
 
    inline std::string const& dot_to_string(std::string const& x) {
      return x;
    }
 
    inline std::string& dot_to_string(std::string& x) {
      return x;
    }
 
    inline std::string&& dot_to_string(std::string&& x) {
      return std::move(x);
    }
 
    inline std::string dot_to_string(char const* x) {
      return std::string(x);
    }
 
    inline std::string dot_to_string(std::string_view x) {
      return std::string(x);
    }
 
    template <typename Thing>
    std::string dot_to_string(Thing&& thing) {
      return std::to_string(std::forward<Thing>(thing));
    }
 
  }  // namespace detail
 
#endif  // LIBSEMIGROUPS_PARSED_BY_DOXYGEN


  class Dot {
   public:
    struct Node {
      std::map<std::string, std::string> attrs;

      std::string name;

      template <typename Thing>
      explicit Node(Thing&& thing)
          : attrs(), name(detail::dot_to_string(std::forward<Thing>(thing))) {}

      Node() = default;

      Node(Node const&) = default;

      Node(Node&&) = default;

      Node& operator=(Node const&) = default;

      Node& operator=(Node&&) = default;
 
      ~Node();

      template <typename Thing1, typename Thing2>
      Node& add_attr(Thing1&& key, Thing2&& val) {
        auto key_str = detail::dot_to_string(std::forward<Thing1>(key));
        auto val_str = detail::dot_to_string(std::forward<Thing2>(val));
 
        add_or_replace_attr(attrs, key_str, val_str);
        return *this;
      }
    };

    struct Edge {
      template <typename Thing1, typename Thing2>
      Edge(Thing1&& h, Thing2&& t)
          : attrs(),
            head(detail::dot_to_string(std::forward<Thing1>(h))),
            tail(detail::dot_to_string(std::forward<Thing2>(t))) {}

      template <typename Thing1, typename Thing2>
      Edge& add_attr(Thing1&& key, Thing2&& val) {
        auto key_str = detail::dot_to_string(std::forward<Thing1>(key));
        auto val_str = detail::dot_to_string(std::forward<Thing2>(val));
 
        add_or_replace_attr(attrs, key_str, val_str);
        return *this;
      }

      Edge() = default;

      Edge(Edge const&) = default;

      Edge(Edge&&) = default;

      Edge& operator=(Edge const&) = default;

      Edge& operator=(Edge&&) = default;
 
      ~Edge();

      std::map<std::string, std::string> attrs;

      std::string head;

      std::string tail;
    };

    enum class Kind {
      digraph,
      graph,
      subgraph
    };

    static constexpr std::array<std::string_view, 24> colors
        = {"#00ff00", "#ff00ff", "#007fff", "#ff7f00", "#7fbf7f", "#4604ac",
           "#de0328", "#19801d", "#d881f5", "#00ffff", "#ffff00", "#00ff7f",
           "#ad5867", "#85f610", "#84e9f5", "#f5c778", "#207090", "#764ef3",
           "#7b4c00", "#0000ff", "#b80c9a", "#601045", "#29b7c0", "#839f12"};
 
   private:
    std::map<std::string, std::string> _attrs;
    std::vector<Edge>                  _edges;
    Kind                               _kind;
    std::string                        _name;
    std::map<std::string, Node>        _nodes;
    std::vector<Dot>                   _subgraphs;
 
   public:
    Dot();

    Dot(Dot const&);

    Dot(Dot&&);

    Dot& operator=(Dot const&);

    Dot& operator=(Dot&&);
 
    ~Dot();

    Dot& kind(Kind val) noexcept {
      _kind = val;
      return *this;
    }

    Kind kind() const noexcept {
      return _kind;
    }

    Dot& name(std::string const& val) {
      _name = val;
      return *this;
    }

    std::string const& name() const noexcept {
      return _name;
    }

    auto nodes() noexcept {
      return rx::iterator_range(_nodes.begin(), _nodes.end())
             | rx::transform([](auto& pair) -> Node& { return pair.second; });
    }

    auto nodes() const noexcept {
      return rx::iterator_range(_nodes.begin(), _nodes.end())
             | rx::transform(
                 [](auto& pair) -> Node const& { return pair.second; });
    }

    std::vector<Edge>& edges() noexcept {
      return _edges;
    }

    std::vector<Edge> const& edges() const noexcept {
      return _edges;
    }

    std::vector<Dot>& subgraphs() noexcept {
      return _subgraphs;
    }

    std::vector<Dot> const& subgraphs() const noexcept {
      return _subgraphs;
    }

    std::map<std::string, std::string> const& attrs() const noexcept {
      return _attrs;
    }

    Dot& add_subgraph(Dot&& subgraph);

    Dot& add_subgraph(Dot const& subgraph);

    template <typename Thing1, typename Thing2>
    Dot& add_attr(Thing1&& key, Thing2&& val) {
      auto key_str = detail::dot_to_string(std::forward<Thing1>(key));
      auto val_str = detail::dot_to_string(std::forward<Thing2>(val));
 
      add_or_replace_attr(_attrs, key_str, val_str);
      return *this;
    }

    template <typename Thing>
    Dot& add_attr(Thing&& key) {
      add_or_replace_attr(_attrs, key, "");
      return *this;
    }

    [[nodiscard]] bool is_node(std::string const& name) const {
      return _nodes.count(name);
    }

    template <typename Thing,
              typename std::enable_if_t<
                  !std::is_same_v<std::decay_t<Thing>, std::string>>>
    [[nodiscard]] bool is_node(Thing&& thing) const {
      return is_node(detail::dot_to_string(std::forward<Thing>(thing)));
    }

    template <typename Thing>
    Node& add_node(Thing&& thing) {
      auto name_str       = detail::dot_to_string(std::forward<Thing>(thing));
      auto [it, inserted] = _nodes.emplace(name_str, Node(name_str));
      if (!inserted) {
        LIBSEMIGROUPS_EXCEPTION("there is already a node named {}!", name_str);
      }
      return it->second;
    }

    template <typename Thing>
    Node& node(Thing&& thing) {
      auto name_str = detail::dot_to_string(std::forward<Thing>(thing));
      auto it       = _nodes.find(name_str);
      if (it == _nodes.cend()) {
        LIBSEMIGROUPS_EXCEPTION("there is no node named {}!", name_str);
      }
      return it->second;
    }

    template <typename Thing1, typename Thing2>
    Edge& add_edge(Thing1&& head, Thing2&& tail) {
      auto head_str = detail::dot_to_string(std::forward<Thing1>(head));
      auto tail_str = detail::dot_to_string(std::forward<Thing2>(tail));
      throw_if_not_node(head_str);
      throw_if_not_node(tail_str);
      _edges.emplace_back(head_str, tail_str);
      return _edges.back();
    }

    template <typename Thing1, typename Thing2>
    Edge& edge(Thing1&& head, Thing2&& tail) {
      auto head_str = detail::dot_to_string(std::forward<Thing1>(head));
      auto tail_str = detail::dot_to_string(std::forward<Thing2>(tail));
      throw_if_not_node(head_str);
      throw_if_not_node(tail_str);
      auto it = std::find_if(_edges.begin(), _edges.end(), [&](Edge const& e) {
        return e.head == head_str && e.tail == tail_str;
      });
      if (it == _edges.cend()) {
        LIBSEMIGROUPS_EXCEPTION(
            "there is no edges from {} to {}!", head_str, tail_str);
      }
      return *it;
    }

    std::string to_string() const;
 
   private:
    void throw_if_not_node(std::string const& s);
 
    std::string_view edge_string() const noexcept;
 
    static void add_or_replace_attr(std::map<std::string, std::string>& attrs,
                                    std::string const&                  key,
                                    std::string const&                  val);
  };  // class Dot

  std::string to_human_readable_repr(Dot const& d);

  std::string to_human_readable_repr(Dot::Node const& n);

  std::string to_human_readable_repr(Dot::Edge const& e);

  std::string to_human_readable_repr(Dot::Kind const&   k,
                                     std::string const& sep = "::");
 
}  // namespace libsemigroups
#endif  // LIBSEMIGROUPS_DOT_HPP_