/***************************************************************************
 *            listswindow.cpp
 *
 *  Sun Nov 13 16:52:24 2005
 *  Copyright  2005  User
 *  Email
 ****************************************************************************/

#include "listswindow.h"
#include "imbuddy.h"

listsWindow::listsWindow(gpointer _owner)
{
	owner = _owner;
	wType = UE_USERLISTS;
}



listsWindow::~listsWindow()
{

}



GtkWidget* listsWindow::createWindowContent()
{
	GtkWidget	*vbox,
				*hbox1,
				*label,
				*image;
	
	
	// create the title and title image
	image = gtk_image_new_from_stock(GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG);
	
	label = gtk_label_new("This window lets you manage all your contacts in a comfortable way. One Tab is for the groups and one for modes...");
	gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
	gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
	gtk_widget_set_size_request(label, 550, -1);
	
	hbox1 = gtk_hbox_new(FALSE, 10);
	gtk_box_pack_start(GTK_BOX(hbox1), image, FALSE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(hbox1), label, FALSE, TRUE, 0);
	
	
	vbox = gtk_vbox_new(FALSE, 5);
	gtk_container_set_border_width(GTK_CONTAINER(vbox), 10);
	
	notebookContainer = gtk_vbox_new(FALSE, 0);
	gtk_box_pack_start(GTK_BOX(notebookContainer), createUsersList(), TRUE, TRUE, 0);
	
	gtk_box_pack_start(GTK_BOX(vbox), hbox1, FALSE, TRUE, 0);
	gtk_box_pack_start(GTK_BOX(vbox), notebookContainer, TRUE, TRUE, 0);
	gtk_box_pack_start(GTK_BOX(vbox), createButtonbar(), FALSE, TRUE, 0);
	
	setWindowSize(600, 500);
	setWindowTitle(tr("IcQnD - Manage user groups / modes"));
	
	return vbox;
}



void listsWindow::destroyWindowContent()
{

}



GtkWidget* listsWindow::createUsersList()
{
	
	GType				*types;
	GList				*searchGroups;
	guint				i;
	GtkTreeViewColumn	*column;
	GtkCellRenderer		*renderer;
	groupInfo			*curGroup;
	GtkWidget			*scrolled1,
						*scrolled2,
						*notebook;
	
	gchar* modeNames[4] = {"Online notify", "Visible to user", "Invisible to user", "Ignore user"};
	
	// Create the stores
	// ------------------
	
	// The groups store
	searchGroups = IO_getGroupManager()->groups->next;
	types = (GType*)g_malloc0(sizeof(GType)*(g_list_length(searchGroups) + 3));
	types[0] = G_TYPE_STRING;		// Alias
	types[1] = G_TYPE_POINTER;		// User pointer
	types[2] = G_TYPE_BOOLEAN;		// Changed
	for (i=0; i<g_list_length(searchGroups); i++)
		types[i+3] = G_TYPE_BOOLEAN;
	groupsStore = gtk_tree_store_newv(g_list_length(searchGroups)+3, types);
	
	g_free(types);
	
	// The modes store					Alias											Online notify	visible			invisible		ignore
	modesStore = gtk_tree_store_new(7, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN);
	
	
	fillUserLists();	
	
	// Create the views
	
	// The groups view	
	groupsView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(groupsStore));
	gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(groupsView), TRUE);
    gtk_tree_view_set_search_column(GTK_TREE_VIEW(groupsView), 0);	
	gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(groupsView), TRUE);
	
	renderer = gtk_cell_renderer_text_new();
	column = gtk_tree_view_column_new_with_attributes("Alias", renderer, 
													  "text", 0,
													  NULL);
	gtk_tree_view_column_set_expand(column, TRUE);
	gtk_tree_view_column_set_sort_column_id(column, 0);
	gtk_tree_view_append_column(GTK_TREE_VIEW(groupsView), column);

	i = 3;
	for (searchGroups = IO_getGroupManager()->groups->next; searchGroups; searchGroups = searchGroups->next)
	{
		curGroup = (groupInfo*)searchGroups->data;

		renderer = gtk_cell_renderer_toggle_new();
		g_object_set_data(G_OBJECT(renderer), "icqndModel", groupsStore);
		g_object_set_data(G_OBJECT(renderer), "icqndField", GINT_TO_POINTER(i));
		g_signal_connect(G_OBJECT(renderer), "toggled", G_CALLBACK(this->cb_itemToggled), this);
		column = gtk_tree_view_column_new_with_attributes(curGroup->name, renderer, "active", i, NULL);
		gtk_tree_view_column_set_sort_column_id(column, i);
		gtk_tree_view_column_set_expand(column, FALSE);

		gtk_tree_view_append_column(GTK_TREE_VIEW(groupsView), column);
		
		i++;		
	}
	
	
	// The modes view
	modesView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(modesStore));
	gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(modesView), TRUE);
    gtk_tree_view_set_search_column(GTK_TREE_VIEW(modesView), 0);	
	gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(modesView), TRUE);
	
	renderer = gtk_cell_renderer_text_new();
	column = gtk_tree_view_column_new_with_attributes("Alias", renderer, 
													  "text", 0,
													  NULL);
	gtk_tree_view_column_set_expand(column, TRUE);
	gtk_tree_view_column_set_sort_column_id(column, 0);
	gtk_tree_view_append_column(GTK_TREE_VIEW(modesView), column);
	
	for (i=0; i<4; i++)
	{
		renderer = gtk_cell_renderer_toggle_new();
		g_object_set_data(G_OBJECT(renderer), "icqndModel", modesStore);
		g_object_set_data(G_OBJECT(renderer), "icqndField", GINT_TO_POINTER(i+3));
		g_signal_connect(G_OBJECT(renderer), "toggled", G_CALLBACK(this->cb_itemToggled), this);
		column = gtk_tree_view_column_new_with_attributes(modeNames[i], renderer,
														  "active", i+3,
														  NULL);
		gtk_tree_view_column_set_sort_column_id(column, i+3);
		gtk_tree_view_column_set_expand(column, FALSE);
		gtk_tree_view_append_column(GTK_TREE_VIEW(modesView), column);
	}		
	
	
	
	// Create scrolled windows around the views and add them to a notebook
	scrolled1 = gtk_scrolled_window_new(NULL, NULL);
	gtk_container_set_border_width(GTK_CONTAINER(scrolled1), 5);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled1), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled1), GTK_SHADOW_IN);
	gtk_container_add(GTK_CONTAINER(scrolled1), groupsView);
	
	scrolled2 = gtk_scrolled_window_new(NULL, NULL);
	gtk_container_set_border_width(GTK_CONTAINER(scrolled2), 5);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled2), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled2), GTK_SHADOW_IN);
	gtk_container_add(GTK_CONTAINER(scrolled2), modesView);
	
	notebook = gtk_notebook_new();
	gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scrolled1, gtk_label_new(tr("Groups")));
	gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scrolled2, gtk_label_new(tr("User modes")));
	
	
	
	return notebook;
}



void listsWindow::fillUserLists()
{
	GList				*searchOwners,
						*searchUsers,
						*search;
	gint				i,  
						groupsLength;
	GtkTreeIter			iter;
	IMUserDaemon		*curUser;
	gulong				groups;
	
	
	// Clear the stores
	gtk_tree_store_clear(groupsStore);
	gtk_tree_store_clear(modesStore);
	
	
	// Insert the users
	searchOwners = IO_getOwnerList();
	groupsLength = g_list_length(IO_getGroupManager()->groups->next);
	
	for (searchOwners = IO_getOwnerList(); searchOwners; searchOwners = searchOwners->next)
	{
		// Load the ignored users
		((IMOwnerDaemon*)searchOwners->data)->loadIgnoredContacts();
		
		searchUsers = ((IMOwnerDaemon*)searchOwners->data)->users;
		for (search = searchUsers; search; search = search->next)
		{
			curUser = (IMUserDaemon*)search->data;
			
			// Fill the groups store
			groups = curUser->getLicqGroups(GROUPS_USER);
			
			gtk_tree_store_append(groupsStore, &iter, NULL);
			
			gtk_tree_store_set(groupsStore, &iter, 0, curUser->info->alias, 
												   1, curUser,
												   2, FALSE,
												   -1);
			for (i = 0; i<groupsLength; i++)
				gtk_tree_store_set(groupsStore, &iter, i+3, groups & (1<<i), -1);	


		
		}
		
		
		// The modes window also includes the ignored users.
		// concat ignored users and normal users into one group
		searchUsers = g_list_concat(((IMOwnerDaemon*)searchOwners->data)->users,
									((IMOwnerDaemon*)searchOwners->data)->ignoredUsers);

		for (; searchUsers; searchUsers = searchUsers->next)
		{			
			curUser = (IMUserDaemon*)searchUsers->data;
			
			// Fill the modes store
			groups = curUser->getLicqGroups(GROUPS_SYSTEM);
			
			gtk_tree_store_append(modesStore, &iter, NULL);

			gtk_tree_store_set(modesStore, &iter, 0, curUser->info->alias, 
												  1, curUser,
												  2, FALSE,
												  -1);

			for (i=0; i<4; i++)
				gtk_tree_store_set(modesStore, &iter, i+3, groups & (1<<i), -1); 				
		}
		
	} 	
}



GtkWidget* listsWindow::createButtonbar()
{
	GtkWidget	*editGroupsButton,
				*applyButton,
				*closeButton,
				*hbox;
	GtkSizeGroup	*sizeGroup;
	
	sizeGroup = gtk_size_group_new(GTK_SIZE_GROUP_BOTH);
	
	editGroupsButton = u_createTextStockImageButton("Edit groups ...", GTK_STOCK_INDEX);
	g_signal_connect_swapped(editGroupsButton, "clicked", G_CALLBACK(this->cb_editGroupsButtonClicked), this);
	applyButton = gtk_button_new_from_stock(GTK_STOCK_APPLY);
	g_signal_connect_swapped(applyButton, "clicked", G_CALLBACK(this->cb_applyButtonClicked), this);
	closeButton = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
	g_signal_connect_swapped(closeButton, "clicked", G_CALLBACK(this->cb_destroyWindow), this);
	
	gtk_size_group_add_widget(sizeGroup, editGroupsButton);
	gtk_size_group_add_widget(sizeGroup, applyButton);
	gtk_size_group_add_widget(sizeGroup, closeButton);
	
	hbox = gtk_hbox_new(FALSE, 2);
	
	gtk_box_pack_start(GTK_BOX(hbox), editGroupsButton, FALSE, TRUE, 0);
	gtk_box_pack_end(GTK_BOX(hbox), closeButton, FALSE, TRUE, 0);	
	gtk_box_pack_end(GTK_BOX(hbox), applyButton, FALSE, TRUE, 0);
	
	return hbox;
}


void listsWindow::recreateWindow()
{
	GList	*search;
	
	// pointers may have changed now -> recreate the list
	for (search = IO_getOwnerList(); search; search = search->next)
		((IMOwnerDaemon*)search->data)->clearIgnoredContacts();	
	
	gtk_container_foreach(GTK_CONTAINER(notebookContainer), (GtkCallback)gtk_widget_destroy, NULL);
	gtk_box_pack_start(GTK_BOX(notebookContainer), createUsersList(), TRUE, TRUE, 0);
	
	gtk_widget_show_all(notebookContainer);
}

	
	
	
	
void listsWindow::cb_itemToggled(GtkCellRenderer* renderer, gchar* path, listsWindow* self)
{
	GtkTreeModel	*model;
	gint			col;
	GtkTreeIter		iter;
	gboolean		val,
					changed;
	GtkTreePath		*curPath;
	IMUserDaemon	*valUser,
					*curUser;
	gulong			groups,
					i;
	GList			*groupsList;
	
	model = (GtkTreeModel*)g_object_get_data(G_OBJECT(renderer), "icqndModel");
	col = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(renderer), "icqndField"));
	
	curPath = gtk_tree_path_new_from_string(path);
	
	gtk_tree_model_get_iter(model, &iter, curPath);
	
	gtk_tree_path_free(curPath);
	
	gtk_tree_model_get(model, &iter, 2, &changed, col, &val, -1);
	changed = TRUE;
	val = !val;
	gtk_tree_store_set(GTK_TREE_STORE(model), &iter, 2, changed, col, val, -1);
	
	// Check whether we should bring the entry into the groups view or delete it
	if (col == 6 && model == GTK_TREE_MODEL(self->modesStore))
	{
		gtk_tree_model_get(model, &iter, 1, &valUser, -1); 
		
		// We have set "ignore" to TRUE -> delete the user from the groups view
		if (val)
		{
			gtk_tree_model_get_iter_first(GTK_TREE_MODEL(self->groupsStore), &iter);
			do
			{
				gtk_tree_model_get(GTK_TREE_MODEL(self->groupsStore), &iter, 1, &curUser, -1);
				
				if (valUser == curUser)
				{
					gtk_tree_store_remove(self->groupsStore, &iter);
					break;
				}
				
			} while(gtk_tree_model_iter_next(GTK_TREE_MODEL(self->groupsStore), &iter));
		} else
		// We have set "ignore" to FALSE -> create the user in the groups view
		{
			gtk_tree_store_append(self->groupsStore, &iter, NULL);
			
			gtk_tree_store_set(self->groupsStore, &iter, 
							   0, valUser->info->alias,
							   1, valUser,
							   2, TRUE,
							   -1);
			
			i = 0;
			groups = valUser->getLicqGroups(GROUPS_USER);
			for (groupsList = IO_getGroupManager()->groups->next; groupsList; groupsList = groupsList->next)
			{
				gtk_tree_store_set(self->groupsStore, &iter,
								   i+3, (groups & (1<<i)), 
								   -1);
				i++;
			}
			
			
		}
	}
}



void listsWindow::cb_editGroupsButtonClicked(listsWindow* self)
{
	((IMOwner*)self->owner)->openEvent(UE_EDITGROUPS, 0);
}



void listsWindow::cb_applyButtonClicked(listsWindow* self)
{
	GtkTreeIter		iter;
	IMUserDaemon	*curUser;
	gulong			groupVal,
					groupLength,
					i;
	gboolean		curVal;
	GList			*search;
		
	// first apply user group info
	groupLength = g_list_length(IO_getGroupManager()->groups)-1;
	
	gtk_tree_model_get_iter_first(GTK_TREE_MODEL(self->groupsStore), &iter);
	
	do
	{
		gtk_tree_model_get(GTK_TREE_MODEL(self->groupsStore), &iter,
						   1, &curUser,
						   2, &curVal,
						   -1);
		
		// did the value change?
		if (curVal)
		{
			groupVal = 0;
			for (i=0; i<groupLength; i++)
			{
				gtk_tree_model_get(GTK_TREE_MODEL(self->groupsStore), &iter, i+3, &curVal, -1);
				if (curVal)
					groupVal|= (1<<i);
			}
			
			curUser->setLicqGroups(GROUPS_USER, groupVal);
		}
		
	} while(gtk_tree_model_iter_next(GTK_TREE_MODEL(self->groupsStore), &iter));
	
	
	// now set the user modes
	gtk_tree_model_get_iter_first(GTK_TREE_MODEL(self->modesStore), &iter);
	
	do
	{
		gtk_tree_model_get(GTK_TREE_MODEL(self->modesStore), &iter,
						   1, &curUser,
						   2, &curVal,
						   -1);
		
		// did the value change?
		if (curVal)
		{
			groupVal = 0;
			for (i=0; i<4; i++)
			{
				gtk_tree_model_get(GTK_TREE_MODEL(self->modesStore), &iter, i+3, &curVal, -1);
				if (curVal)
					groupVal|= (1<<i);
			}
			
			curUser->setLicqGroups(GROUPS_SYSTEM, groupVal);
		}
		
	} while(gtk_tree_model_iter_next(GTK_TREE_MODEL(self->modesStore), &iter));	
	
	
	
	// pointers may have changed now -> recreate the list
	for (search = IO_getOwnerList(); search; search = search->next)
		((IMOwnerDaemon*)search->data)->clearIgnoredContacts();
	self->fillUserLists();
}