using System;
using System.Collections;
using System.Xml;
using System.IO;
namespace Repository
{
	/// <summary>
	/// <p>Describes Repository archives.<br/>
	/// Serialized in archives.xml. Named ArchiveRep in PHP version.</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 RepoArchs : Deployer
	{
		/// <summary>
		/// <p>Array of archives.<br/>
		/// Key: archive name.<br/>
		/// Value: archive publisher (owner).</p>
		/// </summary>
		public Hashtable archives = null;
		private Hashtable internalArchs = new Hashtable();
		/// <summary>
		/// <p>Array of archive documentation URLs.<br/>
		/// Key: archive name.<br/>
		/// Value: archive documentation URL.</p>
		/// <summary>
		public Hashtable docs = null;
		public Hashtable internalDocs = new Hashtable();
		/// <summary>
		/// Array of administrators. Administrators can see and unpublish any archive.
		/// They can also publish archives.
		/// </summary>
		Hashtable administrators = new Hashtable();
		/// <summary>
		/// Array of publishers. Publishers can see and unpublish the archives that they have published.
		/// They can also publish archives.
		/// </summary>
		Hashtable publishers = new Hashtable();
		/// <summary>
		/// This URL ../download
		/// </summary>
		string downloadURL;
		/// <summary>
		/// This directory ../download
		/// </summary>
		public string downloadPath;
		/// <summary>
		/// Subscriber repository. RepoSubsObj in PHP version.
		/// </summary>
		RepoSubs subRep;
		/// <summary>
		/// Creation of a new Archive repository.
		/// </summary>
		public RepoArchs()
		{
			archives = Hashtable.Synchronized(internalArchs);
			docs = Hashtable.Synchronized(internalDocs);
		}
		/// <summary>
		/// Restore administrators and publishers from authorization.xml.
		/// </summary>
		private void restoreAuth() 
		{
			if (!File.Exists(Global.path + "\\authorization.xml")) 
				return;
			XmlTextReader r = new XmlTextReader(Global.path + "\\authorization.xml");
			r.WhitespaceHandling = WhitespaceHandling.None;
			r.ReadStartElement("authorization");
			restoreHash(administrators, r, "administrators");
			restoreHash(publishers, r, "publishers");
			r.Close();
		}
		/// <summary>
		/// Populate a Hashtable, either administrators or publishers.
		/// </summary>
		/// <param name="h">Hashtable to populate</param>
		/// <param name="r">XML stream to read</param>
		/// <param name="elt">Element to process</param>
		private void restoreHash(Hashtable h, XmlReader r, string elt)
		{
			r.ReadStartElement(elt);
			while (true) 
			{
				if (r.NodeType == XmlNodeType.Element) 
				{
					if (r.LocalName.Equals("user")) 
					{
						string user = r.ReadElementString("user");
						h.Add(user, true);
					} else
						return;
				}
				if ((r.NodeType == XmlNodeType.EndElement) && r.LocalName.Equals(elt)) 
					break;
				if (r.NodeType == XmlNodeType.None)
					return;
			}
			r.ReadEndElement();
		}
		/// <summary>
		/// Archive repository initialization.
		/// </summary>
		/// <param name="du">download URL</param>
		/// <param name="rs">Archive repository</param>
		/// <param name="dp">download path</param>
		public void init(string du, RepoSubs rs, string dp) 
		{
			downloadURL = du;
			subRep = rs;
			downloadPath = dp;
			restoreAuth();
		}
		/// <summary>
		/// Unserialization of an existing Archive repository.
		/// </summary>
		/// <param name="r">XML stream to unserialize</param>
		public RepoArchs(XmlReader r) 
		{
			r.ReadStartElement("RepoArchs");
			restoreHash2(internalArchs, r, "archives");
			restoreHash2(internalDocs, r, "docs");
			archives = Hashtable.Synchronized(internalArchs);
			docs = Hashtable.Synchronized(internalDocs);
		}
		/// <summary>
		/// Restore internalArchs or internalDocs.
		/// Invoked in the RepArchs constructor.
		/// </summary>
		/// <param name="h">Publisher table to restore</param>
		/// <param name="r">XML stream to unserialize</param>
		/// <param name="elt">Element to process</param>
		private void restoreHash2(Hashtable h, XmlReader r, string elt) 
		{
			r.ReadStartElement(elt);
			while (true) 
			{
				if (r.NodeType == XmlNodeType.Element) 
				{
					if (r.LocalName.Equals("entry")) 
					{
						r.Read();
						string arch = r.ReadElementString("arch");
						string val = r.ReadElementString("val");	// owner or doc URL
						h.Add(arch, val);
					}
					else
						return;
				}
				if ((r.NodeType == XmlNodeType.EndElement) && r.LocalName.Equals(elt)) 
					break;
				if (r.NodeType == XmlNodeType.None)
					return;
				r.Read();
			}
			r.ReadEndElement();
		}
		/// <summary>
		/// Serializer.
		/// </summary>
		/// <param name="w">Stream where the Repository archives must be serialized</param>
		public void WriteXml(XmlWriter w) 
		{
			w.WriteStartElement("RepoArchs");
			w.WriteStartElement("archives");
			IDictionaryEnumerator ide = internalArchs.GetEnumerator();
			while(ide.MoveNext()) 
			{
				w.WriteStartElement("entry");
				w.WriteElementString("arch", (string)ide.Key);
				w.WriteElementString("val", (string)ide.Value);
				w.WriteEndElement();
			}
			w.WriteEndElement();
			w.WriteStartElement("docs");
			ide = internalDocs.GetEnumerator();
			while(ide.MoveNext()) 
			{
				w.WriteStartElement("entry");
				w.WriteElementString("arch", (string)ide.Key);
				w.WriteElementString("val", (string)ide.Value);
				w.WriteEndElement();
			}
			w.WriteEndElement();
			w.WriteEndElement();
		}
		/// <summary>
		/// Adds an archive to the repository.
		/// </summary>
		/// <returns>status</returns>
		/// <param name="user">user who issued the command</param>
		/// <param name="host">host which issued the command</param>
		/// <param name="arch">archive name</param>
		/// <param name="owner">archive owner</param>
		/// <param name="docURL">documentation URL</param>
		public string add(string user, string host, string arch, string owner, string docURL) 
		{
			lock(this) 
			{
				string status = null;
				IDictionaryEnumerator ide = null;
				Subscriber sub = null;
				if (archives.Contains(arch)) 
				{
					status = "'" + arch + "' updated";
					ide = subRep.asubscribers.GetEnumerator();
					while(ide.MoveNext()) 
					{
						sub = (Subscriber)ide.Value;
						if (sub.state.Equals("pending unsubscribe"))
							continue;
						if (sub.archs.Contains(arch))
						{
							string d = deploy(user, host, (string)ide.Key, arch, owner, docURL, downloadURL);
							if (d != null) 
							{
								sub.archs[arch] = d;
								subRep.dirty = true;
							}
						}
					}
					if (docs.Contains(arch))	// Should be the case
						docs[arch] = docURL;
					else
						docs.Add(arch, docURL);
				} 
				else 
				{
					status = "'" + arch + "' created";
					archives.Add(arch, owner);
					docs.Add(arch, docURL);
					Global.saveArchRep();
				}
				ide = subRep.subscribers.GetEnumerator();
				while(ide.MoveNext()) 
				{
					sub = (Subscriber)ide.Value;
					if (sub.state.Equals("pending unsubscribe"))
						continue;
					string d = deploy(user, host, (string)ide.Key, arch, owner, docURL, downloadURL);
					if (d != null) 
					{
						if (sub.archs.Contains(arch))
							sub.archs[arch] = d;	// Shouldn't happen
						else
							sub.archs.Add(arch, d);
						subRep.dirty = true;
					}
				}
				if (subRep.dirty)
					Global.saveSubRep();
				return status;
			}
		}
		/// <summary>
		/// Remove an archive from the repository.
		/// </summary>
		/// <returns>status</returns>
		/// <param name="user">user who issued the command</param>
		/// <param name="host">host which issued the command</param>
		/// <param name="arch">archive name</param>
		/// <param name="isForce">isForce bool If true remove the archive from the subscriber even
		/// if the subscriber cannot be contacted</param>
		public string delete(string user, string host, string arch, bool isForce) 
		{
			lock(this) 
			{
				if (!archives.Contains(arch))
					return "'" + arch + "' doesn't exist";
				delete(user, host, subRep.subscribers, arch, isForce);
				delete(user, host, subRep.asubscribers, arch, isForce);
				archives.Remove(arch);
				docs.Remove(arch);
				if (File.Exists(downloadPath + arch))
					File.Delete(downloadPath + arch);
				Global.saveArchRep();
				if (subRep.dirty)
					Global.saveSubRep();
				return arch + " deleted";
			}
		}
		/// <summary>
		/// Cleanup a subscriber list when an archive is removed.
		/// </summary>
		/// <param name="user">user who issued the command</param>
		/// <param name="host">host which issued the command</param>
		/// <param name="h">subscribers or asubscribers</param>
		/// <param name="arch">archive name</param>
		/// <param name="isForce">If true remove the archive from the subscriber even
		/// if the subscriber cannot be contacted</param>
		private void delete(string user, string host, Hashtable h, string arch, bool isForce) 
		{
			Hashtable subs = (Hashtable)h.Clone();
			IDictionaryEnumerator ide = subs.GetEnumerator();
			while(ide.MoveNext())
			{
				Subscriber sub = (Subscriber)ide.Value;
				if (sub.archs.Contains(arch))
				{
					bool rc = true;
					string status = (string)sub.archs[arch];
					if (!status.Equals("pending deploy"))
						rc = undeploy(user, host, (string)ide.Key, arch, (string)archives[arch], 
							downloadURL);
					if (rc || isForce) 
					{
						sub.archs.Remove(arch);
						if (sub.state.Equals("pending unsubscribe") &&
							(sub.archs.Count == 0))
							h.Remove(ide.Key);
					}
					else
						sub.archs[arch] = "pending undeploy";
					subRep.dirty = true;
				}
			}
		}
		/// <summary>
		/// Check if the user is an administrator.
		/// </summary>
		/// <param name="user">User name</param>
		/// <returns></returns>
		public bool isAdministrator(string user) 
		{
			if (administrators.Contains(user))
				return true;
			else
				return false;
		}
		/// <summary>
		/// Check if the user is a publisher.
		/// </summary>
		/// <param name="user">User name</param>
		/// <returns></returns>
		public bool isPublisher(string user) 
		{
			if (publishers.Contains(user))
				return true;
			else
				return false;
		}
	}
}