using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace Eugen.ESystem
{
    public class DeleteFileFolder
    {
		#region Version und Copyright
		// Version und Copyright
		static string dllName = Path.GetFileNameWithoutExtension(System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase); //Den Programmnamen auslesen
		static string dllVersion = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString();
        static object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyCopyrightAttribute), false);
		static string copyright = GenerateCopyright();
		static string icon = Application.StartupPath + "\\Info.bmp";

        //Assembly Datum und Zeit
        static DateTime value = AssemblyDateTime();
		static string date = value.ToShortDateString();
		static string time = value.ToLongTimeString();

		private static DateTime AssemblyDateTime()
        {
            var version = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
            var buildDateTime = new DateTime(2000, 1, 1).Add(new TimeSpan(TimeSpan.TicksPerDay * version.Build + TimeSpan.TicksPerSecond * 2 * version.Revision));
            //Tage seit dem 1. Januar 2000 und Sekunden seit Mitternacht, (multiplizier mit 2 ergibt das Original)
            return buildDateTime;
        }

        private static string CurrentYear()
        {
            DateTime dtn = DateTime.Now;
            return dtn.Year.ToString();
        }

        private static string StartYear()
        {
            string startYear = "";
            if (((AssemblyCopyrightAttribute)attributes[0]).Copyright.Contains("Copyright © "))
            {
                startYear = ((AssemblyCopyrightAttribute)attributes[0]).Copyright.Replace("Copyright © ", "");
                while (startYear.StartsWith(" "))
                {
                    startYear = startYear.Remove(0, 1);
                }
                startYear = startYear.Remove(startYear.IndexOf(" "));
                return startYear;
            }
            else
            {
                DateTime dtn = DateTime.Now;
                return dtn.Year.ToString();
            }
        }

        private static string GenerateCopyright()
        {
            string startYear = StartYear();
            string currentYear = CurrentYear();

            if (startYear == currentYear)
            {
                return ((AssemblyCopyrightAttribute)attributes[0]).Copyright;
            }
            else
            {
                return ((AssemblyCopyrightAttribute)attributes[0]).Copyright.Replace(startYear, String.Concat(startYear, "-", currentYear));
            }
        }
        #endregion

        #region DLL-Info
        /// <summary>
        /// Contains the name of the program file
        /// </summary>
        public static string DllName { set; get; }

        /// <summary>
        /// Contains the version of the program file
        /// </summary>
        public static string DllVersion { set; get; }

        /// <summary>
        /// Contains the copyright notice
        /// </summary>
        public static string Copyright { set; get; }

        private static void SetDllInfo()
        {
            //Name, Version und Copyright setzen
            DllName = dllName;
            DllVersion = dllVersion;
            Copyright = copyright;
        }
        #endregion

		/// <summary>
		/// Constructor (for DLL-Information)
		/// </summary>
		static DeleteFileFolder()
        {
			SetDllInfo();
			Dir = false;
		}

        ///// <summary>
        ///// Delete Files in a folder
        ///// </summary>
        //public DeleteFileFolder()
        //{
        //    SetDllInfo();

        //    Dir = false;
        //}

        //public static List<string> UndeletableFiles = new List<string>(); //Liste der unlöschbaren Dateien
        //public static  List<string> UndeletableDirectories = new List<string>(); //Liste der unlöschbaren Verzeichnisse

        private static long FileCounter { set; get; } //Anzahl der abgearbeiteten Dateien
        private static long DirectoryCounter { set; get; } //Anzahl der abgearbeiteten Verzeichnisse

		public static long NumberOfFiles { set; get; } //Anzahl der Dateien
		public static long NumberOfDirectories { set; get; } //Anzahl der Verzeichnisse
        public static long PercentDone { set; get; } //Prozent abgeschlossen
        private static bool Dir { set; get; } //true = Verzeichnisse und Dateien; false = Nur Dateien

		public static string Status { set; get; }	//Statustext

		/// <summary>
		/// List of undeletable files
		/// </summary>
		public static List<string> UndeletableFiles { set; get; } //Liste der unlöschbaren Dateien

		/// <summary>
		/// List of undeletable directories
		/// </summary>
		public static List<string> UndeletableDirectories { set; get; } //Liste der unlöschbaren Verzeichnisse

		/// <summary>
		/// Deletes a singel File.
		/// </summary>
		/// <param name="fileName">A valid filename with path.</param>
		/// <returns>If the file was successfully deleted, 'null' is returned, otherwise the filename.</returns>
		public static string File(string fileName)
		{
			try
			{
				FileCounter++; //Zähler hochzählen

				System.IO.File.SetAttributes(fileName, FileAttributes.Normal); //Attribute zurücksetzen
				System.IO.File.Delete(fileName); //Datei löschen

				return null; //Wenn löschen möglich war
			}
			catch (Exception)
			{
				return fileName; //Wenn löschen nicht möglich war
			}
		}

		/// <summary>
		/// Deletes a singel File with the declared extension.
		/// </summary>
		/// <param name="fileName">A valid filename with path.</param>
		/// <param name="searchPattern">A valid file extension, e.g.: .txt</param>
		/// <returns>If the file was successfully deleted, 'null' is returned, otherwise the filename.</returns>
		public static string File(string fileName, string searchPattern)
		{
			try
			{
				if (Path.GetExtension(fileName) != searchPattern)
				{
					return null;
				}
				FileCounter++; //Zähler hochzählen
				PercentDone = 100 / NumberOfFiles * FileCounter;

				System.IO.File.SetAttributes(fileName, FileAttributes.Normal); //Attribute zurücksetzen
				System.IO.File.Delete(fileName); //Datei löschen

				return null; //Wenn löschen möglich war
			}
			catch (Exception)
			{
				return fileName; //Wenn löschen nicht möglich war
			}
		}

		/// <summary>
		/// Delete all files in a specified folder.
		/// </summary>
		/// <param name="path">Full path of a folder.</param>
		/// <returns>Returns a list of all undeletable files.</returns>
		public static List<string> AllFiles(string path)
		{
			NumberOfFiles = CountFiles(path); //Anzahl der löschbaren Dateien

			FileCounter = 0; //Zähler zurücksetzen
			string result = ""; //Rückgabewert

			UndeletableFiles.Clear();

			foreach (var file in Directory.GetFiles(path))
			{
				result = File(file); //Dateien löschen

				//Berechnen wie viel Prozenz bereits gelöscht sind
				if (Dir)
				{
					//Dateien und Verzeichnisse werden berücksichtigt
					PercentDone = Convert.ToInt32(100 / Convert.ToDouble(NumberOfFiles + NumberOfDirectories) * Convert.ToDouble(FileCounter + DirectoryCounter));
				}
				else
				{
					//Nur Dateien werden berücksichtigt
					PercentDone = Convert.ToInt32(100 / Convert.ToDouble(NumberOfFiles) * Convert.ToDouble(FileCounter));
					OnEvent(PercentDone, Status);
				}

				if (result != null)
				{
					//Wenn ein Dateiname zurückgeliefert wird, dann in die Liste aufnehmen
					UndeletableFiles.Add(result);
				}
			}
			return UndeletableFiles; //Gibt die Liste der unlöschbaren Dateien zurück
		}

		/// <summary>
		/// Delete all files in a specified folder and subfolders.
		/// </summary>
		/// <param name="path">Full path of a folder.</param>
		/// <param name="subFolder">If true, then all files in all subdirectories are also deleted.</param>
		/// <returns></returns>
		public static List<string> AllFiles(string path, bool subFolder)
		{
			NumberOfFiles = CountFiles(path, subFolder); //Anzahl der löschbaren Dateien

			FileCounter = 0; //Zähler zurücksetzen

			UndeletableFiles.Clear(); //Liste der unlöschbaren Dateien zurücksetzen

			//Löscht alle Dateien und gibt die Liste der unlöschbaren Dateien zurück
			return AllFilesInFolders(path, true);
		}

		/// <summary>
		/// Delete all files in a specified folder and subfolders with the declared extension.
		/// </summary>
		/// <param name="path">Full path of a folder.</param>
		/// <param name="subFolder">If true, then all files in all subdirectories are also deleted.</param>
		/// <param name="searchPattern">A valid file extension, e.g.: .txt</param>
		/// <returns>Returns a list of all undeletable files.</returns>
		public static List<string> AllFiles(string path, bool subFolder, string searchPattern)
		{
			NumberOfFiles = CountFiles(path, subFolder); //Anzahl der löschbaren Dateien

			FileCounter = 0; //Zähler zurücksetzen

			UndeletableFiles.Clear(); //Liste der unlöschbaren Dateien zurücksetzen

			//Löscht alle Dateien und gibt die Liste der unlöschbaren Dateien zurück
			return AllFilesInFolders(path, true, searchPattern);
		}

		private static List<string> AllFilesInFolders(string path, bool subFolder)
		{
			string result = ""; //Rückgabewert

			foreach (var file in Directory.GetFiles(path))
			{
				result = File(file); //Dateien löschen

				//Berechnen wie viel Prozenz bereits gelöscht sind
				if (Dir)
				{
					//Dateien un Verzeichnisse werden berücksichtigt
					PercentDone = Convert.ToInt32(100 / Convert.ToDouble(NumberOfFiles + NumberOfDirectories) * Convert.ToDouble(FileCounter + DirectoryCounter));
					OnEvent(PercentDone, Status);
				}
				else
				{
					//Nur Dateien werden berücksichtigt
					PercentDone = Convert.ToInt32(100 / Convert.ToDouble(NumberOfFiles) * Convert.ToDouble(FileCounter));
					OnEvent(PercentDone, Status);
				}

				if (result != null)
				{
					//Wenn ein Dateiname zurückgeliefert wird, dann in die Liste aufnehmen
					UndeletableFiles.Add(result);
				}
			}
			if (subFolder)
			{
				//Alle Dateien in den Unterverzeichnissen löschen
				foreach (var sFolder in Directory.GetDirectories(path))
				{
					AllFilesInFolders(sFolder, true);
				}
			}

			return UndeletableFiles; //Gibt die Liste der unlöschbaren Dateien zurück
		}

		private static List<string> AllFilesInFolders(string path, bool subFolder, string searchPattern)
		{
			string result = ""; //Rückgabewert

			foreach (var file in Directory.GetFiles(path))
			{
				result = File(file, searchPattern); //Dateien löschen

				if (result != null)
				{
					//Wenn ein Dateiname zurückgeliefert wird, dann in die Liste aufnehmen
					UndeletableFiles.Add(result);
				}
			}
			if (subFolder)
			{
				//Alle Dateien in den Unterverzeichnissen löschen
				foreach (var sFolder in Directory.GetDirectories(path))
				{
					AllFilesInFolders(sFolder, true, searchPattern);
				}
			}

			return UndeletableFiles; //Gibt die Liste der unlöschbaren Dateien zurück
		}


		public static string SingleDirectory(string path)
		{
			try
			{
				DirectoryCounter++; //Zähler hochzählen

				DirectoryInfo dirInfo = new DirectoryInfo(path);
				dirInfo.Attributes = FileAttributes.Normal;
				System.IO.Directory.Delete(path);

				return null; //Wenn löschen möglich war
			}
			catch (Exception)
			{
				return path; //Wenn löschen nicht möglich war
			}
		}

		public static List<List<string>> AllDirectories(string path)
		{
			//object[] undeleteableFilesFolders = new object[2];
			List<List<string>> undeleteableFilesFolders = new List<List<string>>();

			UndeletableFiles.Clear();
			UndeletableDirectories.Clear();

			if (!Directory.Exists(path))
			{
				UndeletableDirectories.Add(path);

				undeleteableFilesFolders[0] = UndeletableFiles;
				undeleteableFilesFolders[1] = UndeletableDirectories;

				return undeleteableFilesFolders;
			}

			Dir = true;

			NumberOfFiles = CountFiles(path, true); //Anzahl der löschbaren Dateien
			NumberOfDirectories = CountDirectories(path); //Anzahl der löschbaren Verzeichnsse

			//Alle Dateien im Verzeichnis löschen
			UndeletableFiles.AddRange(AllFiles(path, true));

			UndeletableDirectories = AllSubDirectories(path); //Alle Verzeichnisse löschen

			string result = SingleDirectory(path);
			if (!String.IsNullOrEmpty(result))
			{
				UndeletableFiles.Add(result);
			}

			//Berechnen wie viel Prozenz bereits gelöscht sind
			PercentDone = Convert.ToInt32(100 / Convert.ToDouble(NumberOfFiles + NumberOfDirectories) * Convert.ToDouble(FileCounter + DirectoryCounter));
			OnEvent(PercentDone, Status);

			undeleteableFilesFolders.Add(UndeletableFiles);
			undeleteableFilesFolders.Add(UndeletableDirectories);
			return undeleteableFilesFolders; //Gibt die Liste der unlöschbaren Dateien und Verzeichnisse zurück
		}

		private static List<string> AllSubDirectories(string path)
		{
			//Unterverzeichnisse löschen
			foreach (var sFolder in Directory.GetDirectories(path))
			{
				UndeletableFiles.AddRange(AllSubDirectories(sFolder));

				SingleDirectory(sFolder);

				//Berechnen wie viel Prozenz bereits gelöscht sind
				PercentDone = Convert.ToInt32(100 / Convert.ToDouble(NumberOfFiles + NumberOfDirectories) * Convert.ToDouble(FileCounter + DirectoryCounter));
				OnEvent(PercentDone, Status);
			}

			return UndeletableFiles; //Gibt die Liste der unlöschbaren Dateien und Verzeichnisse zurück
		}

		/// <summary>
		/// Counts all files in a specified folder.
		/// </summary>
		/// <param name="path">Full path of a folder.</param>
		/// <returns>The number of files.</returns>
		public static long CountFiles(string path)
		{
			long numberOfFiles = 0; //Anzahl der löschbaren Dateien

			foreach (var file in Directory.GetFiles(path))
			{
				numberOfFiles++; //Zähler erhöhen
			}

			return numberOfFiles;
		}

		/// <summary>
		/// Counts all files in a specified folder and all subfolders.
		/// </summary>
		/// <param name="path">Full path of a folder.</param>
		/// <param name="subFolder">If true, then all files in all subdirectories are also counted.</param>
		/// <returns>The number of files.</returns>
		public static long CountFiles(string path, bool subFolder)
		{
			if (!Directory.Exists(path))
			{
				return 0; //Wenn das Verzeichnis nicht existiert, dann 0 zurückgeben
			}

			NumberOfFiles = 0; //Zähler zurücksetzen

			NumberOfFiles = CountAllFiles(path, subFolder); //Die Zählfunktion aufrufen
			return NumberOfFiles;
		}

		/// <summary>
		/// Counts all files in a specified folder and subfolder with the declared extension.
		/// </summary>
		/// <param name="path">Full path of a folder.</param>
		/// <param name="subFolder">If true, then all files in all subdirectories are also counted.</param>
		/// <param name="searchPattern">A valid file extension, e.g.: .txt</param>
		/// <returns>The number of files.</returns>
		private static long CountFile(string path, bool subFolder, string searchPattern)
		{
			long numberOfFiles = 0; //Anzahl der löschbaren Dateien

			foreach (var file in Directory.GetFiles(path))
			{
				if (Path.GetExtension(file) == searchPattern)
				{
					numberOfFiles++; //Zähler erhöhen
				}
			}
			if (subFolder)
			{
				foreach (var sFolder in Directory.GetDirectories(path))
				{
					CountFile(sFolder, true, searchPattern);
				}
			}

			return numberOfFiles;
		}

		private static long CountAllFiles(string path, bool subFolder)
		{
			foreach (var file in Directory.GetFiles(path))
			{
				NumberOfFiles++; //Zähler erhöhen
			}
			if (subFolder)
			{
				foreach (var sFolder in Directory.GetDirectories(path))
				{
					CountAllFiles(sFolder, true); //Rekursiver Aufruf
				}
			}

			return NumberOfFiles;
		}

		private static long CountAllFiles(string path, bool subFolder, string searchPattern)
		{
			foreach (var file in Directory.GetFiles(path))
			{
				if (Path.GetExtension(file) == searchPattern)
				{
					NumberOfFiles++; //Zähler erhöhen
				}
			}
			if (subFolder)
			{
				foreach (var sFolder in Directory.GetDirectories(path))
				{
					CountAllFiles(sFolder, true, searchPattern); //Rekursiver Aufruf
				}
			}

			return NumberOfFiles;
		}

		/// <summary>
		/// Counts all directoreis in a specified folder and all subfolders.
		/// </summary>
		/// <param name="path">Full path of a folder.</param>
		/// <returns>The number of directories.</returns>
		public static long CountDirectories(string path)
		{
			if (!Directory.Exists(path))
			{
				return 0; //Wenn das Verzeichnis nicht existiert, dann 0 zurückgeben
			}

			NumberOfDirectories = 0; //Zähler zurücksetzen

			NumberOfDirectories = CountAllDirectories(path) + 1; //Für das Root-Verzeichnis 1 dazu zählen
			return NumberOfDirectories;
		}

		private static long CountAllDirectories(string path)
		{
			//Rekursive Aufruf
			foreach (var sFolder in Directory.GetDirectories(path))
			{
				CountAllDirectories(sFolder);
				NumberOfDirectories++;
			}

			return NumberOfDirectories;
		}

		/// <summary>
		/// Clears the undeletabele directory list.
		/// </summary>
		public void ClearUndeletableFiles()
        {
			UndeletableFiles.Clear();
        }

		/// <summary>
		/// Clears the undeletabele directory list.
		/// </summary>
		public void ClearUndeletableDirectories()
        {
			UndeletableDirectories.Clear();
        }

		#region Reset Counters
		/// <summary>
		/// Resets the file counter to 0.
		/// </summary>
		public static void ResetFileCounter()
		{
			FileCounter = 0;
		}

		/// <summary>
		/// Resets the directory counter to 0.
		/// </summary>
		public static void ResetDirectoryCounter()
		{
			DirectoryCounter = 0;
		}

		/// <summary>
		/// Resets the number of files to 0.
		/// </summary>
		public static void ResetNumberOfFiles()
		{
			NumberOfFiles = 0;
		}

		/// <summary>
		/// Resets the number of directories to 0.
		/// </summary>
		public static void ResetNumberOfDirectories()
		{
			NumberOfDirectories = 0;
		}
		#endregion

		#region Event Handler
		// Der Delegat muß die gleiche Signatur aufweisen wie die Eventhandler-Methode.
		public delegate void EventDelegate(long result, string status);

		// Das Event-Objekt ist vom Typ dieses Delegaten.
		public static event EventDelegate MyEvent;

		public static void OnEvent(long result, string status)
		{
			// Prüft ob das Event überhaupt einen Abonnenten hat.
			if (MyEvent != null)
			{
				MyEvent(result, status);
			}
		}
		#endregion
	}
}