/**

  * 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);

 }

 }

 }