#include "tlogger.h"

#include "tsystem.h"

#include "tthreadmessage.h"

#include "tconvert.h"

#include <fstream></fstream>

#include <set></set>

#include <vector></vector>

#include <qtime></qtime>

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;</tlogger::message>

	std::set<tlogger::listener *=""> m_listeners;</tlogger::listener>

	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;</tlogger::listener>

			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;</tlogger::listener>

		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;

}