using System;
using System.Collections;
using System.Threading;
using System.IO.Compression;
using System.Text.RegularExpressions;
using System.IO;
using Tamir.SharpSsh;
using System.Data.SQLite;
using Dizzy;
 
namespace Dizzy
{
 
 
	public class ProtocolException : ApplicationException
	{
		public ProtocolException () {}
		public ProtocolException (string Message) {}
	}
 
	public class Protocol
	{
 
		// I transfer attivi
		ArrayList transfers = new ArrayList ();
 
		public delegate void Del (string src, string dest,
		                          int transferredBytes, int totalBytes, string message);
 
 
		ArrayList threads = new ArrayList  ();
 
		Thread finder, listUpdater;
 
		// Dati letti dal thread che cerca per capire cosa cercare
		string keyword;
		FileTreeView fileTreeView;
 
		GlobalConfig config;
 
		public delegate void ProtocolEvent ();
 
		// Questo evento sembra non dare problemi perché ogni volta che
		// è emesso aspettiamo che l'utente inserisca i dati necessari
		// con while(!this.config.authenticated) {}
		public event ProtocolEvent AuthenticationRequired;
 
		public Protocol (ref GlobalConfig config)
		{
			this.config = config;
			this.UpdateFileList ();
		}
 
		public void Search(string keyword, ref FileTreeView f)
		{
			if (this.finder != null && this.finder.IsAlive)
			{
				Log.Info ("Ricerca in corso");
				return;
			}
			if (!System.IO.File.Exists(this.config.ListFileName ()))
			{
				// Dovremmo notificare l'utente che non c'è la lista
				Log.Warning ("La lista non è presente, chiedo di scaricarla");
			    this.UpdateFileList ();
			}
			else
			{
				Log.Info ("Avvio la ricerca nel database");
				this.keyword = keyword;
				this.fileTreeView = f;
				this.finder = new Thread(new ThreadStart (this._Search));
				this.finder.Start ();
			}
 
		}
 
		protected File ReadFile(StreamReader file)
		{
			string path = file.ReadLine();
			string user = file.ReadLine ();
			int size = System.Convert.ToInt32(file.ReadLine (), 10);
			return new File(path, user, size);
		}
 
		protected void _Search()
		{
			// Questa funzione viene chiamata quando qualcuno richiede
			// una ricerca. Inoltre abbiamo la quasi certezza che ne venga
			// chiamata solo un'istanza nello stesso momento.
			FileList list = new FileList (ref this.config);
 
			ArrayList files;
			try { files = list.Search (this.keyword); }
			catch (Exception e) {
				// Probabilmente stiamo solamente scaricando il database,
				// ma tant'è.
				Log.Error ("Impossibile effettuare la ricerca nel database: " + e.Message);
				files = new ArrayList ();
			}
 
			this.fileTreeView.Clear ();
			if (files.Count == 0)
				this.fileTreeView.AddFile (new File("Nessun risultato", " "));
			foreach(File f in files)
			{
				this.fileTreeView.AddFile (f);
			}
		}
 
		public void UpdateFileList ()
		{
			if(this.listUpdater != null && this.listUpdater.IsAlive)
			{
				Log.Warning ("La lista è già in fase di aggiornamento, non faccio nulla");
				return;
			}
 
			this.listUpdater = new Thread (new ThreadStart (this._UpdateFileList));
			this.listUpdater.Start ();
		}
 
 
 
		protected void _UpdateFileList ()
		{
			SFTPConnection s;
 
			if (!this.config.authenticated)
			{
				Log.Info ("I dati di autenticazione non sono presenti");
				this.AuthenticationRequired ();
 
				// Aspetto che l'utente abbia fatto.
				while(!this.config.authenticated) {}
				Log.Info ("Ho acquisito utente e password");
			}
 
			// Inizializziamo la connessione con i dati che supponiamo
			// di avere.
			s = new SFTPConnection (this.config.GetValue("user"),
			                       	this.config.password);
 
			try {
				s.Connect ();
			}
			catch (Exception e) {
				Log.Error ("Autenticazione errata (" + e.Message + ")");
				this.config.authenticated = false;
			}
 
			if(!this.config.authenticated)
			{
				// Chiamiamo questo con Glib per non far crashare tutto.
				GLib.Idle.Add (new GLib.IdleHandler(MainWindow.OnAuthenticationFailed));
			}
			else
			{
				Log.Info ("Aggiornamento della lista avviato");
 
				s.Download (new File("/nobackup/robol/index.db", "robol"),
					            this.config.ConfigDir ());
 
				Log.Info ("Lista Aggiornata");
				s.Disconnect ();
			}
		}
 
 
		public void Disconnect ()
		{
			foreach(FileTransfer t in this.transfers)
			{
				t.Stop ();
			}
			foreach(Thread t in this.threads)
			{
				if(t.IsAlive)
					t.Abort ();
			}
			if(this.finder != null && this.finder.IsAlive)
			{
				this.finder.Abort ();
			}
 
		}
 
 
		public void Download(File f, ref TaskTreeView tasks, string downloadFolder)
		{
			// Preparo gli argomento da passare alla funzione.
			if (!this.config.authenticated)
				this.AuthenticationRequired ();
			while(!this.config.authenticated) {}
 
			ArrayList args = new ArrayList ();
			args.Add (f);
			args.Add (tasks);
			args.Add (downloadFolder);
			Thread t = new Thread (new ParameterizedThreadStart(_Download));
			t.Start (args);
			this.threads.Add (t);
		}
 
		protected void _Download(object args)
		{
			// Questi cast sono piuttosto brutali ma posso passare
			// solo un oggetto a Download e quindi è il meglio che
			// mi riesce di fare.
			File f = (File) ((ArrayList) args)[0];
			TaskTreeView tasks = (TaskTreeView) ((ArrayList) args)[1];
			string downloadFolder = (string) ((ArrayList) args)[2];
			Log.Info ("Avvio il download di " + f.name);
 
			try {
				FileTransfer transfer = new FileTransfer (f, ref tasks, this.config.GetValue("user"), this.config.password, downloadFolder);
				this.transfers.Add (transfer);
			} catch (Exception e) {
 
				Log.Error (e.Message);
				this.config.authenticated = false;
				this.Download (f, ref tasks, downloadFolder);
			}
		}
 
	}
 
	public class SFTPConnection
	{
 
		public Sftp sftp;
		public delegate void SFTPEvent (string src, string dest, int transferredBytes,
		                                int totalBytes, string message);
 
		public event SFTPEvent TransferStarted;
		public event SFTPEvent TransferProgress;
		public event SFTPEvent TransferStopped;
 
		public delegate void Del (string src, string dest,
		                          int transferredBytes, int totalBytes, string message);
 
		public SFTPConnection (string user, string password)
		{
 
			// Inizializziamo il protocollo
			this.sftp = new Sftp ("poisson.phc.unipi.it", user);
			this.sftp.Password = password;
 
			this.sftp.OnTransferStart += new FileTransferEvent(this.TransferStartedHandler);
			this.sftp.OnTransferProgress += new FileTransferEvent(this.TransferProgressHandler);
			this.sftp.OnTransferEnd += new FileTransferEvent(this.TransferStoppedHandler);
 
		}
 
		private void TransferStartedHandler(string src, string dest, int transferredBytes,
		                                    int totalBytes, string message)
		{
			if(TransferStarted != null)
				TransferStarted(src, dest, transferredBytes, totalBytes, message);
		}
 
		private void TransferProgressHandler(string src, string dest, int transferredBytes,
		                                    int totalBytes, string message)
		{
			if (TransferProgress != null)
				TransferProgress(src, dest, transferredBytes, totalBytes, message);
		}
 
		private void TransferStoppedHandler(string src, string dest, int transferredBytes,
		                                    int totalBytes, string message)
		{
			if (TransferStopped != null)
				TransferStopped(src, dest, transferredBytes, totalBytes, message);
		}
 
		public void Connect()
		{
			sftp.Connect (22);
		}
 
		public ArrayList SearchFiles()
		{
			ArrayList matches = new ArrayList ();
			Console.WriteLine(" => Scan della nobackup");
			// ArrayList users = sftp.GetFileList ("/nobackup/");
			ArrayList users = new ArrayList();
			users.Add("robol");
			users.Add("bianchi");
			foreach(string folder in users)
			{
				if (folder == ".")
					continue;
				else if (folder == "..")
					continue;
				Console.WriteLine(" => Scan di {0}", folder);
				try {  matches.AddRange (GetFolderContent(folder)); }
				catch(Exception e) { Console.WriteLine (e.Message); }
			}
			Console.WriteLine(" => Scan terminato");
			return matches;
		}
 
		protected ArrayList GetFolderContent(string folder)
		{
			ArrayList matches, files;
			File f;
			string user;
			files = sftp.GetFileList("/nobackup/" + folder + "/");
			matches = new ArrayList ();
			foreach(string entry in files)
			{
				// Controllo che non sia una cartella. Evidentemente
				// questo metodo non è affidabile, ma per ora è il meglio
				// che SFTP ci permetta di fare.
				if(entry.IndexOf(".") == -1)
					matches.AddRange(GetFolderContent(folder + "/" + entry));
				else if(!entry.StartsWith("."))
				{
					user = folder;
					if(user.Contains("/"))
						user = user.Substring(0, user.IndexOf("/"));
					f = new File("/nobackup/" + folder + "/" + entry, user );
					matches.Add(f);
				}
			}
			return matches;
		}
 
		public void Download(File f, string downloadFolder)
		{
			this.sftp.Get (f.path, downloadFolder + Path.DirectorySeparatorChar +  f.name);
		}
 
		public void Disconnect ()
		{
			sftp.Close ();
		}
	}
 
	public class FileTransfer
	{
 
		TaskTreeView tasks;
		File file;
		Gtk.TreeIter iter;
 
		SFTPConnection sftp;
 
		public delegate void Handler(string src, string dest, int transferredBytes,
		                             int totalBytes, string message);
 
		public FileTransfer (File f, ref TaskTreeView tasks, string user, string password, string downloadFolder)
		{
			// Connessione al server
			this.sftp = new SFTPConnection (user, password);
			this.sftp.Connect ();
 
			this.tasks = tasks;
			this.file = f;
 
			sftp.TransferStarted += new SFTPConnection.SFTPEvent(OnTransferStarted);
			sftp.TransferProgress += new SFTPConnection.SFTPEvent(OnTransferProgress);
			sftp.TransferStopped += new SFTPConnection.SFTPEvent(OnTransferStopped);
 
			sftp.Download (this.file, downloadFolder);
			sftp.Disconnect ();
		}
 
		public void Stop ()
		{
			this.sftp.Disconnect ();
		}
 
		public void OnTransferStarted (string src, string dest, int transferredBytes,
		                          int totalBytes, string message)
		{
			this.iter = this.tasks.AddTask(file.name, 0);
		}
 
		public void OnTransferProgress(string src, string dest, int transferredBytes,
		                               int totalBytes, string message)
		{
			int perc = transferredBytes / (totalBytes / 100);
			this.tasks.SetProgress(this.iter, perc);
		}
 
		public void OnTransferStopped (string src, string dest, int transferredBytes,
		                               int totalBytes, string message)
		{
			this.tasks.DeleteRow (this.iter);
		}
	}
 
 
	class FileSearch
{
	SshExec sshexec;
	string username, password, keywords;
	FileTreeView f;
 
	public FileSearch (string username, string password, string keywords, ref FileTreeView f)
	{
		this.username = username;
		this.password = password;
		this.keywords = keywords;
		this.f = f;
	}
 
	public void DoSearch ()
	{
		sshexec = new SshExec("poisson.phc.unipi.it", this.username, this.password);
		sshexec.Connect ();
 
		string command = "locate -i -e --regex /nobackup/.+" + this.keywords;
		string output = sshexec.RunCommand (command);
		f.Clear ();
		foreach(string line in Regex.Split(output, "\n"))
		{
			if (line.StartsWith("/nobackup/") && Regex.Match(line,".*[.].*").Success)
				this.f.AddFile (new File(line, ""));
		}
		sshexec.Close ();
	}
 
}
 
	public class FileList
	{
 
		GlobalConfig config;
		SQLiteConnection connection;
 
		public FileList(ref GlobalConfig config) {
 
			this.config = config;
 
			string connectionString = "Data Source=" + this.config.ListFileName () + ";Version=3";
			this.connection = new SQLiteConnection(connectionString);
		}
 
		public ArrayList Search(string keyword) {
 
			this.connection.Open ();
			ArrayList matches = new ArrayList ();
 
			// Eseguiamo la query
			SQLiteCommand sqlCmd = this.connection.CreateCommand ();
			sqlCmd.CommandText = "SELECT * from files WHERE name LIKE '%" + keyword + "%';";
			SQLiteDataReader reader = sqlCmd.ExecuteReader ();
 
			while(reader.Read())
			{
				matches.Add (new File(reader.GetString(0),   // Path
				                      reader.GetString(2),   // User
				                      reader.GetInt32(3)));  // Size
			}
			this.connection.Close ();
			return matches;
		}
	}
 
}