#include <boost/log/sources/record_ostream.hpp>
#include <boost/log/attributes.hpp>
#include <boost/log/expressions.hpp>
#include <boost/log/sinks/async_frontend.hpp>
#include <boost/log/sinks/text_ostream_backend.hpp>
#include <boost/log/sources/severity_channel_logger.hpp>
#include <boost/log/core.hpp>
#include <boost/core/null_deleter.hpp>
#include <boost/make_shared.hpp>

#include <iostream>
#include <fstream>

enum Level {
    A, B, C
};

enum Group {
    G0, G1, G2
};

std::ostream& operator<<(
    std::ostream& stream,
    const Level& level
) {
    static const std::array<std::string, 3> strings = {
        "A", "B", "C"
    };
    const auto levelIndex =
        static_cast<int>(level)-static_cast<int>(Level::A);
    assert(levelIndex >= 0);
    assert(levelIndex < strings.size());

    return stream << strings[levelIndex];
}

std::ostream& operator<<(
    std::ostream& stream,
    const Group& group
) {
    static const std::array<std::string, 3> strings = {
        "G0", "G1", "G2"
    };
    const auto groupIndex =
        static_cast<int>(group) - static_cast<int>(Group::G0);
    assert(groupIndex >= 0);
    assert(groupIndex < strings.size());

    return stream << strings[groupIndex];
}

namespace
{
    BOOST_LOG_ATTRIBUTE_KEYWORD(level, "Severity", Level)
    BOOST_LOG_ATTRIBUTE_KEYWORD(group, "Channel", Group)
}

namespace blog = boost::log;
namespace expr = blog::expressions;

void formatter(
    blog::record_view const& record,
    blog::formatting_ostream& stream
) {
    stream << "[" << record[level] << "]";
    stream << "[" << record[group] << "]";
    stream << " " << record[expr::smessage];
}

typedef blog::sinks::asynchronous_sink<
   boost::log::sinks::text_ostream_backend 
> async_sink_t;

auto async_sink0 = boost::make_shared<async_sink_t>();
auto async_sink1 = boost::make_shared<async_sink_t>();

void init()
{
    async_sink0->locked_backend()->add_stream(
        boost::shared_ptr<std::ostream>(&std::cout, boost::null_deleter{})
    );
    async_sink0->set_formatter(&formatter);
    blog::core::get()->add_sink(async_sink0);
    
    async_sink1->locked_backend()->add_stream(
        boost::make_shared<std::ofstream>("xxx.log")
    );
    async_sink1->set_formatter(&formatter);
    blog::core::get()->add_sink(async_sink1);
}

void deinit()
{
    blog::core::get()->remove_sink(async_sink0); // No logs going into sink
    async_sink0->stop(); // Stop the feed loop
    async_sink0->flush(); // All the waiting records are flushed to sink

    blog::core::get()->remove_sink(async_sink1); // No logs going into sink
    async_sink1->stop(); // Stop the feed loop
    async_sink1->flush(); // All the waiting records are flushed to sink
}

// Run this program several times. From time to time (timing issue?) you will see:
// [][G0] Foo bar
// [B][] Foo bar
int main()
{   
    init();
    blog::sources::severity_channel_logger_mt<Level, Group> log;

    BOOST_LOG_CHANNEL_SEV(log, Group::G0, Level::B) << "Foo bar";

    deinit();

    std::cin.get();

    return 0;
}