//
//  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 StubAppender : public logging::appender {
  StubAppender() : threshold(logging::level::trace) { }
  std::ostream & stream() override { return sstream; }
  void flush() override {}
  void write(logging::logpacket const & pkt, logging::layout & lay) override {
    lay.format(sstream, pkt);
  }
  bool should_log(logging::level ll) const override {
    return ll >= threshold;
  }
  logging::level threshold;
  std::stringstream sstream;
};

struct MockAppender : public StubAppender {
  MockAppender() { }
  MOCK_METHOD0(flush, void());
  MOCK_METHOD2(write, void(logging::logpacket const &, logging::layout &));
};

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>();
    auto layout = std::make_shared<StubLayout>();
    auto log = std::make_shared<logging::log_appender>(appender, layout);
    pimpl->impls.push_back(log);
    
    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 */