//
//  mock_logger.h
//  logger_test
//
//  Created by Sam Jaffe on 4/2/19.
//

#ifndef mock_logger_h
#define mock_logger_h

#include <gmock/gmock.h>

#include <sstream>

#include "logger/detail/appender.h"
#include "logger/detail/layout.h"
#include "logger/detail/logger_impl.h"
#include "logger/logpacket.h"

namespace logging {
  inline void PrintTo(location_info const & info, std::ostream * os) {
    if (info.line) {
      (*os) << "{\"" << info.filename << "\", \"" <<
      info.function << "\", " << info.line << "}";
    } else {
      (*os) << "NULL";
    }
  }
  
  inline void PrintTo(logpacket const & pkt, std::ostream * os) {
    (*os) << "{ " << pkt.level << ", ";
    PrintTo(pkt.info, os);
    (*os) << ", \"" << pkt.logger << "\", \"" << pkt.message.str() << "\" }";
  }
}

struct MockAppender : public logging::appender {
  MockAppender() { SetLogLevel(logging::level::trace); }
  void SetLogLevel(logging::level ll) { min_log_level = ll; }
  MOCK_METHOD0(flush, void());
  MOCK_METHOD1(write, void(logging::logpacket const &));
};

struct StubAppender : public logging::appender {
  StubAppender() { SetLogLevel(logging::level::trace); }
  void SetLogLevel(logging::level ll) { min_log_level = ll; }
  void flush() override {}
  void write(logging::logpacket const & pkt) override {
    layout->format(stream, pkt);
  }
  std::stringstream stream;
};

struct MockLayout : public logging::layout {
  MOCK_CONST_METHOD2(format, void(std::ostream&, logging::logpacket const&));
};

struct StubLayout : public logging::layout {
  void format(std::ostream& os, logging::logpacket const& pkt) const {
    os << pkt.message.str();
  }
};

ACTION(LogMessage) {
  arg0 << arg1.message.str();
}

MATCHER_P(MessageEq, value, "") {
  return arg.message.str() == value;
}

struct LoggerTest : public testing::Test {
  void SetUp() override {
    appender.reset(new MockAppender);
    pimpl = std::make_shared<logging::logger_impl>();
    pimpl->impls.push_back(appender);
    
    using testing::_;
    using testing::AnyNumber;

    EXPECT_CALL(*appender, write(_)).Times(AnyNumber());
    EXPECT_CALL(*appender, flush()).Times(AnyNumber());
  }
  void TearDown() override {
    pimpl.reset();
    appender.reset();
  }
  
  std::shared_ptr<MockAppender> appender;
  std::shared_ptr<logging::logger_impl> pimpl;
};

#endif /* mock_logger_h */