using System;
using System.Collections;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;

namespace System.IO
{
	// Token: 0x0200011E RID: 286
	internal class InotifyWatcher : IFileWatcher
	{
		// Token: 0x06000A25 RID: 2597 RVA: 0x0001BA38 File Offset: 0x00019C38
		private InotifyWatcher()
		{
		}

		// Token: 0x06000A27 RID: 2599 RVA: 0x0001BA4C File Offset: 0x00019C4C
		public static bool GetInstance(out IFileWatcher watcher, bool gamin)
		{
			if (InotifyWatcher.failed)
			{
				watcher = null;
				return false;
			}
			if (InotifyWatcher.instance != null)
			{
				watcher = InotifyWatcher.instance;
				return true;
			}
			InotifyWatcher.FD = InotifyWatcher.GetInotifyInstance();
			if ((long)InotifyWatcher.FD == -1L)
			{
				InotifyWatcher.failed = true;
				watcher = null;
				return false;
			}
			InotifyWatcher.watches = Hashtable.Synchronized(new Hashtable());
			InotifyWatcher.requests = Hashtable.Synchronized(new Hashtable());
			InotifyWatcher.instance = new InotifyWatcher();
			watcher = InotifyWatcher.instance;
			return true;
		}

		// Token: 0x06000A28 RID: 2600 RVA: 0x0001BAD4 File Offset: 0x00019CD4
		public void StartDispatching(FileSystemWatcher fsw)
		{
			ParentInotifyData parentInotifyData;
			lock (this)
			{
				if ((long)InotifyWatcher.FD == -1L)
				{
					InotifyWatcher.FD = InotifyWatcher.GetInotifyInstance();
				}
				if (InotifyWatcher.thread == null)
				{
					InotifyWatcher.thread = new Thread(new ThreadStart(this.Monitor));
					InotifyWatcher.thread.IsBackground = true;
					InotifyWatcher.thread.Start();
				}
				parentInotifyData = (ParentInotifyData)InotifyWatcher.watches[fsw];
			}
			if (parentInotifyData == null)
			{
				InotifyData inotifyData = new InotifyData();
				inotifyData.FSW = fsw;
				inotifyData.Directory = fsw.FullPath;
				parentInotifyData = new ParentInotifyData();
				parentInotifyData.IncludeSubdirs = fsw.IncludeSubdirectories;
				parentInotifyData.Enabled = true;
				parentInotifyData.children = new ArrayList();
				parentInotifyData.data = inotifyData;
				InotifyWatcher.watches[fsw] = parentInotifyData;
				try
				{
					InotifyWatcher.StartMonitoringDirectory(inotifyData, false);
					lock (this)
					{
						InotifyWatcher.AppendRequestData(inotifyData);
						InotifyWatcher.stop = false;
					}
				}
				catch
				{
				}
			}
		}

		// Token: 0x06000A29 RID: 2601 RVA: 0x0001BC2C File Offset: 0x00019E2C
		private static void AppendRequestData(InotifyData data)
		{
			int watch = data.Watch;
			object obj = InotifyWatcher.requests[watch];
			if (obj == null)
			{
				InotifyWatcher.requests[data.Watch] = data;
			}
			else if (obj is InotifyData)
			{
				ArrayList arrayList = new ArrayList();
				arrayList.Add(obj);
				arrayList.Add(data);
				InotifyWatcher.requests[data.Watch] = arrayList;
			}
			else
			{
				ArrayList arrayList = (ArrayList)obj;
				arrayList.Add(data);
			}
		}

		// Token: 0x06000A2A RID: 2602 RVA: 0x0001BCC0 File Offset: 0x00019EC0
		private static bool RemoveRequestData(InotifyData data)
		{
			int watch = data.Watch;
			object obj = InotifyWatcher.requests[watch];
			if (obj == null)
			{
				return true;
			}
			if (obj is InotifyData)
			{
				if (obj == data)
				{
					InotifyWatcher.requests.Remove(watch);
					return true;
				}
				return false;
			}
			else
			{
				ArrayList arrayList = (ArrayList)obj;
				arrayList.Remove(data);
				if (arrayList.Count == 0)
				{
					InotifyWatcher.requests.Remove(watch);
					return true;
				}
				return false;
			}
		}

		// Token: 0x06000A2B RID: 2603 RVA: 0x0001BD40 File Offset: 0x00019F40
		private static InotifyMask GetMaskFromFilters(NotifyFilters filters)
		{
			InotifyMask inotifyMask = InotifyMask.Create | InotifyMask.Delete | InotifyMask.DeleteSelf | InotifyMask.AddMask;
			if ((filters & NotifyFilters.Attributes) != (NotifyFilters)0)
			{
				inotifyMask |= InotifyMask.Attrib;
			}
			if ((filters & NotifyFilters.Security) != (NotifyFilters)0)
			{
				inotifyMask |= InotifyMask.Attrib;
			}
			if ((filters & NotifyFilters.Size) != (NotifyFilters)0)
			{
				inotifyMask |= InotifyMask.Attrib;
				inotifyMask |= InotifyMask.Modify;
			}
			if ((filters & NotifyFilters.LastAccess) != (NotifyFilters)0)
			{
				inotifyMask |= InotifyMask.Attrib;
				inotifyMask |= InotifyMask.Access;
				inotifyMask |= InotifyMask.Modify;
			}
			if ((filters & NotifyFilters.LastWrite) != (NotifyFilters)0)
			{
				inotifyMask |= InotifyMask.Attrib;
				inotifyMask |= InotifyMask.Modify;
			}
			if ((filters & NotifyFilters.FileName) != (NotifyFilters)0)
			{
				inotifyMask |= InotifyMask.MovedFrom;
				inotifyMask |= InotifyMask.MovedTo;
			}
			if ((filters & NotifyFilters.DirectoryName) != (NotifyFilters)0)
			{
				inotifyMask |= InotifyMask.MovedFrom;
				inotifyMask |= InotifyMask.MovedTo;
			}
			return inotifyMask;
		}

		// Token: 0x06000A2C RID: 2604 RVA: 0x0001BDD0 File Offset: 0x00019FD0
		private static void StartMonitoringDirectory(InotifyData data, bool justcreated)
		{
			InotifyMask maskFromFilters = InotifyWatcher.GetMaskFromFilters(data.FSW.NotifyFilter);
			int num = InotifyWatcher.AddDirectoryWatch(InotifyWatcher.FD, data.Directory, maskFromFilters);
			if (num != -1)
			{
				FileSystemWatcher fsw = data.FSW;
				data.Watch = num;
				ParentInotifyData parentInotifyData = (ParentInotifyData)InotifyWatcher.watches[fsw];
				if (parentInotifyData.IncludeSubdirs)
				{
					foreach (string text in Directory.GetDirectories(data.Directory))
					{
						InotifyData inotifyData = new InotifyData();
						inotifyData.FSW = fsw;
						inotifyData.Directory = text;
						if (justcreated)
						{
							FileSystemWatcher fileSystemWatcher = fsw;
							lock (fileSystemWatcher)
							{
								RenamedEventArgs renamedEventArgs = null;
								if (fsw.Pattern.IsMatch(text))
								{
									fsw.DispatchEvents(FileAction.Added, text, ref renamedEventArgs);
									if (fsw.Waiting)
									{
										fsw.Waiting = false;
										global::System.Threading.Monitor.PulseAll(fsw);
									}
								}
							}
						}
						try
						{
							InotifyWatcher.StartMonitoringDirectory(inotifyData, justcreated);
							InotifyWatcher.AppendRequestData(inotifyData);
							parentInotifyData.children.Add(inotifyData);
						}
						catch
						{
						}
					}
				}
				if (justcreated)
				{
					foreach (string text2 in Directory.GetFiles(data.Directory))
					{
						FileSystemWatcher fileSystemWatcher2 = fsw;
						lock (fileSystemWatcher2)
						{
							RenamedEventArgs renamedEventArgs2 = null;
							if (fsw.Pattern.IsMatch(text2))
							{
								fsw.DispatchEvents(FileAction.Added, text2, ref renamedEventArgs2);
								fsw.DispatchEvents(FileAction.Modified, text2, ref renamedEventArgs2);
								if (fsw.Waiting)
								{
									fsw.Waiting = false;
									global::System.Threading.Monitor.PulseAll(fsw);
								}
							}
						}
					}
				}
				return;
			}
			int lastWin32Error = Marshal.GetLastWin32Error();
			if (lastWin32Error == 4)
			{
				string text3 = "(unknown)";
				try
				{
					using (StreamReader streamReader = new StreamReader("/proc/sys/fs/inotify/max_user_watches"))
					{
						text3 = streamReader.ReadLine();
					}
				}
				catch
				{
				}
				string text4 = string.Format("The per-user inotify watches limit of {0} has been reached. If you're experiencing problems with your application, increase that limit in /proc/sys/fs/inotify/max_user_watches.", text3);
				throw new global::System.ComponentModel.Win32Exception(lastWin32Error, text4);
			}
			throw new global::System.ComponentModel.Win32Exception(lastWin32Error);
		}

		// Token: 0x06000A2D RID: 2605 RVA: 0x0001C074 File Offset: 0x0001A274
		public void StopDispatching(FileSystemWatcher fsw)
		{
			lock (this)
			{
				ParentInotifyData parentInotifyData = (ParentInotifyData)InotifyWatcher.watches[fsw];
				if (parentInotifyData != null)
				{
					if (InotifyWatcher.RemoveRequestData(parentInotifyData.data))
					{
						InotifyWatcher.StopMonitoringDirectory(parentInotifyData.data);
					}
					InotifyWatcher.watches.Remove(fsw);
					if (InotifyWatcher.watches.Count == 0)
					{
						InotifyWatcher.stop = true;
						IntPtr fd = InotifyWatcher.FD;
						InotifyWatcher.FD = (IntPtr)(-1);
						InotifyWatcher.Close(fd);
					}
					if (parentInotifyData.IncludeSubdirs)
					{
						foreach (object obj in parentInotifyData.children)
						{
							InotifyData inotifyData = (InotifyData)obj;
							if (InotifyWatcher.RemoveRequestData(inotifyData))
							{
								InotifyWatcher.StopMonitoringDirectory(inotifyData);
							}
						}
					}
				}
			}
		}

		// Token: 0x06000A2E RID: 2606 RVA: 0x0001C1A0 File Offset: 0x0001A3A0
		private static void StopMonitoringDirectory(InotifyData data)
		{
			InotifyWatcher.RemoveWatch(InotifyWatcher.FD, data.Watch);
		}

		// Token: 0x06000A2F RID: 2607 RVA: 0x0001C1B4 File Offset: 0x0001A3B4
		private void Monitor()
		{
			byte[] array = new byte[4096];
			while (!InotifyWatcher.stop)
			{
				int num = InotifyWatcher.ReadFromFD(InotifyWatcher.FD, array, (IntPtr)array.Length);
				if (num != -1)
				{
					lock (this)
					{
						this.ProcessEvents(array, num);
					}
				}
			}
			lock (this)
			{
				InotifyWatcher.thread = null;
				InotifyWatcher.stop = false;
			}
		}

		// Token: 0x06000A30 RID: 2608 RVA: 0x0001C26C File Offset: 0x0001A46C
		private static int ReadEvent(byte[] source, int off, int size, out InotifyEvent evt)
		{
			evt = default(InotifyEvent);
			if (size <= 0 || off > size - 16)
			{
				return -1;
			}
			int num;
			if (BitConverter.IsLittleEndian)
			{
				evt.WatchDescriptor = (int)source[off] + ((int)source[off + 1] << 8) + ((int)source[off + 2] << 16) + ((int)source[off + 3] << 24);
				evt.Mask = (InotifyMask)((int)source[off + 4] + ((int)source[off + 5] << 8) + ((int)source[off + 6] << 16) + ((int)source[off + 7] << 24));
				num = (int)source[off + 12] + ((int)source[off + 13] << 8) + ((int)source[off + 14] << 16) + ((int)source[off + 15] << 24);
			}
			else
			{
				evt.WatchDescriptor = (int)source[off + 3] + ((int)source[off + 2] << 8) + ((int)source[off + 1] << 16) + ((int)source[off] << 24);
				evt.Mask = (InotifyMask)((int)source[off + 7] + ((int)source[off + 6] << 8) + ((int)source[off + 5] << 16) + ((int)source[off + 4] << 24));
				num = (int)source[off + 15] + ((int)source[off + 14] << 8) + ((int)source[off + 13] << 16) + ((int)source[off + 12] << 24);
			}
			if (num > 0)
			{
				if (off > size - 16 - num)
				{
					return -1;
				}
				string @string = Encoding.UTF8.GetString(source, off + 16, num);
				evt.Name = @string.Trim(new char[1]);
			}
			else
			{
				evt.Name = null;
			}
			return 16 + num;
		}

		// Token: 0x06000A31 RID: 2609 RVA: 0x0001C3C4 File Offset: 0x0001A5C4
		private static IEnumerable GetEnumerator(object source)
		{
			if (source == null)
			{
				yield break;
			}
			if (source is InotifyData)
			{
				yield return source;
			}
			if (source is ArrayList)
			{
				ArrayList list = (ArrayList)source;
				for (int i = 0; i < list.Count; i++)
				{
					yield return list[i];
				}
			}
			yield break;
		}

		// Token: 0x06000A32 RID: 2610 RVA: 0x0001C3F0 File Offset: 0x0001A5F0
		private void ProcessEvents(byte[] buffer, int length)
		{
			ArrayList arrayList = null;
			int num = 0;
			RenamedEventArgs renamedEventArgs = null;
			while (length > num)
			{
				InotifyEvent inotifyEvent;
				int num2 = InotifyWatcher.ReadEvent(buffer, num, length, out inotifyEvent);
				if (num2 <= 0)
				{
					break;
				}
				num += num2;
				InotifyMask inotifyMask = inotifyEvent.Mask;
				bool flag = (inotifyMask & InotifyMask.Directory) != (InotifyMask)0U;
				inotifyMask &= InotifyWatcher.Interesting;
				if (inotifyMask != (InotifyMask)0U)
				{
					foreach (object obj in InotifyWatcher.GetEnumerator(InotifyWatcher.requests[inotifyEvent.WatchDescriptor]))
					{
						InotifyData inotifyData = (InotifyData)obj;
						ParentInotifyData parentInotifyData = (ParentInotifyData)InotifyWatcher.watches[inotifyData.FSW];
						if (inotifyData != null && parentInotifyData.Enabled)
						{
							string directory = inotifyData.Directory;
							string text = inotifyEvent.Name;
							if (text == null)
							{
								text = directory;
							}
							FileSystemWatcher fsw = inotifyData.FSW;
							FileAction fileAction = (FileAction)0;
							if ((inotifyMask & (InotifyMask.Modify | InotifyMask.Attrib)) != (InotifyMask)0U)
							{
								fileAction = FileAction.Modified;
							}
							else if ((inotifyMask & InotifyMask.Create) != (InotifyMask)0U)
							{
								fileAction = FileAction.Added;
							}
							else if ((inotifyMask & InotifyMask.Delete) != (InotifyMask)0U)
							{
								fileAction = FileAction.Removed;
							}
							else if ((inotifyMask & InotifyMask.DeleteSelf) != (InotifyMask)0U)
							{
								if (inotifyData.Watch != parentInotifyData.data.Watch)
								{
									continue;
								}
								fileAction = FileAction.Removed;
							}
							else
							{
								if ((inotifyMask & InotifyMask.MoveSelf) != (InotifyMask)0U)
								{
									continue;
								}
								if ((inotifyMask & InotifyMask.MovedFrom) != (InotifyMask)0U)
								{
									InotifyEvent inotifyEvent2;
									int num3 = InotifyWatcher.ReadEvent(buffer, num, length, out inotifyEvent2);
									if (num3 == -1 || (inotifyEvent2.Mask & InotifyMask.MovedTo) == (InotifyMask)0U || inotifyEvent.WatchDescriptor != inotifyEvent2.WatchDescriptor)
									{
										fileAction = FileAction.Removed;
									}
									else
									{
										num += num3;
										fileAction = FileAction.RenamedNewName;
										renamedEventArgs = new RenamedEventArgs(WatcherChangeTypes.Renamed, inotifyData.Directory, inotifyEvent2.Name, inotifyEvent.Name);
										if (inotifyEvent.Name != inotifyData.Directory && !fsw.Pattern.IsMatch(inotifyEvent.Name))
										{
											text = inotifyEvent2.Name;
										}
									}
								}
								else if ((inotifyMask & InotifyMask.MovedTo) != (InotifyMask)0U)
								{
									fileAction = FileAction.Added;
								}
							}
							if (fsw.IncludeSubdirectories)
							{
								string fullPath = fsw.FullPath;
								string text2 = inotifyData.Directory;
								if (text2 != fullPath)
								{
									int length2 = fullPath.Length;
									int num4 = 1;
									if (length2 > 1 && fullPath[length2 - 1] == Path.DirectorySeparatorChar)
									{
										num4 = 0;
									}
									string text3 = text2.Substring(fullPath.Length + num4);
									text2 = Path.Combine(text2, text);
									text = Path.Combine(text3, text);
								}
								else
								{
									text2 = Path.Combine(fullPath, text);
								}
								if (fileAction == FileAction.Added && flag)
								{
									if (arrayList == null)
									{
										arrayList = new ArrayList(2);
									}
									arrayList.Add(new InotifyData
									{
										FSW = fsw,
										Directory = text2
									});
								}
								if (fileAction == FileAction.RenamedNewName && flag)
								{
									string oldFullPath = renamedEventArgs.OldFullPath;
									string fullPath2 = renamedEventArgs.FullPath;
									int length3 = oldFullPath.Length;
									foreach (object obj2 in parentInotifyData.children)
									{
										InotifyData inotifyData2 = (InotifyData)obj2;
										if (inotifyData2.Directory.StartsWith(oldFullPath, StringComparison.Ordinal))
										{
											inotifyData2.Directory = fullPath2 + inotifyData2.Directory.Substring(length3);
										}
									}
								}
							}
							if (fileAction == FileAction.Removed && text == inotifyData.Directory)
							{
								int num5 = parentInotifyData.children.IndexOf(inotifyData);
								if (num5 != -1)
								{
									parentInotifyData.children.RemoveAt(num5);
									if (!fsw.Pattern.IsMatch(Path.GetFileName(text)))
									{
										continue;
									}
								}
							}
							if (!(text != inotifyData.Directory) || fsw.Pattern.IsMatch(Path.GetFileName(text)))
							{
								FileSystemWatcher fileSystemWatcher = fsw;
								lock (fileSystemWatcher)
								{
									fsw.DispatchEvents(fileAction, text, ref renamedEventArgs);
									if (fileAction == FileAction.RenamedNewName)
									{
										renamedEventArgs = null;
									}
									if (fsw.Waiting)
									{
										fsw.Waiting = false;
										global::System.Threading.Monitor.PulseAll(fsw);
									}
								}
							}
						}
					}
				}
			}
			if (arrayList != null)
			{
				foreach (object obj3 in arrayList)
				{
					InotifyData inotifyData3 = (InotifyData)obj3;
					try
					{
						InotifyWatcher.StartMonitoringDirectory(inotifyData3, true);
						InotifyWatcher.AppendRequestData(inotifyData3);
						((ParentInotifyData)InotifyWatcher.watches[inotifyData3.FSW]).children.Add(inotifyData3);
					}
					catch
					{
					}
				}
				arrayList.Clear();
			}
		}

		// Token: 0x06000A33 RID: 2611 RVA: 0x0001C99C File Offset: 0x0001AB9C
		private static int AddDirectoryWatch(IntPtr fd, string directory, InotifyMask mask)
		{
			mask |= InotifyMask.Directory;
			return InotifyWatcher.AddWatch(fd, directory, mask);
		}

		// Token: 0x06000A34 RID: 2612
		[DllImport("libc", EntryPoint = "close")]
		internal static extern int Close(IntPtr fd);

		// Token: 0x06000A35 RID: 2613
		[DllImport("libc", EntryPoint = "read")]
		private static extern int ReadFromFD(IntPtr fd, byte[] buffer, IntPtr length);

		// Token: 0x06000A36 RID: 2614
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern IntPtr GetInotifyInstance();

		// Token: 0x06000A37 RID: 2615
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern int AddWatch(IntPtr fd, string name, InotifyMask mask);

		// Token: 0x06000A38 RID: 2616
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern IntPtr RemoveWatch(IntPtr fd, int wd);

		// Token: 0x0400039B RID: 923
		private static bool failed;

		// Token: 0x0400039C RID: 924
		private static InotifyWatcher instance;

		// Token: 0x0400039D RID: 925
		private static Hashtable watches;

		// Token: 0x0400039E RID: 926
		private static Hashtable requests;

		// Token: 0x0400039F RID: 927
		private static IntPtr FD;

		// Token: 0x040003A0 RID: 928
		private static Thread thread;

		// Token: 0x040003A1 RID: 929
		private static bool stop;

		// Token: 0x040003A2 RID: 930
		private static InotifyMask Interesting = InotifyMask.Modify | InotifyMask.Attrib | InotifyMask.MovedFrom | InotifyMask.MovedTo | InotifyMask.Create | InotifyMask.Delete | InotifyMask.DeleteSelf;
	}
}