using System;
using System.IO;

namespace ICSharpCode.SharpZipLib.Core
{
	// Token: 0x02000017 RID: 23
	public class FileSystemScanner
	{
		// Token: 0x060000AD RID: 173 RVA: 0x00006D9C File Offset: 0x00005D9C
		public FileSystemScanner(string filter)
		{
			this.fileFilter_ = new PathFilter(filter);
		}

		// Token: 0x060000AE RID: 174 RVA: 0x00006DB0 File Offset: 0x00005DB0
		public FileSystemScanner(string fileFilter, string directoryFilter)
		{
			this.fileFilter_ = new PathFilter(fileFilter);
			this.directoryFilter_ = new PathFilter(directoryFilter);
		}

		// Token: 0x060000AF RID: 175 RVA: 0x00006DD0 File Offset: 0x00005DD0
		public FileSystemScanner(IScanFilter fileFilter)
		{
			this.fileFilter_ = fileFilter;
		}

		// Token: 0x060000B0 RID: 176 RVA: 0x00006DDF File Offset: 0x00005DDF
		public FileSystemScanner(IScanFilter fileFilter, IScanFilter directoryFilter)
		{
			this.fileFilter_ = fileFilter;
			this.directoryFilter_ = directoryFilter;
		}

		// Token: 0x060000B1 RID: 177 RVA: 0x00006DF8 File Offset: 0x00005DF8
		private bool OnDirectoryFailure(string directory, Exception e)
		{
			DirectoryFailureHandler directoryFailure = this.DirectoryFailure;
			bool flag = directoryFailure != null;
			if (flag)
			{
				ScanFailureEventArgs scanFailureEventArgs = new ScanFailureEventArgs(directory, e);
				directoryFailure(this, scanFailureEventArgs);
				this.alive_ = scanFailureEventArgs.ContinueRunning;
			}
			return flag;
		}

		// Token: 0x060000B2 RID: 178 RVA: 0x00006E34 File Offset: 0x00005E34
		private bool OnFileFailure(string file, Exception e)
		{
			FileFailureHandler fileFailure = this.FileFailure;
			bool flag = fileFailure != null;
			if (flag)
			{
				ScanFailureEventArgs scanFailureEventArgs = new ScanFailureEventArgs(file, e);
				this.FileFailure(this, scanFailureEventArgs);
				this.alive_ = scanFailureEventArgs.ContinueRunning;
			}
			return flag;
		}

		// Token: 0x060000B3 RID: 179 RVA: 0x00006E78 File Offset: 0x00005E78
		private void OnProcessFile(string file)
		{
			ProcessFileHandler processFile = this.ProcessFile;
			if (processFile != null)
			{
				ScanEventArgs scanEventArgs = new ScanEventArgs(file);
				processFile(this, scanEventArgs);
				this.alive_ = scanEventArgs.ContinueRunning;
			}
		}

		// Token: 0x060000B4 RID: 180 RVA: 0x00006EAC File Offset: 0x00005EAC
		private void OnCompleteFile(string file)
		{
			CompletedFileHandler completedFile = this.CompletedFile;
			if (completedFile != null)
			{
				ScanEventArgs scanEventArgs = new ScanEventArgs(file);
				completedFile(this, scanEventArgs);
				this.alive_ = scanEventArgs.ContinueRunning;
			}
		}

		// Token: 0x060000B5 RID: 181 RVA: 0x00006EE0 File Offset: 0x00005EE0
		private void OnProcessDirectory(string directory, bool hasMatchingFiles)
		{
			ProcessDirectoryHandler processDirectory = this.ProcessDirectory;
			if (processDirectory != null)
			{
				DirectoryEventArgs directoryEventArgs = new DirectoryEventArgs(directory, hasMatchingFiles);
				processDirectory(this, directoryEventArgs);
				this.alive_ = directoryEventArgs.ContinueRunning;
			}
		}

		// Token: 0x060000B6 RID: 182 RVA: 0x00006F13 File Offset: 0x00005F13
		public void Scan(string directory, bool recurse)
		{
			this.alive_ = true;
			this.ScanDir(directory, recurse);
		}

		// Token: 0x060000B7 RID: 183 RVA: 0x00006F24 File Offset: 0x00005F24
		private void ScanDir(string directory, bool recurse)
		{
			try
			{
				string[] files = Directory.GetFiles(directory);
				bool flag = false;
				for (int i = 0; i < files.Length; i++)
				{
					if (!this.fileFilter_.IsMatch(files[i]))
					{
						files[i] = null;
					}
					else
					{
						flag = true;
					}
				}
				this.OnProcessDirectory(directory, flag);
				if (this.alive_ && flag)
				{
					foreach (string text in files)
					{
						try
						{
							if (text != null)
							{
								this.OnProcessFile(text);
								if (!this.alive_)
								{
									break;
								}
							}
						}
						catch (Exception ex)
						{
							if (!this.OnFileFailure(text, ex))
							{
								throw;
							}
						}
					}
				}
			}
			catch (Exception ex2)
			{
				if (!this.OnDirectoryFailure(directory, ex2))
				{
					throw;
				}
			}
			if (this.alive_ && recurse)
			{
				try
				{
					string[] directories = Directory.GetDirectories(directory);
					foreach (string text2 in directories)
					{
						if (this.directoryFilter_ == null || this.directoryFilter_.IsMatch(text2))
						{
							this.ScanDir(text2, true);
							if (!this.alive_)
							{
								break;
							}
						}
					}
				}
				catch (Exception ex3)
				{
					if (!this.OnDirectoryFailure(directory, ex3))
					{
						throw;
					}
				}
			}
		}

		// Token: 0x04000077 RID: 119
		public ProcessDirectoryHandler ProcessDirectory;

		// Token: 0x04000078 RID: 120
		public ProcessFileHandler ProcessFile;

		// Token: 0x04000079 RID: 121
		public CompletedFileHandler CompletedFile;

		// Token: 0x0400007A RID: 122
		public DirectoryFailureHandler DirectoryFailure;

		// Token: 0x0400007B RID: 123
		public FileFailureHandler FileFailure;

		// Token: 0x0400007C RID: 124
		private IScanFilter fileFilter_;

		// Token: 0x0400007D RID: 125
		private IScanFilter directoryFilter_;

		// Token: 0x0400007E RID: 126
		private bool alive_;
	}
}