/**

 * DJM-Fix

 * Copyright © 2025 František Kučera (Frantovo.cz, GlobalCode.info)

 *

 * This program is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation, version 3 of the License.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program. If not, see <http://www.gnu.org/licenses/>.

 */

#include <iostream>

#include <iomanip>

#include <sstream>

#include <stdexcept>

#include <thread>

#include <mutex>

#include <atomic>

#include <regex>

#include <alsa/asoundlib.h>

#include "AlsaBridge.h"

#include "Logger.h"

namespace djmfix {

namespace alsa {

using L = djmfix::logging::Level;

class AlsaBridgeImpl : public AlsaBridge, private djmfix::MidiSender {

private:

	djmfix::DJMFix* djmFix;

	djmfix::logging::Logger* logger;

	snd_rawmidi_t* input;

	snd_rawmidi_t* output;

	std::thread receivingThread;

	std::recursive_mutex midiMutex;

	std::atomic<bool> stopped{false};

	struct FoundDevice {

		std::string id;

		std::string name;

	};

	FoundDevice findDeviceName(std::regex cardNamePattern) {

		std::vector<int> cardNumbers;

		std::vector<std::string> cardNames;

		logger->log(L::INFO, "Looking for available cards:");

		for (int card = -1; snd_card_next(&card) == 0 && card >= 0;) {

			char* longName = nullptr;

			snd_card_get_longname(card, &longName);

			std::stringstream logMessage;

			logMessage << " - card: #" << card << ": '" << longName << "'";

			if (std::regex_match(longName, cardNamePattern)) {

				cardNumbers.push_back(card);

				cardNames.push_back(longName);

				logMessage << " [matches]";

			}

			logger->log(L::INFO, logMessage.str());

			free(longName);

		}

		if (cardNumbers.size() == 1) {

			const auto n = std::to_string(cardNumbers[0]);

			logger->log(L::INFO, "Going to fix card #" + n);

			return {"hw:" + n, cardNames[0]};

		} else if (cardNumbers.empty()) {

			throw std::invalid_argument(

					"No card with matching name found. Is the card connected? "

					"Maybe try to provide different name pattern.");

		} else {

			throw std::invalid_argument(

					"Multiple cards with matching name found. "

					"Please provide a name pattern that matches only one card");

		}

	}

	std::string toString(const MidiMessage& midiMessage) {

		std::stringstream result;

		for (uint8_t b : midiMessage)

			result << std::hex << std::setw(2) << std::setfill('0') << (int) b;

		return result.str();

	}

	void run() {

		MidiMessage msg;

		while (!stopped) {

			{

				std::lock_guard<std::recursive_mutex> lock(midiMutex);

				// TODO: poll

				uint8_t buf[256];

				ssize_t length = snd_rawmidi_read(input, buf, sizeof (buf));

				if (length > 0 && length <= sizeof (buf)) {

					// Parse MIDI messages and ignore/skip unwanted data.

					// Needed for DJM-V10 that sends annoying amounts of 0xF8.

					for (int i = 0; i < length; i++) {

						uint8_t b = buf[i];

						if (b == MIDI_CMD_COMMON_SYSEX) {

							// start of MIDI SysEx message

							msg.clear();

							msg.push_back(b);

						} else if (b == MIDI_CMD_COMMON_SYSEX_END) {

							// end of MIDI SysEx message

							msg.push_back(b);

							djmFix->receive(msg);

							msg.clear();

						} else if (b == MIDI_CMD_COMMON_CLOCK) {

							logger->log(L::FINEST, "timing clock ignored");

						} else if (b == MIDI_CMD_COMMON_SENSING) {

							logger->log(L::FINEST, "active sensing ignored");

						} else if (b & 0x80) {

							// unknown status, drop previous data

							msg.clear();

							logger->log(L::FINER, "unknown message ignored");

						} else {

							// message data

							msg.push_back(b);

						}

					}

				}

			}

			std::this_thread::sleep_for(std::chrono::milliseconds(100));

		}

	}

public:

	AlsaBridgeImpl(

			djmfix::DJMFix* djmFix,

			const std::string& cardNamePattern,

			djmfix::logging::Logger* logger)

	: djmFix(djmFix), logger(logger ? logger : djmfix::logging::blackhole()) //

	{

		if (djmFix == nullptr)

			throw std::invalid_argument("Need a djmFix for AlsaBridge.");

		FoundDevice found = findDeviceName(std::regex(cardNamePattern));

		int mode = SND_RAWMIDI_NONBLOCK;

		int error = snd_rawmidi_open(&input, &output, found.id.c_str(), mode);

		if (error) throw std::invalid_argument("Unable to open ALSA device.");

		djmFix->setDeviceName(found.name);

		djmFix->setMidiSender(this);

	}

	virtual ~AlsaBridgeImpl() {

		// TODO: do not use raw/exclusive access to the MIDI device

		snd_rawmidi_close(input);

		snd_rawmidi_close(output);

		logger->log(L::FINER, "~AlsaBridgeImpl()");

	}

	virtual void start() override {

		djmFix->start();

		receivingThread = std::thread(&AlsaBridgeImpl::run, this);

	}

	virtual void stop() override {

		stopped = true;

		receivingThread.join();

		djmFix->stop();

	}

	virtual void send(MidiMessage msg) override {

		std::lock_guard<std::recursive_mutex> lock(midiMutex);

		ssize_t length = snd_rawmidi_write(output, msg.data(), msg.size());

		logger->log(L::FINE, "Sent message:"

				" length = " + std::to_string(length)

				+ " data = " + toString(msg));

	}

};

AlsaBridge* create(

		djmfix::DJMFix* djmFix,

		const std::string& deviceName,

		djmfix::logging::Logger* logger) //

{

	return new AlsaBridgeImpl(djmFix, deviceName, logger);

}

}

}