#ifndef PAD_H
#define PAD_H



#define PAD_DEFINITION_DIR "pads"

#include "AbsInput.h"
#include "MidiPort.h"

class InputAction;
class InputDefinition;

class Button;
class AbsInput;
class PadDefinition;

typedef AbsInput* (*CreateInputCallback)(PadDefinition* p, void* data);


AbsInput* __pad_default_button(PadDefinition* p, void * data);
AbsInput* __pad_default_controller(PadDefinition* p, void * data);

class PadDefinition : public IMidiPortListener, public IMidiPortErrorListener
{
    public:
									PadDefinition();
									PadDefinition(Json::Value v);
									PadDefinition(const std::string& );
		virtual                     ~PadDefinition();

        void                        read_conf(const std::string&);
        void                        read_conf(Json::Value& v);

        virtual MidiPortIn&         get_input_port() {return *m_iport;}
        virtual MidiPortOut&        get_control_port() {return *m_cport;}
        virtual MidiPortOut&        get_output_port() { return *m_oport;}

        void                        connect_to_device(bool input=true, bool output=true);


        void                        set_error_listener(IMidiPortErrorListener*);
        void                        set_port_listener(IMidiPortListener*);

        virtual void                on_error(RtMidiError::Type type, const std::string &errorText);
        virtual void                on_new_message(double ts, MidiMessage* m);

        AbsInput*                   get_by_channel_key(InputType type, int channel, int key);
        AbsInput*                   input_at(int i, int j=-1);
        AbsInput*                   get_by_message(const MidiMessage* msg);


        InputAction*                get_action_def(const std::string& s);
        InputDefinition*            get_input_def(const std::string& s);
        void                        clear();
        void                        send_all(const std::string&);


        Button*                     instanciate_new_button() const;
        Controller*                 instanciate_new_controller() const;

        std::vector<AbsInput*>&     get_matrix();

        int                         get_width() const {return m_width;}
        int                         get_height() const {return m_height;}
        AbsInput*                   at(int x, int y) {return m_matrix[x+y*m_width];}
		const std::string&			get_name() const {return m_name;}

		static PadDefinition*       from_file(const std::string& str);
		static PadDefinition*       from_name(const std::string& str);



    protected:
        void _dispatch_message(double ts, MidiMessage* m);


        //port du Pad Réel, permet de récupérer les entrées
        MidiPortIn*                         m_iport;
        bool                                m_iport_open;

        //Port destiné au pad réel afin de le commander
        MidiPortOut*                        m_cport;
        bool                                m_cport_open;

        //Port de sortie MIDI "classique" pour y brancher un instrument
        MidiPortOut*                        m_oport;
        bool                                m_oport_open;

        //Nom du pad
        std::string                         m_name;

        //nom du port MIDI du PAD
        std::string                         m_port_in_name;
        std::string                         m_port_out_name;

        //taille de la grille
        int                                 m_width;
        int                                 m_height;

        //liste des boutons
        std::vector<AbsInput*>              m_matrix;
        std::vector<InputDefinition*>       m_input_def;

        IMidiPortErrorListener*            m_error_listener;
        IMidiPortListener*                 m_port_listener;

        //
        CreateInputCallback                m_create_button;
        void*                              m_create_button_data;
        CreateInputCallback                m_create_controller;
        void*                              m_create_controller_data;

    private:
        friend class PadConfiguration;
};

#endif // PAD_H