midi_formater.hpp

#pragma once
#include <bugui/concepts/color.hpp>
#include <bugui/concepts/protocol.hpp>
#include <bugui/color/color_converter.hpp>
 
#include <libremidi/libremidi.hpp>
 
namespace bugui
{
template <is_sysex_out_component Component>
struct sysex_formater
{
  static consteval auto prefix_size()
  { return Component::out_message_t::sysex_id().size() + 1; };
  static consteval auto prefix_incremented()
  { return prefix_size() + 1; };
};

template <typename Component>
struct base_midi_formater
{
  virtual void set(uint8_t id
                   , const color_converter
                   <typename Component::color_t>& converter)
  {
    if constexpr(is_sysex_out_component<Component>)
      if (bytes.size() == sysex_formater<Component>
         ::prefix_size())
        bytes.push_back(Component::color_t::constant_id());
 
    bytes.push_back(id);
    bytes.push_back(converter.get());
  };

  void add(uint8_t element) { bytes.push_back(element); }

  virtual void clear()
  {
    if constexpr(is_sysex_out_component<Component>)
      bytes.erase(bytes.cbegin() +
                      sysex_formater<Component>::prefix_size()
                  , bytes.cend());
    else
      bytes.erase(bytes.cbegin() + 1, bytes.cend());
  }

  bool has_message() const
  {
    if constexpr(is_sysex_out_component<Component>)
      return bytes.size() >
             sysex_formater<Component>::prefix_size();
    else
    return bytes.size() > 1;
  }

  const libremidi::midi_bytes& get() const { return bytes; }
 
protected:
  explicit base_midi_formater()
  {
    using namespace std;
    using namespace libremidi;
 
    if constexpr(is_on_off_out_component<Component>)
      bytes.push_back(to_underlying(message_type::NOTE_ON));
 
    if constexpr(is_cc_out_component<Component>)
      bytes.push_back(to_underlying(message_type
                                    ::CONTROL_CHANGE));
 
    if constexpr(is_sysex_out_component<Component>)
    {
      bytes.push_back(to_underlying(message_type
                                    ::SYSTEM_EXCLUSIVE));
 
      for (const auto& id
          : Component::out_message_t::sysex_id())
        bytes.push_back(id);
    }
  }
 
  libremidi::midi_bytes bytes;
};

template <typename Component>
struct midi_formater final
    : base_midi_formater<Component>
{ };

template <has_dual_blink Component>
struct dual_blinker : virtual base_midi_formater<Component>
{
  bool has_blink_message() const
  {
    if constexpr(is_sysex_out_component<Component>)
      return blink_bytes.size() >
             sysex_formater<Component>::prefix_incremented();
    else
      return blink_bytes.size() > 1;
  }

  void add_blink(uint8_t element)
  { blink_bytes.push_back(element); }

  const libremidi::midi_bytes& get_blink() const
  { return blink_bytes; }
 
protected:
  explicit dual_blinker()
      : base_midi_formater<Component>{}
  {
    using namespace std;
    using namespace libremidi;
 
    if constexpr(is_on_off_out_component<Component>)
      blink_bytes.push_back(channel_events::make_command
                            (message_type::NOTE_ON
                             , Component::color_t
                             ::blinking_channel()));
 
    if constexpr(is_cc_out_component<Component>)
      blink_bytes.push_back(channel_events::make_command
                            (message_type::CONTROL_CHANGE
                             , Component::color_t
                             ::blinking_channel()));
 
    if constexpr(is_sysex_out_component<Component>)
    {
      blink_bytes = this->bytes;
      blink_bytes.push_back(Component::color_t::blinking_id());
    }
  }
 
  void clear() override
  {
    if constexpr(is_sysex_out_component<Component>)
      this->blink_bytes.erase(this->blink_bytes.cbegin() +
                                  sysex_formater<Component>
                                  ::prefix_incremented()
                              , this->blink_bytes.cend());
    else
      this->blink_bytes.erase(this->blink_bytes.cbegin() + 1
                              , this->blink_bytes.cend());
  }
 
  libremidi::midi_bytes blink_bytes;
};

template <typename Component>
  requires (has_dual_blink<Component>
           && !has_dual_pulse<Component>)
struct midi_formater<Component> final
    : dual_blinker<Component>
{
  using color_cnvrtr =
      color_converter<typename Component::color_t>;
 
  void set(uint8_t id, const color_cnvrtr& converter) override
  {
    if constexpr(is_sysex_out_component<Component>)
      if (this->bytes.size() == sysex_formater<Component>
         ::prefix_size())
        this->bytes.push_back(Component::color_t::constant_id());
 
    this->bytes.push_back(id);
 
    if (converter.get_state() != color::states::constant)
    {
        this->blink_bytes.push_back(id);
        this->bytes.push_back(color_cnvrtr::clear_value);
        this->blink_bytes.push_back(converter.get());
    }
    else
      this->bytes.push_back(converter.get());
  }
 
  void clear() override
  {
    base_midi_formater<Component>::clear();
    dual_blinker<Component>::clear();
  }
};

template <has_dual_pulse Component>
struct dual_pulser : virtual base_midi_formater<Component>
{
  bool has_pulse_message() const
  {
    if constexpr(is_sysex_out_component<Component>)
      return pulse_bytes.size() >
             sysex_formater<Component>::prefix_incremented();
    else
      return pulse_bytes.size() > 1;
  }

  void add_pulse(uint8_t element)
  { pulse_bytes.push_back(element); }

  const libremidi::midi_bytes& get_pulse() const
  { return pulse_bytes; }
 
protected:
  explicit dual_pulser()
      : base_midi_formater<Component>{}
  {
    using namespace std;
    using namespace libremidi;
 
    if constexpr(is_on_off_out_component<Component>)
      pulse_bytes.push_back(channel_events::make_command
                            (message_type::NOTE_ON
                             , Component::color_t
                             ::pulsing_channel()));
 
    if constexpr(is_cc_out_component<Component>)
      pulse_bytes.push_back(channel_events::make_command
                            (message_type::CONTROL_CHANGE
                             , Component::color_t
                             ::pulsing_channel()));
 
    if constexpr(is_sysex_out_component<Component>)
    {
      pulse_bytes = this->bytes;
      pulse_bytes.push_back(Component::color_t::pulsing_id());
    }
  }
 
  void clear() override
  {
    if constexpr(is_sysex_out_component<Component>)
      this->pulse_bytes.erase(this->pulse_bytes.cbegin() +
                                  sysex_formater<Component>
                                  ::prefix_incremented()
                              , this->pulse_bytes.cend());
    else
      this->pulse_bytes.erase(this->pulse_bytes.cbegin() + 1
                              , this->pulse_bytes.cend());
  }
 
  libremidi::midi_bytes pulse_bytes;
};

template <typename Component>
  requires (!has_dual_blink<Component>
           && has_dual_pulse<Component>)
struct midi_formater<Component> final
    : dual_pulser<Component>
{
  using color_cnvrtr =
      color_converter<typename Component::color_t>;
 
  void set(uint8_t id, const color_cnvrtr& converter) override
  {    
    if constexpr(is_sysex_out_component<Component>)
      if (this->bytes.size() == sysex_formater<Component>
         ::prefix_size())
        this->bytes.push_back(Component::color_t::constant_id());
 
    this->bytes.push_back(id);
 
    if (converter.get_state() != color::states::constant)
    {
      this->bytes.push_back(color_cnvrtr::clear_value);
      this->pulse_bytes.push_back(converter.get());
      this->pulse_bytes.push_back(id);
    }
    else
      this->bytes.push_back(converter.get());
  }
 
  void clear() override
  {
    base_midi_formater<Component>::clear();
    dual_pulser<Component>::clear();
  }
};

template <typename Component>
  requires (has_dual_blink<Component>
           && has_dual_pulse<Component>)
struct midi_formater<Component> final
    : dual_blinker<Component>
    , dual_pulser<Component>
{
  using color_cnvrtr =
      color_converter<typename Component::color_t>;
 
  void set(uint8_t id, const color_cnvrtr& converter) override
  {    
    if constexpr(is_sysex_out_component<Component>)
      if (this->bytes.size() == sysex_formater<Component>
         ::prefix_size())
        this->bytes.push_back(Component::color_t::constant_id());
 
    this->bytes.push_back(id);
 
    switch (converter.get_state())
    {
      case color::blinking:
        this->bytes.push_back(color_cnvrtr::clear_value);
        this->blink_bytes.push_back(id);
        this->blink_bytes.push_back(converter.get());
        break;
      case color::pulsing:
        this->bytes.push_back(color_cnvrtr::clear_value);
        this->pulse_bytes.push_back(id);
        this->pulse_bytes.push_back(converter.get());
        break;
      default:
        this->bytes.push_back(converter.get());
        break;
    }
  }
 
  void clear() override
  {
    base_midi_formater<Component>::clear();
    dual_blinker<Component>::clear();
    dual_pulser<Component>::clear();
  }
};

template <typename Component>
  requires (has_blink_offset<Component>
           || has_pulse_offset<Component>)
struct midi_formater<Component> final
    : base_midi_formater<Component>
{
  using cmpnnt_clr = Component::color_t;
 
  virtual void set(uint8_t id
                   , const color_converter<cmpnnt_clr>& converter)
  {
    this->bytes.push_back(id);
    uint8_t value = converter.get();
 
    switch (converter.get_state())
    {
      case color::states::blinking:
        if constexpr (has_blink_offset<Component>)
          value += cmpnnt_clr::blinking_offset();
        else
          value += cmpnnt_clr::pulsing_offset();
        break;
      case color::states::pulsing:
        if constexpr (has_pulse_offset<Component>)
          value += cmpnnt_clr::pulsing_offset();
        else
          value += cmpnnt_clr::blinking_offset();
        break;
      default:
        break;
    }
 
    this->bytes.push_back(value);
  };
};
 
} // namespace buugi