using System;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Diagnostics.Eventing.Reader;
using System.IO;
using JetBrains.Annotations;

namespace Microsoft.Win32.TaskScheduler
{
	/// <summary>
	/// Information about the task event.
	/// </summary>
	[PublicAPI]
	public class TaskEventArgs : EventArgs
	{
		private readonly TaskService taskService;

		internal TaskEventArgs([NotNull] TaskEvent evt, TaskService ts = null)
		{
			TaskEvent = evt;
			TaskPath = evt.TaskPath;
			taskService = ts;
		}

		/// <summary>
		/// If possible, gets the task associated with this event.
		/// </summary>
		/// <value>
		/// The task or <c>null</c> if unable to retrieve.
		/// </value>
		public Task Task
		{
			get { try { return taskService?.GetTask(TaskPath); } catch { return null; } }
		}

		/// <summary>
		/// Gets the <see cref="TaskEvent"/>.
		/// </summary>
		/// <value>
		/// The TaskEvent.
		/// </value>
		[NotNull]
		public TaskEvent TaskEvent { get; }

		/// <summary>
		/// Gets the task name.
		/// </summary>
		/// <value>
		/// The task name.
		/// </value>
		public string TaskName => Path.GetFileName(TaskPath);

		/// <summary>
		/// Gets the task path.
		/// </summary>
		/// <value>
		/// The task path.
		/// </value>
		public string TaskPath { get; }
	}

	/// <summary>
	/// Watches system events related to tasks and issues a <see cref="TaskEventWatcher.EventRecorded"/> event when the filtered conditions are met.
	/// <note>Only available for Task Scheduler 2.0 on Windows Vista or Windows Server 2003 and later.</note>
	/// </summary>
	/// <remarks>Sometimes, a developer will need to know about events as they occur. In this case, they can use the TaskEventWatcher component that enables the developer to watch a task, a folder, or the entire system for filtered events.</remarks>
	/// <example>
	/// <para>Below is information on how to watch a folder for all task events. For a complete example, look at this sample project: TestTaskWatcher.zip</para>
	/// <code lang="cs"><![CDATA[
	/// private TaskEventWatcher watcher;
	/// 
	/// // Create and configure a new task watcher for the task folder
	/// private void SetupWatcher(TaskFolder tf)
	/// {
	/// 	if (tf != null)
	/// 	{
	/// 		// Set up a watch over the supplied task folder.
	/// 		watcher = new TaskEventWatcher(tf);
	/// 
	/// 		// Assign a SynchronizingObject to a local UI class to synchronize the events in this thread.
	/// 		watcher.SynchronizingObject = this;
	/// 
	/// 		// Only watch for tasks that start with my company name
	/// 		watcher.Filter.TaskName = "MyCo*";
	/// 
	/// 		// Only watch for task events that are informational
	/// 		watcher.Filter.EventLevels = new int[]
	/// 		   { 0 /* StandardEventLevel.LogAlways */, (int)StandardEventLevel.Informational };
	/// 
	/// 		// Assign an event handler for when events are recorded
	/// 		watcher.EventRecorded += Watcher_EventRecorded;
	/// 
	/// 		// Start watching the folder by enabling the watcher
	/// 		watcher.Enabled = true;
	/// 	}
	/// }
	/// 
	/// // Cleanup and release the task watcher
	/// private void TearDownWatcher()
	/// {
	/// 	if (watcher != null)
	/// 	{
	/// 		// Unhook the event
	/// 		watcher.EventRecorded -= Watcher_EventRecorded;
	/// 		// Stop watching for events
	/// 		watcher.Enabled = false;
	/// 		// Initiate garbage collection for the watcher
	/// 		watcher = null;
	/// 	}
	/// }
	/// 
	/// // Update ListView instance when task events occur
	/// private void Watcher_EventRecorded(object sender, TaskEventArgs e)
	/// {
	/// 	int idx = IndexOfTask(e.TaskName);
	/// 
	/// 	// If event is for a task we already have in the list...
	/// 	if (idx != -1)
	/// 	{
	/// 		// If event indicates that task has been deleted, remove it from the list
	/// 		if (e.TaskEvent.StandardEventId == StandardTaskEventId.TaskDeleted)
	/// 		{
	/// 			listView1.Items.RemoveAt(idx);
	/// 		}
	/// 
	/// 		// If event is anything else, it most likely represents a change,
	/// 		// so update the item using information supplied through the
	/// 		// TaskEventArgs instance.
	/// 		else
	/// 		{
	/// 			var lvi = listView1.Items[idx];
	/// 			lvi.Subitems[0].Text = e.TaskName;
	/// 			lvi.Subitems[1].Text = e.Task.State.ToString();
	/// 			lvi.Subitems[2].Text = GetNextRunTimeString(e.Task);
	/// 		}
	/// 	}
	/// 
	/// 	// If event is for a task we don't have in our list, add it
	/// 	else
	/// 	{
	/// 		var lvi = new ListViewItem(new string[] { e.TaskName,
	/// 	 e.Task.State.ToString(), GetNextRunTimeString(e.Task) });
	/// 		listView1.Items.Add(lvi);
	/// 		listView1.Sort();
	/// 	}
	/// }
	/// 
	/// // Get the next run time for a task
	/// private string GetNextRunTimeString(Task t)
	/// {
	/// 	if (t.State == TaskState.Disabled || t.NextRunTime < DateTime.Now)
	/// 		return string.Empty;
	/// 	return t.NextRunTime.ToString("G");
	/// }
	/// ]]></code></example>
	[DefaultEvent(nameof(EventRecorded)), DefaultProperty(nameof(Folder))]
#if DESIGNER
	[Designer(typeof(Design.TaskEventWatcherDesigner))]
#endif
	[ToolboxItem(true), Serializable]
	[PublicAPI]
	public class TaskEventWatcher : Component, ISupportInitialize
	{
		private const string root = "\\";
		private const string star = "*";

		private static readonly TimeSpan MaxV1EventLapse = TimeSpan.FromSeconds(1);

		private bool disposed;
		private bool enabled;
		private string folder = root;
		private bool includeSubfolders;
		private bool initializing;
		private StandardTaskEventId lastId = 0;
		private DateTime lastIdTime = DateTime.MinValue;
		private TaskService ts;
		private FileSystemWatcher v1Watcher;
		private EventLogWatcher watcher;
		private ISynchronizeInvoke synchronizingObject;

		/// <summary>
		/// Initializes a new instance of the <see cref="TaskEventWatcher"/> class. If other
		/// properties are not set, this will watch for all events for all tasks on the local machine.
		/// </summary>
		public TaskEventWatcher() : this(TaskService.Instance)
		{
		}

		/// <summary>
		/// Initializes a new instance of the <see cref="TaskEventWatcher" /> class watching only
		/// those events for the task with the provided path on the local machine.
		/// </summary>
		/// <param name="taskPath">The full path (folders and name) of the task to watch.</param>
		/// <param name="taskService">The task service.</param>
		/// <exception cref="System.ArgumentException">$Invalid task name: {taskPath}</exception>
		public TaskEventWatcher(string taskPath, TaskService taskService = null) : this(taskService ?? TaskService.Instance)
		{
			InitTask(taskPath);
		}

		/// <summary>
		/// Initializes a new instance of the <see cref="TaskEventWatcher"/> class watching only
		/// those events for the specified task.
		/// </summary>
		/// <param name="task">The task to watch.</param>
		/// <exception cref="ArgumentNullException">Occurs if the <paramref name="task"/> is <c>null</c>.</exception>
		public TaskEventWatcher([NotNull] Task task) : this(task?.TaskService)
		{
			if (task == null)
				throw new ArgumentNullException(nameof(task));
			InitTask(task);
		}

		/// <summary>
		/// Initializes a new instance of the <see cref="TaskEventWatcher"/> class watching only those events for
		/// the tasks whose name matches the <paramref name="taskFilter"/> in the specified <paramref name="taskFolder"/>
		/// and optionally all subfolders.
		/// </summary>
		/// <param name="taskFolder">The task folder to watch.</param>
		/// <param name="taskFilter">The filter for task names using standard file system wildcards. Use "*" to include all tasks.</param>
		/// <param name="includeSubfolders">if set to <c>true</c> include events from tasks subfolders.</param>
		/// <exception cref="ArgumentNullException">Occurs if the <paramref name="taskFolder"/> is <c>null</c>.</exception>
		public TaskEventWatcher([NotNull] TaskFolder taskFolder, string taskFilter = "*", bool includeSubfolders = false) : this(taskFolder?.TaskService)
		{
			if (taskFolder == null)
				throw new ArgumentNullException(nameof(taskFolder));
			InitTask(taskFolder, taskFilter, includeSubfolders);
		}

		/// <summary>
		/// Initializes a new instance of the <see cref="TaskEventWatcher" /> class.
		/// </summary>
		/// <param name="folder">The task folder to watch.</param>
		/// <param name="taskFilter">The filter for task names using standard file system wildcards. Use "*" to include all tasks.</param>
		/// <param name="includeSubfolders">if set to <c>true</c> include events from tasks subfolders.</param>
		/// <param name="taskService">The task service.</param>
		public TaskEventWatcher(string folder, string taskFilter, bool includeSubfolders, TaskService taskService = null) : this(taskService ?? TaskService.Instance)
		{
			InitTask(folder, taskFilter, includeSubfolders);
		}

		/// <summary>
		/// Initializes a new instance of the <see cref="TaskEventWatcher" /> class on a remote machine.
		/// </summary>
		/// <param name="machineName">Name of the remote machine.</param>
		/// <param name="taskPath">The task path.</param>
		/// <param name="domain">The domain of the user account.</param>
		/// <param name="user">The user name with permissions on the remote machine.</param>
		/// <param name="password">The password for the user.</param>
		public TaskEventWatcher(string machineName, string taskPath, string domain = null, string user = null, string password = null) : this(new TaskService(machineName, user, domain, password))
		{
			InitTask(taskPath);
		}

		/// <summary>
		/// Initializes a new instance of the <see cref="TaskEventWatcher" /> class on a remote machine.
		/// </summary>
		/// <param name="machineName">Name of the remote machine.</param>
		/// <param name="folder">The task folder to watch.</param>
		/// <param name="taskFilter">The filter for task names using standard file system wildcards. Use "*" to include all tasks.</param>
		/// <param name="includeSubfolders">if set to <c>true</c> include events from tasks subfolders.</param>
		/// <param name="domain">The domain of the user account.</param>
		/// <param name="user">The user name with permissions on the remote machine.</param>
		/// <param name="password">The password for the user.</param>
		public TaskEventWatcher(string machineName, string folder, string taskFilter = "*", bool includeSubfolders = false, string domain = null, string user = null, string password = null) : this(new TaskService(machineName, user, domain, password))
		{
			InitTask(folder, taskFilter, includeSubfolders);
		}

		private TaskEventWatcher(TaskService ts)
		{
			TaskService = ts;
			Filter = new EventFilter(this);
		}

		/// <summary>
		/// Occurs when a task or the task engine records an event.
		/// </summary>
		[Category("Action"), Description("Event recorded by a task or the task engine.")]
		public event EventHandler<TaskEventArgs> EventRecorded;

		/// <summary>
		/// Gets or sets a value indicating whether the component is enabled.
		/// </summary>
		/// <value>
		///   <c>true</c> if enabled; otherwise, <c>false</c>.
		/// </value>
		[DefaultValue(false), Category("Behavior"), Description("Indicates whether the component is enabled.")]
		public bool Enabled
		{
			get { return enabled; }
			set
			{
				if (enabled != value)
				{
					System.Diagnostics.Debug.WriteLine($"TaskEventWather: Set {nameof(Enabled)} = {value}");
					enabled = value;
					if (!IsSuspended())
					{
						if (enabled)
							StartRaisingEvents();
						else
							StopRaisingEvents();
					}
				}
			}
		}

		/// <summary>
		/// Gets the filter for this <see cref="TaskEventWatcher"/>.
		/// </summary>
		/// <value>
		/// The filter.
		/// </value>
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content), Category("Behavior"), Description("Indicates the filter for the watcher.")]
		public EventFilter Filter { get; }

		/// <summary>
		/// Gets or sets the folder to watch.
		/// </summary>
		/// <value>
		/// The folder path to watch. This value should include the leading "\" to indicate the root folder.
		/// </value>
		/// <exception cref="System.ArgumentException">Thrown if the folder specified does not exist or contains invalid characters.</exception>
		[DefaultValue(root), Category("Behavior"), Description("Indicates the folder to watch.")]
		public string Folder
		{
			get { return folder; }
			set
			{
				if (string.IsNullOrEmpty(value))
					value = root;
				if (!value.EndsWith("\\"))
					value += "\\";
				if (string.Compare(folder, value, StringComparison.OrdinalIgnoreCase) == 0) return;
				if ((DesignMode && (value.IndexOfAny(new[] { '*', '?' }) != -1 || value.IndexOfAny(Path.GetInvalidPathChars()) != -1)) || (TaskService.GetFolder(value == root ? value : value.TrimEnd('\\')) == null))
					throw new ArgumentException($"Invalid folder name: {value}");
				folder = value;
			}
		}

		/// <summary>
		/// Gets or sets a value indicating whether to include events from subfolders when the
		/// <see cref="Folder"/> property is set. If the <see cref="TaskEventWatcher.EventFilter.TaskName"/> property is set,
		/// this property is ignored.
		/// </summary>
		/// <value><c>true</c> if include events from subfolders; otherwise, <c>false</c>.</value>
		[DefaultValue(false), Category("Behavior"), Description("Indicates whether to include events from subfolders.")]
		public bool IncludeSubfolders
		{
			get { return includeSubfolders; }
			set
			{
				if (includeSubfolders == value) return;
				includeSubfolders = value;
				Restart();
			}
		}

		/// <summary>
		/// Gets or sets the synchronizing object.
		/// </summary>
		/// <value>
		/// The synchronizing object.
		/// </value>
		[Browsable(false), DefaultValue(null)]
		public ISynchronizeInvoke SynchronizingObject
		{
			get
			{
				if (synchronizingObject == null && DesignMode)
				{
					var so = ((IDesignerHost)GetService(typeof(IDesignerHost)))?.RootComponent as ISynchronizeInvoke;
					if (so != null)
						synchronizingObject = so;
				}
				return synchronizingObject;
			}
			set { synchronizingObject = value; }
		}

		/// <summary>
		/// Gets or sets the name of the computer that is running the Task Scheduler service that the user is connected to.
		/// </summary>
		[Category("Connection"), Description("The name of the computer to connect to."), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		public string TargetServer
		{
			get { return TaskService.TargetServer; }
			set
			{
				if (value == null || value.Trim() == string.Empty) value = null;
				if (string.Compare(value, TaskService.TargetServer, StringComparison.OrdinalIgnoreCase) == 0) return;
				TaskService.TargetServer = value;
				Restart();
			}
		}

		/// <summary>
		/// Gets or sets the <see cref="TaskService"/> instance associated with this event watcher. Setting this value
		/// will override any values set for <see cref="TargetServer"/>, <see cref="UserAccountDomain"/>,
		/// <see cref="UserName"/>, and <see cref="UserPassword"/> and set them to those values in the supplied
		/// <see cref="TaskService"/> instance.
		/// </summary>
		/// <value>The TaskService.</value>
		[Category("Data"), Description("The TaskService for this event watcher.")]
		public TaskService TaskService
		{
			get { return ts; }
			set { ts = value; Restart(); }
		}

		/// <summary>
		/// Gets or sets the user account domain to be used when connecting to the <see cref="TargetServer"/>.
		/// </summary>
		/// <value>The user account domain.</value>
		[Category("Connection"), Description("The user account domain to be used when connecting."), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		public string UserAccountDomain
		{
			get { return TaskService.UserAccountDomain; }
			set
			{
				if (value == null || value.Trim() == string.Empty) value = null;
				if (string.Compare(value, TaskService.UserAccountDomain, StringComparison.OrdinalIgnoreCase) == 0) return;
				TaskService.UserAccountDomain = value;
				Restart();
			}
		}

		/// <summary>
		/// Gets or sets the user name to be used when connecting to the <see cref="TargetServer"/>.
		/// </summary>
		/// <value>The user name.</value>
		[Category("Connection"), Description("The user name to be used when connecting."), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		public string UserName
		{
			get { return TaskService.UserName; }
			set
			{
				if (value == null || value.Trim() == string.Empty) value = null;
				if (string.Compare(value, TaskService.UserName, StringComparison.OrdinalIgnoreCase) == 0) return;
				TaskService.UserName = value;
				Restart();
			}
		}

		/// <summary>
		/// Gets or sets the user password to be used when connecting to the <see cref="TargetServer"/>.
		/// </summary>
		/// <value>The user password.</value>
		[Category("Connection"), Description("The user password to be used when connecting."), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		public string UserPassword
		{
			get { return TaskService.UserPassword; }
			set
			{
				if (value == null || value.Trim() == string.Empty) value = null;
				if (string.Compare(value, TaskService.UserPassword, StringComparison.OrdinalIgnoreCase) == 0) return;
				TaskService.UserPassword = value;
				Restart();
			}
		}

		/// <summary>
		/// Gets a value indicating if watching is available.
		/// </summary>
		[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		private bool IsHandleInvalid => IsV1 ? v1Watcher == null : watcher == null;

		private static bool IsV1 => Environment.OSVersion.Version.Major < 6;

		/// <summary>
		/// Signals the object that initialization is starting.
		/// </summary>
		public void BeginInit()
		{
			System.Diagnostics.Debug.WriteLine($"TaskEventWather: {nameof(BeginInit)}");
			initializing = true;
			var localEnabled = enabled;
			StopRaisingEvents();
			enabled = localEnabled;
			TaskService.BeginInit();
		}

		/// <summary>
		/// Signals the object that initialization is complete.
		/// </summary>
		public void EndInit()
		{
			System.Diagnostics.Debug.WriteLine($"TaskEventWather: {nameof(EndInit)}");
			initializing = false;
			TaskService.EndInit();
			if (enabled)
				StartRaisingEvents();
		}

		/// <summary>
		/// Releases the unmanaged resources used by the FileSystemWatcher and optionally releases the managed resources.
		/// </summary>
		/// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
		protected override void Dispose(bool disposing)
		{
			try
			{
				if (disposing)
				{
					StopRaisingEvents();
					TaskService = null;
				}
				else
				{
					StopListening();
				}
			}
			finally
			{
				disposed = true;
				base.Dispose(disposing);
			}
		}

		/// <summary>
		/// Fires the <see cref="EventRecorded"/> event.
		/// </summary>
		/// <param name="sender">The sender.</param>
		/// <param name="e">The <see cref="Microsoft.Win32.TaskScheduler.TaskEventArgs" /> instance containing the event data.</param>
		protected virtual void OnEventRecorded(object sender, TaskEventArgs e)
		{
			var h = EventRecorded;
			if (h == null) return;
			if (SynchronizingObject != null && SynchronizingObject.InvokeRequired)
				SynchronizingObject.BeginInvoke(h, new object[] { this, e });
			else
				h(sender, e);
		}

		private void InitTask([NotNull] Task task)
		{
			Filter.TaskName = task.Name;
			Folder = task.Folder.Path;
		}

		private void InitTask(TaskFolder taskFolder, string taskFilter, bool includeSubfolders)
		{
			this.includeSubfolders = includeSubfolders;
			Filter.TaskName = taskFilter;
			Folder = taskFolder?.Path;
		}

		private void InitTask(string taskFolder, string taskFilter, bool includeSubfolders)
		{
			this.includeSubfolders = includeSubfolders;
			Filter.TaskName = taskFilter;
			Folder = taskFolder;
		}

		private void InitTask(string taskPath)
		{
			Filter.TaskName = Path.GetFileNameWithoutExtension(taskPath);
			Folder = Path.GetDirectoryName(taskPath);
		}

		private bool IsSuspended() => initializing || DesignMode;

		private void ReleaseWatcher()
		{
			if (IsV1)
			{
				if (v1Watcher == null) return;
				v1Watcher.EnableRaisingEvents = false;
				v1Watcher.Changed -= Watcher_DirectoryChanged;
				v1Watcher.Created -= Watcher_DirectoryChanged;
				v1Watcher.Deleted -= Watcher_DirectoryChanged;
				v1Watcher.Renamed -= Watcher_DirectoryChanged;
				v1Watcher = null;
			}
			else
			{
				if (watcher == null) return;
				watcher.Enabled = false;
				watcher.EventRecordWritten -= Watcher_EventRecordWritten;
				watcher = null;
			}
		}

		private void ResetTaskService() { ts = TaskService.Instance; }

		private void Restart()
		{
			if (IsSuspended() || !enabled) return;
			System.Diagnostics.Debug.WriteLine($"TaskEventWather: {nameof(Restart)}");
			StopRaisingEvents();
			StartRaisingEvents();
		}

		private void SetupWatcher()
		{
			ReleaseWatcher();
			string taskPath = null;
			if (Filter.Wildcard == null)
				taskPath = Path.Combine(folder, Filter.TaskName);
			if (IsV1)
			{
				var di = new DirectoryInfo(Environment.GetFolderPath(Environment.SpecialFolder.System));
				string dir = di.Parent != null ? Path.Combine(di.Parent.FullName, "Tasks") : "Tasks";
				v1Watcher = new FileSystemWatcher(dir, "*.job") { NotifyFilter = NotifyFilters.Size | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.Attributes };
				v1Watcher.Changed += Watcher_DirectoryChanged;
				v1Watcher.Created += Watcher_DirectoryChanged;
				v1Watcher.Deleted += Watcher_DirectoryChanged;
				v1Watcher.Renamed += Watcher_DirectoryChanged;
			}
			else
			{
				var log = new TaskEventLog(taskPath, Filter.EventIds, Filter.EventLevels, DateTime.UtcNow, TargetServer, UserAccountDomain, UserName, UserPassword);
				log.Query.ReverseDirection = false;
				watcher = new EventLogWatcher(log.Query);
				watcher.EventRecordWritten += Watcher_EventRecordWritten;
			}
		}

		private bool ShouldSerializeFilter() => Filter.ShouldSerialize();

		private bool ShouldSerializeTaskService() => !Equals(TaskService, TaskService.Instance);

		private void StartRaisingEvents()
		{
			if (disposed)
				throw new ObjectDisposedException(GetType().Name);

			if (IsSuspended()) return;
			System.Diagnostics.Debug.WriteLine($"TaskEventWather: {nameof(StartRaisingEvents)}");
			enabled = true;
			SetupWatcher();
			if (IsV1)
				try { v1Watcher.EnableRaisingEvents = true; } catch { }
			else
				try { watcher.Enabled = true; } catch { }
		}

		private void StopListening()
		{
			enabled = false;
			ReleaseWatcher();
		}

		private void StopRaisingEvents()
		{
			System.Diagnostics.Debug.WriteLine($"TaskEventWather: {nameof(StopRaisingEvents)}");
			if (IsSuspended())
				enabled = false;
			else if (!IsHandleInvalid)
				StopListening();
		}

		private void Watcher_DirectoryChanged(object sender, FileSystemEventArgs e)
		{
			StandardTaskEventId id = StandardTaskEventId.TaskUpdated;
			if (e.ChangeType == WatcherChangeTypes.Deleted)
				id = StandardTaskEventId.TaskDeleted;
			else if (e.ChangeType == WatcherChangeTypes.Created)
				id = StandardTaskEventId.JobRegistered;
			if (lastId == id && DateTime.Now.Subtract(lastIdTime) <= MaxV1EventLapse) return;
			OnEventRecorded(this, new TaskEventArgs(new TaskEvent(Path.Combine("\\", e.Name.Replace(".job", "")), id, DateTime.Now), TaskService));
			lastId = id;
			lastIdTime = DateTime.Now;
		}

		private void Watcher_EventRecordWritten(object sender, EventRecordWrittenEventArgs e)
		{
			try
			{
				var taskEvent = new TaskEvent(e.EventRecord);
				System.Diagnostics.Debug.WriteLine("Task event: " + taskEvent.ToString());

				// Get the task name and folder
				if (string.IsNullOrEmpty(taskEvent.TaskPath)) return;
				int cpos = taskEvent.TaskPath.LastIndexOf('\\');
				string name = taskEvent.TaskPath.Substring(cpos + 1);
				string fld = taskEvent.TaskPath.Substring(0, cpos + 1);

				// Check folder and name filters
				if (!string.IsNullOrEmpty(Filter.TaskName) && string.Compare(Filter.TaskName, taskEvent.TaskPath, StringComparison.OrdinalIgnoreCase) != 0)
				{
					if (Filter.Wildcard != null && !Filter.Wildcard.IsMatch(name))
						return;
					if (IncludeSubfolders && !fld.StartsWith(folder, StringComparison.OrdinalIgnoreCase))
						return;
					if (!IncludeSubfolders && string.Compare(folder, fld, StringComparison.OrdinalIgnoreCase) != 0)
						return;
				}

				OnEventRecorded(this, new TaskEventArgs(taskEvent, TaskService));
			}
			catch (Exception ex)
			{
				System.Diagnostics.Debug.WriteLine($"{nameof(Watcher_EventRecordWritten)} has failed. Error: {ex.ToString()}");
			}
		}

		/// <summary>
		/// Holds filter information for a <see cref="TaskEventWatcher"/>.
		/// </summary>
		[TypeConverter(typeof(ExpandableObjectConverter)), Serializable]
		[PublicAPI]
		public class EventFilter
		{
			private string filter = star;
			private int[] ids;
			private int[] levels;
			private readonly TaskEventWatcher parent;

			internal EventFilter([NotNull] TaskEventWatcher parent)
			{
				this.parent = parent;
			}

			/// <summary>
			/// Gets or sets an optional array of event identifiers to use when filtering those events that will fire a <see cref="TaskEventWatcher.EventRecorded"/> event.
			/// </summary>
			/// <value>
			/// The array of event identifier filters. All know task event identifiers are declared in the <see cref="StandardTaskEventId"/> enumeration.
			/// </value>
			[DefaultValue(null), Category("Filter"), Description("An array of event identifiers to use when filtering.")]
			public int[] EventIds
			{
				get { return ids; }
				set
				{
					if (ids != value)
					{
						ids = value;
						parent.Restart();
					}
				}
			}

			/// <summary>
			/// Gets or sets an optional array of event levels to use when filtering those events that will fire a <see cref="TaskEventWatcher.EventRecorded"/> event.
			/// </summary>
			/// <value>
			/// The array of event levels. While event providers can define custom levels, most will use integers defined in the System.Diagnostics.Eventing.Reader.StandardEventLevel enumeration.
			/// </value>
			[DefaultValue(null), Category("Filter"), Description("An array of event levels to use when filtering.")]
			public int[] EventLevels
			{
				get { return levels; }
				set
				{
					if (levels != value)
					{
						levels = value;
						parent.Restart();
					}
				}
			}

			/// <summary>
			/// Gets or sets the task name, which can utilize wildcards, to look for when watching a folder.
			/// </summary>
			/// <value>A task name or wildcard.</value>
			[DefaultValue(star), Category("Filter"), Description("A task name, which can utilize wildcards, for filtering.")]
			public string TaskName
			{
				get { return filter; }
				set
				{
					if (string.IsNullOrEmpty(value))
						value = star;
					if (string.Compare(filter, value, StringComparison.OrdinalIgnoreCase) != 0)
					{
						filter = value;
						Wildcard = (value.IndexOfAny(new[] { '?', '*' }) == -1) ? null : new Wildcard(value);
						parent.Restart();
					}
				}
			}

			internal Wildcard Wildcard { get; private set; } = new Wildcard(star);

			/// <summary>
			/// Returns a <see cref="System.String" /> that represents this instance.
			/// </summary>
			/// <returns>
			/// A <see cref="System.String" /> that represents this instance.
			/// </returns>
			public override string ToString() => filter + (levels == null ? "" : " +levels") + (ids == null ? "" : " +id's");

			internal bool ShouldSerialize() => ids != null || levels != null || filter != star;
		}
	}

#if DESIGNER
	namespace Design
	{
		internal class TaskEventWatcherDesigner : ComponentDesigner
		{
			public override void InitializeNewComponent(IDictionary defaultValues)
			{
				base.InitializeNewComponent(defaultValues);
				var refs = GetService<IReferenceService>();
				var tsColl = refs?.GetReferences(typeof(TaskService));
				System.Diagnostics.Debug.Assert(refs != null && tsColl != null && tsColl.Length > 0, "Designer couldn't find host, reference service, or existing TaskService.");
				if (tsColl != null && tsColl.Length > 0)
				{
					TaskEventWatcher tsComp = Component as TaskEventWatcher;
					TaskService ts = tsColl[0] as TaskService;
					if (tsComp != null)
						tsComp.TaskService = ts;
				}
			}

			protected virtual T GetService<T>() => (T)Component?.Site?.GetService(typeof(T));
		}
	}
#endif
}