using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;


namespace RobvanderWoude
{
	internal class FileHistory
	{
		static readonly string progver = "1.00";


		static string sourcedir;
		static string destination;
		static string excludepattern;
		static string regexexcludepattern;
		static bool excludehidden = false;
		static bool excludelockedoffice = false;


		static int Main( string[] args )
		{
			#region Check Command Line

			if ( args.Length < 2 )
			{
				return ShowHelp( );
			}

			if ( args.Contains( "/?" ) )
			{
				return ShowHelp( );
			}

			sourcedir = args[0];
			destination = args[1];

			if ( !Directory.Exists( sourcedir ) )
			{
				return ShowHelp( "Source directory not found" );
			}

			if ( !Directory.Exists( destination ) )
			{
				return ShowHelp( "Destination directory not found" );
			}

			foreach ( string filter in args.Skip( 2 ) )
			{
				if ( filter[0] == '/' )
				{
					if ( filter.ToUpper( ) == "/H" )
					{
						if ( excludehidden )
						{
							return ShowHelp( "Duplicate command line switch /H" );
						}
						excludehidden = true;
					}
					else if ( filter.ToUpper( ) == "/O" )
					{
						if ( excludelockedoffice )
						{
							return ShowHelp( "Duplicate command line switch /O" );
						}
						excludelockedoffice = true;
					}
					else if ( filter.ToUpper( ).StartsWith( "/R:" ) && filter.Length > 3 )
					{
						if ( !string.IsNullOrWhiteSpace( regexexcludepattern ) )
						{
							return ShowHelp( "Duplicate command line switch /R" );
						}
						regexexcludepattern = filter.Substring( 3 );
					}
					else if ( filter.ToUpper( ).StartsWith( "/X:" ) && filter.Length > 3 )
					{
						if ( !string.IsNullOrWhiteSpace( excludepattern ) )
						{
							return ShowHelp( "Duplicate command line switch /X" );
						}
						excludepattern = filter.Substring( 3 );
					}
					else
					{
						return ShowHelp( "Invalid command line switch {0}", filter );
					}
				}
			}

			#endregion Check Command Line


			#region Initial Backup

			Console.WriteLine( "Checking initial backup set . . ." );
			foreach ( string filter in args.Skip( 2 ) )
			{
				if ( filter[0] != '/' )
				{
					foreach ( string file in Directory.GetFiles( sourcedir, filter ) )
					{
						if ( Directory.GetFiles( destination, Path.GetFileNameWithoutExtension( file ) + ".*" + Path.GetExtension( file ) ).Length == 0 )
						{
							BackupFile( file );
						}
					}
				}
			}

			#endregion Initial Backup


			foreach ( string filter in args.Skip( 2 ) )
			{
				if ( filter[0] != '/' )
				{
					FileSystemWatcher watcher = new FileSystemWatcher( sourcedir )
					{
						EnableRaisingEvents = true,
						NotifyFilter = NotifyFilters.Attributes
									 | NotifyFilters.CreationTime
									 | NotifyFilters.DirectoryName
									 | NotifyFilters.FileName
									 | NotifyFilters.LastAccess
									 | NotifyFilters.LastWrite
									 | NotifyFilters.Security
									 | NotifyFilters.Size,
						Filter = filter,
						IncludeSubdirectories = true
					};
					watcher.Changed += OnChanged;
					watcher.Created += OnCreated;
					watcher.Deleted += OnDeleted;
					watcher.Renamed += OnRenamed;
					watcher.Error += OnError;
				}
			}

			Console.WriteLine( "Press enter to exit.\n" );
			Console.ReadLine( );
			return 0;
		}


		static bool BackupFile( string sourcefile )
		{
			if ( IsExcluded( sourcefile ) )
			{
				return true;
			}
			string timestamp = DateTime.Now.ToString( "yyyyMMddHHmmss" );
			string relpath = sourcefile.Replace( sourcedir, "" );
			if ( relpath[0] == '\\' )
			{
				relpath = relpath.Substring( 1 );
			}
			string reldir = Path.GetDirectoryName( relpath );
			string destinationfile = Path.Combine( destination, reldir, Path.GetFileNameWithoutExtension( relpath ) + "." + timestamp + Path.GetExtension( relpath ) );
			try
			{
				if ( !File.Exists( destinationfile ) )
				{
					File.Copy( sourcefile, destinationfile, true );
					Console.WriteLine( $"Copied \"{sourcefile}\" to \"{destinationfile}\"\n" );
				}
			}
			catch ( Exception ex )
			{
				PrintException( ex );
				return false;
			}
			return true;
		}


		static bool FileCompare( string file1, string file2 )
		{
			if ( new FileInfo( file1 ).Length != new FileInfo( file2 ).Length )
			{
				return false;
			}
			byte[] bytes1 = File.ReadAllBytes( file1 );
			byte[] bytes2 = File.ReadAllBytes( file2 );
			for ( int i = 0; i < bytes1.Length; i++ )
			{
				if ( bytes1[i] != bytes2[i] )
				{
					return false;
				}
			}
			return true;
		}


		static string GetLastBackup( string sourcefile )
		{
			string lastbackup;
			string ext = Path.GetExtension( sourcefile );
			string name = Path.GetFileNameWithoutExtension( sourcefile );
			string srcdir = Path.GetDirectoryName( sourcefile );
			string target = sourcefile.Replace( sourcedir, destination );
			string targetdir = Path.GetDirectoryName( target );
			List<string> targetfiles = Directory.GetFiles( targetdir, name + ".*" + ext ).ToList( );
			targetfiles.Sort( );
			lastbackup = targetfiles.LastOrDefault( );
			return lastbackup;
		}


		static bool IsExcluded( string file )
		{
			if ( excludehidden )
			{
				try
				{
					if ( File.GetAttributes( file ).HasFlag( FileAttributes.Hidden ) )
					{
						return true;
					}
				}
				catch
				{
					// ignore
				}
			}
			if ( excludelockedoffice )
			{
				string ext = Path.GetExtension( file );
				if ( Regex.IsMatch( ext, @"^\.(doc|ppt|xls)x?$", RegexOptions.IgnoreCase ) )
				{
					string parentdir = Path.GetDirectoryName( file );
					string name = Path.GetFileName( file );
					string lockfile = Path.Combine( parentdir, @"~$" + name );
					if ( File.Exists( lockfile ) )
					{
						return true;
					}
				}
			}
			if ( !string.IsNullOrWhiteSpace( excludepattern ) )
			{
				foreach ( string pattern in excludepattern.Split( ";".ToCharArray( ) ) )
				{
					if ( file.ToUpper( ).Contains( pattern.ToUpper( ) ) )
					{
						return true;
					}
				}
			}
			if ( !string.IsNullOrWhiteSpace( regexexcludepattern ) )
			{
				Regex regex = new Regex( regexexcludepattern, RegexOptions.IgnoreCase );
				if ( regex.IsMatch( file ) )
				{
					return true;
				}
			}
			return false;
		}


		private static void OnChanged( object sender, FileSystemEventArgs e )
		{
			if ( e.ChangeType != WatcherChangeTypes.Changed )
			{
				return;
			}
			if ( IsExcluded( e.FullPath ) )
			{
				return;
			}
			Console.WriteLine( $"Changed: {e.FullPath}" );
			BackupFile( e.FullPath );
		}


		private static void OnCreated( object sender, FileSystemEventArgs e )
		{
			if ( IsExcluded( e.FullPath ) )
			{
				return;
			}
			string value = $"Created: {e.FullPath}";
			Console.WriteLine( value );
			BackupFile( e.FullPath );
		}


		private static void OnDeleted( object sender, FileSystemEventArgs e )
		{
			#region Office lock file
			string ext = Path.GetExtension( e.FullPath );
			string name = Path.GetFileName( e.FullPath );
			string parentdir = Path.GetDirectoryName( e.FullPath );
			if ( name.StartsWith( "~$" ) && Regex.IsMatch( ext, @"^\.(doc|ppt|xls)x?$", RegexOptions.IgnoreCase ) )
			{
				if ( excludelockedoffice )
				{
					name = name.Substring( 2 );
					string lastbackup = GetLastBackup( Path.Combine( parentdir, name ) );
					if ( string.IsNullOrWhiteSpace( lastbackup ) || !FileCompare( lastbackup, Path.Combine( parentdir, name ) ) )
					{
						OnChanged( sender, new FileSystemEventArgs( WatcherChangeTypes.Changed, parentdir, name ) );
					}
					return;
				}
			}
			#endregion Office lock file

			if ( IsExcluded( e.FullPath ) )
			{
				return;
			}
			Console.WriteLine( $"Deleted: {e.FullPath}" );
		}


		private static void OnRenamed( object sender, RenamedEventArgs e )
		{
			if ( IsExcluded( e.FullPath ) )
			{
				return;
			}
			Console.WriteLine( $"Renamed:" );
			Console.WriteLine( $"    Old: {e.OldFullPath}" );
			Console.WriteLine( $"    New: {e.FullPath}" );
			BackupFile( e.FullPath );
		}


		private static void OnError( object sender, ErrorEventArgs e )
		{
			PrintException( e.GetException( ) );
		}


		private static void PrintException( Exception ex )
		{
			if ( ex != null )
			{
				Console.WriteLine( $"Message: {ex.Message}" );
				Console.WriteLine( "Stacktrace:" );
				Console.WriteLine( ex.StackTrace );
				Console.WriteLine( );
				PrintException( ex.InnerException );
			}
		}


		public static int ShowHelp( params string[] errmsg )
		{
			#region Error Message

			if ( errmsg.Length > 0 )
			{
				List<string> errargs = new List<string>( errmsg );
				errargs.RemoveAt( 0 );
				Console.Error.WriteLine( );
				Console.ForegroundColor = ConsoleColor.Red;
				Console.Error.Write( "ERROR:\t" );
				Console.ForegroundColor = ConsoleColor.White;
				Console.Error.WriteLine( errmsg[0], errargs.ToArray( ) );
				Console.ResetColor( );
			}

			#endregion Error Message


			#region Help Text

			/*
			FileHistory.exe,  Version 1.00
			Save a timestamped copy of any monitored file when it is changed

			Usage:    FileHistory   sourcedir  destination  [ filters ]  [ options ]

			Where:    sourcedir     is the directory to monitor
			          destination   is the directory where backups will be kept
			          filters       optional file type filter(s), e.g. "*.txt"
			                        (default: "*.*" i.e. all files)
			
			Options:  /H            exclude Hidden files
			          /O            exclude locked MS-Office Word, Excel, PowerPoint files
			          /R:pattern    exclude files matching regular expressions pattern
			          /X:pattern    exclude files matching DOS files pattern

			Notes:    Unlike Microsoft's built-in File History, this program can monitor
			          ANY directory, not just the user libraries.
			          Specified source and destination directories must both exist.
			          You may use as many filters as you like, e.g. *.doc* *.xls* *.ppt*
			          to monitor MS-Office Word, Excel and PowerPoint files.
			          When using /O to exclude locked MS-Office files, a backup copy will
			          be saved as soon as the locked MS-Office file is closed, unless it
			          is identical to the last backup of that file.
			          Use /R to specify a regular expressions pattern for files to be
			          excluded, or /X to specify (multiple) DOS file pattern(s).
			          Multiple DOS file patterns can be combined by using a semicolon for
			          separator and embedding the combined pattern in doublequotes, e.g.
			          /X:"~$*.doc*;~$*.xls*" to exclude MS-Office Word and Excel lock files.
			          Command line switches /R and /X may be used simultaneously.
			          This program will keep running until the Enter key is pressed.
			          Return code is 0 when all goes well, or -1 on (command line) errors.

			Written by Rob van der Woude
			https://www.robvanderwoude.com
			*/

			#endregion Help Text


			#region Display Help Text

			Console.Error.WriteLine( );

			Console.Error.WriteLine( "FileHistory.exe,  Version {0}", progver );

			Console.Error.WriteLine( "Save a timestamped copy of any monitored file when it is changed" );

			Console.Error.WriteLine( );

			Console.Error.Write( "Usage:    " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.WriteLine( "FileHistory   sourcedir  destination  [ filters ]  [ options ]" );
			Console.ResetColor( );

			Console.Error.WriteLine( );

			Console.Error.Write( "Where:    " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "sourcedir" );
			Console.ResetColor( );
			Console.Error.WriteLine( "     is the directory to monitor" );

			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "          destination" );
			Console.ResetColor( );
			Console.Error.WriteLine( "   is the directory where backups will be kept" );

			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "          filters" );
			Console.ResetColor( );
			Console.Error.WriteLine( "       optional file type filter(s), e.g. \"*.txt\"" );

			Console.Error.WriteLine( "                        (default: \"*.*\" i.e. all files)" );

			Console.Error.WriteLine( );

			Console.Error.Write( "Options:  " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "/H" );
			Console.ResetColor( );
			Console.Error.Write( "            exclude " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "H" );
			Console.ResetColor( );
			Console.Error.WriteLine( "idden files" );

			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "          /O" );
			Console.ResetColor( );
			Console.Error.Write( "            exclude locked MS-" );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "O" );
			Console.ResetColor( );
			Console.Error.WriteLine( "ffice Word, Excel, PowerPoint files" );

			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "          /R:pattern" );
			Console.ResetColor( );
			Console.Error.Write( "    exclude files matching regular expressions " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.WriteLine( "pattern" );

			Console.Error.Write( "          /X:pattern" );
			Console.ResetColor( );
			Console.Error.Write( "    exclude files matching DOS files " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.WriteLine( "pattern" );
			Console.ResetColor( );

			Console.Error.WriteLine( );

			Console.Error.WriteLine( "Notes:    Unlike Microsoft's built-in File History, this program can monitor" );

			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "          ANY" );
			Console.ResetColor( );
			Console.Error.WriteLine( " directory, not just the user libraries." );

			Console.Error.WriteLine( "          Specified source and destination directories must both exist." );

			Console.Error.Write( "          You may use as many " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "filters" );
			Console.ResetColor( );
			Console.Error.Write( " as you like, e.g. " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.WriteLine( "*.doc* *.xls* *.ppt*" );
			Console.ResetColor( );

			Console.Error.WriteLine( "          to monitor MS-Office Word, Excel and PowerPoint files." );

			Console.Error.Write( "          When using " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "/O" );
			Console.ResetColor( );
			Console.Error.WriteLine( " to exclude locked MS-Office files, a backup copy will" );

			Console.Error.WriteLine( "          be saved as soon as the locked MS-Office file is closed, unless it" );

			Console.Error.WriteLine( "          is identical to the last backup of that file." );

			Console.Error.Write( "          Use " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "/R" );
			Console.ResetColor( );
			Console.Error.WriteLine( " to specify a regular expressions pattern for files to be" );

			Console.Error.Write( "          excluded, or " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "/X" );
			Console.ResetColor( );
			Console.Error.WriteLine( " to specify (multiple) DOS file pattern(s)." );

			Console.Error.WriteLine( "          Multiple DOS file patterns can be combined by using a semicolon for" );

			Console.Error.WriteLine( "          separator and embedding the combined pattern in doublequotes, e.g." );

			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "          /X:\"~$*.doc*;~$*.xls*\"" );
			Console.ResetColor( );
			Console.Error.WriteLine( " to exclude MS-Office Word and Excel lock files." );

			Console.Error.Write( "          Command line switches " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "/R" );
			Console.ResetColor( );
			Console.Error.Write( " and " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "/X" );
			Console.ResetColor( );
			Console.Error.WriteLine( " may be used simultaneously." );

			Console.Error.WriteLine( "          This program will keep running until the Enter key is pressed." );

			Console.Error.WriteLine( "          Return code is 0 when all goes well, or -1 on (command line) errors." );

			Console.Error.WriteLine( );

			Console.Error.WriteLine( "Written by Rob van der Woude" );

			Console.Error.WriteLine( "https://www.robvanderwoude.com" );

			#endregion Display Help Text


			return -1;
		}
	}
}