#pragma once

#include <atomic>
#include <memory>
#include <mutex>
#include <shared_mutex>
#include <unordered_map>

#include <featherlog/logger.hpp>
#include <featherlog/log_level.hpp>
#include <featherlog/log_message.hpp>
#include <featherlog/log_outputter.hpp>
#include <featherlog/flog_definitions.h>
#include <featherlog/push_result.hpp>

namespace flog
{
    class FLOG_API LogManager : public std::enable_shared_from_this<LogManager>
    {
    public:
        LogManager(const LogManager &) = delete;
        LogManager &operator=(const LogManager &) = delete;
        LogManager(LogManager &&) = delete;
        LogManager &operator=(LogManager &&) = delete;

        _NODISCARD static std::shared_ptr<LogManager> FLOG_CALL create();

        ~LogManager();

        _NODISCARD LogLevel FLOG_CALL get_min_log_level() const noexcept;
                   void     FLOG_CALL set_min_log_level(LogLevel level) noexcept;

        _NODISCARD PushResult<std::unique_ptr<LogOutputter>> FLOG_CALL add_outputter(
            std::unique_ptr<LogOutputter> outputter);

        _NODISCARD bool FLOG_CALL contains_outputter(std::string_view name) const;
        std::optional<std::unique_ptr<LogOutputter>> FLOG_CALL try_delete_outputter(std::string_view name);

        _NODISCARD std::shared_ptr<Logger> FLOG_CALL get_logger(const std::string &name);

        size_t FLOG_CALL clean_unused_loggers();

    private:
        LogManager() noexcept = default;

        void FLOG_CALL write_log(const LogMessage &message) const;

        std::atomic<LogLevel> m_minLogLevel{LogLevel::DEBUG};

        mutable std::shared_mutex m_logOutputtersMutex;
        std::unordered_map<std::string, std::unique_ptr<LogOutputter>> m_logOutputters;

        mutable std::mutex m_loggersMutex;
        std::unordered_map<std::string, std::shared_ptr<Logger>> m_loggers;
    };
}