#include "ScenarioWidget.hpp"
#include <Hardware/Widgets/IntervalWidget.hpp>

namespace Hardware
{
ScenarioWidget::ScenarioWidget(base_widget* parent,
                               Scenario::ProcessModel* scenario)
    : bugui::base_widget{parent}
    , model{scenario}
{
  model->intervals.mutable_added.connect<&ScenarioWidget::on_interval_added>(this);
  model->intervals.removed.connect<&ScenarioWidget::on_interval_removed>(this);

  connect(model,
          &Scenario::ProcessModel::intervalMoved,
          [this] { update(); });

  for(Scenario::IntervalModel& s : model->intervals)
    widgets.emplace_back(std::make_unique<IntervalWidget>(this, s));
}

void ScenarioWidget::paint(bugui::painter& painter) const
{
  for (const auto& w : widgets) w->paint(painter);
}

bool ScenarioWidget::on_press(int x, int y, bool pressed)
{
  if (!is_inside(x, y)) return false;

  for (auto& w : widgets)
    if (w->on_press(x, y, pressed)) return true;

  return true;
}

bool ScenarioWidget::on_double_press(int x, int y)
{
  if (!is_inside(x, y)) return false;

  for (auto& w : widgets)
    if (w->on_double_press(x, y)) return true;

  return true;
}

bool ScenarioWidget::on_drag(int from_x, int from_y, int to_x, int to_y)
{
  if (!is_inside(from_x, from_y)) return false;

  for (auto& w : widgets)
    if (w->on_drag(from_x, from_y, to_x, to_y)) return true;

  return true;
}

int ScenarioWidget::x() const
{
  return bugui::base_widget::parent->x();
}

int ScenarioWidget::y() const
{
  return bugui::base_widget::parent->x();
}

int ScenarioWidget::width() const
{
  return bugui::base_widget::parent->width();
}

int ScenarioWidget::height() const
{
  return bugui::base_widget::parent->height();
}

void ScenarioWidget::on_interval_added(Scenario::IntervalModel& interval)
{
  widgets.emplace_back(std::make_unique<IntervalWidget>(this, interval));
  update();
}

void ScenarioWidget::on_interval_removed(const Scenario::IntervalModel& interval)
{
  std::erase_if(widgets,
                [&interval]
                (auto& w)
  {
    auto ntrvl = static_cast<IntervalWidget*>(w.get());
    return ntrvl->get_model().id() == interval.id();
  });

  update();
}

void ScenarioWidget::on_interval_changed(const Scenario::IntervalModel &)
{
  update();
}

} // namespace Hardware

#include "wobjectimpl.h"
W_OBJECT_IMPL(Hardware::ScenarioWidget)