#ifndef LOGGER_H
#define LOGGER_H

#include <pthread.h>
#include <iostream>

class Logger {
  std::ostream* m_stream;
  pthread_mutex_t m_mutex;
public:
  Logger() : m_stream(&std::clog) { pthread_mutex_init(&m_mutex, 0); }
  ~Logger() { pthread_mutex_destroy(&m_mutex); }
  std::ostream& stream() { return *m_stream; }
  void lock() { pthread_mutex_lock(&m_mutex); }
  void unlock() { pthread_mutex_unlock(&m_mutex); }  
};

template <typename Helper, typename T>
class LoggerHelperBase {
protected:
  Helper& m_helper;
  const T& m_value;
  bool m_active;
public:
  LoggerHelperBase(Helper& helper, const T& value)
  : m_helper(helper)
  , m_value(value)
  , m_active(true) { }
  
  void deactivate() { m_active = false; }
};

template <typename Helper, typename T>
class LoggerHelper : public LoggerHelperBase<Helper, T> {
public:
  LoggerHelper(Helper& helper, const T& value)
  : LoggerHelperBase<Helper, T>(helper, value) {
    helper.deactivate();
  }
  
  ~LoggerHelper() {
    if (m_active) {
      Logger& logger = getLogger();
      logger.lock();
      run(logger.stream());
      logger.stream() << std::endl;
      logger.unlock();
    }
  }
  
  void run(std::ostream& stream) {
    m_helper.run(stream);
    stream << m_value;
  }
  
  Logger& getLogger() { return m_helper.getLogger(); }
};

template <typename T>
class LoggerHelper<Logger, T> : public LoggerHelperBase<Logger, T> {
public:
  LoggerHelper(Logger& logger, const T& value)
  : LoggerHelperBase<Logger, T>(logger, value) { }
  
  ~LoggerHelper() {
    if (m_active) {
      Logger& logger = m_helper;
      logger.lock();
      run(logger.stream());
      logger.stream() << std::endl;
      logger.unlock();
    }
  }
    
  void run(std::ostream& stream) {
    stream << m_value;
  }
  
  Logger& getLogger() { return m_helper; }
};

template <typename T>
LoggerHelper<Logger, T> operator<<(Logger& logger, const T& value) {
  return LoggerHelper<Logger, T>(logger, value);
}

template <typename Helper, typename T1, typename T2>
LoggerHelper<LoggerHelper<Helper, T1>, T2> operator<<(LoggerHelper<Helper, T1> helper, const T2& value) {
  return LoggerHelper<LoggerHelper<Helper, T1>, T2>(helper, value);
}


#endif // LOGGER_H