pokerth/src/gui/qt/gametable/log/guilog.cpp

/*****************************************************************************
 * PokerTH - The open source texas holdem engine                             *
 * Copyright (C) 2006-2011 Felix Hammer, Florian Thauer, Lothar May          *
 *                                                                           *
 * This program is free software: you can redistribute it and/or modify      *
 * it under the terms of the GNU Affero General Public License as            *
 * published by the Free Software Foundation, either version 3 of the        *
 * License, or (at your option) any later version.                           *
 *                                                                           *
 * This program is distributed in the hope that it will be useful,           *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
 * GNU Affero General Public License for more details.                       *
 *                                                                           *
 * You should have received a copy of the GNU Affero General Public License  *
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.     *
 *****************************************************************************/
#include "guilog.h"

#include "gametableimpl.h"
#include <handinterface.h>
#include <session.h>
#include <game.h>
#include <cardsvalue.h>
#include <game_defs.h>
#include "gametablestylereader.h"

using namespace std;

guiLog::guiLog(gameTableImpl* w, ConfigFile *c) : myW(w), myConfig(c), myLogDir(0), myHtmlLogFile(0), myHtmlLogFile_old(0), myTxtLogFile(0), tb(0)
{

	myW->setGuiLog(this);
	myStyle = myW->getMyGameTableStyle();

	myAppDataPath = QString::fromUtf8(myConfig->readConfigString("AppDataDir").c_str());

	connect(this, SIGNAL(signalLogPlayerActionMsg(QString, int, int)), this, SLOT(logPlayerActionMsg(QString, int, int)));
	connect(this, SIGNAL(signalLogNewGameHandMsg(int, int)), this, SLOT(logNewGameHandMsg(int, int)));
	connect(this, SIGNAL(signalLogNewBlindsSetsMsg(int, int, QString, QString)), this, SLOT(logNewBlindsSetsMsg(int, int, QString, QString)));
	connect(this, SIGNAL(signalLogPlayerWinsMsg(QString, int, bool)), this, SLOT(logPlayerWinsMsg(QString, int, bool)));
	connect(this, SIGNAL(signalLogPlayerSitsOut(QString)), this, SLOT(logPlayerSitsOut(QString)));
	connect(this, SIGNAL(signalLogDealBoardCardsMsg(int, int, int, int, int, int)), this, SLOT(logDealBoardCardsMsg(int, int, int, int, int, int)));
	connect(this, SIGNAL(signalLogFlipHoleCardsMsg(QString, int, int, int, QString)), this, SLOT(logFlipHoleCardsMsg(QString, int, int, int, QString)));
	connect(this, SIGNAL(signalLogPlayerLeftMsg(QString, int)), this, SLOT(logPlayerLeftMsg(QString, int)));
	connect(this, SIGNAL(signalLogPlayerJoinedMsg(QString)), this, SLOT(logPlayerJoinedMsg(QString)));
	connect(this, SIGNAL(signalLogNewGameAdminMsg(QString)), this, SLOT(logNewGameAdminMsg(QString)));
	connect(this, SIGNAL(signalLogPlayerWinGame(QString, int)), this, SLOT(logPlayerWinGame(QString, int)));
	connect(this, SIGNAL(signalFlushLogAtGame(int)), this, SLOT(flushLogAtGame(int)));
	connect(this, SIGNAL(signalFlushLogAtHand()), this, SLOT(flushLogAtHand()));


	logFileStreamString = "";
	lastGameID = 0;

	if(myConfig->readConfigInt("LogOnOff")) {
		//if write logfiles is enabled

		QDir logDir(QString::fromUtf8(myConfig->readConfigString("LogDir").c_str()));

		if(myConfig->readConfigString("LogDir") != "" && logDir.exists()) {

			int i;

			if(HTML_LOG) {

				myLogDir = new QDir(QString::fromUtf8(myConfig->readConfigString("LogDir").c_str()));
				QDateTime currentTime = QDateTime::currentDateTime();
				if(SQLITE_LOG) {
					myHtmlLogFile_old = new QFile(myLogDir->absolutePath()+"/pokerth-log-"+currentTime.toString("yyyy-MM-dd_hh.mm.ss")+"_old.html");
				} else {
					myHtmlLogFile_old = new QFile(myLogDir->absolutePath()+"/pokerth-log-"+currentTime.toString("yyyy-MM-dd_hh.mm.ss")+".html");
				}

				//Logo-Pixmap extrahieren
				QPixmap logoChipPixmapFile(":/gfx/logoChip3D.png");
				logoChipPixmapFile.save(myLogDir->absolutePath()+"/logo.png");

//                myW->textBrowser_Log->append(myHtmlLogFile_old->fileName());

				// erstelle html-Datei
				myHtmlLogFile_old->open( QIODevice::WriteOnly );
				QTextStream stream_old( myHtmlLogFile_old );
				stream_old << "<html>\n";
				stream_old << "<head>\n";
				stream_old << "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf8\">";
				stream_old << "</head>\n";
				stream_old << "<body style=\"font-size:smaller\">\n";
				stream_old << "<img src='logo.png'>\n";
				stream_old << QString("<h3><b>Log-File for PokerTH %1 Session started on ").arg(POKERTH_BETA_RELEASE_STRING)+QDate::currentDate().toString("yyyy-MM-dd")+" at "+QTime::currentTime().toString("hh:mm:ss")+"</b></h3>\n";
				myHtmlLogFile_old->close();

			}

			// delete old log files
			int daysUntilWaste = myConfig->readConfigInt("LogStoreDuration");

			QStringList filters("pokerth-log*");
			QStringList logFileList = myLogDir->entryList(filters, QDir::Files);

			for(i=0; i<logFileList.count(); i++) {

//                cout << logFileList.at(i).toStdString() << endl;

				QString dateString = logFileList.at(i);
				dateString.remove("pokerth-log-");
				dateString.remove(10,14);

				QDate dateOfFile(QDate::fromString(dateString, Qt::ISODate));
				QDate today(QDate::currentDate());

//                cout << dateOfFile.daysTo(today) << endl;

				if (dateOfFile.daysTo(today) > daysUntilWaste) {

					//                cout << QString::QString(myLogDir->absolutePath()+"/"+logFileList.at(i)).toStdString() << endl;
					QFile fileToDelete(myLogDir->absolutePath()+"/"+logFileList.at(i));
					fileToDelete.remove();
				}

			}

		} else {
			cout << "Log directory doesn't exist. Cannot create log files";
		}
	}
}

guiLog::~guiLog()
{
	delete myLogDir;
	delete myHtmlLogFile;
	delete myHtmlLogFile_old;

}

void guiLog::logPlayerActionMsg(QString msg, int action, int setValue)
{

	switch (action) {

	case 1:
		msg += " folds.";
		break;
	case 2:
		msg += " checks.";
		break;
	case 3:
		msg += " calls ";
		break;
	case 4:
		msg += " bets ";
		break;
	case 5:
		msg += " bets ";
		break;
	case 6:
		msg += " is all in with ";
		break;
	default:
		msg += "ERROR";
	}

	if (action >= 3) {
		msg += "$"+QString::number(setValue,10)+".";
	}

	myW->textBrowser_Log->append("<span style=\"color:#"+myStyle->getChatLogTextColor()+";\">"+msg+"</span>");

	if(myConfig->readConfigInt("LogOnOff")) {
		//if write logfiles is enabled

		if(HTML_LOG) {

			logFileStreamString += msg+"</br>\n";

			if(myConfig->readConfigInt("LogInterval") == 0) {
				writeLogFileStream(logFileStreamString);
				logFileStreamString = "";
			}

		}

	}
}

void guiLog::logNewGameHandMsg(int gameID, int handID)
{

	PlayerListConstIterator it_c;
	boost::shared_ptr<HandInterface> currentHand = myW->getSession()->getCurrentGame()->getCurrentHand();

	PlayerList activePlayerList = currentHand->getActivePlayerList();

	myW->textBrowser_Log->append("<span style=\"color:#"+myStyle->getChatLogTextColor()+"; font-size:large; font-weight:bold\">## Game: "+QString::number(gameID,10)+" | Hand: "+QString::number(handID,10)+" ##</span>");

	if(myConfig->readConfigInt("LogOnOff")) {
		//if write logfiles is enabled

		if(HTML_LOG) {

			logFileStreamString += "<table><tr><td width=\"600\" align=\"center\"><hr noshade size=\"3\"><b>Game: "+QString::number(gameID,10)+" | Hand: "+QString::number(handID,10)+"</b></td><td></td></tr></table>";
			logFileStreamString += "BLIND LEVEL: $"+QString::number(currentHand->getSmallBlind())+" / $"+QString::number(currentHand->getSmallBlind()*2)+"</br>";

			//print cash only for active players
			for(it_c=activePlayerList->begin(); it_c!=activePlayerList->end(); ++it_c) {

				logFileStreamString += "Seat " + QString::number((*it_c)->getMyID()+1,10) + ": <b>" +  QString::fromUtf8((*it_c)->getMyName().c_str()) + "</b> ($" + QString::number((*it_c)->getMyCash()+(*it_c)->getMySet(),10)+")</br>";

			}

		}

	}

}

void guiLog::logNewBlindsSetsMsg(int sbSet, int bbSet, QString sbName, QString bbName)
{

	// log blinds
	myW->textBrowser_Log->append("<span style=\"color:#"+myStyle->getChatLogTextColor()+";\">"+sbName+" posts small blind ($"+QString::number(sbSet,10)+")</span>");
	myW->textBrowser_Log->append("<span style=\"color:#"+myStyle->getChatLogTextColor()+";\">"+bbName+" posts big blind ($"+QString::number(bbSet,10)+")</span>");

	if(myConfig->readConfigInt("LogOnOff")) {
		//if write logfiles is enabled

		if(HTML_LOG) {

			logFileStreamString += "BLINDS: ";

			logFileStreamString += sbName+" ($"+QString::number(sbSet,10)+"), ";
			logFileStreamString += bbName+" ($"+QString::number(bbSet,10)+")";

			PlayerListConstIterator it_c;
			boost::shared_ptr<Game> currentGame = myW->getSession()->getCurrentGame();
			PlayerList activePlayerList = currentGame->getActivePlayerList();

			for(it_c=activePlayerList->begin(); it_c!=activePlayerList->end(); ++it_c) {

				if(activePlayerList->size() > 2) {
					if((*it_c)->getMyButton() == BUTTON_DEALER) {

						logFileStreamString += "</br>" + QString::fromUtf8((*it_c)->getMyName().c_str()) + " starts as dealer.";
						break;
					}
				} else {
					if((*it_c)->getMyButton() == BUTTON_SMALL_BLIND) {

						logFileStreamString += "</br>" + QString::fromUtf8((*it_c)->getMyName().c_str()) + " starts as dealer.";
						break;
					}
				}
			}

			logFileStreamString += "</br></br><b>PREFLOP</b>";
			logFileStreamString += "</br>\n";

		}

	}

}

void guiLog::logPlayerWinsMsg(QString playerName, int pot, bool main)
{

	if(main) {
		myW->textBrowser_Log->append("<span style=\"color:#"+myStyle->getLogWinnerMainPotColor()+";\">"+playerName+" wins $"+QString::number(pot,10)+"</span>");
	} else {
		myW->textBrowser_Log->append("<span style=\"color:#"+myStyle->getLogWinnerSidePotColor()+";\">"+playerName+" wins $"+QString::number(pot,10)+" (side pot)</span>");
	}

	if(myConfig->readConfigInt("LogOnOff")) {
		//if write logfiles is enabled

		logFileStreamString += "</br><i>"+playerName+" wins $"+QString::number(pot,10);
		if(!main) {
			logFileStreamString += " (side pot)";
		}
		logFileStreamString += "</i>\n";

		if(myConfig->readConfigInt("LogInterval") == 0) {
			writeLogFileStream(logFileStreamString);
			logFileStreamString = "";
		}
	}
}

void guiLog::logPlayerSitsOut(QString playerName)
{

	myW->textBrowser_Log->append("<i><span style=\"color:#"+myStyle->getLogPlayerSitsOutColor()+";\">"+playerName+" sits out</span></i>");

	if(myConfig->readConfigInt("LogOnOff")) {

		logFileStreamString += "</br><i><span style=\"font-size:smaller;\">"+playerName+" sits out</span></i>\n";

		if(myConfig->readConfigInt("LogInterval") == 0) {
			writeLogFileStream(logFileStreamString);
			logFileStreamString = "";
		}
	}
}

void guiLog::logDealBoardCardsMsg(int roundID, int card1, int card2, int card3, int card4, int card5)
{

	QString round;

	switch (roundID) {

	case 1:
		round = "Flop";
		myW->textBrowser_Log->append("<span style=\"color:#"+myStyle->getLogPlayerSitsOutColor()+";\">--- "+round+" --- "+"["+translateCardCode(card1).at(0)+translateCardCode(card1).at(1)+","+translateCardCode(card2).at(0)+translateCardCode(card2).at(1)+","+translateCardCode(card3).at(0)+translateCardCode(card3).at(1)+"]</span>");
		break;
	case 2:
		round = "Turn";
		myW->textBrowser_Log->append("<span style=\"color:#"+myStyle->getLogPlayerSitsOutColor()+";\">--- "+round+" --- "+"["+translateCardCode(card1).at(0)+translateCardCode(card1).at(1)+","+translateCardCode(card2).at(0)+translateCardCode(card2).at(1)+","+translateCardCode(card3).at(0)+translateCardCode(card3).at(1)+","+translateCardCode(card4).at(0)+translateCardCode(card4).at(1)+"]</span>");
		break;
	case 3:
		round = "River";
		myW->textBrowser_Log->append("<span style=\"color:#"+myStyle->getLogPlayerSitsOutColor()+";\">--- "+round+" --- "+"["+translateCardCode(card1).at(0)+translateCardCode(card1).at(1)+","+translateCardCode(card2).at(0)+translateCardCode(card2).at(1)+","+translateCardCode(card3).at(0)+translateCardCode(card3).at(1)+","+translateCardCode(card4).at(0)+translateCardCode(card4).at(1)+","+translateCardCode(card5).at(0)+translateCardCode(card5).at(1)+"]</span>");
		break;
	default:
		round = "ERROR";
	}

	if(myConfig->readConfigInt("LogOnOff")) {
		//if write logfiles is enabled

		if(HTML_LOG) {

			switch (roundID) {

			case 1:
				round = "Flop";
				logFileStreamString += "</br><b>"+round.toUpper()+"</b> [board cards <b>"+translateCardCode(card1).at(0)+"</b>"+translateCardCode(card1).at(1)+",<b>"+translateCardCode(card2).at(0)+"</b>"+translateCardCode(card2).at(1)+",<b>"+translateCardCode(card3).at(0)+"</b>"+translateCardCode(card3).at(1)+"]"+"</br>\n";
				break;
			case 2:
				round = "Turn";
				logFileStreamString += "</br><b>"+round.toUpper()+"</b> [board cards <b>"+translateCardCode(card1).at(0)+"</b>"+translateCardCode(card1).at(1)+",<b>"+translateCardCode(card2).at(0)+"</b>"+translateCardCode(card2).at(1)+",<b>"+translateCardCode(card3).at(0)+"</b>"+translateCardCode(card3).at(1)+",<b>"+translateCardCode(card4).at(0)+"</b>"+translateCardCode(card4).at(1)+"]"+"</br>\n";
				break;
			case 3:
				round = "River";
				logFileStreamString += "</br><b>"+round.toUpper()+"</b> [board cards <b>"+translateCardCode(card1).at(0)+"</b>"+translateCardCode(card1).at(1)+",<b>"+translateCardCode(card2).at(0)+"</b>"+translateCardCode(card2).at(1)+",<b>"+translateCardCode(card3).at(0)+"</b>"+translateCardCode(card3).at(1)+",<b>"+translateCardCode(card4).at(0)+"</b>"+translateCardCode(card4).at(1)+",<b>"+translateCardCode(card5).at(0)+"</b>"+translateCardCode(card5).at(1)+"]"+"</br>\n";
				break;
			default:
				round = "ERROR";
			}

			if(myConfig->readConfigInt("LogInterval") == 0) {
				writeLogFileStream(logFileStreamString);
				logFileStreamString = "";
			}

		}

	}
}

void guiLog::logFlipHoleCardsMsg(QString playerName, int card1, int card2, int cardsValueInt, QString showHas)
{

	QString tempHandName;

	if (cardsValueInt != -1) {

		tempHandName = CardsValue::determineHandName(cardsValueInt,myW->getSession()->getCurrentGame()->getActivePlayerList()).c_str();

		myW->textBrowser_Log->append("<span style=\"color:#"+myStyle->getChatLogTextColor()+";\">"+playerName+" "+showHas+" ["+translateCardCode(card1).at(0)+translateCardCode(card1).at(1)+","+translateCardCode(card2).at(0)+translateCardCode(card2).at(1)+"] - \""+tempHandName+"\"</span>");

	} else {

		myW->textBrowser_Log->append("<span style=\"color:#"+myStyle->getChatLogTextColor()+";\">"+playerName+" "+showHas+" ["+translateCardCode(card1).at(0)+translateCardCode(card1).at(1)+","+translateCardCode(card2).at(0)+translateCardCode(card2).at(1)+"]</span>");

	}

	if(myConfig->readConfigInt("LogOnOff")) {
		//if write logfiles is enabled

		if(HTML_LOG) {

			if (cardsValueInt != -1) {

				tempHandName.fromStdString(CardsValue::determineHandName(cardsValueInt,myW->getSession()->getCurrentGame()->getActivePlayerList()));

				logFileStreamString += playerName+" "+showHas+" [ <b>"+translateCardCode(card1).at(0)+"</b>"+translateCardCode(card1).at(1)+",<b>"+translateCardCode(card2).at(0)+"</b>"+translateCardCode(card2).at(1)+"] - "+tempHandName+"</br>\n";

				if(myConfig->readConfigInt("LogInterval") == 0) {
					writeLogFileStream(logFileStreamString);
					logFileStreamString = "";
				}

			} else {

				logFileStreamString += playerName+" "+showHas+" [<b>"+translateCardCode(card1).at(0)+"</b>"+translateCardCode(card1).at(1)+",<b>"+translateCardCode(card2).at(0)+"</b>"+translateCardCode(card2).at(1)+"]"+"</br>\n";
				if(myConfig->readConfigInt("LogInterval") == 0) {
					writeLogFileStream(logFileStreamString);
					logFileStreamString = "";
				}
			}
		}

	}

}

void guiLog::logPlayerLeftMsg(QString playerName, int wasKicked)
{

	QString action;
	if(wasKicked) action = "was kicked from";
	else action = "has left";

	myW->textBrowser_Log->append( "<span style=\"color:#"+myStyle->getChatLogTextColor()+";\"><i>"+playerName+" "+action+" the game!</i></span>");

	if(myConfig->readConfigInt("LogOnOff")) {

		logFileStreamString += "<i>"+playerName+" "+action+" the game!</i><br>\n";

		if(myConfig->readConfigInt("LogInterval") == 0) {
			writeLogFileStream(logFileStreamString);
			logFileStreamString = "";
		}
	}
}

void guiLog::logNewGameAdminMsg(QString playerName)
{

	myW->textBrowser_Log->append( "<i><span style=\"color:#"+myStyle->getLogNewGameAdminColor()+";\">"+playerName+" is game admin now!</span></i>");

	if(myConfig->readConfigInt("LogOnOff")) {

		logFileStreamString += "<i>"+playerName+" is game admin now!</i><br>\n";

		if(myConfig->readConfigInt("LogInterval") == 0) {
			writeLogFileStream(logFileStreamString);
			logFileStreamString = "";
		}
	}
}

void guiLog::logPlayerJoinedMsg(QString playerName)
{
	myW->textBrowser_Log->append("<span style=\"color:#"+myStyle->getChatLogTextColor()+";\"><i>"+playerName+" has joined the game!</i></span>");
}


void guiLog::logPlayerWinGame(QString playerName, int gameID)
{

	myW->textBrowser_Log->append( "<i><b>"+playerName+" wins game " + QString::number(gameID,10)  +"!</i></b><br>");

	if(myConfig->readConfigInt("LogOnOff")) {

		logFileStreamString += "</br></br><i><b>"+playerName+" wins game " + QString::number(gameID,10)  +"!</i></b></br>\n";

		if(myConfig->readConfigInt("LogInterval") == 0) {
			writeLogFileStream(logFileStreamString);
			logFileStreamString = "";
		}
	}

}

QStringList guiLog::translateCardCode(int cardCode)
{

	int value = cardCode%13;
	int color = cardCode/13;

	QStringList cardString;

	switch (value) {

	case 0:
		cardString << "2";
		break;
	case 1:
		cardString << "3";
		break;
	case 2:
		cardString << "4";
		break;
	case 3:
		cardString << "5";
		break;
	case 4:
		cardString << "6";
		break;
	case 5:
		cardString << "7";
		break;
	case 6:
		cardString << "8";
		break;
	case 7:
		cardString << "9";
		break;
	case 8:
		cardString << "T";
		break;
	case 9:
		cardString << "J";
		break;
	case 10:
		cardString << "Q";
		break;
	case 11:
		cardString << "K";
		break;
	case 12:
		cardString << "A";
		break;
	default:
		cardString << "ERROR";
	}

	switch (color) {

	case 0:
		cardString << "d";
		break;
	case 1:
		cardString << "h";
		break;
	case 2:
		cardString << "s";
		break;
	case 3:
		cardString << "c";
		break;
	default:
		cardString << "ERROR";
	}

	return cardString;
}

void guiLog::writeLogFileStream(QString streamString)
{

	if(myHtmlLogFile_old) {
		if(myHtmlLogFile_old->open( QIODevice::ReadWrite )) {
			QTextStream stream_old( myHtmlLogFile_old );
			stream_old.readAll();
			stream_old << streamString;
			myHtmlLogFile_old->close();
		} else {
			cout << "Could not open log-file to write log-messages!" << endl;
		}
	} else {
		cout << "Could not find log-file to write log-messages!" << endl;
	}
}

void guiLog::writeLogFileStream(string log_string, QFile *LogFile)
{

	QTextStream stream( LogFile );
	stream.readAll();
	stream << log_string.data();

}

void guiLog::writeLog(string log_string, int modus)
{

	switch(modus) {
	case 1:
		writeLogFileStream(log_string,myHtmlLogFile);
		break;
	case 2:
		writeLogFileStream(log_string,myTxtLogFile);
		break;
	case 3:
		tb->append(log_string.data());
		break;
	default:
		;
	}

}

void guiLog::flushLogAtHand()
{

	if(myConfig->readConfigInt("LogOnOff")) {
		if(myConfig->readConfigInt("LogInterval") < 2) {
			// 	write for log after every action and after every hand
			writeLogFileStream(logFileStreamString);
			logFileStreamString = "";
		}
	}
}

void guiLog::flushLogAtGame(int gameID)
{

	if(myConfig->readConfigInt("LogOnOff")) {
		//	write for log after every game
		if(gameID > lastGameID) {
			writeLogFileStream(logFileStreamString);
			logFileStreamString = "";
			lastGameID = gameID;
		}
	}
}

void guiLog::exportLogPdbToHtml(QString fileStringPdb, QString exportFileString)
{

	myHtmlLogFile = new QFile(exportFileString);

	myHtmlLogFile->open( QIODevice::ReadWrite | QFile::Truncate);

	string log_string = "<html>\n";
	log_string += "<head>\n";
	log_string += "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf8\">";
	log_string += "</head>\n";
	log_string += "<body style=\"font-size:smaller\">\n";
	writeLog(log_string,1);

	exportLog(fileStringPdb,1);

	myHtmlLogFile->close();

}

void guiLog::exportLogPdbToTxt(QString fileStringPdb, QString exportFileString)
{

	myTxtLogFile = new QFile(exportFileString);

	myTxtLogFile->open( QIODevice::ReadWrite | QFile::Truncate );

	exportLog(fileStringPdb,2);

	myTxtLogFile->close();

}

void guiLog::showLog(QString fileStringPdb, QTextBrowser *tb_tmp)
{

	tb = tb_tmp;
	tb->clear();
	exportLog(fileStringPdb,3);

}

int guiLog::exportLog(QString fileStringPdb,int modus)
{
	bool neu = false;

	string sql = "";
	string log_string = "";
	bool data_found = false;
	char **result_Session = 0, **result_Game = 0, **result_Hand = 0, **result_Hand_ID = 0, **result_Action = 0;
	int nRow_Session=0, nRow_Game=0, nRow_Hand=0, nRow_Hand_ID=0, nRow_Action=0;
	int nCol_Session=0, nCol_Game=0, nCol_Hand=0, nCol_Action=0;
	char *errmsg = 0;
	int game_ctr = 0, hand_ctr = 0, round_ctr = 0, action_ctr = 0;
	int i = 0, j = 0;
	int gameID = 0;
	string cmpString = "", string_tmp = "";
	string player[MAX_NUMBER_OF_PLAYERS];
	for(i=1; i<=MAX_NUMBER_OF_PLAYERS; i++) {
		player[i-1] = "";
	}

	// open sqlite log-db
	sqlite3 *mySqliteLogDb;
	sqlite3_open(fileStringPdb.toStdString().data(), &mySqliteLogDb);
	if( mySqliteLogDb != 0 ) {

		// read session
		sql = "SELECT * FROM Session";
		if(sqlite3_get_table(mySqliteLogDb,sql.data(),&result_Session,&nRow_Session,&nCol_Session,&errmsg) != SQLITE_OK) {
			cout << "Error in statement: " << sql.data() << "[" << errmsg << "]." << endl;
			sqlite3_close(mySqliteLogDb);
			return 1;
		}
		if(nRow_Session<1 || nRow_Session>1) {
			cout << "Number of Sessions implausible!" << endl;
			sqlite3_close(mySqliteLogDb);
			return 1;
		}

		log_string += "Log-File for PokerTH ";

		// pokerth version
		data_found = false;
		for(i=0; i<nCol_Session; i++) {
			if(boost::lexical_cast<std::string>(result_Session[i]) == "PokerTH_Version") {
				log_string += boost::lexical_cast<std::string>(result_Session[i+nCol_Session]);
				data_found = true;
			}
		}
		if(!data_found) {
			cout << "Missing PokerTH version information!" << endl;
			sqlite3_close(mySqliteLogDb);
			return 1;
		}

		log_string += " Session started on ";

		// logging date
		data_found = false;
		for(i=0; i<nCol_Session; i++) {
			if(boost::lexical_cast<std::string>(result_Session[i]) == "Date") {
				log_string += boost::lexical_cast<std::string>(result_Session[i+nCol_Session]);
				data_found = true;
			}
		}
		if(!data_found) {
			cout << "Missing date information!" << endl;
			sqlite3_close(mySqliteLogDb);
			return 1;
		}

		log_string += " at ";

		// logging time
		data_found = false;
		for(i=0; i<nCol_Session; i++) {
			if(boost::lexical_cast<std::string>(result_Session[i]) == "Time") {
				log_string += boost::lexical_cast<std::string>(result_Session[i+nCol_Session]);
				data_found = true;
			}
		}
		if(!data_found) {
			cout << "Missing time information!" << endl;
			sqlite3_close(mySqliteLogDb);
			return 1;
		}

		sqlite3_free_table(result_Session);

		switch(modus) {
		case 1:
			log_string = "<h3><b>" + log_string + "</b></h3>";
			if(!neu) log_string = "<img src='logo.png'>" + log_string;
			break;
		case 2:
			log_string += "\n";
			break;
		case 3:
			log_string = "<h4><b>" + log_string + "</b></h4>";
			break;
		default:
			;
		}
		writeLog(log_string,modus);
		log_string = "";

		// read game
		sql = "SELECT * FROM Game";
		if(sqlite3_get_table(mySqliteLogDb,sql.data(),&result_Game,&nRow_Game,&nCol_Game,&errmsg) != SQLITE_OK) {
			cout << "Error in statement: " << sql.data() << "[" << errmsg << "]." << endl;
			sqlite3_close(mySqliteLogDb);
			return 1;
		}

		// run through all games
		for(game_ctr=1; game_ctr<=nRow_Game; game_ctr++) {

			// game id
			data_found = false;
			for(i=0; i<nCol_Game; i++) {
				if(boost::lexical_cast<std::string>(result_Game[i]) == "GameID") {
					gameID = boost::lexical_cast<int>(result_Game[i+nCol_Game*game_ctr]);
					data_found = true;
				}
			}

			if(!data_found) {
				sqlite3_close(mySqliteLogDb);
				return 1;
			}

			// read player
			for(i=1; i<=MAX_NUMBER_OF_PLAYERS; i++) {
				data_found = false;
				for(j=0; j<nCol_Game; j++) {
					cmpString = "Seat_";
					cmpString+= boost::lexical_cast<std::string>(i);
					if(boost::lexical_cast<std::string>(result_Game[j]) == cmpString) {
						// Seat found
						if(result_Game[j+nCol_Game*game_ctr]) {
							// the Seat is not empty
							player[i-1] = boost::lexical_cast<std::string>(result_Game[j+nCol_Game*game_ctr]);
						} else {
							player[i-1] = "";
						}
						data_found = true;
					}
				}
				if(!data_found) {
					cout << "Missing some seats!" << endl;
					sqlite3_close(mySqliteLogDb);
					return 1;
				}
			}

			// read all hand id
			sql = "SELECT HandID FROM Hand WHERE GameID=";
			sql+= boost::lexical_cast<std::string>(gameID);
			if(sqlite3_get_table(mySqliteLogDb,sql.data(),&result_Hand_ID,&nRow_Hand_ID,&nCol_Hand,&errmsg) != SQLITE_OK) {
				cout << "Error in statement: " << sql.data() << "[" << errmsg << "]." << endl;
				sqlite3_close(mySqliteLogDb);
				return 1;
			}

			// run through all hands
			for(hand_ctr=1; hand_ctr<=nRow_Hand_ID-1; hand_ctr++) {

				// log game and hand id
				log_string += "Game: ";
				log_string += boost::lexical_cast<std::string>(gameID);
				log_string += " | Hand: ";
				log_string += boost::lexical_cast<std::string>(result_Hand_ID[hand_ctr]);

				switch(modus) {
				case 1:
					log_string = "<table><tr><td width=\"600\" align=\"center\"><hr noshade size=\"3\"><b>" + log_string;
					log_string += "</b></td></tr></table>";
					break;
				case 2:
					log_string += "\n";
					break;
				case 3:
					log_string = "----------- <b>" + log_string;
					log_string += "</b> -----------<br />";
					break;
				default:
					;
				}

				// read current hand
				sql = "SELECT * FROM Hand WHERE GameID=";
				sql+= boost::lexical_cast<std::string>(gameID);
				sql+= " AND HandID=";
				sql+= boost::lexical_cast<std::string>(result_Hand_ID[hand_ctr]);
				if(sqlite3_get_table(mySqliteLogDb,sql.data(),&result_Hand,&nRow_Hand,&nCol_Hand,&errmsg) != SQLITE_OK) {
					cout << "Error in statement: " << sql.data() << "[" << errmsg << "]." << endl;
					sqlite3_close(mySqliteLogDb);
					return 1;
				}


				// log blind level
				log_string += "BLIND LEVEL: $";

				// read small blind amount
				data_found = false;
				for(i=0; i<nCol_Hand; i++) {
					if(boost::lexical_cast<std::string>(result_Hand[i]) == "Sb_Amount") {
						log_string += boost::lexical_cast<std::string>(result_Hand[i+nCol_Hand]);
						data_found = true;
					}
				}
				if(!data_found) {
					cout << "Missing small blind information!" << endl;
					sqlite3_close(mySqliteLogDb);
					return 1;
				}

				log_string += " / $";

				// read big blind amount
				data_found = false;
				for(i=0; i<nCol_Hand; i++) {
					if(boost::lexical_cast<std::string>(result_Hand[i]) == "Bb_Amount") {
						log_string += boost::lexical_cast<std::string>(result_Hand[i+nCol_Hand]);
						data_found = true;
					}
				}
				if(!data_found) {
					cout << "Missing big blind information!" << endl;
					sqlite3_close(mySqliteLogDb);
					return 1;
				}

				switch(modus) {
				case 1:
					log_string += "<br />";
					break;
				case 2:
					log_string += "\n";
					break;
				case 3:
					log_string += "<br />";
					break;
				default:
					;
				}

				// read seat cash
				for(i=1; i<=MAX_NUMBER_OF_PLAYERS; i++) {

					data_found = false;
					for(j=0; j<nCol_Hand; j++) {
						cmpString = "Seat_";
						cmpString+= boost::lexical_cast<std::string>(i);
						cmpString+= "_Cash";
						if(boost::lexical_cast<std::string>(result_Hand[j]) == cmpString) { // seat found
							if(result_Hand[j+nCol_Hand]) { // player has cash > 0
								log_string += "Seat ";
								log_string += boost::lexical_cast<std::string>(i);
								log_string += ": ";
								if(modus == 1 || modus == 3) {
									log_string += "<b>";
								}
								log_string += player[i-1];
								if(modus == 1 || modus == 3) {
									log_string += "</b>";
								}
								log_string += "($";
								log_string += boost::lexical_cast<std::string>(result_Hand[j+nCol_Hand]);
								log_string += ")";
								switch(modus) {
								case 1:
									log_string += "<br />";
									break;
								case 2:
									log_string += "\n";
									break;
								case 3:
									log_string += "<br />";
									break;
								default:
									;
								}
							}
							data_found = true;
						}
					}
					if(!data_found) {
						cout << "Missing seat information in game " << gameID << " and hand " << result_Hand_ID[hand_ctr] << "!" << endl;
						sqlite3_close(mySqliteLogDb);
						return 1;
					}
				}

				if(neu) {

					if(modus == 1) log_string += "</br>";

					// read dealer and blinds
					sql = "SELECT Player,Action,Amount FROM Action WHERE GameID=";
					sql += boost::lexical_cast<std::string>(gameID);
					sql += " AND HandID=";
					sql += boost::lexical_cast<std::string>(result_Hand_ID[hand_ctr]);
					sql += " AND BeRo=0";

					if(sqlite3_get_table(mySqliteLogDb,sql.data(),&result_Action,&nRow_Action,&nCol_Action,&errmsg) != SQLITE_OK) {
						cout << "Error in statement: " << sql.data() << "[" << errmsg << "]." << endl;
						sqlite3_close(mySqliteLogDb);
						return 1;
					}
					if(nRow_Action<1) {
						cout << "Missing information about dealer and blinds in game " << gameID << " hand " << result_Hand_ID[hand_ctr] << "!" << endl;
						sqlite3_close(mySqliteLogDb);
						return 1;
					}
					// log dealer and blind setting
					for(i=1; i<=nRow_Action; i++) {
						log_string += player[boost::lexical_cast<int>(result_Action[3*i])-1];
						log_string += " ";
						log_string += boost::lexical_cast<std::string>(result_Action[3*i+1]);
						if(result_Action[3*i+2]) {
							// with amount
							log_string +=  " $";
							log_string += boost::lexical_cast<std::string>(result_Action[3*i+2]);
						}
						log_string += ".";
						switch(modus) {
						case 1:
							log_string += "<br />";
							break;
						case 2:
							log_string += "\n";
							break;
						case 3:
							;
							break;
						default:
							;
						}
					}

					sqlite3_free_table(result_Action);

				} else {

					log_string += "BLINDS: ";

					// read small blind
					sql = "SELECT Player,Amount FROM Action WHERE GameID=";
					sql += boost::lexical_cast<std::string>(gameID);
					sql += " AND HandID=";
					sql += boost::lexical_cast<std::string>(result_Hand_ID[hand_ctr]);
					sql += " AND BeRo=0 AND Action='posts small blind'";

					if(sqlite3_get_table(mySqliteLogDb,sql.data(),&result_Action,&nRow_Action,&nCol_Action,&errmsg) != SQLITE_OK) {
						cout << "Error in statement: " << sql.data() << "[" << errmsg << "]." << endl;
						sqlite3_close(mySqliteLogDb);
						return 1;
					}
					if(nRow_Action<1 || nRow_Action>1) {
						cout << "Missing information about small blinds in game " << gameID << " hand " << result_Hand_ID[hand_ctr] << "!" << endl;
						sqlite3_close(mySqliteLogDb);
						return 1;
					}

					// log small blind
					log_string += player[boost::lexical_cast<int>(result_Action[2])-1];
					log_string += " ($";
					log_string += boost::lexical_cast<std::string>(result_Action[3]);
					log_string += "), ";

					sqlite3_free_table(result_Action);

					// read big blind
					sql = "SELECT Player,Amount FROM Action WHERE GameID=";
					sql += boost::lexical_cast<std::string>(gameID);
					sql += " AND HandID=";
					sql += boost::lexical_cast<std::string>(result_Hand_ID[hand_ctr]);
					sql += " AND BeRo=0 AND Action='posts big blind'";

					if(sqlite3_get_table(mySqliteLogDb,sql.data(),&result_Action,&nRow_Action,&nCol_Action,&errmsg) != SQLITE_OK) {
						cout << "Error in statement: " << sql.data() << "[" << errmsg << "]." << endl;
						sqlite3_close(mySqliteLogDb);
						return 1;
					}
					if(nRow_Action<1 || nRow_Action>1) {
						cout << "Missing information about small blinds in game " << gameID << " hand " << result_Hand_ID[hand_ctr] << "!" << endl;
						sqlite3_close(mySqliteLogDb);
						return 1;
					}

					// log big blind
					log_string += player[boost::lexical_cast<int>(result_Action[2])-1];
					log_string += " ($";
					log_string += boost::lexical_cast<std::string>(result_Action[3]);
					log_string += ")";

					sqlite3_free_table(result_Action);

					// read dealer
					sql = "SELECT Player,Amount FROM Action WHERE GameID=";
					sql += boost::lexical_cast<std::string>(gameID);
					sql += " AND HandID=";
					sql += boost::lexical_cast<std::string>(result_Hand_ID[hand_ctr]);
					sql += " AND BeRo=0 AND Action='starts as dealer'";

					if(sqlite3_get_table(mySqliteLogDb,sql.data(),&result_Action,&nRow_Action,&nCol_Action,&errmsg) != SQLITE_OK) {
						cout << "Error in statement: " << sql.data() << "[" << errmsg << "]." << endl;
						sqlite3_close(mySqliteLogDb);
						return 1;
					}
					if(nRow_Action>1) {
						cout << "Implausible information about dealer in game " << gameID << " hand " << result_Hand_ID[hand_ctr] << "!" << endl;
						sqlite3_close(mySqliteLogDb);
						return 1;
					}

					if(nRow_Action == 1) {
						if(modus == 1 || modus == 3) log_string += "<br />";
						log_string += player[boost::lexical_cast<int>(result_Action[2])-1];
						log_string += " starts as dealer.";
					}

					sqlite3_free_table(result_Action);

				}

				writeLog(log_string,modus);
				log_string = "";

				for(round_ctr=GAME_STATE_PREFLOP; round_ctr<=GAME_STATE_POST_RIVER; round_ctr++) {

					// write round name and board cards
					if(round_ctr<=GAME_STATE_RIVER) {
						switch(round_ctr) {
						case GAME_STATE_PREFLOP:
							log_string += "PREFLOP";
							break;
						case GAME_STATE_FLOP:
							log_string += "FLOP";
							break;
						case GAME_STATE_TURN:
							log_string += "TURN";
							break;
						case GAME_STATE_RIVER:
							log_string += "RIVER";
							break;
						default:
							;
						}
						switch(modus) {
						case 1:
							log_string = "<br /><b>" + log_string + "</b>";
							break;
						case 3:
							log_string = "<b>" + log_string + "</b>";
							break;
						default:
							;
						}
						log_string += " [board cards ";
						for(i=1; i<=round_ctr+2; i++) {
							data_found = false;
							for(j=0; j<nCol_Hand; j++) {
								if(boost::lexical_cast<std::string>(result_Hand[j]) == "BoardCard_"+boost::lexical_cast<std::string>(i)) {
									if(result_Hand[j+nCol_Hand]) {
										if(modus == 1 || modus == 3) log_string += "<b>";
										string_tmp = convertCardIntToString(boost::lexical_cast<int>(result_Hand[j+nCol_Hand]));
										if(string_tmp == "") {
											cout << "Implausible board card in game " << gameID << " hand " << result_Hand_ID[hand_ctr] << "!" << endl;
											sqlite3_close(mySqliteLogDb);
											return 1;
										}
										log_string += boost::lexical_cast<std::string>(string_tmp.at(0));
										if(modus==1 || modus == 3) log_string += "</b>";
										log_string += boost::lexical_cast<std::string>(string_tmp.at(1));
										if(round_ctr+2-i > 0) log_string += ",";

										data_found = true;
									}
								}
							}
						}
						log_string += "]";
						if(modus == 1 || modus == 3) log_string += "<br />";
					}

					// read round action
					sql = "SELECT Player,Action,Amount FROM Action WHERE GameID=";
					sql += boost::lexical_cast<std::string>(gameID);
					sql += " AND HandID=";
					sql += boost::lexical_cast<std::string>(result_Hand_ID[hand_ctr]);
					sql += " AND BeRo=";
					sql += boost::lexical_cast<std::string>(round_ctr);
					sql += " AND Action<>'starts as dealer' AND Action<>'posts big blind' AND Action<>'posts small blind'";

					if(sqlite3_get_table(mySqliteLogDb,sql.data(),&result_Action,&nRow_Action,&nCol_Action,&errmsg) != SQLITE_OK) {
						cout << "Error in statement: " << sql.data() << "[" << errmsg << "]." << endl;
						sqlite3_close(mySqliteLogDb);
						return 1;
					}

					for(action_ctr=1; action_ctr<=nRow_Action; action_ctr++) {
						log_string += player[boost::lexical_cast<int>(result_Action[3*action_ctr])-1];
						log_string += " ";
						log_string += boost::lexical_cast<std::string>(result_Action[3*action_ctr+1]);
						if(result_Action[3*action_ctr+2]) {
							// with amount
							log_string += " $";
							log_string += boost::lexical_cast<std::string>(result_Action[3*action_ctr+2]);
						}

						// show
						if(boost::lexical_cast<std::string>(result_Action[3*action_ctr+1]) == "shows") {
							// log cards
							log_string += " [";
							if(modus == 1 || modus == 3) log_string += "<b>";

							// find hole card 1
							data_found = false;
							for(i=0; i<nCol_Hand; i++) {
								cmpString = "Seat_";
								cmpString += boost::lexical_cast<std::string>(result_Action[3*action_ctr]);
								cmpString += "_Card_1";
								if(boost::lexical_cast<std::string>(result_Hand[i]) == cmpString) {
									string_tmp = convertCardIntToString(boost::lexical_cast<int>(result_Hand[i+nCol_Hand]));
									if(string_tmp == "") {
										cout << "Hole card information implausible in game " << gameID << " hand " << result_Hand_ID[hand_ctr] << "!" << endl;
										sqlite3_close(mySqliteLogDb);
										return 1;
									}
									log_string += boost::lexical_cast<std::string>(string_tmp.at(0));
									if(modus == 1 || modus == 3) log_string += "</b>";
									log_string += boost::lexical_cast<std::string>(string_tmp.at(1));
									if(modus == 1 || modus == 3) log_string += ",<b>";
									data_found = true;
								}
							}
							if(!data_found) {
								cout << "Missing hole card information in game " << gameID << " hand " << result_Hand_ID[hand_ctr] << "!" << endl;
								sqlite3_close(mySqliteLogDb);
								return 1;
							}

							// find hole card 2
							data_found = false;
							for(i=0; i<nCol_Hand; i++) {
								cmpString = "Seat_";
								cmpString += boost::lexical_cast<std::string>(result_Action[3*action_ctr]);
								cmpString += "_Card_2";
								if(boost::lexical_cast<std::string>(result_Hand[i]) == cmpString) {
									string_tmp = convertCardIntToString(boost::lexical_cast<int>(result_Hand[i+nCol_Hand]));
									if(string_tmp == "") {
										cout << "Hole card information implausible in game " << gameID << " hand " << result_Hand_ID[hand_ctr] << "!" << endl;
										sqlite3_close(mySqliteLogDb);
										return 1;
									}
									log_string += boost::lexical_cast<std::string>(string_tmp.at(0));
									if(modus == 1 || modus == 3) log_string += "</b>";
									log_string += boost::lexical_cast<std::string>(string_tmp.at(1));
									log_string += "]";
									data_found = true;
								}
							}
							if(!data_found) {
								cout << "Missing hole card information in game " << gameID << " hand " << result_Hand_ID[hand_ctr] << "!" << endl;
								sqlite3_close(mySqliteLogDb);
								return 1;
							}

						}

						log_string += ".";
						if(action_ctr<nRow_Action && (modus == 1 || modus == 3)) {
							log_string += "<br />";
						}
					}
					if(modus == 1) log_string += "<br />";

					sqlite3_free_table(result_Action);

					// log river actions together with post river actions
					if(round_ctr!=GAME_STATE_RIVER) {
						writeLog(log_string,modus);
						log_string = "";
					}


				}



			}

		}

	}

	/*switch(modus) {
	case 1:
	    break;
	case 2:
	    break;
	case 3:
	    break;
	default:
	    ;
	}*/

	return 0;

}

int guiLog::convertCardStringToInt(string val, string col)
{

	int tmp;

	switch(*col.data()) {
	case 'd':
		tmp = 0;
		break;
	case 'h':
		tmp = 13;
		break;
	case 's':
		tmp = 26;
		break;
	case 'c':
		tmp = 39;
		break;
	default:
		return -1;
	}

	switch(*val.data()) {
	case '2':
		tmp += 0;
		break;
	case '3':
		tmp += 1;
		break;
	case '4':
		tmp += 2;
		break;
	case '5':
		tmp += 3;
		break;
	case '6':
		tmp += 4;
		break;
	case '7':
		tmp += 5;
		break;
	case '8':
		tmp += 6;
		break;
	case '9':
		tmp += 7;
		break;
	case 'T':
		tmp += 8;
		break;
	case 'J':
		tmp += 9;
		break;
	case 'Q':
		tmp += 10;
		break;
	case 'K':
		tmp += 11;
		break;
	case 'A':
		tmp += 12;
		break;
	default:
		return -1;
	}

	return tmp;

}

string guiLog::convertCardIntToString(int code)
{

	string tmp;

	switch(code%13) {
	case 0:
		tmp = "2";
		break;
	case 1:
		tmp = "3";
		break;
	case 2:
		tmp = "4";
		break;
	case 3:
		tmp = "5";
		break;
	case 4:
		tmp = "6";
		break;
	case 5:
		tmp = "7";
		break;
	case 6:
		tmp = "8";
		break;
	case 7:
		tmp = "9";
		break;
	case 8:
		tmp = "T";
		break;
	case 9:
		tmp = "J";
		break;
	case 10:
		tmp = "Q";
		break;
	case 11:
		tmp = "K";
		break;
	case 12:
		tmp = "A";
		break;
	default:
		return "";
	}

	switch(code/13) {
	case 0:
		tmp+= "d";
		break;
	case 1:
		tmp+= "h";
		break;
	case 2:
		tmp+= "s";
		break;
	case 3:
		tmp+= "c";
		break;
	default:
		return "";
	}

	return tmp;
}