//
//  Logger.hpp
//  DanmakuRPG
//
//  Created by Sam Jaffe on 7/18/15.
//  Copyright (c) 2015 Sam Jaffe. All rights reserved.
//

#pragma once

#include <cstdarg>
#include <cstdlib>
#include <cstring>
#include <string>
#include <memory>

#define VA_LOGN(level, size) \
do { \
va_list vargs; \
va_start( vargs, fmt ); \
vlognf( level, size, fmt, vargs ); \
va_end( vargs ); \
} while(0)

#define VA_LOG(level) VA_LOGN(level, logger::LOGF_MAX_SIZE)

namespace logging {
  class logger_impl;
  typedef logger_impl& (*_binding)(void);
  bool bind_logger_impl(_binding impl);
    
  enum log_level {
    LTRACE,
    LDEBUG,
    LINFO,
    LWARNING,
    LERROR,
    LCRITICAL,
    LFATAL,
    LNONE
  };
  
  const char* level_header(log_level);
  std::string timestamp();
  
//  struct logpacket {
//    struct tm time;
//    long milliseconds;
//    int thread_id;
//    log_level level;
//    const char* logger;
//    std::string message;
//  };
    
  class logger {
  public:
    static const size_t LOGF_MAX_SIZE = 2048;
    static logger& instance();
    static logger& instance(const char* key);
  public:    
    inline void tracef(char const* fmt, ...) { VA_LOG(LTRACE); }
    inline void tracenf(size_t n, char const* fmt, ...) { VA_LOGN(LTRACE, n); }
    inline void trace(char const* msg) { log(LTRACE, msg); }
    inline void trace(std::string const& msg) { log(LTRACE, msg); }
    
    inline void debugf(char const* fmt, ...) { VA_LOG(LDEBUG); }
    inline void debugnf(size_t n, char const* fmt, ...) { VA_LOGN(LDEBUG, n); }
    inline void debug(char const* msg) { log(LDEBUG, msg); }
    inline void debug(std::string const& msg) { log(LDEBUG, msg); }
    
    inline void infof(char const* fmt, ...) { VA_LOG(LINFO); }
    inline void infonf(size_t n, char const* fmt, ...) { VA_LOGN(LINFO, n); }
    inline void info(char const* msg) { log(LINFO, msg); }
    inline void info(std::string const& msg) { log(LINFO, msg); }
    
    inline void warnf(char const* fmt, ...) { VA_LOG(LWARNING); }
    inline void warnnf(size_t n, char const* fmt, ...) { VA_LOGN(LWARNING, n); }
    inline void warn(char const* msg) { log(LWARNING, msg); }
    inline void warn(std::string const& msg) { log(LWARNING, msg); }
    
    inline void errorf(char const* fmt, ...) { VA_LOG(LERROR); }
    inline void errornf(size_t n, char const* fmt, ...) { VA_LOGN(LERROR, n); }
    inline void error(char const* msg) { log(LERROR, msg); }
    inline void error(std::string const& msg) { log(LERROR, msg); }
    
    inline void criticalf(char const* fmt, ...) { VA_LOG(LCRITICAL); }
    inline void criticalnf(size_t n, char const* fmt, ...) { VA_LOGN(LCRITICAL, n); }
    inline void critical(char const* msg) { log(LCRITICAL, msg); }
    inline void critical(std::string const& msg) { log(LCRITICAL, msg); }
    
    inline void fatalf(char const* fmt, ...) { VA_LOG(LFATAL); }
    inline void fatalnf(size_t n, char const* fmt, ...) { VA_LOGN(LFATAL, n); }
    inline void fatal(char const* msg) { log(LFATAL, msg); }
    inline void fatal(std::string const& msg) { log(LFATAL, msg); }
    
    void flush();
    
    ~logger();
  private:
    void vlognf(log_level, size_t, char const*, va_list);
    void log(log_level, std::string const&);
    std::string get_header(log_level level);
    
    logger(const char* name = "");
    logger(logger const&);
    logger& operator=(logger const&);
    
    log_level min_level_;
    const char* logger_name_;
    logger_impl& impl_;
  };
  
  class logger_impl {
  public:
    virtual void write(log_level level, std::string const& msg) = 0;
    virtual void flush() = 0;
    virtual ~logger_impl() = default;
  };
}
#undef VA_LOG
#undef LA_LOGN