#pragma once

#include <Process/Style/ScenarioStyle.hpp>
#include <Scenario/Process/ScenarioModel.hpp>
#include <Scenario/Document/Interval/IntervalModel.hpp>

namespace bugui
{
struct base_widget;
struct container_widget;
}

namespace Hardware
{
class ScenarioWidget;

template <typename T = bugui::base_widget>
  requires (std::same_as<T, bugui::base_widget> ||
           std::derived_from<T, bugui::base_widget>)
struct ScenarioComponent : T
{
  virtual bool this_model(const Scenario::IntervalModel&) const { return false; };
  virtual bool this_model(const Scenario::TimeSyncModel&) const { return false; };
  virtual bool this_model(const Scenario::EventModel&) const { return false; };
  virtual bool this_model(const Scenario::StateModel&) const { return false; };

protected:
  explicit ScenarioComponent(ScenarioWidget* s,
                             bugui::container_widget* parent)
      : T{parent}
      , scenario{s}
      , skin{Process::Style::instance()}
  { }

  ScenarioWidget* scenario{nullptr};
  const Process::Style& skin;
};

template <typename T, typename Base = bugui::base_widget>
  requires (std::same_as<T, Scenario::IntervalModel> ||
           std::same_as<T, Scenario::TimeSyncModel> ||
           std::same_as<T, Scenario::EventModel> ||
           std::same_as<T, Scenario::StateModel>)
struct ScenarioComponentSpec : ScenarioComponent<Base>
{
  bool this_model(const T& m) const override { return m.id() == model.id(); };
  const T& get_model() const { return model; }

protected:
  explicit ScenarioComponentSpec(T& m,
                                 ScenarioWidget* scenario,
                                 bugui::container_widget* parent)
      : ScenarioComponent<Base>{scenario, parent}
      , model{m}
  { }

  T& model;
};

} // hardware