#include "tlogger.h"
#include "tsystem.h"
#include "tthreadmessage.h"
#include "tconvert.h"
 
#include <fstream>
#include <set>
#include <vector>
#include <QTimer>
 
using std::endl;
 
/*
class TLogger::Imp {
public:
  std::ofstream m_os;
  TThread::Mutex m_mutex;
 
  Imp(const TFilePath &fp) 
  : m_os(toString(fp.getWideString()).c_str(), std::ios_base::out | std::ios_base::app)
  , m_mutex()
  {
    TTime t = TSystem::getCurrentTime(); 
    m_os << "========================" << std::endl;
    m_os << t.getDate() << " " << t.getTime() << endl;
    m_os << "Start logging" << endl << endl;
  }
};
 
 
TLogger::TLogger()
: m_imp(new Imp(TSystem::getTempDir() + "log.txt"))
{
}
 
 
TLogger::~TLogger()
{
  delete m_imp;
}
 
TLogger *TLogger::instance()
{
  static TLogger _instance;
  return &_instance;
}
 
 
void TLogger::print(string module, string msg)
{
  QMutexLocker sl(m_imp->m_mutex);
  m_imp->m_os << module << " : " << msg << std::endl;
}
*/
 
class TLogger::Imp
{
public:
	std::vector<TLogger::Message> m_messages;
	std::set<TLogger::Listener *> m_listeners;
	TThread::Mutex m_mutex;
 
	class ListenerNotifier : public TThread::Message
	{
		Imp *m_imp;
 
	public:
		ListenerNotifier(Imp *imp) : m_imp(imp) {}
		void onDeliver()
		{
			QMutexLocker sl(&m_imp->m_mutex);
			std::set<TLogger::Listener *>::iterator it;
			for (it = m_imp->m_listeners.begin();
				 it != m_imp->m_listeners.end(); ++it)
				(*it)->onLogChanged();
		}
		TThread::Message *clone() const { return new ListenerNotifier(*this); }
	};
 
	void notify()
	{
		//ListenerNotifier(this).send();//onDeliver()
		std::set<TLogger::Listener *>::iterator it;
		for (it = m_listeners.begin();
			 it != m_listeners.end(); ++it)
			(*it)->onLogChanged();
	}
};
 
TLogger::TLogger()
	: m_imp(new Imp())
{
}
 
TLogger::~TLogger()
{
	delete m_imp;
}
 
TLogger *TLogger::instance()
{
	static TLogger _instance;
	return &_instance;
}
 
TLogger::Message::Message(MessageType type, string text)
	: m_type(type), m_text(text)
{
	QTime t = QTime::currentTime();
	m_timestamp = t.toString("hh:mm:ss.zzz").toStdString();
}
 
void TLogger::addMessage(const Message &msg)
{
	QMutexLocker sl(&m_imp->m_mutex);
	m_imp->m_messages.push_back(msg);
	m_imp->notify();
}
 
void TLogger::clearMessages()
{
	QMutexLocker sl(&m_imp->m_mutex);
	m_imp->m_messages.clear();
	m_imp->notify();
}
 
int TLogger::getMessageCount() const
{
	QMutexLocker sl(&m_imp->m_mutex);
	return m_imp->m_messages.size();
}
 
TLogger::Message TLogger::getMessage(int index) const
{
	QMutexLocker sl(&m_imp->m_mutex);
	assert(0 <= index && index < getMessageCount());
	return m_imp->m_messages[index];
}
 
void TLogger::addListener(TLogger::Listener *listener)
{
	m_imp->m_listeners.insert(listener);
}
 
void TLogger::removeListener(TLogger::Listener *listener)
{
	m_imp->m_listeners.erase(listener);
}
 
TLogger::Stream::Stream(MessageType type)
	: m_type(type), m_text()
{
}
 
TLogger::Stream::~Stream()
{
	try {
		TLogger::Message msg(m_type, m_text);
		TLogger::instance()->addMessage(msg);
	} catch (...) {
	}
}
 
TLogger::Stream &TLogger::Stream::operator<<(string v)
{
	m_text += v;
	return *this;
}
 
TLogger::Stream &TLogger::Stream::operator<<(int v)
{
	m_text += toString(v);
	return *this;
}
 
TLogger::Stream &TLogger::Stream::operator<<(double v)
{
	m_text += toString(v);
	return *this;
}
 
TLogger::Stream &TLogger::Stream::operator<<(const TFilePath &v)
{
	m_text += toString(v.getWideString());
	return *this;
}