RtMidiInput.hpp

#ifndef RTMIDIINPUT_HPP
#define RTMIDIINPUT_HPP

#include "IMidiInput.hpp"
#include "Logger.hpp"
#include <atomic>
#include <memory>
#include <mutex>
#include <thread>
#include <vector>

// Forward declarations to avoid including RtMidi.h if possible, or include it
// if needed for types. RtMidi uses std::string and vector.
#include <string>

// Interfaces for wrapping RtMidi
class IRtMidiIn {
  public:
    virtual ~IRtMidiIn() = default;
    virtual void
    openPort(unsigned int portNumber = 0,
             const std::string& portName = std::string("RtMidi Input")) = 0;
    virtual void openVirtualPort(const std::string& portName) = 0;
    virtual void ignoreTypes(bool midiSysex, bool midiTime, bool midiSense) = 0;
    virtual double getMessage(std::vector<unsigned char>* message) = 0;
    virtual unsigned int getPortCount() = 0;
    virtual std::string getPortName(unsigned int portNumber) = 0;
};

class IRtMidiOut {
  public:
    virtual ~IRtMidiOut() = default;
    virtual void
    openPort(unsigned int portNumber = 0,
             const std::string& portName = std::string("RtMidi Output")) = 0;
    virtual void openVirtualPort(const std::string& portName) = 0;
    virtual unsigned int getPortCount() = 0;
    virtual std::string getPortName(unsigned int portNumber) = 0;
};

/**
 * @brief Implémentation de l'entrée MIDI via RTMidi
 *
 * Gère la réception des notes MIDI depuis un périphérique
 */
class RtMidiInput : public IMidiInput {
  private:
    std::unique_ptr<IRtMidiIn> midiIn{nullptr};   ///< Instance RTMidi (Wrapper)
    std::unique_ptr<IRtMidiOut> midiOut{nullptr}; ///< Sortie MIDI (Wrapper)
    std::vector<Note> lastNotes;                  ///< Dernières notes jouées
    std::atomic<bool> notesAvailable{false};      ///< Notes disponibles?
    std::mutex notesMutex; ///< Mutex pour accès aux notes

    std::atomic<bool> shouldStop{false}; ///< Flag d'arrêt du thread
    std::thread inputThread;             ///< Thread de traitement

  private:
    /**
     * @brief Traite les messages MIDI reçus (thread séparé)
     */
    void processMidiMessages();

    /**
     * @brief Convertit un numéro MIDI en Note
     * @param midiNote Numéro MIDI (0-127)
     * @return Note correspondante
     */
    Note convertMidiToNote(int midiNote) const;

  public:
    RtMidiInput(const RtMidiInput&) = delete;
    RtMidiInput& operator=(const RtMidiInput&) = delete;
    RtMidiInput(RtMidiInput&&) = delete;
    RtMidiInput& operator=(RtMidiInput&&) = delete;

    RtMidiInput() { Logger::log("[RtMidiInput] Instance créée"); }

    ~RtMidiInput() override {
        close();
        Logger::log("[RtMidiInput] Instance détruite");
    }

    /**
     * @brief Initialise l'entrée MIDI
     * @return true si initialisation réussie
     */
    bool initialize() override;

    /**
     * @brief Lit les notes jouées (bloquant)
     * @return Vecteur de notes jouées
     */
    std::vector<Note> readNotes() override;

    /**
     * @brief Vérifie si des notes sont disponibles
     * @return true si des notes sont prêtes à être lues
     */
    bool hasNotes() const override;

    /**
     * @brief Ferme l'entrée MIDI
     */
    void close() override;

    /**
     * @brief Vérifie si MIDI est prêt
     * @return true si MIDI est prêt
     */
    bool isReady() const override;

  protected:
    /**
     * @brief Crée l'instance IRtMidiIn
     * @return Pointeur unique vers IRtMidiIn
     */
    virtual std::unique_ptr<IRtMidiIn> createMidiIn();

    /**
     * @brief Crée l'instance IRtMidiOut
     * @return Pointeur unique vers IRtMidiOut
     */
    virtual std::unique_ptr<IRtMidiOut> createMidiOut();
};

#endif // RTMIDIINPUT_HPP