#pragma once

#include "types.h"
#include "submitter.h"
#include "sender.h"

#include <rtmidi/RtMidi.h>

#include <string>
#include <mutex>

namespace midi_router
{

struct Device_Connection : public Sender
{
    Device_Connection(Device_Id const & source_id, std::string const & device_name, Submitter & submitter, RtMidiIn::RtMidiCallback callback, bool virtual_device):
        source_id(source_id),
        device_name(device_name),
        submitter(submitter),
        virtual_device(virtual_device)
    {
        if (virtual_device)
        {
            midi_in.openVirtualPort(device_name + " In");
            midi_out.openVirtualPort(device_name + " Out");
        }

        midi_in.setCallback(callback, this);
        midi_in.ignoreTypes(true, false, true);
    }

    Device_Id const & source_id;
    std::string const & device_name;
    Submitter & submitter;
    bool const virtual_device;
    RtMidiIn midi_in {};
    RtMidiOut midi_out {};
    std::mutex mutex {};

    void
    send(std::vector<std::uint8_t> const & payload) override
    {
        const std::lock_guard<std::mutex> lock(mutex);
        if (midi_out.isPortOpen() || virtual_device)
        {
            midi_out.sendMessage(&payload);
        }
    }

    std::string
    get_id() const override
    {
        return source_id;
    }

    void
    connect(std::size_t port)
    {
        if (!virtual_device)
        {
            const std::lock_guard<std::mutex> lock(mutex);
            if (!midi_in.isPortOpen()) midi_in.openPort(port);
            if (!midi_out.isPortOpen()) midi_out.openPort(port);
        }
    }

    void
    disconnect()
    {
        if (!virtual_device)
        {
            const std::lock_guard<std::mutex> lock(mutex);
            if (midi_in.isPortOpen()) midi_in.closePort();
            if (midi_out.isPortOpen()) midi_out.closePort();
        }
    }
};

} // namespace midi_router