#pragma once
#include <string>
#include <iostream>
#include <unordered_map>
#include <unordered_set>
#include <memory>
#include <mutex>

/// \brief Класс для логирования сообщений по категориям и уровням серьезности.
/// Позволяет вести логирование с разными уровнями и подавлять вывод по категориям.
class Logger {
public:
	/// \brief Уровни серьезности сообщений для логгера.
	enum class Severity {
		Debug,   ///< Отладочная информация
		Info,    ///< Информационные сообщения
		Warning, ///< Предупреждения
		Error    ///< Ошибки
	};

	// Получить логгер по категории (создаёт, если нет)
	static Logger& get(const std::string& category) {
		std::lock_guard<std::mutex> lock(registry_mutex_);
		auto it = registry_.find(category);
		if (it == registry_.end()) {
			auto logger = std::unique_ptr<Logger>(new Logger(category));
			auto [inserted_it, _] = registry_.emplace(category, std::move(logger));
			return *(inserted_it->second);
		}
		return *(it->second);
	}

	// Настроить suppression для категории
	static void suppressCategory(const std::string& category) {
		get(category).suppressed_ = true;
	}
	static void unsuppressCategory(const std::string& category) {
		get(category).suppressed_ = false;
	}
	static void setMinSeverity(const std::string& category, Severity level) {
		get(category).min_severity_ = level;
	}
	static Severity getMinSeverity(const std::string& category) {
		return get(category).min_severity_;
	}
	static bool isSuppressed(const std::string& category) {
		return get(category).suppressed_;
	}

	void log(const std::string& message, Severity severity = Severity::Info) const {
		if (suppressed_) return;
		if (severity < min_severity_) return;
		std::cout << "[" << category_ << "] " << severityToString(severity) << ": " << message << std::endl << std::flush;
	}

	// Удобные методы для логирования по уровню
	void dbg(const std::string& message) const { log(message, Severity::Debug); }
	void info(const std::string& message) const { log(message, Severity::Info); }
	void warn(const std::string& message) const { log(message, Severity::Warning); }
	void err(const std::string& message) const { log(message, Severity::Error); }

	static std::string severityToString(Severity severity) {
		switch (severity) {
			case Severity::Debug: return "DEBUG";
			case Severity::Info: return "INFO";
			case Severity::Warning: return "WARNING";
			case Severity::Error: return "ERROR";
			default: return "UNKNOWN";
		}
	}

	const std::string& category() const { return category_; }
	Severity minSeverity() const { return min_severity_; }
	void setMinSeverity(Severity s) { min_severity_ = s; }
	bool suppressed() const { return suppressed_; }
	void setSuppressed(bool s) { suppressed_ = s; }

private:
	explicit Logger(std::string category)
		: category_(std::move(category)), min_severity_(Severity::Debug), suppressed_(false) {}

	std::string category_;
	Severity min_severity_;
	bool suppressed_;

	static std::unordered_map<std::string, std::unique_ptr<Logger>> registry_;
	static std::mutex registry_mutex_;
};

// Определения статических членов
inline std::unordered_map<std::string, std::unique_ptr<Logger>> Logger::registry_{};
inline std::mutex Logger::registry_mutex_;