#include <iostream>
#include <fstream>
#include <cerrno>
#include <cstdlib>

#include <boost/config.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/log/log.hpp>
#include <boost/log/functions.hpp>

#include <boost/timer.hpp>

#include <unistd.h>
#include <signal.h>

BOOST_DECLARE_LOG (mylog);

BOOST_DEFINE_LOG (mylog, "mylog");

using namespace std;
using namespace boost;
using namespace boost::logging;

volatile sig_atomic_t signalled = 0;

void
alarm_clock (int sig)
{
    signalled = 1;
}

class my_write_to_file {
    shared_ptr<ofstream> m_file;

public:
    my_write_to_file (const char* filename)
        : m_file (new ofstream (filename, ios::app))
        {
            if (!m_file->is_open ())
                throw runtime_error (strerror (errno));
        }

    void operator () (const logging_types::string&,
                      const logging_types::string& msg) {
        m_file->write (msg.data (), msg.size ());
    }
};

int
main (int argc, char* argv[])
{
    bool bypass = false;
    bool disabled = false;
    bool iostreams = false;
    const char* filename = 0;

    for (int i = 1; i < argc; ++i)
        {
        const char* arg = argv[i];

        if (strcmp (arg, "-b") == 0 ||
            strcmp (arg, "--bypass") == 0)
            bypass = true;
        else if (strcmp (arg, "-d") == 0 ||
            strcmp (arg, "--disable") == 0)
            {
            disabled = true;
            disable_logs ("mylog");
            }
        else if ((strcmp (arg, "-f") == 0 ||
                  strcmp (arg, "--file") == 0) &&
                 i < argc - 1)
            {
            filename = argv[++i];
            manipulate_logs ("*").
            add_appender (my_write_to_file (filename));
            }
        else if (strcmp (arg, "-i") == 0 ||
                 strcmp (arg, "--iostreams") == 0)
            iostreams = true;
        }

    if (bypass)
        cout << "Not using any logging\n";
    else
        {
        cout << "Using "
             << (disabled ? "disabled " : "enabled ")
             << (iostreams ? "iostreams" : "Boost.Log");

        if (!disabled)
            cout << ", output to " << (filename ? filename : "(nowhere)");

        cout << "\n";
        }

    timer timer;
    size_t counter = 0;

    signal (SIGALRM, alarm_clock);
    alarm (1);

    if (bypass)
        {
        while (!signalled)
            ++counter;
        }
    else if (iostreams)
        {
        ofstream output (filename ? filename : "/dev/null", ios::app);

        while (!signalled)
            {
            ++counter;

            if (!disabled)
                output << "Hello World!\n";
            }
        }
    else
        {
        while (!signalled)
            {
            BOOST_LOG (mylog) << "Hello, World!\n";
            ++counter;
            }
        }

    cout << counter << " logging operations in " << timer.elapsed ()
         << " sec = " << counter / timer.elapsed () << " ops/sec or "
         << timer.elapsed () / counter << " sec/op\n";

    return 0;
}