using System;
using Gtk;
using System.Collections.Generic;
 
namespace Dizzy
{
 
	/*
	 * Problema: Supponiamo di avere un thread disperso per il programma
	 * che ad un certo punto decide che deve comunicare all'utente che è
	 * successo un gran casino. Come va?
	 *
	 * Soluzione 1: Emette un evento che da qualche altra parte è stato
	 * collegato ad una funzione che crea un dialog. Questo crea problemi
	 * con il fatto che le chiamate alle gtk vengono fatte dal thread sbagliato.
	 *
	 * Soluzione attuale: Riceviamo le chiamate qua dentro. Questo oggetto
	 * inserisce le chiamate corrette nel thread principale.
	 */
 
	public class EventManager
	{
 
		public static MessageDialog searchInProgress = null;
		public static MessageDialog listUpdate = null;
 
		// Gestione dei file e dei task. Questi devono essere inizializzati
		// Appena sono creati.
		public static FileTreeView fileTreeView = null;
		public static TaskTreeView taskTreeView = null;
		public static void RegisterFileTreeView (ref FileTreeView f) { fileTreeView = f; }
		public static void RegisterTaskTreeView (ref TaskTreeView t) { taskTreeView = t; }
 
		public EventManager () {}
 
		protected static Dictionary<string,TreeIter> iters = new Dictionary<string, TreeIter> ();
 
		// Metodo generico per segnalare un'errore dell'applicazione.
		public static void ErrorMessage (string message) {
 
			GLib.Idle.Add(delegate {
				Log.Error (message);
 
				MessageDialog d = new Gtk.MessageDialog(null,
				       	                  Gtk.DialogFlags.DestroyWithParent,
				                          Gtk.MessageType.Error,
				                          Gtk.ButtonsType.Ok, "");
				d.Markup = message;
				d.Run ();
				d.Destroy ();
				return false;
			});
		}
 
		// Metodi per gestire la ricerca
		public static void SearchStarted () {
 
			// Questo significa che stiamo già effettuando una ricerca
			if (searchInProgress != null)
				return;
 
			searchInProgress = new MessageDialog(null,
			                                     DialogFlags.Modal,
			                                     MessageType.Info,
			                                     ButtonsType.None,
			                                     true, "");
			searchInProgress.Markup = "Ricerca in corso, attendere.";
			GLib.Idle.Add (delegate {
				if (EventManager.searchInProgress != null)
					EventManager.searchInProgress.Run ();
				return false;
			});
		}
 
		public static void SearchFinished () {
			if (searchInProgress == null)
			{
				Log.Warning ("Sembra che la ricerca sia già morta di per sè");
				return;
			}
			else
			{
				GLib.Idle.Add(delegate {
					searchInProgress.Destroy ();
					searchInProgress = null;
					return false;
				});
			}
		}
 
		// Metodi per gestire l'update della lista
		public static void ListUpdateStarted () {
 
			// Questo significa che stiamo già effettuando una ricerca
			if (listUpdate != null)
				return;
 
			listUpdate = new MessageDialog(null,
			                                     DialogFlags.Modal,
			                                     MessageType.Info,
			                                     ButtonsType.None,
			                                     true, "");
			listUpdate.Markup = "Aggiornamento della lista in corso";
			GLib.Idle.Add (delegate {
				if (EventManager.listUpdate != null)
					EventManager.listUpdate.Run ();
				return false;
			});
		}
 
		public static void ListUpdateFinished () {
			if (listUpdate == null)
				return;
			else
			{
				GLib.Idle.Add(delegate {
					listUpdate.Destroy ();
					Log.Info ("Aggiornamento completato");
					EventManager.listUpdate = null;
					return false;
				});
			}
		}
 
		public static void FileTreeViewAddFile(File f)
		{
			if (fileTreeView == null) { return; }
			GLib.Idle.Add(delegate {
				fileTreeView.AddFile (f);
				return false;
			});
		}
 
		public static void FileTreeViewClear() {
			if (fileTreeView == null) { return; }
			GLib.Idle.Add(delegate {
				fileTreeView.Clear ();
				return false;
			});
		}
 
		public static void TaskTreeViewAddTask (string filename, int perc)
		{
			if (taskTreeView == null)
				return;
			GLib.Idle.Add (delegate {
				EventManager.AddIter(filename, taskTreeView.AddTask (filename, perc));
				return false;
			});
 
		}
 
		public static void TaskTreeViewSetProgress (TreeIter iter, int perc)
		{
			if (taskTreeView == null)
				return;
			GLib.Idle.Add(delegate {
				taskTreeView.SetProgress (iter, perc);
				return false;
			});
		}
 
		public static void TaskTreeViewRemove (TreeIter iter)
		{
			if (taskTreeView == null)
				return;
			GLib.Idle.Add (delegate {
				taskTreeView.DeleteRow (iter);
				return false;
			});
		}
 
		public static void AddIter (string filename, TreeIter iter)
		{
			iters.Add(filename, iter);
		}
 
		public static TreeIter GetIter (string filename)
		{
			try {return iters[filename];}
			catch (Exception e)
			{
				// Aspettiamo nella speranza che le cose vadano meglio
				Log.Warning ("Sto richiamando GetIter () per ottenre l'iter (" + e.Message + ")");
				System.Threading.Thread.Sleep(200);
			}
			return GetIter(filename);
		}
 
	}
}