sysex_out.hpp

#pragma once
#include <hardware/component.hpp>
#include <concepts/device.hpp>
#include <concepts/message.hpp>
#include <concepts/common.hpp>
 
#include <libremidi/libremidi.hpp>
 
namespace bugui
{
template <typename Device, typename Controller>
class sysex_out
    : virtual public component<Device, Controller>
{
  using grid_t = grid<Device, Controller>;
  using buttons_t = buttons<Device, Controller>;
 
  static constexpr auto prefix{Device::sysex_prefix()};
  static constexpr auto p_size{prefix.size()};
  static constexpr auto p_size_incr{p_size + 1};
  libremidi::midi_bytes bytes{prefix.cbegin(), prefix.cend()};
  libremidi::midi_bytes blink_bytes{bytes};
  libremidi::midi_bytes pulse_bytes{bytes};
 
  void send_color()
  {
    if (bytes.size() > p_size_incr)
      send();
    else
      bytes.erase(bytes.begin() + p_size, bytes.end());
 
    if (blink_bytes.size() > p_size_incr)
      send_blink();
    else
      blink_bytes.erase(blink_bytes.begin() + p_size_incr
                        , blink_bytes.end());
 
    if (pulse_bytes.size() > p_size_incr)
      send_pulse();
    else
      pulse_bytes.erase(pulse_bytes.begin() + p_size_incr
                        , pulse_bytes.end());
  }
 
  void send()
  {
    bytes.push_back(Device::sysex_sufix());
    m_output.send_message(bytes);
    bytes.erase(bytes.begin() + p_size, bytes.end());
  }
 
  void send_blink()
  {
    blink_bytes.push_back(Device::sysex_sufix());
    m_output.send_message(blink_bytes);
    blink_bytes.erase(blink_bytes.begin() + p_size_incr
                      , blink_bytes.end());
  }
 
  void send_pulse()
  {
    pulse_bytes.push_back(Device::sysex_sufix());
    m_output.send_message(pulse_bytes);
    pulse_bytes.erase(pulse_bytes.begin() + p_size_incr
                      , pulse_bytes.end());
  }
 
protected:
  ~sysex_out() override
  {
    clear();
    m_output.close_port();
  }
 
  void init()
  {
    if (blink_bytes.size() == p_size)
      blink_bytes.push_back(Device::blinking_color());
    if (pulse_bytes.size() == p_size)
      pulse_bytes.push_back(Device::pulsing_color());
 
    if constexpr(has_init<Device>)
    {
      static constexpr auto init_m{Device::init()};
      bytes.insert(bytes.end(), init_m.cbegin(), init_m.cend());
      send();
    }
  }
 
  void clear() override
  {
    if constexpr(has_clear<Device>)
    {
      static constexpr auto clear_m{Device::clear()};
      bytes.insert(bytes.end(), clear_m.cbegin(), clear_m.cend());
    }
    else
    {
      if constexpr (has_color<Device>)
      {
        bytes.push_back(Device::constant_color());
 
        if constexpr (has_grid<Device>)
          grid_t::clear([this] (auto id)
          {
            this->bytese.push_back(id);
            this->bytese.push_back(0); // OFF
          });
 
        if constexpr (has_buttons<Device>)
          buttons_t::paint([this] (auto id)
          {
            bytes.push_back(id);
            bytes.push_back(0); // OFF
          });
      }
    }
 
    send();
  }
 
  void set_grid(painter& p) override
  {
    if constexpr (has_color<Device> && has_grid<Device>)
    {
      bytes.push_back(Device::constant_color());
 
      grid_t::paint(p, [this] (auto id, const auto& color)
      {
        bytes.push_back(id);
 
        switch (color.get_state())
        {
          case color::blinking:
            blink_bytes.push_back(id);
            bytes.push_back(color.get_secondary());
            blink_bytes.push_back(color.get());
            break;
          case color::pulsing:
            pulse_bytes.push_back(id);
            bytes.push_back(color.get_secondary());
            pulse_bytes.push_back(color.get());
            break;
          default:
            bytes.push_back(color.get());
            break;
        }
      });
 
      send_color();
    }
  }
 
  void set_button(const button_painter& p) override
  {
    if constexpr (has_color<Device> && has_buttons<Device>)
    {
      bytes.push_back(Device::constant_color());
 
      buttons_t::paint(p, [this] (auto id, const auto& color)
      {
        bytes.push_back(id);
 
        switch (color.get_state())
        {
          case color::blinking:
            blink_bytes.push_back(id);
            bytes.push_back(color.get_secondary());
            blink_bytes.push_back(color.get());
            break;
          case color::pulsing:
            pulse_bytes.push_back(id);
            bytes.push_back(color.get_secondary());
            pulse_bytes.push_back(color.get());
            break;
          default:
            bytes.push_back(color.get());
            break;
        }
      });
 
      send_color();
    }
  }
 
  libremidi::midi_out m_output;
};
 
} // namespace bugui