node-editor.cpp

// Copyright (c) 2020 INRA 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)

#ifdef _WIN32
#define NOMINMAX
#define WINDOWS_LEAN_AND_MEAN
#endif

#include "node-editor.hpp"
#include "gui.hpp"
#include "imnodes.hpp"
#include "implot.h"

#include <cinttypes>
#include <fstream>
#include <string>

#include <fmt/format.h>
#include <irritator/core.hpp>
#include <irritator/examples.hpp>
#include <irritator/io.hpp>

namespace irt {

static ImVec4
operator*(const ImVec4& lhs, const float rhs) noexcept
{
    return ImVec4(lhs.x * rhs, lhs.y * rhs, lhs.z * rhs, lhs.w * rhs);
}

void
editor::settings_manager::compute_colors() noexcept
{
    gui_hovered_model_color =
      ImGui::ColorConvertFloat4ToU32(gui_model_color * 1.25f);
    gui_selected_model_color =
      ImGui::ColorConvertFloat4ToU32(gui_model_color * 1.5f);

    gui_hovered_model_transition_color =
      ImGui::ColorConvertFloat4ToU32(gui_model_transition_color * 1.25f);
    gui_selected_model_transition_color =
      ImGui::ColorConvertFloat4ToU32(gui_model_transition_color * 1.5f);

    gui_hovered_cluster_color =
      ImGui::ColorConvertFloat4ToU32(gui_cluster_color * 1.25f);
    gui_selected_cluster_color =
      ImGui::ColorConvertFloat4ToU32(gui_cluster_color * 1.5f);
}

template<size_t N, typename... Args>
void
format(small_string<N>& str, const char* fmt, const Args&... args)
{
    auto ret = fmt::format_to_n(str.begin(), N - 1, fmt, args...);
    str.size(ret.size);
}

void
editor::clear() noexcept
{
    clusters.clear();
    sim.clear();

    std::fill(std::begin(clusters_mapper),
              std::end(clusters_mapper),
              undefined<cluster_id>());

    std::fill(std::begin(models_mapper),
              std::end(models_mapper),
              undefined<cluster_id>());

    top.clear();
}

cluster_id
editor::ancestor(const child_id child) const noexcept
{
    if (child.index() == 0) {
        const auto mdl_id = std::get<model_id>(child);
        auto parent = models_mapper[get_index(mdl_id)];
        auto ret = parent;

        while (parent != undefined<cluster_id>()) {
            ret = parent;
            parent = clusters_mapper[get_index(parent)];
        }

        return ret;
    } else {
        const auto gp_id = std::get<cluster_id>(child);
        auto parent = clusters_mapper[get_index(gp_id)];
        auto ret = parent;

        while (parent != undefined<cluster_id>()) {
            ret = parent;
            parent = clusters_mapper[get_index(parent)];
        }

        return ret;
    }
}

int
editor::get_top_group_ref(const child_id child) const noexcept
{
    const auto top_ref = ancestor(child);

    return top_ref == undefined<cluster_id>() ? top.get_index(child)
                                              : top.get_index(top_ref);
}

bool
editor::is_in_hierarchy(const cluster& group,
                        const cluster_id group_to_search) const noexcept
{
    if (clusters.get_id(group) == group_to_search) {
        log_w.log(7, "clusters.get_id(group) == group_to_search\n");
        return true;
    }

    // TODO: Derecursive this part of the function.
    for (const auto elem : group.children) {
        if (elem.index() == 1) {
            const auto id = std::get<cluster_id>(elem);

            if (id == group_to_search) {
                log_w.log(7, "id == group_to_search\n");
                return true;
            }

            if (const auto* gp = clusters.try_to_get(id); gp) {
                if (is_in_hierarchy(*gp, group_to_search)) {
                    log_w.log(7, "is_in_hierarchy = true\n");
                    return true;
                }
            }
        }
    }

    return false;
}

void
editor::group(const ImVector<int>& nodes) noexcept
{
    if (!clusters.can_alloc(1)) {
        log_w.log(5, "Fail to allocate a new group.");
        return;
    }

    auto& new_cluster = clusters.alloc();
    auto new_cluster_id = clusters.get_id(new_cluster);
    format(new_cluster.name, "Group {}", new_cluster_id);
    parent(new_cluster_id, undefined<cluster_id>());

    /* First, move children models and groups from the current cluster into the
       newly allocated cluster. */

    for (int i = 0, e = nodes.size(); i != e; ++i) {
        if (auto index = top.get_index(nodes[i]); index != not_found) {
            new_cluster.children.push_back(top.children[index].first);
            top.pop(index);
        }
    }

    top.emplace_back(new_cluster_id);

    for (const auto child : new_cluster.children) {
        if (child.index() == 0) {
            const auto id = std::get<model_id>(child);
            parent(id, new_cluster_id);
        } else {
            const auto id = std::get<cluster_id>(child);
            parent(id, new_cluster_id);
        }
    }

    /* For all input and output ports of the remaining models in the current
       cluster, we try to detect if the corresponding model is or is not in the
       same cluster. */

    for (const auto& child : top.children) {
        if (child.first.index() == 0) {
            const auto child_id = std::get<model_id>(child.first);

            if (auto* model = sim.models.try_to_get(child_id); model) {
                sim.dispatch(
                  *model,
                  [this, &new_cluster]<typename Dynamics>(Dynamics& dyn) {
                      if constexpr (is_detected_v<has_input_port_t, Dynamics>) {
                          for (sz i = 0u, e = std::size(dyn.x); i != e; ++i) {
                              for (const auto& elem : dyn.x[i].connections) {
                                  auto* src = sim.models.try_to_get(elem.model);
                                  if (src &&
                                      is_in_hierarchy(new_cluster,
                                                      this->parent(elem.model)))
                                      new_cluster.output_ports.emplace_back(
                                        make_output_node_id(elem.model,
                                                            elem.port_index));
                              }
                          }
                      }

                      if constexpr (is_detected_v<has_output_port_t,
                                                  Dynamics>) {
                          for (sz i = 0u, e = std::size(dyn.y); i != e; ++i) {
                              for (const auto& elem : dyn.y[i].connections) {
                                  auto* src = sim.models.try_to_get(elem.model);
                                  if (src &&
                                      is_in_hierarchy(new_cluster,
                                                      this->parent(elem.model)))
                                      new_cluster.input_ports.emplace_back(
                                        make_input_node_id(elem.model,
                                                           elem.port_index));
                              }
                          }
                      }
                  });
            }
        } else {
            const auto child_id = std::get<cluster_id>(child.first);

            if (auto* group = clusters.try_to_get(child_id); group) {
                for (const auto id : group->input_ports) {
                    const auto model_port = get_in(id);

                    if (model_port.model) {
                        sim.dispatch(
                          *model_port.model,
                          [this, &new_cluster, &model_port]<typename Dynamics>(
                            Dynamics& dyn) {
                              if constexpr (is_detected_v<has_input_port_t,
                                                          Dynamics>) {
                                  for (sz i = 0u, e = std::size(dyn.x); i != e;
                                       ++i) {
                                      for (const auto& elem :
                                           dyn.x[model_port.port_index]
                                             .connections) {
                                          auto* src =
                                            sim.models.try_to_get(elem.model);
                                          if (src &&
                                              is_in_hierarchy(
                                                new_cluster,
                                                this->parent(elem.model)))
                                              new_cluster.output_ports
                                                .emplace_back(
                                                  make_output_node_id(
                                                    elem.model,
                                                    elem.port_index));
                                      }
                                  }
                              }
                          });
                    }
                }

                for (const auto id : group->output_ports) {
                    const auto model_port = get_out(id);

                    if (model_port.model) {
                        sim.dispatch(
                          *model_port.model,
                          [this, &new_cluster, &model_port]<typename Dynamics>(
                            Dynamics& dyn) {
                              if constexpr (is_detected_v<has_output_port_t,
                                                          Dynamics>) {
                                  for (sz i = 0u, e = std::size(dyn.y); i != e;
                                       ++i) {
                                      for (const auto& elem :
                                           dyn.y[model_port.port_index]
                                             .connections) {
                                          auto* dst =
                                            sim.models.try_to_get(elem.model);
                                          if (dst &&
                                              is_in_hierarchy(
                                                new_cluster,
                                                this->parent(elem.model)))
                                              new_cluster.input_ports
                                                .emplace_back(
                                                  make_input_node_id(
                                                    elem.model,
                                                    elem.port_index));
                                      }
                                  }
                              }
                          });
                    }
                }
            }
        }
    }
}

void
editor::ungroup(const int node) noexcept
{
    const auto index = top.get_index(node);

    if (index == not_found) {
        log_w.log(5, "ungroup model not in top\n");
        return;
    }

    if (top.children[index].first.index() == 0) {
        log_w.log(5, "node is not a group\n");
        return;
    }

    auto* group =
      clusters.try_to_get(std::get<cluster_id>(top.children[index].first));
    if (!group) {
        log_w.log(5, "group does not exist\n");
        return;
    }

    const auto group_id = clusters.get_id(*group);
    top.pop(index);

    for (size_t i = 0, e = group->children.size(); i != e; ++i) {
        if (group->children[i].index() == 0) {
            const auto id = std::get<model_id>(group->children[i]);
            if (auto* mdl = sim.models.try_to_get(id); mdl) {
                parent(id, undefined<cluster_id>());
                top.emplace_back(group->children[i]);
            }
        } else {
            auto id = std::get<cluster_id>(group->children[i]);
            if (auto* gp = clusters.try_to_get(id); gp) {
                parent(id, undefined<cluster_id>());
                top.emplace_back(group->children[i]);
            }
        }
    }

    clusters.free(*group);
    parent(group_id, undefined<cluster_id>());
}

void
editor::free_group(cluster& group) noexcept
{
    const auto group_id = clusters.get_id(group);

    for (const auto child : group.children) {
        if (child.index() == 0) {
            auto id = std::get<model_id>(child);
            models_mapper[get_index(id)] = undefined<cluster_id>();
            if (auto* mdl = sim.models.try_to_get(id); mdl) {
                log_w.log(7, "delete model %" PRIu64 "\n", id);
                sim.deallocate(id);

                observation_dispatch(
                  get_index(id),
                  [this](auto& outs, auto id) { outs.free(id); });

                observation_outputs[get_index(id)] = std::monostate{};
            }
        } else {
            auto id = std::get<cluster_id>(child);
            clusters_mapper[get_index(id)] = undefined<cluster_id>();
            if (auto* gp = clusters.try_to_get(id); gp) {
                log_w.log(7, "delete group %" PRIu64 "\n", gp);
                free_group(*gp);
            }
        }
    }

    parent(group_id, undefined<cluster_id>());
    clusters.free(group);
}

void
editor::free_children(const ImVector<int>& nodes) noexcept
{
    for (int i = 0, e = nodes.size(); i != e; ++i) {
        const auto index = top.get_index(nodes[i]);
        if (index == not_found)
            continue;

        const auto child = top.children[index];

        if (child.first.index() == 0) {
            const auto id = std::get<model_id>(child.first);
            if (auto* mdl = sim.models.try_to_get(id); mdl) {
                models_mapper[get_index(id)] = undefined<cluster_id>();
                log_w.log(7, "delete %" PRIu64 "\n", id);
                parent(id, undefined<cluster_id>());
                sim.deallocate(id);

                observation_dispatch(
                  get_index(id),
                  [this](auto& outs, const auto id) { outs.free(id); });

                observation_outputs[get_index(id)] = std::monostate{};
            }
        } else {
            const auto id = std::get<cluster_id>(child.first);
            if (auto* gp = clusters.try_to_get(id); gp) {
                clusters_mapper[get_index(id)] = undefined<cluster_id>();
                log_w.log(7, "delete group %" PRIu64 "\n", id);
                free_group(*gp);
            }
        }

        top.pop(index);
    }
}

struct copier
{
    struct copy_model
    {
        copy_model() = default;

        copy_model(const model_id src_, const model_id dst_) noexcept
          : src(src_)
          , dst(dst_)
        {}

        model_id src, dst;
    };

    struct copy_cluster
    {
        copy_cluster() = default;

        copy_cluster(const cluster_id src_, const cluster_id dst_) noexcept
          : src(src_)
          , dst(dst_)
        {}

        cluster_id src, dst;
    };

    struct copy_input_port
    {
        copy_input_port() = default;

        copy_input_port(const int src_, const int dst_) noexcept
          : src(src_)
          , dst(dst_)
        {}

        int src, dst;
    };

    struct copy_output_port
    {
        copy_output_port() = default;

        copy_output_port(const int src_, const int dst_) noexcept
          : src(src_)
          , dst(dst_)
        {}

        int src, dst;
    };

    std::vector<copy_model> c_models;
    std::vector<copy_cluster> c_clusters;
    std::vector<copy_input_port> c_input_ports;
    std::vector<copy_output_port> c_output_ports;

    void sort() noexcept
    {
        std::sort(std::begin(c_models),
                  std::end(c_models),
                  [](const auto left, const auto right) {
                      return static_cast<u64>(left.src) <
                             static_cast<u64>(right.src);
                  });

        std::sort(std::begin(c_clusters),
                  std::end(c_clusters),
                  [](const auto left, const auto right) {
                      return static_cast<u64>(left.src) <
                             static_cast<u64>(right.src);
                  });

        std::sort(std::begin(c_input_ports),
                  std::end(c_input_ports),
                  [](const auto left, const auto right) {
                      return static_cast<u64>(left.src) <
                             static_cast<u64>(right.src);
                  });

        std::sort(std::begin(c_output_ports),
                  std::end(c_output_ports),
                  [](const auto left, const auto right) {
                      return static_cast<u64>(left.src) <
                             static_cast<u64>(right.src);
                  });
    }

    template<typename Container, typename T>
    static int get(const Container& c, const T src) noexcept
    {
        const typename Container::value_type val{};

        auto it = std::lower_bound(std::begin(c),
                                   std::end(c),
                                   val,
                                   [](const auto& left, const auto& right) {
                                       return static_cast<u64>(left.src) <
                                              static_cast<u64>(right.src);
                                   });

        return (it != std::end(c) &&
                static_cast<u64>(src) == static_cast<u64>(it->src))
                 ? static_cast<int>(std::distance(std::begin(c), it))
                 : not_found;
    }

    int get_model(const model_id src) const noexcept
    {
        return get(c_models, src);
    }

    int get_cluster(const cluster_id src) const noexcept
    {
        return get(c_clusters, src);
    }

    int get_input_port(const int src) const noexcept
    {
        return get(c_input_ports, src);
    }

    int get_output_port(const int src) const noexcept
    {
        return get(c_output_ports, src);
    }

    status copy(editor& ed,
                const size_t models_to_merge_with_top,
                const size_t clusters_to_merge_with_top)
    {
        auto& sim = ed.sim;

        for (size_t i = 0, e = std::size(c_models); i != e; ++i) {
            auto* mdl = sim.models.try_to_get(c_models[i].src);
            auto* mdl_id_dst = &c_models[i].dst;

            auto ret = sim.dispatch(
              *mdl,
              [this, &sim, mdl, &mdl_id_dst]<typename Dynamics>(
                Dynamics& /*dyn*/) -> status {
                  irt_return_if_fail(sim.models.can_alloc(1),
                                     status::dynamics_not_enough_memory);

                  auto& new_dyn = sim.alloc<Dynamics>();
                  *mdl_id_dst = sim.get_id(new_dyn);

                  if constexpr (is_detected_v<has_input_port_t, Dynamics>)
                      for (sz j = 0u, ej = std::size(new_dyn.x); j != ej; ++j)
                          this->c_input_ports.emplace_back(
                            make_input_node_id(sim.models.get_id(mdl), (int)j),
                            make_input_node_id(*mdl_id_dst, (int)j));

                  if constexpr (is_detected_v<has_output_port_t, Dynamics>)
                      for (sz j = 0, ej = std::size(new_dyn.y); j != ej; ++j)
                          this->c_output_ports.emplace_back(
                            make_output_node_id(sim.models.get_id(mdl), (int)j),
                            make_input_node_id(*mdl_id_dst, (int)j));

                  return status::success;
              });

            irt_return_if_bad(ret);
        }

        for (size_t i = 0, e = std::size(c_clusters); i != e; ++i) {
            auto* gp_src = ed.clusters.try_to_get(c_clusters[i].src);
            auto& gp_dst = ed.clusters.alloc(*gp_src);
            c_clusters[i].dst = ed.clusters.get_id(gp_dst);
        }

        sort();

        for (size_t i = 0, e = std::size(c_clusters); i != e; ++i) {
            auto* gp_src = ed.clusters.try_to_get(c_clusters[i].src);
            auto* gp_dst = ed.clusters.try_to_get(c_clusters[i].dst);

            for (size_t j = 0, ej = gp_src->children.size(); j != ej; ++j) {
                if (gp_src->children[j].index() == 0) {
                    const auto id = std::get<model_id>(gp_src->children[j]);
                    const auto index = get_model(id);
                    gp_dst->children[j] = c_models[index].dst;
                } else {
                    const auto id = std::get<cluster_id>(gp_src->children[j]);
                    const auto index = get_cluster(id);
                    gp_dst->children[j] = c_clusters[index].dst;
                }
            }

            for (size_t j = 0, ej = gp_src->input_ports.size(); j != ej; ++j) {
                const auto index = get_input_port(gp_src->input_ports[j]);
                gp_dst->input_ports[j] = c_input_ports[index].dst;
            }

            for (size_t j = 0, ej = gp_src->output_ports.size(); j != ej; ++j) {
                const auto index = get_output_port(gp_src->output_ports[j]);
                gp_dst->output_ports[j] = c_output_ports[index].dst;
            }
        }

        // for (size_t i = 0, e = std::size(c_input_ports); i != e; ++i) {
        //    const auto* src =
        //    sim.input_ports.try_to_get(c_input_ports[i].src); auto* dst =
        //    sim.input_ports.try_to_get(c_input_ports[i].dst);

        //    assert(dst->connections.empty());

        //    for (const auto port : src->connections) {
        //        const auto index = get_output_port(port);
        //        dst->connections.emplace_front(c_output_ports[index].dst);
        //    }
        //}

        // for (size_t i = 0, e = std::size(c_output_ports); i != e; ++i) {
        //    const auto* src =
        //      sim.output_ports.try_to_get(c_output_ports[i].src);
        //    auto* dst = sim.output_ports.try_to_get(c_output_ports[i].dst);

        //    assert(dst->connections.empty());

        //    for (const auto port : src->connections) {
        //        const auto index = get_input_port(port);
        //        dst->connections.emplace_front(c_input_ports[index].dst);
        //    }
        //}

        for (size_t i = 0, e = std::size(c_models); i != e; ++i) {
            const auto parent_src = ed.parent(c_models[i].src);
            const auto index = get_cluster(parent_src);

            if (index == not_found)
                ed.parent(c_models[i].dst, parent_src);
            else
                ed.parent(c_models[i].dst, c_clusters[index].dst);
        }

        for (size_t i = 0, e = std::size(c_clusters); i != e; ++i) {
            const auto parent_src = ed.parent(c_clusters[i].src);
            const auto index = get_cluster(parent_src);

            if (index == not_found)
                ed.parent(c_models[i].dst, parent_src);
            else
                ed.parent(c_models[i].dst, c_clusters[index].dst);
        }

        /* Finally, merge clusters and models from user selection into the
           editor.top structure. */

        for (size_t i = 0; i != models_to_merge_with_top; ++i) {
            ed.top.emplace_back(c_models[i].dst);
            ed.parent(c_models[i].dst, undefined<cluster_id>());
        }

        for (size_t i = 0; i != clusters_to_merge_with_top; ++i) {
            ed.top.emplace_back(c_clusters[i].dst);
            ed.parent(c_clusters[i].dst, undefined<cluster_id>());
        }

        return status::success;
    }
};

static void
compute_connection_distance(const child_id src,
                            const child_id dst,
                            editor& ed,
                            const float k)
{
    const auto v = ed.get_top_group_ref(src);
    const auto u = ed.get_top_group_ref(dst);

    const float dx = ed.positions[v].x - ed.positions[u].x;
    const float dy = ed.positions[v].y - ed.positions[u].y;
    if (dx && dy) {
        const float d2 = dx * dx / dy * dy;
        const float coeff = std::sqrt(d2) / k;

        ed.displacements[v].x -= dx * coeff;
        ed.displacements[v].y -= dy * coeff;
        ed.displacements[u].x += dx * coeff;
        ed.displacements[u].y += dy * coeff;
    }
}

static void
compute_connection_distance(const model& mdl,
                            const int port,
                            editor& ed,
                            const float k)
{
    ed.sim.dispatch(
      mdl, [&mdl, port, &ed, k]<typename Dynamics>(Dynamics& dyn) -> void {
          if constexpr (is_detected_v<has_output_port_t, Dynamics>) {
              for (auto& dst : dyn.y[port].connections)
                  compute_connection_distance(
                    ed.sim.get_id(mdl), dst.model, ed, k);
          }
      });
}

static void
compute_connection_distance(const model& mdl, editor& ed, const float k)
{
    ed.sim.dispatch(
      mdl, [&mdl, &ed, k]<typename Dynamics>(Dynamics& dyn) -> void {
          if constexpr (is_detected_v<has_output_port_t, Dynamics>) {
              for (sz i = 0, e = std::size(dyn.y); i != e; ++i)
                  for (auto& dst : dyn.y[i].connections)
                      compute_connection_distance(
                        ed.sim.get_id(mdl), dst.model, ed, k);
          }
      });
}

void
editor::compute_grid_layout() noexcept
{
    const auto size = length(top.children);

    if (size == 0)
        return;

    const auto tmp = std::sqrt(size);
    const auto column = static_cast<int>(tmp);
    auto line = column;
    auto remaining = size - (column * line);

    while (remaining > column) {
        ++line;
        remaining -= column;
    }

    const auto panning = imnodes::EditorContextGetPanning();
    auto new_pos = panning;

    int elem = 0;

    for (int i = 0; i < column; ++i) {
        new_pos.y =
          panning.y + static_cast<float>(i) * settings.grid_layout_y_distance;
        for (int j = 0; j < line; ++j) {
            new_pos.x = panning.x +
                        static_cast<float>(j) * settings.grid_layout_x_distance;
            imnodes::SetNodeGridSpacePos(top.children[elem].second, new_pos);
            positions[elem].x = new_pos.x;
            positions[elem].y = new_pos.y;
            ++elem;
        }
    }

    new_pos.x = panning.x;
    new_pos.y =
      panning.y + static_cast<float>(column) * settings.grid_layout_y_distance;
    for (int j = 0; j < remaining; ++j) {
        new_pos.x =
          panning.x + static_cast<float>(j) * settings.grid_layout_x_distance;
        imnodes::SetNodeGridSpacePos(top.children[elem].second, new_pos);
        positions[elem].x = new_pos.x;
        positions[elem].y = new_pos.y;
        ++elem;
    }

    imnodes::EditorContextResetPanning(positions[0]);
}

void
editor::compute_automatic_layout() noexcept
{
    /* See. Graph drawing by Forced-directed Placement by Thomas M. J.
       Fruchterman and Edward M. Reingold in Software--Pratice and
       Experience, Vol. 21(1 1), 1129-1164 (november 1991).
       */

    const auto size = length(top.children);
    const auto tmp = std::sqrt(size);
    const auto column = static_cast<int>(tmp);
    auto line = column;
    auto remaining = size - (column * line);

    while (remaining > column) {
        ++line;
        remaining -= column;
    }

    const float W =
      static_cast<float>(column) * settings.automatic_layout_x_distance;
    const float L =
      line + (remaining > 0) ? settings.automatic_layout_y_distance : 0.f;
    const float area = W * L;
    const float k_square = area / static_cast<float>(top.children.size());
    const float k = std::sqrt(k_square);

    // float t = 1.f - static_cast<float>(iteration) /
    //                   static_cast<float>(automatic_layout_iteration_limit);
    // t *= t;

    float t =
      1.f - 1.f / static_cast<float>(settings.automatic_layout_iteration_limit);

    for (int iteration = 0;
         iteration < settings.automatic_layout_iteration_limit;
         ++iteration) {
        for (int i_v = 0; i_v < size; ++i_v) {
            const int v = i_v;

            displacements[v].x = displacements[v].y = 0.f;

            for (int i_u = 0; i_u < size; ++i_u) {
                const int u = i_u;

                if (u != v) {
                    const ImVec2 delta{ positions[v].x - positions[u].x,
                                        positions[v].y - positions[u].y };

                    if (delta.x && delta.y) {
                        const float d2 = delta.x * delta.x + delta.y * delta.y;
                        const float coeff = k_square / d2;

                        displacements[v].x += coeff * delta.x;
                        displacements[v].y += coeff * delta.y;
                    }
                }
            }
        }

        for (size_t i = 0, e = top.children.size(); i != e; ++i) {
            if (top.children[i].first.index() == 0) {
                const auto id = std::get<model_id>(top.children[i].first);
                if (const auto* mdl = sim.models.try_to_get(id); mdl)
                    compute_connection_distance(*mdl, *this, k);
            } else {
                const auto id = std::get<cluster_id>(top.children[i].first);
                if (auto* gp = clusters.try_to_get(id); gp) {
                    for (sz i = 0; i < std::size(gp->output_ports); ++i) {
                        auto model_port = get_out(gp->output_ports[i]);
                        if (model_port.model) {
                            compute_connection_distance(*model_port.model,
                                                        model_port.port_index,
                                                        *this,
                                                        k);
                        }
                    }
                }
            }
        }

        auto sum = 0.f;
        for (int i_v = 0; i_v < size; ++i_v) {
            const int v = i_v;

            const float d2 = displacements[v].x * displacements[v].x +
                             displacements[v].y * displacements[v].y;
            const float d = std::sqrt(d2);

            if (d > t) {
                const float coeff = t / d;
                displacements[v].x *= coeff;
                displacements[v].y *= coeff;
                sum += t;
            } else {
                sum += d;
            }

            positions[v].x += displacements[v].x;
            positions[v].y += displacements[v].y;

            imnodes::SetNodeGridSpacePos(top.children[v].second, positions[v]);
        }
    }

    imnodes::EditorContextResetPanning(positions[0]);
}

status
editor::copy(const ImVector<int>& nodes) noexcept
{
    copier cp;

    std::vector<cluster_id> copy_stack;

    for (int i = 0, e = nodes.size(); i != e; ++i) {
        const auto index = top.get_index(nodes[i]);
        if (index == not_found)
            continue;

        const auto child = top.children[index];

        if (child.first.index() == 0) {
            const auto id = std::get<model_id>(child.first);
            if (auto* mdl = sim.models.try_to_get(id); mdl)
                cp.c_models.emplace_back(id, undefined<model_id>());
        } else {
            const auto id = std::get<cluster_id>(child.first);
            if (auto* gp = clusters.try_to_get(id); gp) {
                cp.c_clusters.emplace_back(id, undefined<cluster_id>());
                copy_stack.emplace_back(id);
            }
        }
    }

    const auto models_to_merge_with_top = std::size(cp.c_models);
    const auto clusters_to_merge_with_top = std::size(cp.c_clusters);

    while (!copy_stack.empty()) {
        const auto gp_id = copy_stack.back();
        copy_stack.pop_back();

        if (auto* gp = clusters.try_to_get(gp_id); gp) {
            for (const auto child : gp->children) {
                if (child.index() == 0) {
                    const auto id = std::get<model_id>(child);
                    if (auto* mdl = sim.models.try_to_get(id); mdl)
                        cp.c_models.emplace_back(id, undefined<model_id>());
                } else {
                    const auto id = std::get<cluster_id>(child);
                    if (auto* gp = clusters.try_to_get(id); gp) {
                        cp.c_clusters.emplace_back(id, undefined<cluster_id>());
                        copy_stack.emplace_back(id);
                    }
                }
            }
        }
    }

    return cp.copy(*this, models_to_merge_with_top, clusters_to_merge_with_top);
}

status
editor::initialize(u32 id) noexcept
{
    irt_return_if_bad(sim.init(to_unsigned(settings.kernel_model_cache),
                               to_unsigned(settings.kernel_message_cache)));
    irt_return_if_bad(clusters.init(sim.models.capacity()));
    irt_return_if_bad(top.init(to_unsigned(settings.gui_node_cache)));
    irt_return_if_bad(plot_outs.init(to_unsigned(settings.kernel_model_cache)));
    irt_return_if_bad(file_outs.init(to_unsigned(settings.kernel_model_cache)));
    irt_return_if_bad(
      file_discrete_outs.init(to_unsigned(settings.kernel_model_cache)));

    sim.source_dispatch = app.srcs;

    try {
        observation_outputs.resize(sim.models.capacity());
        models_mapper.resize(sim.models.capacity(), undefined<cluster_id>());
        clusters_mapper.resize(sim.models.capacity(), undefined<cluster_id>());
        models_make_transition.resize(sim.models.capacity(), false);

        positions.resize(sim.models.capacity() + clusters.capacity(),
                         ImVec2{ 0.f, 0.f });
        displacements.resize(sim.models.capacity() + clusters.capacity(),
                             ImVec2{ 0.f, 0.f });

        observation_directory = std::filesystem::current_path();

    } catch (const std::bad_alloc& /*e*/) {
        return status::gui_not_enough_memory;
    }

    use_real_time = false;
    synchronize_timestep = 0.;

    format(name, "Editor {}", id);

    initialized = true;

    return status::success;
}

status
editor::add_lotka_volterra() noexcept
{
    if (!sim.models.can_alloc(10))
        return status::simulation_not_enough_model;

    auto& sum_a = sim.alloc<adder_2>();
    auto& sum_b = sim.alloc<adder_2>();
    auto& product = sim.alloc<mult_2>();
    auto& integrator_a = sim.alloc<integrator>();
    auto& integrator_b = sim.alloc<integrator>();
    auto& quantifier_a = sim.alloc<quantifier>();
    auto& quantifier_b = sim.alloc<quantifier>();

    integrator_a.default_current_value = 18.0;

    quantifier_a.default_adapt_state = irt::quantifier::adapt_state::possible;
    quantifier_a.default_zero_init_offset = true;
    quantifier_a.default_step_size = 0.01;
    quantifier_a.default_past_length = 3;

    integrator_b.default_current_value = 7.0;

    quantifier_b.default_adapt_state = irt::quantifier::adapt_state::possible;
    quantifier_b.default_zero_init_offset = true;
    quantifier_b.default_step_size = 0.01;
    quantifier_b.default_past_length = 3;

    product.default_input_coeffs[0] = 1.0;
    product.default_input_coeffs[1] = 1.0;
    sum_a.default_input_coeffs[0] = 2.0;
    sum_a.default_input_coeffs[1] = -0.4;
    sum_b.default_input_coeffs[0] = -1.0;
    sum_b.default_input_coeffs[1] = 0.1;

    irt_return_if_bad(sim.connect(sum_a, 0, integrator_a, 1));
    irt_return_if_bad(sim.connect(sum_b, 0, integrator_b, 1));

    irt_return_if_bad(sim.connect(integrator_a, 0, sum_a, 0));
    irt_return_if_bad(sim.connect(integrator_b, 0, sum_b, 0));

    irt_return_if_bad(sim.connect(integrator_a, 0, product, 0));
    irt_return_if_bad(sim.connect(integrator_b, 0, product, 1));

    irt_return_if_bad(sim.connect(product, 0, sum_a, 1));
    irt_return_if_bad(sim.connect(product, 0, sum_b, 1));

    irt_return_if_bad(sim.connect(quantifier_a, 0, integrator_a, 0));
    irt_return_if_bad(sim.connect(quantifier_b, 0, integrator_b, 0));
    irt_return_if_bad(sim.connect(integrator_a, 0, quantifier_a, 0));
    irt_return_if_bad(sim.connect(integrator_b, 0, quantifier_b, 0));

    top.emplace_back(sim.get_id(sum_a));
    top.emplace_back(sim.get_id(sum_b));
    top.emplace_back(sim.get_id(product));
    top.emplace_back(sim.get_id(integrator_a));
    top.emplace_back(sim.get_id(integrator_b));
    top.emplace_back(sim.get_id(quantifier_a));
    top.emplace_back(sim.get_id(quantifier_b));

    parent(sim.get_id(sum_a), undefined<cluster_id>());
    parent(sim.get_id(sum_b), undefined<cluster_id>());
    parent(sim.get_id(product), undefined<cluster_id>());
    parent(sim.get_id(integrator_a), undefined<cluster_id>());
    parent(sim.get_id(integrator_b), undefined<cluster_id>());
    parent(sim.get_id(quantifier_a), undefined<cluster_id>());
    parent(sim.get_id(quantifier_b), undefined<cluster_id>());

    return status::success;
}

status
editor::add_izhikevitch() noexcept
{
    if (!sim.models.can_alloc(14))
        return status::simulation_not_enough_model;

    auto& constant = sim.alloc<irt::constant>();
    auto& constant2 = sim.alloc<irt::constant>();
    auto& constant3 = sim.alloc<irt::constant>();
    auto& sum_a = sim.alloc<irt::adder_2>();
    auto& sum_b = sim.alloc<irt::adder_2>();
    auto& sum_c = sim.alloc<irt::adder_4>();
    auto& sum_d = sim.alloc<irt::adder_2>();
    auto& product = sim.alloc<irt::mult_2>();
    auto& integrator_a = sim.alloc<irt::integrator>();
    auto& integrator_b = sim.alloc<irt::integrator>();
    auto& quantifier_a = sim.alloc<irt::quantifier>();
    auto& quantifier_b = sim.alloc<irt::quantifier>();
    auto& cross = sim.alloc<irt::cross>();
    auto& cross2 = sim.alloc<irt::cross>();

    double a = 0.2;
    double b = 2.0;
    double c = -56.0;
    double d = -16.0;
    double I = -99.0;
    double vt = 30.0;

    constant.default_value = 1.0;
    constant2.default_value = c;
    constant3.default_value = I;

    cross.default_threshold = vt;
    cross2.default_threshold = vt;

    integrator_a.default_current_value = 0.0;

    quantifier_a.default_adapt_state = irt::quantifier::adapt_state::possible;
    quantifier_a.default_zero_init_offset = true;
    quantifier_a.default_step_size = 0.01;
    quantifier_a.default_past_length = 3;

    integrator_b.default_current_value = 0.0;

    quantifier_b.default_adapt_state = irt::quantifier::adapt_state::possible;
    quantifier_b.default_zero_init_offset = true;
    quantifier_b.default_step_size = 0.01;
    quantifier_b.default_past_length = 3;

    product.default_input_coeffs[0] = 1.0;
    product.default_input_coeffs[1] = 1.0;

    sum_a.default_input_coeffs[0] = 1.0;
    sum_a.default_input_coeffs[1] = -1.0;
    sum_b.default_input_coeffs[0] = -a;
    sum_b.default_input_coeffs[1] = a * b;
    sum_c.default_input_coeffs[0] = 0.04;
    sum_c.default_input_coeffs[1] = 5.0;
    sum_c.default_input_coeffs[2] = 140.0;
    sum_c.default_input_coeffs[3] = 1.0;
    sum_d.default_input_coeffs[0] = 1.0;
    sum_d.default_input_coeffs[1] = d;

    irt_return_if_bad(sim.connect(integrator_a, 0, cross, 0));
    irt_return_if_bad(sim.connect(constant2, 0, cross, 1));
    irt_return_if_bad(sim.connect(integrator_a, 0, cross, 2));

    irt_return_if_bad(sim.connect(cross, 0, quantifier_a, 0));
    irt_return_if_bad(sim.connect(cross, 0, product, 0));
    irt_return_if_bad(sim.connect(cross, 0, product, 1));
    irt_return_if_bad(sim.connect(product, 0, sum_c, 0));
    irt_return_if_bad(sim.connect(cross, 0, sum_c, 1));
    irt_return_if_bad(sim.connect(cross, 0, sum_b, 1));

    irt_return_if_bad(sim.connect(constant, 0, sum_c, 2));
    irt_return_if_bad(sim.connect(constant3, 0, sum_c, 3));

    irt_return_if_bad(sim.connect(sum_c, 0, sum_a, 0));
    irt_return_if_bad(sim.connect(integrator_b, 0, sum_a, 1));
    irt_return_if_bad(sim.connect(cross2, 0, sum_a, 1));
    irt_return_if_bad(sim.connect(sum_a, 0, integrator_a, 1));
    irt_return_if_bad(sim.connect(cross, 0, integrator_a, 2));
    irt_return_if_bad(sim.connect(quantifier_a, 0, integrator_a, 0));

    irt_return_if_bad(sim.connect(cross2, 0, quantifier_b, 0));
    irt_return_if_bad(sim.connect(cross2, 0, sum_b, 0));
    irt_return_if_bad(sim.connect(quantifier_b, 0, integrator_b, 0));
    irt_return_if_bad(sim.connect(sum_b, 0, integrator_b, 1));

    irt_return_if_bad(sim.connect(cross2, 0, integrator_b, 2));
    irt_return_if_bad(sim.connect(integrator_a, 0, cross2, 0));
    irt_return_if_bad(sim.connect(integrator_b, 0, cross2, 2));
    irt_return_if_bad(sim.connect(sum_d, 0, cross2, 1));
    irt_return_if_bad(sim.connect(integrator_b, 0, sum_d, 0));
    irt_return_if_bad(sim.connect(constant, 0, sum_d, 1));

    top.emplace_back(sim.get_id(constant));
    top.emplace_back(sim.get_id(constant2));
    top.emplace_back(sim.get_id(constant3));
    top.emplace_back(sim.get_id(sum_a));
    top.emplace_back(sim.get_id(sum_b));
    top.emplace_back(sim.get_id(sum_c));
    top.emplace_back(sim.get_id(sum_d));
    top.emplace_back(sim.get_id(product));
    top.emplace_back(sim.get_id(integrator_a));
    top.emplace_back(sim.get_id(integrator_b));
    top.emplace_back(sim.get_id(quantifier_a));
    top.emplace_back(sim.get_id(quantifier_b));
    top.emplace_back(sim.get_id(cross));
    top.emplace_back(sim.get_id(cross2));

    parent(sim.get_id(constant), undefined<cluster_id>());
    parent(sim.get_id(constant2), undefined<cluster_id>());
    parent(sim.get_id(constant3), undefined<cluster_id>());
    parent(sim.get_id(sum_a), undefined<cluster_id>());
    parent(sim.get_id(sum_b), undefined<cluster_id>());
    parent(sim.get_id(sum_c), undefined<cluster_id>());
    parent(sim.get_id(sum_d), undefined<cluster_id>());
    parent(sim.get_id(product), undefined<cluster_id>());
    parent(sim.get_id(integrator_a), undefined<cluster_id>());
    parent(sim.get_id(integrator_b), undefined<cluster_id>());
    parent(sim.get_id(quantifier_a), undefined<cluster_id>());
    parent(sim.get_id(quantifier_b), undefined<cluster_id>());
    parent(sim.get_id(cross), undefined<cluster_id>());
    parent(sim.get_id(cross2), undefined<cluster_id>());

    return status::success;
}

static int
show_connection(editor& ed, const model& mdl, int port, int connection_id)
{
    ed.sim.dispatch(
      mdl,
      [&ed, &mdl, port, &connection_id]<typename Dynamics>(
        Dynamics& dyn) -> void {
          if constexpr (is_detected_v<has_output_port_t, Dynamics>) {
              int out = make_output_node_id(ed.sim.get_id(dyn), port);

              for (const auto& c : dyn.y[port].connections) {
                  if (auto* mdl_dst = ed.sim.models.try_to_get(c.model);
                      mdl_dst) {
                      int in = make_input_node_id(c.model, c.port_index);
                      imnodes::Link(connection_id++, out, in);
                  }
              }
          }
      });

    return connection_id;
}

static int
show_connection(editor& ed, const model& mdl, int connection_id)
{
    ed.sim.dispatch(
      mdl,
      [&ed, &mdl, &connection_id]<typename Dynamics>(Dynamics& dyn) -> void {
          if constexpr (is_detected_v<has_output_port_t, Dynamics>) {
              for (sz i = 0, e = std::size(dyn.y); i != e; ++i) {
                  int out = make_output_node_id(ed.sim.get_id(dyn), (int)i);

                  for (const auto& c : dyn.y[i].connections) {
                      if (auto* mdl_dst = ed.sim.models.try_to_get(c.model);
                          mdl_dst) {
                          int in = make_input_node_id(c.model, c.port_index);
                          imnodes::Link(connection_id++, out, in);
                      }
                  }
              }
          }
      });

    return connection_id;
}

void
editor::show_connections() noexcept
{
    int connection_id = 0;

    for (size_t i = 0, e = top.children.size(); i != e; ++i) {
        if (top.children[i].first.index() == 0) {
            const auto id = std::get<model_id>(top.children[i].first);
            if (const auto* mdl = sim.models.try_to_get(id); mdl)
                connection_id = show_connection(*this, *mdl, connection_id<