using System;

namespace System.IO
{
	// Token: 0x0200012A RID: 298
	internal class SearchPattern2
	{
		// Token: 0x06000A5D RID: 2653 RVA: 0x0001D540 File Offset: 0x0001B740
		public SearchPattern2(string pattern)
			: this(pattern, false)
		{
		}

		// Token: 0x06000A5E RID: 2654 RVA: 0x0001D54C File Offset: 0x0001B74C
		public SearchPattern2(string pattern, bool ignore)
		{
			this.ignore = ignore;
			this.pattern = pattern;
			this.Compile(pattern);
		}

		// Token: 0x06000A60 RID: 2656 RVA: 0x0001D5AC File Offset: 0x0001B7AC
		public bool IsMatch(string text, bool ignorecase)
		{
			if (this.hasWildcard)
			{
				return this.Match(this.ops, text, 0);
			}
			bool flag = string.Compare(this.pattern, text, ignorecase) == 0;
			if (flag)
			{
				return true;
			}
			int num = text.LastIndexOf('/');
			if (num == -1)
			{
				return false;
			}
			num++;
			return num != text.Length && string.Compare(this.pattern, text.Substring(num), ignorecase) == 0;
		}

		// Token: 0x06000A61 RID: 2657 RVA: 0x0001D628 File Offset: 0x0001B828
		public bool IsMatch(string text)
		{
			return this.IsMatch(text, this.ignore);
		}

		// Token: 0x170002A0 RID: 672
		// (get) Token: 0x06000A62 RID: 2658 RVA: 0x0001D638 File Offset: 0x0001B838
		public bool HasWildcard
		{
			get
			{
				return this.hasWildcard;
			}
		}

		// Token: 0x06000A63 RID: 2659 RVA: 0x0001D640 File Offset: 0x0001B840
		private void Compile(string pattern)
		{
			if (pattern == null || pattern.IndexOfAny(SearchPattern2.InvalidChars) >= 0)
			{
				throw new ArgumentException("Invalid search pattern: '" + pattern + "'");
			}
			if (pattern == "*")
			{
				this.ops = new SearchPattern2.Op(SearchPattern2.OpCode.True);
				this.hasWildcard = true;
				return;
			}
			this.ops = null;
			int i = 0;
			SearchPattern2.Op op = null;
			while (i < pattern.Length)
			{
				char c = pattern[i];
				SearchPattern2.Op op2;
				if (c != '*')
				{
					if (c != '?')
					{
						op2 = new SearchPattern2.Op(SearchPattern2.OpCode.ExactString);
						int num = pattern.IndexOfAny(SearchPattern2.WildcardChars, i);
						if (num < 0)
						{
							num = pattern.Length;
						}
						op2.Argument = pattern.Substring(i, num - i);
						if (this.ignore)
						{
							op2.Argument = op2.Argument.ToLower();
						}
						i = num;
					}
					else
					{
						op2 = new SearchPattern2.Op(SearchPattern2.OpCode.AnyChar);
						i++;
						this.hasWildcard = true;
					}
				}
				else
				{
					op2 = new SearchPattern2.Op(SearchPattern2.OpCode.AnyString);
					i++;
					this.hasWildcard = true;
				}
				if (op == null)
				{
					this.ops = op2;
				}
				else
				{
					op.Next = op2;
				}
				op = op2;
			}
			if (op == null)
			{
				this.ops = new SearchPattern2.Op(SearchPattern2.OpCode.End);
			}
			else
			{
				op.Next = new SearchPattern2.Op(SearchPattern2.OpCode.End);
			}
		}

		// Token: 0x06000A64 RID: 2660 RVA: 0x0001D79C File Offset: 0x0001B99C
		private bool Match(SearchPattern2.Op op, string text, int ptr)
		{
			while (op != null)
			{
				switch (op.Code)
				{
				case SearchPattern2.OpCode.ExactString:
				{
					int length = op.Argument.Length;
					if (ptr + length > text.Length)
					{
						return false;
					}
					string text2 = text.Substring(ptr, length);
					if (this.ignore)
					{
						text2 = text2.ToLower();
					}
					if (text2 != op.Argument)
					{
						return false;
					}
					ptr += length;
					break;
				}
				case SearchPattern2.OpCode.AnyChar:
					if (++ptr > text.Length)
					{
						return false;
					}
					break;
				case SearchPattern2.OpCode.AnyString:
					while (ptr <= text.Length)
					{
						if (this.Match(op.Next, text, ptr))
						{
							return true;
						}
						ptr++;
					}
					return false;
				case SearchPattern2.OpCode.End:
					return ptr == text.Length;
				case SearchPattern2.OpCode.True:
					return true;
				}
				op = op.Next;
			}
			return true;
		}

		// Token: 0x04000ABF RID: 2751
		private SearchPattern2.Op ops;

		// Token: 0x04000AC0 RID: 2752
		private bool ignore;

		// Token: 0x04000AC1 RID: 2753
		private bool hasWildcard;

		// Token: 0x04000AC2 RID: 2754
		private string pattern;

		// Token: 0x04000AC3 RID: 2755
		internal static readonly char[] WildcardChars = new char[] { '*', '?' };

		// Token: 0x04000AC4 RID: 2756
		internal static readonly char[] InvalidChars = new char[]
		{
			Path.DirectorySeparatorChar,
			Path.AltDirectorySeparatorChar
		};

		// Token: 0x0200012B RID: 299
		private class Op
		{
			// Token: 0x06000A65 RID: 2661 RVA: 0x0001D890 File Offset: 0x0001BA90
			public Op(SearchPattern2.OpCode code)
			{
				this.Code = code;
				this.Argument = null;
				this.Next = null;
			}

			// Token: 0x04000AC5 RID: 2757
			public SearchPattern2.OpCode Code;

			// Token: 0x04000AC6 RID: 2758
			public string Argument;

			// Token: 0x04000AC7 RID: 2759
			public SearchPattern2.Op Next;
		}

		// Token: 0x0200012C RID: 300
		private enum OpCode
		{
			// Token: 0x04000AC9 RID: 2761
			ExactString,
			// Token: 0x04000ACA RID: 2762
			AnyChar,
			// Token: 0x04000ACB RID: 2763
			AnyString,
			// Token: 0x04000ACC RID: 2764
			End,
			// Token: 0x04000ACD RID: 2765
			True
		}
	}
}