using System;
using System.Threading;
using System.Net;
using System.Collections;
using System.IO;
using System.Xml;
using System.Diagnostics;
using System.Web.Services.Protocols;

namespace TestRepoCleanup
{
	/// <summary>
	/// <p>Worker thread implementation.<br/>
	/// Reads cleanup.xml and invokes the Retry web service.</p>
	/// <p>Copyright (c) 2002 Alexis Grandemange<br/>
	/// Mail: alexis.grandemange@pagebox.net</p>
	/// <pre>This program is free software; you can redistribute it and/or
	/// modify it under the terms of the GNU Lesser General Public
	/// License as published by the Free Software Foundation; version
	/// 2.1 of the License.
	/// This library 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 Lesser General Public License for more details.
	/// A copy of the GNU Lesser General Public License lesser.txt should be
	/// included in the distribution.</pre>
	/// </summary>
	public class CleanupThread
	{
		/// <summary>
		/// ThreadRun loops up to the time toStop = true
		/// </summary>
		public bool toStop = false;
		/// <summary>
		/// If true, log events (debug mode)
		/// </summary>
		private bool toLog;
		/// <summary>
		/// Repository list. Contains RepositoryEntry objects.
		/// </summary>
		private ArrayList reps = new ArrayList();
		/// <summary>
		/// Constructor. Restores cleanup.xml
		/// </summary>
		/// <param name="path">Full path of cleanup.xml</param>
		/// <param name="tl">If true, log events</param>
		public CleanupThread(string path, bool tl)
		{
			if (!File.Exists(path)) 
			{
				log("CleanupThread.CleanupThread " + path + " not found");
				return;
			}
			toLog = tl;
			XmlTextReader r = new XmlTextReader(path);
			r.WhitespaceHandling = WhitespaceHandling.None;
			try 
			{
				r.ReadStartElement("cleanup");
				while (true) 
				{
					if (r.NodeType == XmlNodeType.Element) 
					{
						if (r.LocalName.Equals("repository")) 
						{
							r.Read();
							string url = r.ReadElementString("url");
							string user = r.ReadElementString("user");
							string password = r.ReadElementString("password");
							RepositoryEntry re = new RepositoryEntry(url, user, password);
							reps.Add(re);
						} 
						else
							break;
					}
					if ((r.NodeType == XmlNodeType.EndElement) && r.LocalName.Equals("cleanup")) 
						break;
					if (r.NodeType == XmlNodeType.None) 
						break;
					r.Read();
				}
			}
			catch(XmlException xe) 
			{
				error("CleanupThread.CleanupThread " + xe.Message);
				reps.Clear();
				r.Close();
				return;
			}
			r.Close();
			log("CleanupThread.CleanupThread restored cleanup.xml (" + reps.Count + ")");
		}
		/// <summary>
		/// Write an Error message on the Application Event Log
		/// </summary>
		/// <param name="msg">message string</param>
		public static void error(string msg) 
		{
			EventLog el = new EventLog("Application");
			el.Source = "RepoCleanup";
			el.WriteEntry(msg, EventLogEntryType.Error);
		}
		/// <summary>
		/// Write an Information message on the Application Event Log
		/// </summary>
		/// <param name="msg">message string</param>
		public void log(string msg) 
		{
			if (!toLog)
				return;
			EventLog el = new EventLog("Application");
			el.Source = "RepoCleanup";
			el.WriteEntry(msg, EventLogEntryType.Information);
		}
		/// <summary>
		/// Called when the thread is started. Calls the Retry web service using the Retry proxy.
		/// </summary>
		public void ThreadRun() 
		{
			while(!toStop) 
			{
				TimeSpan to = new TimeSpan(0, 30, 0);
				log("CleanupThread.ThreadRun cleanup");
				lock(this) 
				{
					try 
					{
						IEnumerator ie = reps.GetEnumerator();
						while(ie.MoveNext()) 
						{
							RepositoryEntry re = (RepositoryEntry)ie.Current;
							Retry rt = new Retry(re.url);
							string rc = null;
							try 
							{
								rt.Discover();
							}
							catch(Exception e) 
							{
								rc = re.url + " Discovery failed " + e.Message;
							}
							if (rc == null) 
							{
								try 
								{
									rc = rt.Cleanup(re.user, re.password);
								}
								catch(System.Net.WebException we) 
								{
									rc = re.url + " Cleanup failed WebException " + we.Message;
								}
								catch(System.Web.HttpException he)
								{
									rc = re.url + " Cleanup failed HttpException " + he.Message;
								}
								catch(SoapException se) 
								{
									rc = re.url + " Cleanup failed SoapException " + se.Message;
								}
							}
							if (!rc.EndsWith("performed"))
								error(rc);
						}
						Monitor.Wait(this, to);
					}
					catch (SynchronizationLockException e) 
					{
						error("CleanupThread.ThreadRun " + e.Message);
					}
					catch (ThreadInterruptedException e) 
					{
						error("CleanupThread.ThreadRun " + e.Message);
					}
				}
			}
		}
	}
	/// <summary>
	/// Describes a repository. Element of the reps list.
	/// </summary>
	public sealed class RepositoryEntry 
	{
		/// <summary>
		/// Uri of the Retry web service on the target repository
		/// </summary>
		public string url;
		/// <summary>
		/// User name
		/// </summary>
		public string user;
		/// <summary>
		/// Password
		/// </summary>
		public string password;
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="ru">Uri of the Retry web service on the target repository</param>
		/// <param name="u">User name</param>
		/// <param name="p">Password</param>
		public RepositoryEntry(string ru, string u, string p) 
		{
			url = ru;
			user = u;
			password = p;
		}
	}
}