// MT4Q5.cpp - Logging Facility

#include <string>
#include <iostream>
#include <vector>
#include <utility>
#include <ctime>
#include <time.h>
#include <fstream>
#include "../Utilities/Utilities.h"

std::string getTimeDate()
{
  //http://stackoverflow.com/questions/997946/how-to-get-current-time-and-date-in-c
  time_t     now = time(0);
  struct tm  tstruct;
  char       buf[80];
  errno_t  err = localtime_s(&tstruct, &now);
  // Visit http://en.cppreference.com/w/cpp/chrono/c/strftime
  // for more information about date/time format
  strftime(buf, sizeof(buf), "%Y-%m-%d %X", &tstruct);
  return buf;
}

template <typename T>
class Message
{
public:
  Message(const std::string& timeDate, const std::string& test, const T& t);
  void show();
  std::string toString();
private:
  std::string timeDate_;
  std::string text_;
  T t_;
};

template<typename T>
Message<T>::Message(const std::string& timeDate, const std::string& text, const T& t)
  : timeDate_(timeDate), text_(text), t_(t) {}

template<typename T>
void Message<T>::show()
{
  std::cout << "\n  " << timeDate << " " << text_ << " " << t_.toString();
}

template <typename T>
std::string Message<T>::toString()
{
  std::string ret = timeDate_ + " " + text_ + " " + t_.toString();
  return ret;
}

template <typename T>
struct ILog
{
  virtual ~ILog() {}
  virtual void message(Message<T>& msg) = 0;
  virtual void show() = 0;
  virtual bool save() = 0;
};

template <typename T>
struct factory
{
  ILog<T>* create();
};

template <typename T>
class Log : public ILog<T>
{
public:
  void message(Message<T>& msg);
  void show();
  bool save();
private:
  static std::vector<Message<T>> log_;
};

template<typename T>
std::vector<Message<T>> Log<T>::log_;

template <typename T>
ILog<T>* factory<T>::create() { return new Log<T>(); }

template <typename T>
void Log<T>::message(Message<T>& msg)
{
  log_.push_back(msg);
}

template <typename T>
void Log<T>::show()
{
  std::cout << "\n  Message Log";
  std::cout << "\n -------------";
  for (auto msg : log_)
  {
    std::cout << "\n  " << msg.toString();
  }
  std::cout << "\n";
}

template <typename T>
bool Log<T>::save()
{
  std::ofstream out("logfile.txt", std::ios::app);
  if (out.good())
  {
    for (auto msg : log_)
    {
      out << "\n  " << msg.toString();
    }
    out.close();
    log_.clear();
    return true;
  }
  return false;
}

class StringWrapper
{
public:
  StringWrapper(const std::string& name) : name_(name) {}
  std::string toString() { return name_; }
private:
  std::string name_;
};

int main()
{
  title("MT1Q2 and MT1Q4 - Message Logger");

  Log<StringWrapper> log;
  Message<StringWrapper> msg1(getTimeDate(), " first message", StringWrapper("Jim"));
  Message<StringWrapper> msg2(getTimeDate(), "second message", StringWrapper("Jim"));
  Message<StringWrapper> msg3(getTimeDate(), " third message", StringWrapper("Jim"));
  Message<StringWrapper> msg4(getTimeDate(), "fourth message", StringWrapper("Jim"));
  log.message(msg1);
  log.message(msg2);
  log.message(msg3);
  log.message(msg4);
  log.show();
  log.save();
  log.show();
  std::cout << "\n";

  factory<StringWrapper> fact;
  ILog<StringWrapper>* pLog = fact.create();
  Message<StringWrapper> msg5(getTimeDate(), "  fifth message", StringWrapper("Taron"));
  Message<StringWrapper> msg6(getTimeDate(), "  sixth message", StringWrapper("Rakesh"));
  Message<StringWrapper> msg7(getTimeDate(), "seventh message", StringWrapper("Zhichen"));
  Message<StringWrapper> msg8(getTimeDate(), "  eigth message", StringWrapper("Xing"));
  Message<StringWrapper> msg9(getTimeDate(), "  ninth message", StringWrapper("Vishal"));
  Message<StringWrapper> msg10(getTimeDate(), "  tenth message", StringWrapper("Elie"));
  pLog->message(msg5);
  pLog->message(msg6);
  pLog->message(msg7);
  pLog->message(msg8);
  pLog->message(msg9);
  pLog->message(msg10);
  pLog->show();

  std::cout << "\n\n";
}