#include "tcontenthistory.h"

#include <qstring></qstring>

#include <qdatetime></qdatetime>

#include <qstringlist></qstringlist>

#include <qprocess></qprocess>

#include <qtextstream></qtextstream>

#ifdef WIN32

#include <windows.h></windows.h>

#endif

#include <map></map>

#include <qfile></qfile>

/*

class HistoryRec

{

QDateTime m_date;

HistoryRec(const QDateTime&date QString&user, const QString&machine)

 : date(date)

 , m_user

};

*/

using namespace std;

//-------------------------------------------------------

TContentHistory::TContentHistory(bool isLevel)

	: m_isLevel(isLevel), m_frozenHistory()

{

}

//-------------------------------------------------------

TContentHistory::~TContentHistory()

{

}

//-------------------------------------------------------

TContentHistory *TContentHistory::clone() const

{

	TContentHistory *history = new TContentHistory(m_isLevel);

	history->deserialize(serialize());

	return history;

}

//-------------------------------------------------------

void TContentHistory::deserialize(const QString ¤tHistory)

{

	m_frozenHistory = currentHistory;

}

/*

QStringList strlist = str.split("#");

//skip strlist[0], is the header

int i;

for (i=1; i

  {

  QString str = strlist.at(i);

  parseLine(&str);

   }

}*/

//--------------------------------------------------------------------

inline QString blanks(const QString &str, int count = 15)

{

	QString res = str;

	if (res.size() >= count)

		res.truncate(count);

	else

		res += QString(count - str.size(), ' ');

	return res;

}

//--------------------------------------------------------------------

inline QString getStr(const TFrameId &id)

{

	if (id.getLetter() != 0)

		return QString::number(id.getNumber()) + id.getLetter();

	else

		return QString::number(id.getNumber());

}

//--------------------------------------------------------------------

const QString Fmt = "dd MMM yy   hh:mm";

QString getLine(int counter, const QDateTime &date, const set<tframeid> &frames)</tframeid>

{

	static QString user;

	static QString machine;

	if (user == "") {

		QStringList list = QProcess::systemEnvironment();

		int j;

		for (j = 0; j < list.size(); j++) {

			QString value = list.at(j);

			if (value.startsWith("USERNAME="))

				user = blanks(value.right(value.size() - 9));

			else if (value.startsWith("COMPUTERNAME="))

				machine = blanks(value.right(value.size() - 13));

		}

	}

	if (frames.empty())

		return "| #" + blanks(QString::number(counter), 4) + blanks(date.toString(Fmt), 20) + blanks(machine, 12) + user + " |";

	QString framesStr;

	set<tframeid>::const_iterator it = frames.begin();</tframeid>

	TFrameId first, last;

	while (it != frames.end()) {

		first = last = *it;

		++it;

		while (it != frames.end() &&

			   ((*it).getNumber() == last.getNumber() || // 1a, 1b....

				(*it).getNumber() == last.getNumber() + 1)) {

			assert(*it > last);

			last = *it, ++it;

		}

		framesStr += getStr(first) + ((first != last) ? "-" + getStr(last) : "");

		if (it != frames.end())

			framesStr += ", ";

	}

	return "| #" + blanks(QString::number(counter), 4) + blanks(date.toString(Fmt), 20) + blanks(machine, 12) + user + blanks(framesStr, 20) + " |";

}

//--------------------------------------------------------------------

int getCurrentCount(const QString &str)

{

	if (str == "")

		return 0;

	int from = str.lastIndexOf('#') + 1;

	assert(from != -1);

	int to = str.indexOf(" ", from) - 1;

	assert(to != -1);

	assert(from <= to);

	return (str.mid(from, to - from + 1)).toInt();

}

//--------------------------------------------------------------------

const QString TContentHistory::currentToString() const

{

	if (m_records.empty())

		return "";

	int counter = getCurrentCount(m_frozenHistory);

	if (!m_isLevel) {

		assert(m_records.size() == 1);

		return getLine(++counter, m_records.begin()->second, set<tframeid>());</tframeid>

	}

	QString out;

	std::multimap<qdatetime, tframeid=""> dateSorted;</qdatetime,>

	std::map<tframeid, qdatetime="">::const_iterator it;</tframeid,>

	for (it = m_records.begin(); it != m_records.end(); ++it)

		dateSorted.insert(pair<qdatetime, tframeid="">(it->second, it->first));</qdatetime,>

	std::multimap<qdatetime, tframeid="">::const_iterator it1 = dateSorted.begin();</qdatetime,>

	QDateTime currDate = it1->first;

	while (it1 != dateSorted.end()) {

		set<tframeid> frames;</tframeid>

		while (it1 != dateSorted.end() && currDate == it1->first) {

			frames.insert(it1->second);

			++it1;

		}

		assert(!frames.empty());

		out += getLine(++counter, currDate, frames);

		if (it1 != dateSorted.end())

			currDate = it1->first;

	}

	return out;

}

//--------------------------------------------------------------------

const QString TContentHistory::serialize() const

{

	const QString currentHistory = currentToString();

	if (m_frozenHistory != "")

		return m_frozenHistory + currentHistory;

	else if (currentHistory != "") {

		if (m_isLevel)

			return "| #    DATE:       Time:   MACHINE:    USER:          FRAMES MODIFIED:     |" + currentHistory;

		else

			return "| #    DATE:       Time:   MACHINE:    USER:           |" + currentHistory;

	} else

		return "";

}

//--------------------------------------------------------------------

void TContentHistory::fixCurrentHistory()

{

	m_frozenHistory = serialize();

	m_records.clear();

}

//--------------------------------------------------------------------

void TContentHistory::frameRangeModifiedNow(const TFrameId &fromId, const TFrameId &toId)

{

	assert(m_isLevel);

	QDateTime date = QDateTime::currentDateTime();

	QDateTime dateNoSecs(date.date(), date.time().addSecs(-date.time().second()));

	assert(dateNoSecs.secsTo(date) == date.time().second());

	int i;

	m_records[fromId] = dateNoSecs;

	if (fromId == toId)

		return;

	for (i = fromId.getNumber() + 1; i <= toId.getNumber() - 1; i++)

		m_records[TFrameId(i)] = dateNoSecs;

	m_records[toId] = dateNoSecs;

}

//--------------------------------------------------------------------

void TContentHistory::modifiedNow()

{

	assert(!m_isLevel);

	QDateTime date = QDateTime::currentDateTime();

	QDateTime dateNoSecs(date.date(), date.time().addSecs(-date.time().second()));

	assert(dateNoSecs.secsTo(date) == date.time().second());

	m_records[0] = dateNoSecs;

}

/*

void testHistory()

{

		{

		TContentHistory ch(true);

		ch.frameModifiedNow(TFrameId(13));

		Sleep(1000);

		ch.frameModifiedNow(TFrameId(3, 'c'));

		ch.frameRangeModifiedNow(TFrameId(5), TFrameId(7));

		ch.fixCurrentHistory();

		Sleep(2000);

		ch.frameRangeModifiedNow(TFrameId(6), TFrameId(9));

		ch.frameModifiedNow(TFrameId(11));

		QString str1 = ch.serialize();

		TContentHistory ch1(true);

		ch1.deserialize(str1);

		ch1.frameRangeModifiedNow(TFrameId(2), TFrameId(3, 'c'));

		Sleep(2000);

		ch1.frameModifiedNow(TFrameId(3, 'a'));

		ch1.fixCurrentHistory();

		Sleep(2000);

		ch1.frameModifiedNow(TFrameId(11, 'b'));

		ch1.frameModifiedNow(TFrameId(12));

		QString str2 = ch1.serialize();

		QFile f("C:\\temp\\out.txt");

		f.open(QIODevice::WriteOnly | QIODevice::Text);

		QTextStream out(&f);

		out << str2;

		}

    {

		TContentHistory ch(false);

		ch.modifiedNow();

		Sleep(1000);

		ch.modifiedNow();

		ch.modifiedNow();

		ch.fixCurrentHistory();

		Sleep(2000);

		ch.modifiedNow();

		ch.modifiedNow();

		QString str1 = ch.serialize();

		TContentHistory ch1(false);

		ch1.deserialize(str1);

		ch1.modifiedNow();

		Sleep(2000);

		ch1.modifiedNow();

		ch1.fixCurrentHistory();

		Sleep(2000);

		ch1.modifiedNow();

		ch1.modifiedNow();

		QString str2 = ch1.serialize();

		QFile f("C:\\temp\\out1.txt");

		f.open(QIODevice::WriteOnly | QIODevice::Text);

		QTextStream out(&f);

		out << str2;

		}

}

*/