#include "MidiSessionALSA.hh"
#include "CliComm.hh"
#include "MidiOutDevice.hh"
#include "MidiInDevice.hh"
#include "MidiInConnector.hh"
#include "EventListener.hh"
#include "EventDistributor.hh"
#include "PlugException.hh"
#include "Poller.hh"
#include "PluggingController.hh"
#include "Scheduler.hh"
#include "narrow.hh"
#include "serialize.hh"
#include "circular_buffer.hh"
#include "checked_cast.hh"
#include <iostream>
#include <memory>
#include <thread>


namespace openmsx {

// MidiOutALSA ==============================================================

class MidiOutALSA final : public MidiOutDevice {
public:
	MidiOutALSA(
			snd_seq_t& seq,
			snd_seq_client_info_t& cinfo, snd_seq_port_info_t& pinfo);
	~MidiOutALSA() override;
	MidiOutALSA(const MidiOutALSA&) = delete;
	MidiOutALSA& operator=(const MidiOutALSA&) = delete;

	// Pluggable
	void plugHelper(Connector& connector, EmuTime::param time) override;
	void unplugHelper(EmuTime::param time) override;
	[[nodiscard]] std::string_view getName() const override;
	[[nodiscard]] std::string_view getDescription() const override;

	// MidiOutDevice
	void recvMessage(
			const std::vector<uint8_t>& message, EmuTime::param time) override;

	template<typename Archive>
	void serialize(Archive& ar, unsigned version);

private:
	void connect();
	void disconnect();

private:
	snd_seq_t& seq;
	snd_midi_event_t* event_parser;
	int sourcePort = -1;
	int destClient;
	int destPort;
	std::string name;
	std::string desc;
	bool connected = false;
};

MidiOutALSA::MidiOutALSA(
		snd_seq_t& seq_,
		snd_seq_client_info_t& cinfo, snd_seq_port_info_t& pinfo)
	: seq(seq_)
	, destClient(snd_seq_port_info_get_client(&pinfo))
	, destPort(snd_seq_port_info_get_port(&pinfo))
	, name(snd_seq_client_info_get_name(&cinfo))
	, desc(snd_seq_port_info_get_name(&pinfo))
{
}

MidiOutALSA::~MidiOutALSA()
{
	if (connected) {
		disconnect();
	}
}

void MidiOutALSA::plugHelper(Connector& /*connector_*/, EmuTime::param /*time*/)
{
	connect();
}

void MidiOutALSA::unplugHelper(EmuTime::param /*time*/)
{
	disconnect();
}

void MidiOutALSA::connect()
{
	sourcePort = snd_seq_create_simple_port(
		&seq, "MIDI out pluggable",
		0, SND_SEQ_PORT_TYPE_MIDI_GENERIC);
	if (sourcePort < 0) {
		throw PlugException(
			"Failed to create ALSA port: ", snd_strerror(sourcePort));
	}

	int err = snd_seq_connect_to(&seq, sourcePort, destClient, destPort);
	if (err) {
		snd_seq_delete_simple_port(&seq, sourcePort);
		throw PlugException(
			"Failed to connect to ALSA port "
			"(", destClient, ':', destPort, ")"
			": ", snd_strerror(err));
	}

	snd_midi_event_new(MAX_MESSAGE_SIZE, &event_parser);

	connected = true;
}

void MidiOutALSA::disconnect()
{
	snd_midi_event_free(event_parser);
	snd_seq_disconnect_to(&seq, sourcePort, destClient, destPort);
	snd_seq_delete_simple_port(&seq, sourcePort);

	connected = false;
}

std::string_view MidiOutALSA::getName() const
{
	return name;
}

std::string_view MidiOutALSA::getDescription() const
{
	return desc;
}

void MidiOutALSA::recvMessage(
		const std::vector<uint8_t>& message, EmuTime::param /*time*/)
{
	snd_seq_event_t ev;
	snd_seq_ev_clear(&ev);

	// Set routing.
	snd_seq_ev_set_source(&ev, narrow_cast<uint8_t>(sourcePort));
	snd_seq_ev_set_subs(&ev);

	// Set message.
	long encodeLen = snd_midi_event_encode(
			event_parser, message.data(), narrow<long>(message.size()), &ev);
	if (encodeLen < 0) {
		std::cerr << "Error encoding MIDI message of type "
		          << std::hex << int(message[0]) << std::dec
		          << ": " << snd_strerror(narrow<int>(encodeLen)) << '\n';
		return;
	}
	if (ev.type == SND_SEQ_EVENT_NONE) {
		std::cerr << "Incomplete MIDI message of type "
		          << std::hex << int(message[0]) << std::dec << '\n';
		return;
	}

	// Send event.
	snd_seq_ev_set_direct(&ev);
	int err = snd_seq_event_output(&seq, &ev);
	if (err < 0) {
		std::cerr << "Error sending MIDI event: "
		          << snd_strerror(err) << '\n';
	}
	snd_seq_drain_output(&seq);
}

template<typename Archive>
void MidiOutALSA::serialize(Archive& /*ar*/, unsigned /*version*/)
{
	if constexpr (Archive::IS_LOADER) {
		connect();
	}
}
INSTANTIATE_SERIALIZE_METHODS(MidiOutALSA);
REGISTER_POLYMORPHIC_INITIALIZER(Pluggable, MidiOutALSA, "MidiOutALSA");

// MidiInALSA ==============================================================
class MidiInALSA final : public MidiInDevice, private EventListener
{
public:
	MidiInALSA(
			EventDistributor& eventDistributor, Scheduler& scheduler, snd_seq_t& seq,
			snd_seq_client_info_t& cinfo, snd_seq_port_info_t& pinfo);
	~MidiInALSA() override;

	// Pluggable
	void plugHelper(Connector& connector, EmuTime::param time) override;
	void unplugHelper(EmuTime::param time) override;
	[[nodiscard]] std::string_view getName() const override;
	[[nodiscard]] std::string_view getDescription() const override;

	// MidiInDevice
	void signal(EmuTime::param time) override;

	template<typename Archive>
	void serialize(Archive& ar, unsigned version);

private:
	void run();
	void connect();
	void disconnect();

	// EventListener
	int signalEvent(const Event& event) override;

private:
	EventDistributor& eventDistributor;
	Scheduler& scheduler;
	std::thread thread;
	snd_seq_t& seq;
	snd_midi_event_t* event_parser;
	int destinationPort = -1;
	int srcClient;
	int srcPort;
	std::string name;
	std::string desc;
	bool connected = false;
	bool stop = false;
	cb_queue<uint8_t> queue;
	std::mutex mutex; // to protect queue
};

MidiInALSA::MidiInALSA(
		EventDistributor& eventDistributor_,
		Scheduler& scheduler_,
		snd_seq_t& seq_,
		snd_seq_client_info_t& cinfo, snd_seq_port_info_t& pinfo)
	: eventDistributor(eventDistributor_)
	, scheduler(scheduler_)
	, seq(seq_)
	, srcClient(snd_seq_port_info_get_client(&pinfo))
	, srcPort(snd_seq_port_info_get_port(&pinfo))
	, name(snd_seq_client_info_get_name(&cinfo))
	, desc(snd_seq_port_info_get_name(&pinfo))
{
	eventDistributor.registerEventListener(EventType::MIDI_IN_ALSA, *this);
	if ((snd_seq_port_info_get_capability(&pinfo) & (SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE))) {
		name.append(" (input)");
	}
}

MidiInALSA::~MidiInALSA()
{
	if (connected) {
		disconnect();
	}
	eventDistributor.unregisterEventListener(EventType::MIDI_IN_ALSA, *this);
}

void MidiInALSA::plugHelper(Connector& connector_, EmuTime::param /*time*/)
{
	auto& midiConnector = checked_cast<MidiInConnector&>(connector_);
	midiConnector.setDataBits(SerialDataInterface::DATA_8); // 8 data bits
	midiConnector.setStopBits(SerialDataInterface::STOP_1); // 1 stop bit
	midiConnector.setParityBit(false, SerialDataInterface::EVEN); // no parity

	setConnector(&midiConnector); // base class will do this in a moment,
	                              // but thread already needs it
	connect();
}

void MidiInALSA::unplugHelper(EmuTime::param /*time*/)
{
	if (connected) {
		disconnect();
	}
}

void MidiInALSA::connect()
{
	destinationPort = snd_seq_create_simple_port(
		&seq, "MIDI in pluggable",
		SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE, SND_SEQ_PORT_TYPE_MIDI_GENERIC);
	if (destinationPort < 0) {
		throw PlugException(
			"Failed to create ALSA port: ", snd_strerror(destinationPort));
	}

	int err = snd_seq_connect_from(&seq, destinationPort, srcClient, srcPort);
	if (err) {
		snd_seq_delete_simple_port(&seq, destinationPort);
		throw PlugException(
			"Failed to connect to ALSA port "
			"(", srcClient, ':', srcPort, ")"
			": ", snd_strerror(err));
	}

	snd_midi_event_new(MidiOutDevice::MAX_MESSAGE_SIZE, &event_parser);
	snd_midi_event_no_status(event_parser, 1);

	connected = true;
	stop = false;

	thread = std::thread([this]() { run(); });
}

void MidiInALSA::disconnect()
{
	stop = true;
	thread.join();

	snd_midi_event_free(event_parser);
	snd_seq_disconnect_from(&seq, destinationPort, srcClient, srcPort);
	snd_seq_delete_simple_port(&seq, destinationPort);

	connected = false;
}

void MidiInALSA::run()
{
	assert(isPluggedIn());

	auto npfd = snd_seq_poll_descriptors_count(&seq, POLLIN);
	std::vector<struct pollfd> pfd(npfd);
	snd_seq_poll_descriptors(&seq, pfd.data(), npfd, POLLIN);

	while (!stop) {
		if (poll(pfd.data(), npfd, 1000) > 0) {
			snd_seq_event_t *ev = nullptr;
			if (auto err = snd_seq_event_input(&seq, &ev); err < 0) {
				std::cerr << "Error receiving MIDI event: "
					<< snd_strerror(err) << '\n';
				continue;
			}
			if (!ev) continue;

			if (ev->type == SND_SEQ_EVENT_SYSEX) {
				std::lock_guard<std::mutex> lock(mutex);
				for (auto i : xrange(ev->data.ext.len)) {
					queue.push_back(static_cast<uint8_t*>(ev->data.ext.ptr)[i]);
				}

			} else {
				std::array<uint8_t, 12> bytes = {};
				auto size = snd_midi_event_decode(event_parser, bytes.data(), bytes.size(), ev);
				if (size < 0) {
					std::cerr << "Error decoding MIDI event: "
					          << snd_strerror(int(size)) << '\n';
					snd_seq_free_event(ev);
					continue;
				}

				std::lock_guard<std::mutex> lock(mutex);
				for (auto i : xrange(size)) {
					queue.push_back(bytes[i]);
				}
			}
			snd_seq_free_event(ev);
			eventDistributor.distributeEvent(
				Event::create<MidiInALSAEvent>());
		}
	}
}

void MidiInALSA::signal(EmuTime::param time)
{
	auto* conn = checked_cast<MidiInConnector*>(getConnector());
	if (!conn->acceptsData()) {
		std::lock_guard<std::mutex> lock(mutex);
		queue.clear();
		return;
	}
	if (!conn->ready()) return;

	uint8_t data;
	{
		std::lock_guard<std::mutex> lock(mutex);
		if (queue.empty()) return;
		data = queue.pop_front();
	}
	conn->recvByte(data, time);
}

// EventListener
int MidiInALSA::signalEvent(const Event& /*event*/)
{
	if (isPluggedIn()) {
		signal(scheduler.getCurrentTime());
	} else {
		std::lock_guard<std::mutex> lock(mutex);
		queue.clear();
	}
	return 0;
}

std::string_view MidiInALSA::getName() const
{
	return name;
}

std::string_view MidiInALSA::getDescription() const
{
	return desc;
}

template<typename Archive>
void MidiInALSA::serialize(Archive& /*ar*/, unsigned /*version*/)
{
	if constexpr (Archive::IS_LOADER) {
		connect();
	}
}
INSTANTIATE_SERIALIZE_METHODS(MidiInALSA);
REGISTER_POLYMORPHIC_INITIALIZER(Pluggable, MidiInALSA, "MidiInALSA");


// MidiSessionALSA ==========================================================

std::unique_ptr<MidiSessionALSA> MidiSessionALSA::instance;

void MidiSessionALSA::registerAll(
		PluggingController& controller, CliComm& cliComm,
		EventDistributor& eventDistributor, Scheduler& scheduler)
{
	if (!instance) {
		// Open the sequencer.
		snd_seq_t* seq;
		int err = snd_seq_open(&seq, "default", SND_SEQ_OPEN_DUPLEX, 0);
		if (err < 0) {
			cliComm.printError(
				"Could not open sequencer: ", snd_strerror(err));
			return;
		}
		snd_seq_set_client_name(seq, "openMSX");
		instance.reset(new MidiSessionALSA(*seq));
	}
	instance->scanClients(controller, eventDistributor, scheduler);
}

MidiSessionALSA::MidiSessionALSA(snd_seq_t& seq_)
	: seq(seq_)
{
}

MidiSessionALSA::~MidiSessionALSA()
{
	// While the Pluggables still have a copy of this pointer, they won't
	// be accessing it anymore when openMSX is exiting.
	snd_seq_close(&seq);
}

void MidiSessionALSA::scanClients(
	PluggingController& controller,
	EventDistributor& eventDistributor,
	Scheduler& scheduler)
{
	// Iterate through all clients.
	snd_seq_client_info_t* cInfo;
	snd_seq_client_info_alloca(&cInfo);
	snd_seq_client_info_set_client(cInfo, -1);
	while (snd_seq_query_next_client(&seq, cInfo) >= 0) {
		int client = snd_seq_client_info_get_client(cInfo);
		if (client == SND_SEQ_CLIENT_SYSTEM) {
			continue;
		}

		// TODO: When there is more than one usable port per client,
		//       register them as separate pluggables.
		snd_seq_port_info_t* pInfo;
		snd_seq_port_info_alloca(&pInfo);
		snd_seq_port_info_set_client(pInfo, client);
		snd_seq_port_info_set_port(pInfo, -1);
		while (snd_seq_query_next_port(&seq, pInfo) >= 0) {
			unsigned int type = snd_seq_port_info_get_type(pInfo);
			if (!(type & SND_SEQ_PORT_TYPE_MIDI_GENERIC)) {
				continue;
			}
			constexpr unsigned int wrCaps =
					SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE;
			constexpr unsigned int rdCaps =
					SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_SUBS_READ;
			if ((snd_seq_port_info_get_capability(pInfo) & wrCaps) == wrCaps) {
				controller.registerPluggable(std::make_unique<MidiOutALSA>(
						seq, *cInfo, *pInfo));
			}
			if ((snd_seq_port_info_get_capability(pInfo) & rdCaps) == rdCaps) {
				controller.registerPluggable(std::make_unique<MidiInALSA>(
						eventDistributor, scheduler, seq, *cInfo, *pInfo));
			}
		}
	}
}

} // namespace openmsx
