#ifndef MIDIPORT_H
#define MIDIPORT_H

#include "utils.h"

class MidiMessage;
class MidiMessageList;

typedef void (*MidiInCallback)(double ts, const MidiMessage*, void* data);
typedef void (*MidiInErrorCallback)(RtMidiError::Type type, const std::string &errorText, void* data);

class IMidiPortListener
{
    public:
        virtual ~IMidiPortListener(){}
        virtual void on_new_message(double ts, MidiMessage* m)=0;
};



class IMidiPortErrorListener
{
    public:
        virtual ~IMidiPortErrorListener(){}
        virtual void on_error(RtMidiError::Type type, const std::string &errorText)=0;
};


class MidiPortBase
{
    public:
        MidiPortBase();
        virtual ~MidiPortBase(){}
        virtual void _error_handler(RtMidiError::Type type, const std::string &errorText);

    protected:
        void*                       m_error_callback_data;
        MidiInErrorCallback         m_error_callback;
        IMidiPortErrorListener*     m_error_listener;
};

class MidiPortIn : public RtMidiIn, public MidiPortBase
{
    public:
        MidiPortIn(const std::string &clientName);
        virtual ~MidiPortIn(){}

        void set_callback(MidiInCallback cb, void *cbd=NULL){
            m_callback=cb;
            m_listener=NULL;
            m_callback_data=NULL;
        }

        void set_listener(IMidiPortListener* cb){
            m_callback=NULL;
            m_listener=cb;
        }

        void _handler(double ts, MidiRawMessage* rm);
		static std::vector<std::string> get_ports();


    protected:
        void*                       m_callback_data;
        MidiInCallback              m_callback;
        IMidiPortListener*          m_listener;



    private:
};


class MidiPortOut : public RtMidiOut, public MidiPortBase
{
    public:
        MidiPortOut(const std::string &clientName);
        virtual ~MidiPortOut(){}


        void send(const MidiMessage& m );
        void send(const MidiMessageList& m );
		static std::vector<std::string> get_ports();
};




#endif // MIDIPORT_H