#pragma once

#ifndef TLOGGER_INCLUDED
#define TLOGGER_INCLUDED

#include <memory>

//
// TLogger
//
// usage example:
//
//    TFilePath fp;
//    TLogger::info() << "Loading " << fp << " ...";
//    TLogger::error() << "File " << fp << "not found";
//
// N.B.
//    TLogger::debug() << ....
//    is automatically removed in the release
//

#include "tcommon.h"

#undef DVAPI
#undef DVVAR
#ifdef TSYSTEM_EXPORTS
#define DVAPI DV_EXPORT_API
#define DVVAR DV_EXPORT_VAR
#else
#define DVAPI DV_IMPORT_API
#define DVVAR DV_IMPORT_VAR
#endif

class TFilePath;

class DVAPI TLogger {  // singleton
  class Imp;
  std::unique_ptr<Imp> m_imp;

  TLogger();

public:
  ~TLogger();

  static TLogger *instance();

  enum MessageType { Debug = 1, Info, Warning, Error };

  class DVAPI Message {
    MessageType m_type;
    std::string m_timestamp;
    std::string m_text;

  public:
    Message(MessageType type, std::string text);
    MessageType getType() const { return m_type; }
    std::string getTimestamp() const { return m_timestamp; }
    std::string getText() const { return m_text; }
  };

  class Listener {
  public:
    virtual void onLogChanged() = 0;
    virtual ~Listener() {}
  };

  void addMessage(const Message &msg);
  void clearMessages();
  int getMessageCount() const;
  Message getMessage(int index) const;

  void addListener(Listener *listener);
  void removeListener(Listener *listener);

  class DVAPI Stream {
    MessageType m_type;
    std::string m_text;

  public:
    Stream(MessageType type);
    ~Stream();

    Stream &operator<<(std::string v);
    Stream &operator<<(int v);
    Stream &operator<<(double v);
    Stream &operator<<(const TFilePath &v);
  };

  class DVAPI NullStream {
  public:
    NullStream() {}
    ~NullStream() {}

    NullStream &operator<<(std::string) { return *this; }
    NullStream &operator<<(int) { return *this; }
    NullStream &operator<<(double) { return *this; }
    NullStream &operator<<(const TFilePath &) { return *this; }
  };

#ifdef NDEBUG
  static NullStream debug() { return NullStream(); }
#else
  static Stream debug() { return Stream(Debug); }
#endif
  static Stream info() { return Stream(Info); }
  static Stream warning() { return Stream(Warning); }
  static Stream error() { return Stream(Error); }
};

#endif