#include "connection_manager.h"

#include "sender.h"

#include <iostream>
#include <rtmidi/RtMidi.h>

namespace midi_router
{

struct Device_Connection : public Sender
{
    Device_Connection(Device_Id const & source_id, Submitter & submitter):
        source_id(source_id),
        submitter(submitter) 
    {}

    Device_Id const & source_id;
    Submitter & submitter;
    RtMidiIn midi_in {};
    RtMidiOut midi_out {};

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

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

static void 
callback(double time_stamp, std::vector<unsigned char> *raw, void *user_data)
{
    Device_Connection* device = static_cast<Device_Connection*>(user_data);

    if (raw->size() > 3)
    {
        std::cerr << "Received message with wrong size (" << raw->size() << ") from " << device->source_id << ", dropping\n";
        for (auto const & byte : *raw) std::cerr << static_cast<unsigned>(byte);
        std::cerr << "\n";
        return;
    }

    Message message { &device->source_id, *raw };
    device->submitter.submit(message);
}

Connection_Manager::Connection_Manager(Device_Map const & device_map, Submitter & submitter):
    m_device_map(device_map),
    m_submitter(submitter),
    m_connections{}
    {
        for (auto const & [name, id] : device_map)
        {
            m_connections[id] = std::make_unique<Device_Connection>(id, submitter);
            auto & connection = m_connections[id];

            connection->midi_in.setCallback(&callback, connection.get());            
            connection->midi_in.ignoreTypes(true, false, true);

            if (!open_port(&connection->midi_in, name))
            {
                std::cerr << "Input port not found for device " << name << "\n";
            }

            if (!open_port(&connection->midi_out, name))
            {
                std::cerr << "Output port not found for device " << name << "\n";
            }

        }
    }

Connection_Manager::~Connection_Manager() = default;

Sender &
Connection_Manager::get_sender(Device_Id const & device) const
{
    return *m_connections.at(device);
}

bool 
Connection_Manager::open_port(RtMidi* const midi, std::string const & name)
{
    for (std::size_t i = 0; i < midi->getPortCount(); ++i)
    {
        if (midi->getPortName(i).contains(name))
        {
            midi->openPort(i);
            return true;
        }
    }
    return false;
}

} // namespace midi_router