/***************************************************************************
 *            logwindow.cpp
 *
 *  Fri Jul 22 01:13:10 2005
 *  Copyright  2005  User
 *  Email
 ****************************************************************************/

#include "logwindow.h"

logWindow::logWindow(IMLogDaemon* _logDaemon)
{
	wType = UE_LOGMESSAGES;
	typeFilter = L_ALL;
	grepFilter = g_strdup("");
	
	logDaemon = _logDaemon;
}



logWindow::~logWindow()
{
	
}


		
GtkWidget* logWindow::createWindowContent()
{
	GtkWidget	*frame,
				*vbox;
	GtkTextIter	iter;
	GdkColor	errorColor,
				warningColor,
				packetColor,
				defaultColor;
	GtkTextTag	*tag;
	
	frame = u_createTextView(&textView);
	gtk_text_view_set_editable(GTK_TEXT_VIEW(textView), FALSE);
	
	// create an end marker
	gtk_text_buffer_get_end_iter(gtk_text_view_get_buffer(GTK_TEXT_VIEW(textView)), &iter);
	gtk_text_buffer_create_mark(gtk_text_view_get_buffer(GTK_TEXT_VIEW(textView)), "last_pos", &iter, TRUE);
	
	settings_getSettings()->getProperties("logwindow",
							  			  "errorColor", &errorColor,
							  			  "warningColor", &warningColor,
							  			  "packetColor", &packetColor,
										  "defaultColor", &defaultColor,
							  			  NULL);
	
	tag = gtk_text_tag_new("default");
	g_object_set(tag, "foreground-gdk", &defaultColor, NULL);
	gtk_text_tag_table_add(gtk_text_buffer_get_tag_table(gtk_text_view_get_buffer(GTK_TEXT_VIEW(textView))), tag);

	tag = gtk_text_tag_new("packet");
	g_object_set(tag, "foreground-gdk", &packetColor, NULL);
	gtk_text_tag_table_add(gtk_text_buffer_get_tag_table(gtk_text_view_get_buffer(GTK_TEXT_VIEW(textView))), tag);

	tag = gtk_text_tag_new("warning");
	g_object_set(tag, "foreground-gdk", &warningColor, NULL);
	gtk_text_tag_table_add(gtk_text_buffer_get_tag_table(gtk_text_view_get_buffer(GTK_TEXT_VIEW(textView))), tag);

	tag = gtk_text_tag_new("error");
	g_object_set(tag, "foreground-gdk", &defaultColor, "weight", PANGO_WEIGHT_BOLD, NULL);
	gtk_text_tag_table_add(gtk_text_buffer_get_tag_table(gtk_text_view_get_buffer(GTK_TEXT_VIEW(textView))), tag);


	// create text tags
	
	vbox = gtk_vbox_new(FALSE, 10);
	gtk_container_set_border_width(GTK_CONTAINER(vbox), 10);
	gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, 0);
	gtk_box_pack_start(GTK_BOX(vbox), createFilterbar(), FALSE, TRUE, 0);
	gtk_box_pack_start(GTK_BOX(vbox), createButtonbar(), FALSE, TRUE, 0);
	
	displayMessages(logDaemon->loggedInfo);
	
	setWindowSize(500, 300);
	setWindowTitle(tr("IcQnD Network window"));
	
	logDaemon->addCallback((IMEventCallback)this->cb_loggingCallback, this);
	
	return vbox;
}


GtkWidget* logWindow::createFilterbar()
{
	GtkWidget	*filterButton,
				*hbox,
				*vbox,
				*table,
				*label,
				*typeCheckbox;
	gchar		*fstr;

	// Create the filter bar	
	grepFilterEntry = gtk_entry_new();
	g_signal_connect_swapped(grepFilterEntry, "activate", G_CALLBACK(this->cb_grepFilterButtonClicked), this);
	
	filterButton = u_createTextStockImageButton(tr("_Filter"), GTK_STOCK_FIND);
	g_signal_connect_swapped(filterButton, "clicked", G_CALLBACK(this->cb_grepFilterButtonClicked), this);
	
	hbox = gtk_hbox_new(FALSE, 1);
	gtk_box_pack_start(GTK_BOX(hbox), grepFilterEntry, TRUE, TRUE, 0);
	gtk_box_pack_start(GTK_BOX(hbox), filterButton, FALSE, FALSE, 0);
	
	// Create the filter-type label
	fstr = g_strdup_printf("<b>%s</b>", tr("Show the following log types"));
	label = gtk_label_new(fstr);
	g_free(fstr);
	gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
	gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
	
	// Create the filter-type table
	table = gtk_table_new(2, 3, TRUE);
	typeCheckbox = gtk_check_button_new_with_label(tr("Information"));
	g_object_set_data(G_OBJECT(typeCheckbox), "icqnd-logtype", GUINT_TO_POINTER(L_INFO));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(typeCheckbox), TRUE);
	g_signal_connect(G_OBJECT(typeCheckbox), "toggled", G_CALLBACK(this->cb_typeFilterChanged), this);
	gtk_table_attach_defaults(GTK_TABLE(table), typeCheckbox, 0, 1, 0, 1);

	typeCheckbox = gtk_check_button_new_with_label(tr("Errors"));
	g_object_set_data(G_OBJECT(typeCheckbox), "icqnd-logtype", GUINT_TO_POINTER(L_ERROR));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(typeCheckbox), TRUE);
	g_signal_connect(G_OBJECT(typeCheckbox), "toggled", G_CALLBACK(this->cb_typeFilterChanged), this);
	gtk_table_attach_defaults(GTK_TABLE(table), typeCheckbox, 1, 2, 0, 1);

	typeCheckbox = gtk_check_button_new_with_label(tr("Warnings"));
	g_object_set_data(G_OBJECT(typeCheckbox), "icqnd-logtype", GUINT_TO_POINTER(L_WARN));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(typeCheckbox), TRUE);
	g_signal_connect(G_OBJECT(typeCheckbox), "toggled", G_CALLBACK(this->cb_typeFilterChanged), this);
	gtk_table_attach_defaults(GTK_TABLE(table), typeCheckbox, 2, 3, 0, 1);

	typeCheckbox = gtk_check_button_new_with_label(tr("Packet Info"));
	g_object_set_data(G_OBJECT(typeCheckbox), "icqnd-logtype", GUINT_TO_POINTER(L_PACKET));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(typeCheckbox), TRUE);
	g_signal_connect(G_OBJECT(typeCheckbox), "toggled", G_CALLBACK(this->cb_typeFilterChanged), this);
	gtk_table_attach_defaults(GTK_TABLE(table), typeCheckbox, 0, 1, 1, 2);

	typeCheckbox = gtk_check_button_new_with_label(tr("Messages"));
	g_object_set_data(G_OBJECT(typeCheckbox), "icqnd-logtype", GUINT_TO_POINTER(L_MESSAGE));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(typeCheckbox), TRUE);
	g_signal_connect(G_OBJECT(typeCheckbox), "toggled", G_CALLBACK(this->cb_typeFilterChanged), this);
	gtk_table_attach_defaults(GTK_TABLE(table), typeCheckbox, 1, 2, 1, 2);

	typeCheckbox = gtk_check_button_new_with_label(tr("Other Info"));
	g_object_set_data(G_OBJECT(typeCheckbox), "icqnd-logtype", GUINT_TO_POINTER(L_UNKNOWN));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(typeCheckbox), TRUE);
	g_signal_connect(G_OBJECT(typeCheckbox), "toggled", G_CALLBACK(this->cb_typeFilterChanged), this);
	gtk_table_attach_defaults(GTK_TABLE(table), typeCheckbox, 2, 3, 1, 2);
	
	
	// create a vbox that contains the filter bar and the event type bar
	vbox = gtk_vbox_new(FALSE, 2);
	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
	gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, TRUE, 0);
	
	return vbox;
}


GtkWidget* logWindow::createButtonbar()
{
	GtkWidget	*hbox,
				*saveButton,
				*closeButton,
				*clearButton;
	
	saveButton = gtk_button_new_from_stock(GTK_STOCK_SAVE);
	g_signal_connect_swapped(saveButton, "clicked", G_CALLBACK(this->cb_saveButtonClicked), this);
	clearButton = gtk_button_new_from_stock(GTK_STOCK_CLEAR);
	g_signal_connect_swapped(clearButton, "clicked", G_CALLBACK(this->cb_clearButtonClicked), this);
	closeButton = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
	g_signal_connect_swapped(closeButton, "clicked", G_CALLBACK(this->cb_closeButtonClicked), this);
	
	hbox = gtk_hbox_new(FALSE, 2);
	
	gtk_box_pack_start(GTK_BOX(hbox), saveButton, FALSE, TRUE, 0);
	gtk_box_pack_start(GTK_BOX(hbox), clearButton, FALSE, TRUE, 0);
	gtk_box_pack_end(GTK_BOX(hbox), closeButton, FALSE, TRUE, 0);
	
	return hbox;
}


void logWindow::displayMessages(GList* msg)
{
	logInfo			*info;
	GtkTextIter		iter;
	GtkTextBuffer	*buf;
	GtkTextMark		*mark;
	gchar			*useTag;
	
	buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textView));	
	
	while(msg)
	{
		info = (logInfo*)msg->data;
		
		// only display the event if it's in out filter type
		// and when it fits the grep
		if ((typeFilter & info->type) &&
			(!*grepFilter ||  g_strrstr(info->message, grepFilter)))
		{
			
			
			useTag = "default";
			switch(info->type)
			{
				case L_ERROR: useTag = "error"; break;
				case L_WARN: useTag = "warning"; break;
				case L_PACKET: useTag = "packet"; break;
			}
		
			gtk_text_buffer_get_end_iter(buf, &iter);
			gtk_text_buffer_insert_with_tags_by_name(buf, &iter, info->message, -1, useTag, NULL);
				
		}
		
		msg = msg->next;
	}
	
	// scroll down
	gtk_text_buffer_get_end_iter(buf, &iter);
	mark = gtk_text_buffer_get_mark(buf, "last_pos");
	gtk_text_buffer_move_mark(buf, mark, &iter);
	gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(textView), mark, 0, FALSE, 0, 0);
}


void logWindow::clearMessageView()
{
	GtkTextIter		iter,
					endIter;
	GtkTextBuffer	*buf;
	
	buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textView));
	
	gtk_text_buffer_get_bounds(buf, &iter, &endIter);
	gtk_text_buffer_delete(buf, &iter, &endIter);
}



void logWindow::destroyWindowContent()
{
	logDaemon->removeCallback((IMEventCallback)this->cb_loggingCallback);
}


	
gboolean logWindow::cb_loggingCallback(userEventType type, gint command, gint lastResult, GList* log, logWindow* self)
{
	self->displayMessages(log);
	
	return TRUE;
}



void logWindow::cb_clearButtonClicked(logWindow* self)
{
	GtkTextIter		startIter,
					endIter;
	GtkTextBuffer	*buf;
	
	buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(self->textView));
	gtk_text_buffer_get_bounds(buf, &startIter, &endIter);
	gtk_text_buffer_delete(buf, &startIter, &endIter);
	
	self->logDaemon->clearLog();
}



void logWindow::cb_saveButtonClicked(logWindow* self)
{
	GtkWidget 	*dialog;
	gchar	  	*fileName,
				*tmp,
				*toWrite;
	FILE	  	*logFile;
	GtkTextIter	startIter,
				endIter;

	dialog = gtk_file_chooser_dialog_new(tr("Save Log File"),
				      					 GTK_WINDOW(self->window),
				      					 GTK_FILE_CHOOSER_ACTION_SAVE,
				      					 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
				      					 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
										 NULL);
	
	fileName = NULL;
	
	do
	{	
		if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
		{
			fileName = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
		
			// check if file already exists
			if (g_file_test(fileName, G_FILE_TEST_EXISTS))
				switch(u_showYesNoDialog(tr("File exists"), tr("The file already exists. Do you want to overwrite it?"), GTK_STOCK_DIALOG_QUESTION, TRUE))
				{
					case GTK_RESPONSE_CANCEL:
						g_free(fileName);
						fileName = (gchar*)1;
						break;

					case GTK_RESPONSE_NO:
						g_free(fileName);
						fileName = NULL;
						break;
						
				}
		} else
			fileName = (gchar*)1;
		
	} while(!fileName);

		
	if (fileName>(gchar*)1)
	{
		logFile = fopen(fileName, "w");
		
		gtk_text_buffer_get_bounds(gtk_text_view_get_buffer(GTK_TEXT_VIEW(self->textView)), &startIter, &endIter);
		tmp = gtk_text_buffer_get_text(gtk_text_view_get_buffer(GTK_TEXT_VIEW(self->textView)), &startIter, &endIter, FALSE);
		toWrite = systemCharsetToLocale(tmp);
				
		
		if (fprintf(logFile, toWrite)<0)
			u_showAlertMessage(tr("Couldn't write"), tr("The log file could not be written. Please check your permissions on the selected folder."), GTK_STOCK_DIALOG_ERROR);
		else
			u_showAlertMessage(tr("Success!"), tr("The log file was successfully written."), GTK_STOCK_DIALOG_INFO);
		
		fclose(logFile);
		g_free(tmp);
		g_free(toWrite);
		g_free(fileName);
	}
	gtk_widget_destroy (dialog);
}



void logWindow::cb_closeButtonClicked(logWindow* self)
{
	self->destroyWindow();
	delete self;
}


void logWindow::cb_typeFilterChanged(GtkWidget* checkBox, logWindow* self)
{
	guint curLog;
	
	curLog = GPOINTER_TO_UINT(g_object_get_data(G_OBJECT(checkBox), "icqnd-logtype"));
	
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkBox)))
		self->typeFilter |= curLog;
	else
		self->typeFilter = (self->typeFilter | curLog) ^ curLog;
	
	self->clearMessageView();
	self->displayMessages(self->logDaemon->loggedInfo);
}


void logWindow::cb_grepFilterButtonClicked(logWindow* self)
{
	g_free(self->grepFilter);
	self->grepFilter = g_strdup(gtk_entry_get_text(GTK_ENTRY(self->grepFilterEntry)));

	self->clearMessageView();
	self->displayMessages(self->logDaemon->loggedInfo);	
}