#include <featherlog/log_manager.hpp>
#include <featherlog/push_result.hpp>

namespace flog
{
    std::shared_ptr<LogManager> LogManager::create(MessageFlagManager flagManager) {
        return std::shared_ptr<LogManager>(new LogManager(std::move(flagManager)));
    }

    LogManager::~LogManager()
    {
        {
            std::lock_guard lock(m_loggersMutex);
            m_loggers.clear();
        }
        {
            std::lock_guard lock(m_logOutputtersMutex);
            m_logOutputters.clear();
        }
    }

    LogLevel LogManager::get_min_log_level() const noexcept
    {
        return m_minLogLevel.load(std::memory_order_relaxed);
    }

    void LogManager::set_min_log_level(const LogLevel level) noexcept
    {
        m_minLogLevel.store(level, std::memory_order_relaxed);
    }

    PushResult<std::unique_ptr<LogOutputter>> LogManager::add_outputter(std::unique_ptr<LogOutputter> outputter)
    {
        std::lock_guard lock(m_logOutputtersMutex);
        if (m_logOutputters.contains(outputter->getName()))
        {
            return PushResult<std::unique_ptr<LogOutputter>>::failWithValue(std::move(outputter));
        }
        m_logOutputters.emplace(outputter->getName(), std::move(outputter));
        return PushResult<std::unique_ptr<LogOutputter>>::success();
    }

    bool LogManager::contains_outputter(const std::string_view name) const
    {
        std::shared_lock lock(m_logOutputtersMutex);
        return m_logOutputters.contains(name.data());
    }

    std::optional<std::unique_ptr<LogOutputter>> LogManager::try_delete_outputter(const std::string_view name)
    {
        if (contains_outputter(name))
        {
            std::lock_guard lock(m_logOutputtersMutex);
            const auto it = m_logOutputters.find(name.data());
            std::optional outputter = std::move(it->second);
            m_logOutputters.erase(it);
            return std::move(outputter);
        }
        return std::nullopt;
    }

    std::shared_ptr<Logger> LogManager::get_logger(const std::string &name)
    {
        std::lock_guard lock(m_loggersMutex);
        if (const auto it = m_loggers.find(name); it != m_loggers.end())
        {
            return it->second;
        }

        const auto logger = std::shared_ptr<Logger>(new Logger(name, weak_from_this()));
        m_loggers.emplace(name, logger);
        return logger;
    }

    size_t LogManager::clean_unused_loggers()
    {
        std::lock_guard lock(m_loggersMutex);
        size_t count = 0;
        for (auto it = m_loggers.begin(); it != m_loggers.end();)
        {
            if (it->second.use_count() == 1)
            {
                it = m_loggers.erase(it);
                count += 1;
            }
            else
            {
                ++it;
            }
        }
        return count;
    }

    void LogManager::write_log(const LogMessage &message) const
    {
        std::shared_lock lock(m_logOutputtersMutex);
        for (const std::unique_ptr<LogOutputter> &outputter: m_logOutputters | std::views::values)
        {
            outputter->write_log(message);
        }
    }
}