ossia / score / 36213733900

ossia::val_type optionType(const config_field& opt)

  if(opt.type == "number")

    return opt.isInteger() ? ossia::val_type::INT : ossia::val_type::FLOAT;

  if(opt.type == "checkbox")

    return ossia::val_type::BOOL;

  if(opt.type == "multidropdown")

    return ossia::val_type::LIST;

  if(opt.type == "colorpicker" && !opt.default_json.isString()

     && opt.returnType != "string")

    return ossia::val_type::INT;

  return ossia::val_type::STRING;

}

void applyDomain(ossia::net::parameter_base& p, const config_field& opt)

  if(opt.type == "number")

    if(opt.min.isValid() && opt.max.isValid())

      if(p.get_value_type() == ossia::val_type::INT)

        p.set_domain(ossia::make_domain(opt.min.toInt(), opt.max.toInt()));

        p.set_domain(ossia::make_domain(opt.min.toFloat(), opt.max.toFloat()));

    }

  }

  else if(opt.type == "dropdown" || opt.type == "multidropdown")

    auto dom = ossia::domain_base<std::string>{};

    for(const auto& choice : opt.choices)

      dom.values.push_back(choice.id.toStdString());

    p.set_domain(std::move(dom));

  }

}

ossia::value receivedValue(const QVariant& v)

  constexpr double int_min = std::numeric_limits<int32_t>::min();

  constexpr double int_max = std::numeric_limits<int32_t>::max();

  switch(v.typeId())

      const double d = v.toDouble();

      if(std::floor(d) != d)

        return (float)d;

      if(d >= int_min && d <= int_max)

        return (int)d;

      return QString::number(d, 'f', 0).toStdString();

      const auto i = v.toLongLong();

      if(i >= int_min && i <= int_max)

        return (int)i;

      return QString::number(i).toStdString();

      return ossia::qt::qt_to_ossia{}(v);

}

childIndex(ossia::net::node_base& n)

  std::unordered_map<std::string, ossia::net::node_base*> res;

  const auto& cld = n.children();

  res.reserve(cld.size());

  for(auto& c : cld)

    res.emplace(c->get_name(), c.get());

  return res;

}

ossia::net::node_base& findOrCreate(

  if(auto it = index.find(name); it != index.end())

    return *it->second;

  auto n = parent.create_child(name);

  index.emplace(name, n);

  return *n;

}

void setDescription(ossia::net::node_base& n, const QString& desc)

  auto str = desc.toStdString();

  if(ossia::net::get_description(n) != str)

    ossia::net::set_description(n, std::move(str));

}

void removeGone(

  std::vector<std::string> gone;

  for(auto& c : parent.children())

    if(!model.contains(QString::fromStdString(c->get_name())))

      gone.push_back(c->get_name());

  for(auto& name : gone)

    if(onRemove)

      onRemove(name);

    parent.remove_child(name);

}

ossia::val_type feedbackType(const bitfocus::module_data::feedback_definition& fb)

  if(fb.type == "boolean")

    return ossia::val_type::BOOL;

  if(fb.type == "advanced")

    return ossia::val_type::MAP;

  return ossia::val_type::STRING;

}

ossia::value bitfocus_protocol::optionDefault(const config_field& opt)

  const auto def = bitfocus::defaultOptionValue(opt);

  switch(optionType(opt))

      return (int)def.toDouble();

      return (float)def.toDouble();

      return def.toBool();

      std::vector<ossia::value> res;

      if(def.isArray())

        for(const auto& v : def.toArray())

          res.push_back(v.toVariant().toString().toStdString());

      else if(!def.isUndefined() && !def.isNull())

        res.push_back(def.toVariant().toString().toStdString());

      return res;

    }

      if(def.isUndefined() || def.isNull())

        return std::string{};

      return def.toVariant().toString().toStdString();

}

bitfocus_protocol::bitfocus_protocol(

    : m_rc{rc}

    , m_context{ctx}

{

  QObject::connect(

      m_rc.get(), &bitfocus::module_handler::variableChanged, this,

      [this](const QString& name, const QVariant& v) {

    if(auto it = m_variables_recv.find(name); it != m_variables_recv.end())

      set_received_value(*it->second, receivedValue(v));

    }

    else if(m_dev)

      auto& m = m_rc->model();

      if(auto def = m.variables.find(name); def != m.variables.end())

        if(!nodes.variables)

          nodes.variables = m_dev->get_root_node().create_child("variable");

        auto index = childIndex(*nodes.variables);

        sync_variable(index, name, def->second);

      }

    }

  });

  QObject::connect(

      m_rc.get(), &bitfocus::module_handler::feedbackValueChanged, this,

      [this](const QString& id, const QString&, const QVariant& v) {

    if(auto it = m_feedbacks_recv.find(id); it != m_feedbacks_recv.end())

      set_received_value(*it->second, receivedValue(v));

  });

  QObject::connect(

      m_rc.get(), &bitfocus::module_handler::definitionsChanged, this,

      [this] { init_device(m_rc->takeChangedDefinitions()); });

  QObject::connect(

      m_rc.get(), &bitfocus::module_handler::reregistered, this, [this] {

    m_subscribed.clear();

    init_device();

  });

}

bitfocus_protocol::~bitfocus_protocol() = default;

void bitfocus_protocol::set_received_value(ossia::net::parameter_base& p, ossia::value v)

  if(!v.valid())

    return;

  const auto cur = p.get_value_type();

  const auto next = v.get_type();

  if(cur == ossia::val_type::FLOAT && next == ossia::val_type::INT)

    p.set_value(float(*v.target<int>()));

    return;

  if(cur != next)

    p.set_value_type(next);

  p.set_value(std::move(v));

}

bool bitfocus_protocol::pull(ossia::net::parameter_base&)

  return true;

QVariantMap bitfocus_protocol::collectOptions(

  std::unique_lock lock{m_touchedMutex};

  QVariantMap options;

  for(const auto& opt : defs)

    if(opt.type == "static-text")

      continue;

    auto cld = const_cast<ossia::net::node_base&>(node).find_child(opt.id.toStdString());

    if(!cld)

      continue;

    auto p = cld->get_parameter();

    if(!p)

      continue;

    const auto val = p->value();

    const QVariant qv = val.apply(ossia::qt::ossia_to_qvariant{});

    const bool touched

        = m_touched.contains({group, node.get_name(), opt.id.toStdString()});

    if(!touched && val == optionDefault(opt))

      if(opt.hasDefault())

        options[opt.id] = bitfocus::defaultOptionValue(opt).toVariant();

      continue;

    const auto jv = bitfocus::toModuleValue(opt, qv);

    if(!jv.isUndefined())

      options[opt.id] = jv.toVariant();

  }

  return options;

}

bool bitfocus_protocol::push(const ossia::net::parameter_base& p, const ossia::value& v)

  auto& node = p.get_node();

  auto parent = node.get_parent();

  if(!parent)

    return false;

  auto actions = m_actionsNode.load();

  auto feedbacks = m_feedbacksNode.load();

  if(auto grand = parent->get_parent(); grand && (grand == actions || grand == feedbacks))

    std::unique_lock lock{m_touchedMutex};

    m_touched.insert(

        {grand == actions ? "action" : "feedback", parent->get_name(), node.get_name()});

  }

  if(actions && parent == actions)

    QMetaObject::invokeMethod(this, [this, id = node.get_name()] { run_action(id); });

  }

  else if(actions && parent->get_parent() == actions && parent->children_count() == 1)

    QMetaObject::invokeMethod(this, [this, id = parent->get_name()] { run_action(id); });

  }

  else if(feedbacks && parent->get_parent() == feedbacks)

    QMetaObject::invokeMethod(this, [this, id = parent->get_name()] {

      subscribe_feedbacks({id});

    });

  }

  return true;

}

void bitfocus_protocol::forget_touched(const std::string& group, const std::string& name)

  std::unique_lock lock{m_touchedMutex};

  std::erase_if(m_touched, [&](const auto& t) {

    return std::get<0>(t) == group && std::get<1>(t) == name;

}

void bitfocus_protocol::run_action(const std::string& id)

  if(!nodes.actions)

    return;

  auto node = nodes.actions->find_child(id);

  const auto& defs = m_rc->model().actions;

  auto it = defs.find(QString::fromStdString(id));

  if(!node || it == defs.end())

    return;

  m_rc->actionRun(id, collectOptions(*node, it->second.options, "action"));

}

bool bitfocus_protocol::push_raw(const ossia::net::full_parameter_data&)

  return true;

bool bitfocus_protocol::observe(ossia::net::parameter_base&, bool)

  return true;

bool bitfocus_protocol::update(ossia::net::node_base& node_base)

  return true;

void bitfocus_protocol::sync_options(

  std::vector<std::string> expected;

  auto index = childIndex(node);

  for(const auto& opt : options)

    if(opt.type == "static-text")

      continue;

    const auto name = opt.id.toStdString();

    expected.push_back(name);

    auto cld = &findOrCreate(node, index, name);

    setDescription(*cld, opt.label);

    const auto type = optionType(opt);

    auto p = cld->get_parameter();

    if(p && p->get_value_type() != type)

      cld->remove_parameter();

      p = nullptr;

    }

    if(!p)

      p = cld->create_parameter(type);

      p->set_value(optionDefault(opt));

    }

    applyDomain(*p, opt);

  }

  std::vector<std::string> extra;

  for(auto& c : node.children())

    if(std::find(expected.begin(), expected.end(), c->get_name()) == expected.end())

      extra.push_back(c->get_name());

  for(auto& name : extra)

    node.remove_child(name);

}

void bitfocus_protocol::sync_actions()

  auto& m = m_rc->model();

  auto& root = m_dev->get_root_node();

  if(m.actions.empty())

    if(nodes.actions)

      root.remove_child("action");

    nodes.actions = nullptr;

    m_actionsNode = nullptr;

    return;

  if(!nodes.actions)

    nodes.actions = root.create_child("action");

    m_actionsNode = nodes.actions;

  }

  removeGone(*nodes.actions, m.actions, [this](const std::string& name) {

    forget_touched("action", name);

  });

  auto index = childIndex(*nodes.actions);

  for(auto& [id, def] : m.actions)

    auto node = &findOrCreate(*nodes.actions, index, id.toStdString());

    setDescription(*node, def.name);

    if(!node->get_parameter())

      node->create_parameter(ossia::val_type::IMPULSE);

    sync_options(*node, def.options);

}

void bitfocus_protocol::sync_feedbacks()

  auto& m = m_rc->model();

  auto& root = m_dev->get_root_node();

  std::map<QString, bitfocus::module_data::feedback_instance> changes;

  if(nodes.feedbacks)

    removeGone(*nodes.feedbacks, m.feedbacks, [&](const std::string& name) {

      forget_touched("feedback", name);

      const auto id = QString::fromStdString(name);

      m_subscribed.erase(id);

      m_feedbacks_recv.erase(id);

      bitfocus::module_data::feedback_instance inst;

      inst.id = id;

      inst.disabled = true;

      changes[id] = inst;

    });

  if(m.feedbacks.empty())

    if(nodes.feedbacks)

      root.remove_child("feedback");

    nodes.feedbacks = nullptr;

    m_feedbacksNode = nullptr;

  }

    if(!nodes.feedbacks)

      nodes.feedbacks = root.create_child("feedback");

      m_feedbacksNode = nodes.feedbacks;

    }

    std::vector<std::string> ids;

    auto index = childIndex(*nodes.feedbacks);

    for(auto& [id, def] : m.feedbacks)

      const auto name = id.toStdString();

      auto node = &findOrCreate(*nodes.feedbacks, index, name);

      setDescription(*node, def.name);

      const auto type = feedbackType(def);

      auto p = node->get_parameter();

      if(p && def.type != "value" && p->get_value_type() != type)

        node->remove_parameter();

        p = nullptr;

      }

      if(!p)

        p = node->create_parameter(type);

      m_feedbacks_recv[id] = p;

      sync_options(*node, def.options);

      ids.push_back(name);

    }

    subscribe_feedbacks(ids);

  }

  if(!changes.empty())

    m_rc->updateFeedbacks(changes);

}

void bitfocus_protocol::subscribe_feedbacks(const std::vector<std::string>& ids)

  if(!nodes.feedbacks)

    return;

  auto& m = m_rc->model();

  std::map<QString, bitfocus::module_data::feedback_instance> instances;

  for(auto& name : ids)

    const auto id = QString::fromStdString(name);

    auto def = m.feedbacks.find(id);

    auto node = nodes.feedbacks->find_child(name);

    if(def == m.feedbacks.end() || !node)

      continue;

    auto options = collectOptions(*node, def->second.options, "feedback");

    auto [sub, isNew] = m_subscribed.try_emplace(id, options);

    if(!isNew && sub->second == options)

      continue;

    sub->second = options;

    bitfocus::module_data::feedback_instance inst;

    inst.id = id;

    inst.controlId = "feedback/" + id;

    inst.definitionId = id;

    inst.options = std::move(options);

    instances[id] = std::move(inst);

  }

  if(!instances.empty())

    m_rc->updateFeedbacks(instances);

}

void bitfocus_protocol::sync_variables()

  auto& m = m_rc->model();

  auto& root = m_dev->get_root_node();

  if(m.variables.empty())

    if(nodes.variables)

      root.remove_child("variable");

    nodes.variables = nullptr;

    m_variables_recv.clear();

    return;

  if(!nodes.variables)

    nodes.variables = root.create_child("variable");

  removeGone(*nodes.variables, m.variables, [this](const std::string& name) {

    m_variables_recv.erase(QString::fromStdString(name));

  });

  auto index = childIndex(*nodes.variables);

  for(auto& [id, def] : m.variables)

    sync_variable(index, id, def);

}

void bitfocus_protocol::sync_variable(

  auto node = &findOrCreate(*nodes.variables, index, id.toStdString());

  if(!def.name.isEmpty())

    setDescription(*node, def.name);

  auto p = node->get_parameter();

  if(!p)

    auto val = receivedValue(def.value);

    p = node->create_parameter(

        val.valid() && val.get_type() != ossia::val_type::IMPULSE

            ? val.get_type()

    if(val.valid())

      p->set_value(val);

  }

  m_variables_recv[id] = p;

}

void bitfocus_protocol::init_device(int categories)

  if(!m_dev)

    return;

  if(categories & bitfocus::module_handler::Actions)

    sync_actions();

  if(categories & bitfocus::module_handler::Feedbacks)

    sync_feedbacks();

  if(categories & bitfocus::module_handler::Variables)

    sync_variables();

}

void bitfocus_protocol::set_device(ossia::net::device_base& dev)

  m_dev = &dev;

}