#pragma once

#include <iostream>
#include <fstream>
#include <string>
#include <memory>
#include <mutex>
#include <unordered_map>
#include <ostream>
#include <sstream>
#include <chrono>
#include <iomanip>
#include <array>
#include <vector>
#include <optional>
#include <functional>

#include <boost/format.hpp>

// Forward declarations
class DaemonLogger;

// The Severity enum is defined outside the class to be available to the template helper,
// resolving the incomplete type compilation error.
enum class Severity { Debug, Info, Warning, Error, _Count };


// Вспомогательный шаблонный класс для управления каскадными свойствами
template <typename T>
class CascadingPropertyResolver {
private:
    std::mutex mtx_;
    T global_default_;
    std::unordered_map<std::string, T> category_defaults_;
    std::unordered_map<std::string, std::unordered_map<Severity, T>> severity_specific_;

public:
    void setGlobal(T value) {
        std::lock_guard<std::mutex> lock(mtx_);
        global_default_ = value;
    }

    void setForCategory(const std::string& category, T value) {
        std::lock_guard<std::mutex> lock(mtx_);
        category_defaults_[category] = value;
    }

    void setForSeverity(const std::string& category, Severity severity, T value) {
        std::lock_guard<std::mutex> lock(mtx_);
        severity_specific_[category][severity] = value;
    }

    T resolve(const std::string& category, Severity severity) {
        std::lock_guard<std::mutex> lock(mtx_);
        // Правило 1: Ищем [категория, уровень]
        if (auto cat_it = severity_specific_.find(category); cat_it != severity_specific_.end()) {
            if (auto sev_it = cat_it->second.find(severity); sev_it != cat_it->second.end()) {
                return sev_it->second;
            }
        }
        // Правило 2: Ищем [категория]
        if (auto cat_it = category_defaults_.find(category); cat_it != category_defaults_.end()) {
            return cat_it->second;
        }
        // Правило 3: Используем глобальное значение
        return global_default_;
    }
};


class DaemonLogger {
public:
    // Re-expose Severity enum inside the class for clarity and namespacing,
    // while the actual definition is outside.
    using Severity = ::Severity;

private:
    // Обертка для потокобезопасной записи в один ostream
    struct SynchronizedStream {
        std::ostream* stream;
        std::mutex mtx;
        SynchronizedStream(std::ostream& s) : stream(&s) {}
    };

    // Контекст, передаваемый каждому функтору формата
    struct LogContext {
        const std::string& category;
        Severity severity;
        const std::string& location;
        const std::string& user_message;
        // Кэш для временной метки, чтобы не вычислять ее многократно
        mutable std::optional<std::string> time_cache;
    };

    // Определяем типы для скомпилированного формата
    using LogPieceFormatter = std::function<void(std::ostream&, const LogContext&)>;
    using CompiledFormat = std::vector<LogPieceFormatter>;

public:
    // --- Конфигурация маршрутизации потоков ---
    static void setGlobalOutputStream(std::ostream& stream) {
        stream_resolver_.setGlobal(get_or_create_synced_stream(stream));
        reconfigureAllLoggers();
    }
    static void setCategoryOutputStream(const std::string& category, std::ostream& stream) {
        stream_resolver_.setForCategory(category, get_or_create_synced_stream(stream));
        reconfigureLogger(category);
    }
    static void setSeverityOutputStream(const std::string& category, Severity severity, std::ostream& stream) {
        stream_resolver_.setForSeverity(category, severity, get_or_create_synced_stream(stream));
        reconfigureLogger(category);
    }

    // --- Конфигурация форматов ---
    static void setGlobalFormat(const std::string& format) {
        format_resolver_.setGlobal(compileFormat(format));
        reconfigureAllLoggers();
    }
    static void setCategoryFormat(const std::string& category, const std::string& format) {
        format_resolver_.setForCategory(category, compileFormat(format));
        reconfigureLogger(category);
    }
    static void setSeverityFormat(const std::string& category, Severity severity, const std::string& format) {
        format_resolver_.setForSeverity(category, severity, compileFormat(format));
        reconfigureLogger(category);
    }

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

    void setMinSeverity(Severity level) { min_severity_ = level; }
    void suppress() { suppressed_ = true; }
    void unsuppress() { suppressed_ = false; }

    // --- Основной метод логирования ---
    template<class... Args>
    void log(Severity severity, const std::string& source_location, const std::string& format, Args... args) const {
        if (suppressed_ || severity < min_severity_) return;

        size_t severity_idx = static_cast<size_t>(severity);
        auto& target_stream = resolved_streams_[severity_idx];
        auto& compiled_format = resolved_compiled_formats_[severity_idx];

        if (!target_stream || !target_stream->stream || !compiled_format || compiled_format->empty()) return;

        // 1. Форматируем только пользовательскую часть сообщения
        std::string user_message;
        try {
            user_message = (boost::format(format) % ... % args).str();
        } catch (const boost::io::format_error& e) {
            user_message = "!!! LOG FORMATTING ERROR: " + std::string(e.what()) + " !!!";
        }

        // 2. Создаем контекст
        LogContext context{category_, severity, source_location, user_message, std::nullopt};

        // 3. Быстро собираем итоговое сообщение, исполняя скомпилированный план
        std::ostringstream final_message_stream;
        for (const auto& formatter : *compiled_format) {
            formatter(final_message_stream, context);
        }

        // 4. Потокобезопасно выводим результат
        {
            std::lock_guard<std::mutex> lock(target_stream->mtx);
            *target_stream->stream << final_message_stream.str() << std::endl;
        }
    }

private:
    explicit DaemonLogger(std::string category) : category_(std::move(category)) {}

    void resolveProperties() {
        for (size_t i = 0; i < static_cast<size_t>(Severity::_Count); ++i) {
            Severity s = static_cast<Severity>(i);
            resolved_streams_[i] = stream_resolver_.resolve(category_, s);
            resolved_compiled_formats_[i] = format_resolver_.resolve(category_, s);
        }
    }

    // "Компилятор" строки формата в набор функторов
    static std::shared_ptr<const CompiledFormat> compileFormat(const std::string& format) {
        static std::mutex compile_mutex;
        static std::unordered_map<std::string, std::shared_ptr<const CompiledFormat>> cache;

        std::lock_guard<std::mutex> lock(compile_mutex);
        if (auto it = cache.find(format); it != cache.end()) {
            return it->second;
        }

        auto compiled = std::make_shared<CompiledFormat>();
        size_t last_pos = 0;
        size_t brace_pos = 0;

        while ((brace_pos = format.find('{', last_pos)) != std::string::npos) {
            // Добавляем литерал перед плейсхолдером
            if (brace_pos > last_pos) {
                compiled->emplace_back(
                    [literal = format.substr(last_pos, brace_pos - last_pos)](auto& os, const auto&) {
                        os << literal;
                    });
            }

            size_t end_brace_pos = format.find('}', brace_pos);
            if (end_brace_pos == std::string::npos) {
                 // Если нет закрывающей скобки, то оставшаяся часть строки, включая '{',
                 // будет обработана как литерал в конце функции.
                 last_pos = brace_pos;
                 break;
            }

            std::string placeholder = format.substr(brace_pos + 1, end_brace_pos - brace_pos - 1);
            if (placeholder == "date") {
                compiled->emplace_back([](auto& os, const auto& ctx) {
                    if (!ctx.time_cache) ctx.time_cache = currentTime();
                    os << *ctx.time_cache;
                });
            } else if (placeholder == "cat") {
                compiled->emplace_back([](auto& os, const auto& ctx) { os << ctx.category; });
            } else if (placeholder == "severity") {
                compiled->emplace_back([](auto& os, const auto& ctx) { os << severityToString(ctx.severity); });
            } else if (placeholder == "loc") {
                compiled->emplace_back([](auto& os, const auto& ctx) { os << ctx.location; });
            } else if (placeholder == "umsg") {
                compiled->emplace_back([](auto& os, const auto& ctx) { os << ctx.user_message; });
            } else {
                // Неизвестный плейсхолдер - выводим как есть, включая скобки
                compiled->emplace_back(
                    [literal = format.substr(brace_pos, end_brace_pos - brace_pos + 1)](auto& os, const auto&) {
                        os << literal;
                    });
            }

            last_pos = end_brace_pos + 1;
        }

        // Добавляем оставшийся хвост строки
        if (last_pos < format.length()) {
            compiled->emplace_back(
                [literal = format.substr(last_pos)](auto& os, const auto&) {
                    os << literal;
                });
        }

        cache[format] = compiled;
        return compiled;
    }

    static void reconfigureAllLoggers() {
        std::lock_guard<std::mutex> lock(registry_mutex_);
        for (auto const& [key, val] : registry_) val->resolveProperties();
    }

    static void reconfigureLogger(const std::string& category) {
        std::lock_guard<std::mutex> lock(registry_mutex_);
        if (auto it = registry_.find(category); it != registry_.end()) {
            it->second->resolveProperties();
        }
    }

    static std::shared_ptr<SynchronizedStream> get_or_create_synced_stream(std::ostream& stream) {
        static std::mutex stream_reg_mutex;
        std::lock_guard<std::mutex> lock(stream_reg_mutex);
        if (auto it = stream_registry_.find(&stream); it != stream_registry_.end()) {
            return it->second;
        }
        auto synced_stream = std::make_shared<SynchronizedStream>(stream);
        stream_registry_[&stream] = synced_stream;
        return synced_stream;
    }

    static std::string currentTime() {
        auto now = std::chrono::system_clock::now();
        auto now_c = std::chrono::system_clock::to_time_t(now);
        std::ostringstream oss;
        // std::localtime is not thread-safe on all platforms, but is often an acceptable trade-off.
        // For a fully thread-safe solution, platform-specific alternatives (localtime_r, localtime_s) would be needed.
        oss << std::put_time(std::localtime(&now_c), "%Y-%m-%d %H:%M:%S");
        return oss.str();
    }

    static const char* severityToString(Severity severity) {
        switch (severity) {
            case Severity::Debug:   return "DEBUG";
            case Severity::Info:    return "INFO ";
            case Severity::Warning: return "WARN ";
            case Severity::Error:   return "ERROR";
            default:                return "UNKNW";
        }
    }

    // --- Данные экземпляра ---
    std::string category_;
    Severity min_severity_ = Severity::Debug;
    bool suppressed_ = false;
    std::array<std::shared_ptr<SynchronizedStream>, static_cast<size_t>(Severity::_Count)> resolved_streams_;
    std::array<std::shared_ptr<const CompiledFormat>, static_cast<size_t>(Severity::_Count)> resolved_compiled_formats_;

    // --- Статические данные класса ---
    inline static std::unordered_map<std::string, std::unique_ptr<DaemonLogger>> registry_;
    inline static std::mutex registry_mutex_;
    inline static std::unordered_map<std::ostream*, std::shared_ptr<SynchronizedStream>> stream_registry_;

    inline static CascadingPropertyResolver<std::shared_ptr<SynchronizedStream>> stream_resolver_;
    inline static CascadingPropertyResolver<std::shared_ptr<const CompiledFormat>> format_resolver_;
};

// --- Макросы для удобного вызова ---
#define __LOG_IMPL(category, severity, format, ...) \
    do { \
        std::string loc = std::string(__func__) + ":" + std::to_string(__LINE__); \
        DaemonLogger::get(category).log(severity, loc, format, ##__VA_ARGS__); \
    } while (0)

#define LOG_DEBUG(category, format, ...)   __LOG_IMPL(category, DaemonLogger::Severity::Debug,   format, ##__VA_ARGS__)
#define LOG_INFO(category, format, ...)    __LOG_IMPL(category, DaemonLogger::Severity::Info,    format, ##__VA_ARGS__)
#define LOG_WARNING(category, format, ...) __LOG_IMPL(category, DaemonLogger::Severity::Warning, format, ##__VA_ARGS__)
#define LOG_ERROR(category, format, ...)   __LOG_IMPL(category, DaemonLogger::Severity::Error,   format, ##__VA_ARGS__)