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


namespace RobvanderWoude
{
	class CaptureDate
	{
		static readonly string progver = "1.05";


		#region Global Variables

		static bool confirmsettimestamp = true;
		static bool filedatereplacescapturedate = false;
		static bool readabletimestamp = true;
		static bool recursive = false;
		static bool settimestamp = false;
		static bool useexiftool = false;
		static bool wildcards = false;
		static double timediffthreshold = 3600;
		static int renamecount = 0;
		static string exiftool = string.Empty;
		static string searchpattern = "*.*";

		#endregion Global Variables


		static int Main( string[] args )
		{
			#region Initialize Variables

			string startdir = Environment.CurrentDirectory; // in case no directory is specified
			string[] filespec;

			#endregion Initialize Variables


			#region Parse Command Line

			if ( args.Length == 0 )
			{
				return ShowHelp( );
			}

			foreach ( string arg in args )
			{
				if ( arg == "/?" || arg.Length < 2 )
				{
					return ShowHelp( );
				}
				if ( arg[0] == '/' )
				{
					switch ( arg.Substring( 0, 2 ).ToUpper( ) )
					{
						case "/D":
							if ( arg.Length > 3 && arg[2] == ':' )
							{
								if ( timediffthreshold != 3600 )
								{
									return ShowHelp( "Duplicate switch: /D" );
								}
								try
								{
									timediffthreshold = Convert.ToDouble( arg.Substring( 3 ) );
								}
								catch
								{
									return ShowHelp( "Invalid value: \"{0}\"", arg );
								}
							}
							else
							{
								return ShowHelp( "Invalid value: \"{0}\"", arg );
							}
							break;
						case "/F":
							if ( filedatereplacescapturedate )
							{
								return ShowHelp( "Duplicate switch: /F" );
							}
							filedatereplacescapturedate = true;
							break;
						case "/R":
							if ( recursive )
							{
								return ShowHelp( "Duplicate switch: /R" );
							}
							recursive = true;
							break;
						case "/S":
							if ( settimestamp )
							{
								return ShowHelp( "Duplicate switch: /S" );
							}
							settimestamp = true;
							break;
						case "/T":
							if ( !readabletimestamp )
							{
								return ShowHelp( "Duplicate switch: /T" );
							}
							readabletimestamp = false;
							break;
						case "/X":
							if ( useexiftool )
							{
								return ShowHelp( "Duplicate switch: /X" );
							}
							useexiftool = true;
							break;
						case "/Y":
							if ( !confirmsettimestamp )
							{
								return ShowHelp( "Duplicate switch: /Y" );
							}
							confirmsettimestamp = false;
							break;
						default:
							return ShowHelp( "Invalid switch: \"{0}\"", arg );
					}
				}
				else
				{
					searchpattern = Path.GetFileName( arg );
					wildcards = ( searchpattern.IndexOfAny( "*?".ToCharArray( ) ) > -1 );
					startdir = Directory.GetParent( arg ).FullName;
					if ( string.IsNullOrEmpty( startdir ) && !Directory.Exists( startdir ) )
					{
						return ShowHelp( "Folder not found: \"{0}\"", startdir );
					}
					filespec = Directory.GetFiles( startdir, searchpattern );
				}
			}
			if ( !confirmsettimestamp && !settimestamp )
			{
				return ShowHelp( "/Y switch is valid only when combined with /S switch." );
			}
			if ( timediffthreshold != 3600 && !settimestamp )
			{
				return ShowHelp( "/D switch is valid only when combined with /S switch." );
			}
			if ( useexiftool )
			{
				string[] path = string.Format( "{0};{1}", startdir, Environment.GetEnvironmentVariable( "PATH" ) ).Split( ";".ToCharArray( ), StringSplitOptions.RemoveEmptyEntries );
				foreach ( string dir in path )
				{
					if ( string.IsNullOrWhiteSpace( exiftool ) && File.Exists( Path.Combine( dir, "exiftool.exe" ) ) )
					{
						exiftool = Path.Combine( dir, "exiftool.exe" );
					}
				}
				if ( string.IsNullOrWhiteSpace( exiftool ) )
				{
					return ShowHelp( "ExifTool.exe not found, which makes /X switch invalid" );
				}
			}
			if ( filedatereplacescapturedate && !( useexiftool && settimestamp ) )
			{
				return ShowHelp( "/F switch is valid only when combined with /S and /X switches." );
			}

			#endregion Parse Command Line


			ProcessFolder( startdir );

			return renamecount;
		}


		static string GetTimestampEXIF( string filename, bool usefiletags = true )
		{
			string photodatedelimited = string.Empty;
			string pattern = "\\b[12]\\d{3}:[01]\\d:[0-3]\\d [0-2]\\d:[0-5]\\d:[0-5]\\d(\\b|\\+)";
			Regex regexp = new Regex( pattern, RegexOptions.None );

			// First try the standard EXIF tag (should return 1 timestamp)
			ProcessStartInfo si = new ProcessStartInfo( )
			{
				FileName = exiftool,
				Arguments = "-EXIF:DateTimeOriginal " + filename,
				UseShellExecute = false,
				RedirectStandardOutput = true,
			};
			Process proc = Process.Start( si );
			proc.WaitForExit( );
			string exif = proc.StandardOutput.ReadToEnd( );
			MatchCollection matches = regexp.Matches( exif );
			if ( matches.Count > 0 )
			{
				photodatedelimited = matches[0].Value;
			}
			else if ( usefiletags )
			{
				// If querying the standard EXIF tag fails, try the file related
				// EXIF tags (will return 3 timestamps, we need the oldest one)
				si = new ProcessStartInfo( )
				{
					FileName = exiftool,
					Arguments = "-FILE:* " + filename,
					UseShellExecute = false,
					RedirectStandardOutput = true,
				};
				proc = Process.Start( si );
				proc.WaitForExit( );
				exif = proc.StandardOutput.ReadToEnd( );

				#region Find Earliest Date String

				regexp = new Regex( pattern, RegexOptions.None );
				matches = regexp.Matches( exif );
				if ( matches.Count == 0 )
				{
					ShowHelp( "No capture date found in EXIF data" );
					return String.Empty;
				}
				foreach ( Match match in matches )
				{
					int compare = string.Compare( photodatedelimited, match.Value, StringComparison.Ordinal );
					if ( string.IsNullOrEmpty( photodatedelimited ) || compare > 0 )
					{
						photodatedelimited = match.Value;
					}
				}

				#endregion Find Earliest Date String
			}

			return photodatedelimited;
		}


		static void ProcessFolder( string folder )
		{
			string[] filespec = Directory.GetFiles( folder, searchpattern );
			foreach ( string filename in filespec )
			{
				if ( filedatereplacescapturedate )
				{
					int rc = SetTimestampEXIF( filename );
					if ( rc != 0 )
					{
						ShowHelp( "Returncode {0} for \"{1}\"", rc.ToString( ), filename );
					}
				}
				else
				{
					ProcessImage( filename );
				}
			}
			if ( recursive )
			{
				string[] subdirs = Directory.GetDirectories( folder );
				foreach ( string subdir in subdirs )
				{
					ProcessFolder( subdir );
				}
			}
		}


		static void ProcessImage( string filename )
		{
			#region Read First MB of File

			long filesize = new FileInfo( filename ).Length;
			int buffersize = Convert.ToInt32( Math.Min( filesize, 1048576 ) ); // Buffer size is 1 MB or file size, whichever is the smallest
			StreamReader file = new StreamReader( filename );
			char[] buffer = new Char[buffersize];
			_ = file.Read( buffer, 0, buffersize - 1 ); // Read only the first 1 MB of the file (or the entire file if smaller than 1 MB)
			file.Close( );
			string header = new String( buffer );

			if ( String.IsNullOrEmpty( header ) )
			{
				ShowHelp( "Could not open file \"{0}\"", filename );
				return;
			}

			#endregion Read First MB of File


			#region Find Earliest Date String

			string photodatedelimited = string.Empty;
			string pattern = "\\b[12]\\d{3}:[01]\\d:[0-3]\\d [0-2]\\d:[0-5]\\d:[0-5]\\d\\b";
			Regex regexp = new Regex( pattern, RegexOptions.None );
			MatchCollection matches = regexp.Matches( header );
			if ( matches.Count == 0 )
			{
				if ( useexiftool )
				{
					photodatedelimited = GetTimestampEXIF( filename );
				}
				else
				{
					ShowHelp( "No capture date found in file header" );
					return;
				}
			}
			else
			{
				foreach ( Match match in matches )
				{
					if ( string.IsNullOrEmpty( photodatedelimited ) || string.Compare( photodatedelimited, match.Value, StringComparison.Ordinal ) > 0 )
					{
						photodatedelimited = match.Value;
					}
				}
			}
			photodatedelimited = photodatedelimited.Substring( 0, 10 ).Replace( ':', '-' ) + photodatedelimited.Substring( 10 );
			string photodatenodelims = photodatedelimited.Replace( ":", "" ).Replace( "-", "" ).Replace( " ", "T" );

			#endregion Find Earliest Date String


			#region Set File Timestamp

			if ( settimestamp )
			{
				string timeformat;
				if ( readabletimestamp )
				{
					timeformat = "{0:yyyy}-{0:MM}-{0:dd} {0:HH}:{0:mm}:{0:ss}";
				}
				else
				{
					timeformat = "{0:yyyy}{0:MM}{0:dd}T{0:HH}{0:mm}{0:ss}";
				}
				DateTime currenttimestamp = File.GetLastWriteTime( filename );
				if ( DateTime.TryParse( photodatedelimited, out DateTime newtimestamp ) ) // Try parsing the new file timestamp using the capture timestamp string
				{
					if ( DateTime.Compare( currenttimestamp, newtimestamp ) == 0 ) // File and capture timestamps are equal
					{
						string photodate = photodatenodelims;
						if ( readabletimestamp )
						{
							photodate = photodatedelimited;
						}
						if ( wildcards )
						{
							Console.WriteLine( "{0}\t\"{1}\"", photodate, filename );
						}
						else
						{
							Console.WriteLine( photodate );
						}
					}
					else
					{
						double timediff = Math.Abs( ( currenttimestamp - newtimestamp ).TotalSeconds ); // Calculate absolute value of timestamps' difference in seconds
						if ( timediff > timediffthreshold ) // Ignore time differences up to threshold (default 1 hour, or value set with /D switch)
						{
							string blanks = "\n" + new String( ' ', 70 ) + new String( '\b', 70 ); // String to erase the first 70 characters on the next line
							Console.WriteLine( "Image file name        : {0}", filename );
							Console.WriteLine( "Current file timestamp : " + timeformat, currenttimestamp );
							Console.WriteLine( "Capture timestamp      : " + timeformat, newtimestamp );
							if ( confirmsettimestamp )
							{
								Console.Write( "Do you want to change the file's timestamp to the capture time? [yN] " );
								string answer = Console.ReadKey( ).KeyChar.ToString( ).ToUpper( );
								if ( answer == "Y" )
								{
									File.SetLastWriteTime( filename, newtimestamp );
									Console.CursorTop -= 1; // Move the cursor 1 line up
									Console.WriteLine( blanks + "New file timestamp     : " + timeformat, File.GetLastWriteTime( filename ) ); // Overwrite prompt with new timestamp
									renamecount += 1;
								}
								else
								{
									Console.WriteLine( "\nskipping . . ." );
								}
							}
							else
							{
								File.SetLastWriteTime( filename, newtimestamp );
								Console.CursorTop -= 1; // Move the cursor 1 line up
								Console.WriteLine( blanks + "New file timestamp     : " + timeformat, File.GetLastWriteTime( filename ) ); // Overwrite prompt with new timestamp
								renamecount += 1;
							}
						}
						else
						{
							Console.WriteLine( photodatedelimited ); // Timespans' difference is not above threshold (default 1 hour, or value set with /D switch)
						}
					}
				}
				else
				{
					ShowHelp( "Could not determine timestamp of \"{0}\"", filename );
					return;
				}
			}
			else
			{
				Console.WriteLine( "{0}\t\"{1}\"", photodatedelimited, filename );
			}

			#endregion Set File Timestamp
		}


		static int SetTimestampEXIF( string filename )
		{
			DateTime filetimestamp = File.GetLastWriteTime( filename );
			string capturetimestamp = GetTimestampEXIF( filename, false );
			string timeformat;
			if ( readabletimestamp )
			{
				timeformat = "{0:yyyy}-{0:MM}-{0:dd} {0:HH}:{0:mm}:{0:ss}";
				if ( capturetimestamp.Length > 10 )
				{
					capturetimestamp = capturetimestamp.Substring( 0, 10 ).Replace( ':', '-' ) + capturetimestamp.Substring( 10 );
				}
			}
			else
			{
				timeformat = "{0:yyyy}{0:MM}{0:dd}T{0:HH}{0:mm}{0:ss}";
				if ( capturetimestamp.Length > 10 )
				{
					capturetimestamp = capturetimestamp.Replace( ":", "" ).Replace( " ", "T" );
				}
			}
			Console.WriteLine( "Image file name           : {0}", filename );
			Console.WriteLine( "Current capture timestamp : {0}", capturetimestamp );
			Console.WriteLine( "Current file timestamp    : " + timeformat, filetimestamp );
			if ( capturetimestamp == string.Format( timeformat, filetimestamp ) )
			{
				return 0;
			}
			string blanks = "\n" + new String( ' ', 70 ) + new String( '\b', 70 ); // String to erase the first 70 characters on the next line
			if ( confirmsettimestamp )
			{
				Console.Write( "Do you want to change the file's capture time to its file timestamp? [yN] " );
				string answer = Console.ReadKey( ).KeyChar.ToString( ).ToUpper( );
				if ( answer == "N" )
				{
					Console.WriteLine( "\nskipping . . ." );
					return -1;
				}
				else
				{
					Console.WriteLine( );
				}
			}

			ProcessStartInfo si = new ProcessStartInfo( )
			{
				FileName = exiftool,
				Arguments = string.Format( "-EXIF:DateTimeOriginal=\"{0:yyyy}:{0:MM}:{0:dd} {0:HH}:{0:mm}:{0:ss}\" \"{1}\"", filetimestamp, filename ),
				UseShellExecute = false,
				RedirectStandardOutput = true,
			};
			Process proc = Process.Start( si );
			proc.WaitForExit( );
			// restore file timestamp
			if ( proc.ExitCode == 0 )
			{
				File.SetLastWriteTime( filename, filetimestamp );
				if ( confirmsettimestamp )
				{
					capturetimestamp = GetTimestampEXIF( filename, false );
					if ( readabletimestamp )
					{
						capturetimestamp = capturetimestamp.Substring( 0, 10 ).Replace( ':', '-' ) + capturetimestamp.Substring( 10 );
					}
					else
					{
						capturetimestamp = capturetimestamp.Replace( ":", "" ).Replace( " ", "T" );
					}
					Console.CursorTop -= 1; // Move the cursor 1 line up
					Console.WriteLine( blanks + "New capture timestamp     : {0}", capturetimestamp ); // Overwrite prompt with new timestamp
				}
				renamecount += 1;
			}
			return proc.ExitCode;
		}


		static string Today( bool usedelims = true )
		{
			string dateformat;
			if ( usedelims )
			{
				dateformat = "{0:yyyy}-{0:MM}-{0:dd} {0:HH}:{0:mm}:{0:ss}";
			}
			else
			{
				dateformat = "{0:yyyy}{0:MM}{0:dd}T{0:HH}{0:mm}{0:ss}";
			}
			return String.Format( dateformat, DateTime.Now );
		}


		#region Error handling

		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

			/*
			CaptureDate,  Version 1.05
			Return the capture date and time for the specified image file

			Usage:   CAPTUREDATE  image  [ options ]
			
			Where:   image        specifies the image file(s) (wildcards allowed)

			Options: /D:seconds   minimum Difference in seconds between current file
			                      timestamp and capture date/time; if the difference
			                      exceeds the specified number of seconds, the file
			                      timestamp will be set to the capture date/time
			                      (default: 3600 seconds = 1 hour; requires /S switch)
			         /F           set capture date/time to current File timestamp
			                      (requires /S and /X switches)
			         /R           Recursive (include subdirectories); you probably want
			                      to use wildcards for image with this option
			         /S           Set the image file timestamp to the capture date/time
			         /T           return the timestamp without "-" and ":" delimiters,
			                      e.g. 20171114T135628 instead of 2017-11-14 13:56:28
			         /X           use eXiftool by Phil Harvey (https://exiftool.org/;
			                      requires exiftool.exe in the current directory or in
			                      a directory listed in the PATH)
			         /Y           do not ask for confirmation before changing the image
			                      file's timestamp (requires /S switch)
			
			Notes:   Result will be displayed on screen, e.g. 2017-11-14 13:56:28.
			         The date/time is extracted by searching for the earliest date/time
			         string in the first 1048576 bytes (1 MB) of the image file. If no
			         capture date/time is found that way, and the /X switch is used,
			         exiftool.exe is used to try and read the capture date/time from the
			         image's EXIF data. If this also fails, you can use the /F switch to
			         set a new capture date/time in EXIF equal to the file date/time.
			         With /S switch used, the timestamp is changed only if the difference
			         between the current timestamp and the capture time exceeds 1 hour or
			         the threshold set with the /D switch.
			         The program will ask for confirmation before changing the file's
			         timestamp, unless the /Y switch is used.
			         Return code ("errorlevel") is -1 in case of errors, or with /S it
			         equals the number of files renamed, or 0 otherwise.

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

			#endregion Help Text


			#region Display Help

			string timestampDelimited = Today( true );
			string timestampNodelims = Today( false );
			Console.Error.WriteLine( );

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

			Console.Error.WriteLine( "Return the capture date and time for the specified image file" );

			Console.Error.WriteLine( );

			Console.Error.Write( "Usage:   " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.WriteLine( "CAPTUREDATE  image  [ options ]" );
			Console.ResetColor( );

			Console.Error.WriteLine( );

			Console.Error.Write( "Where:   " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "image" );
			Console.ResetColor( );
			Console.Error.WriteLine( "        specifies the image file(s) (wildcards allowed)" );

			Console.Error.WriteLine( );

			Console.Error.Write( "Options: " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "/D:seconds" );
			Console.ResetColor( );
			Console.Error.Write( "   minimum " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "D" );
			Console.ResetColor( );
			Console.Error.Write( "ifference in " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "seconds" );
			Console.ResetColor( );
			Console.Error.WriteLine( " between current file" );

			Console.Error.WriteLine( "                      timestamp and capture date/time; if the difference" );

			Console.Error.WriteLine( "                      exceeds the specified number of seconds, the file" );

			Console.Error.WriteLine( "                      timestamp will be set to the capture date/time" );

			Console.Error.Write( "                      (default: 3600 seconds = 1 hour; requires " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "/S" );
			Console.ResetColor( );
			Console.Error.WriteLine( " switch)" );

			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "         /F" );
			Console.ResetColor( );
			Console.Error.Write( "           set capture date/time to current " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "F" );
			Console.ResetColor( );
			Console.Error.WriteLine( "ile timestamp" );

			Console.Error.Write( "                      (requires " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "/S" );
			Console.ResetColor( );
			Console.Error.Write( " and " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "/X" );
			Console.ResetColor( );
			Console.Error.WriteLine( " switches)" );

			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "         /R           R" );
			Console.ResetColor( );
			Console.Error.WriteLine( "ecursive (include subdirectories); you probably want" );

			Console.Error.Write( "                      to use wildcards for " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "image" );
			Console.ResetColor( );
			Console.Error.WriteLine( " with this option" );

			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "         /S           S" );
			Console.ResetColor( );
			Console.Error.WriteLine( "et the image file's timestamp to the capture date/time" );

			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "         /T" );
			Console.ResetColor( );
			Console.Error.WriteLine( "           return the timestamp without \"-\" and \":\" delimiters," );

			Console.Error.Write( "                      e.g. " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( timestampNodelims );
			Console.ResetColor( );
			Console.Error.Write( " instead of " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( timestampDelimited );
			Console.ResetColor( );
			Console.Error.WriteLine( "." );

			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "         /X" );
			Console.ResetColor( );
			Console.Error.Write( "           use e" );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "X" );
			Console.ResetColor( );
			Console.Error.Write( "iftool by Phil Harvey (" );
			Console.ForegroundColor = ConsoleColor.DarkGray;
			Console.Error.Write( "https://exiftool.org/" );
			Console.ResetColor( );
			Console.Error.WriteLine( ";" );

			Console.Error.WriteLine( "                      requires exiftool.exe in the current directory or in" );

			Console.Error.WriteLine( "                      a directory listed in the PATH)" );

			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "         /Y" );
			Console.ResetColor( );
			Console.Error.WriteLine( "           do not ask for confirmation before changing the image" );

			Console.Error.Write( "                      file's timestamp (requires " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "/S" );
			Console.ResetColor( );
			Console.Error.WriteLine( " switch)" );

			Console.Error.WriteLine( );

			Console.Error.Write( "Notes:   Result will be displayed on screen, e.g. " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( timestampDelimited );
			Console.ResetColor( );
			Console.Error.WriteLine( "." );

			Console.Error.WriteLine( "         The date/time is extracted by searching for the earliest date/time" );

			Console.Error.WriteLine( "         in the first 1048576 bytes (1 MB) of the image file. If no" );

			Console.Error.Write( "         capture date/time is found that way, and the " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "/X" );
			Console.ResetColor( );
			Console.Error.WriteLine( " switch is used," );

			Console.Error.WriteLine( "         exiftool.exe is used to try and read the capture date/time from the" );

			Console.Error.Write( "         image's EXIF data. If this also fails, you can use the " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "/F" );
			Console.ResetColor( );
			Console.Error.WriteLine( " switch to" );

			Console.Error.Write( "         set a " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "new" );
			Console.ResetColor( );
			Console.Error.WriteLine( " capture date/time in EXIF equal to the file date/time." );

			Console.Error.Write( "         With " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "/S" );
			Console.ResetColor( );
			Console.Error.WriteLine( " switch used, the timestamp is changed only if the difference" );

			Console.Error.WriteLine( "         between the current timestamp and the capture time exceeds 1 hour or" );

			Console.Error.Write( "         the threshold set with the " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "/D" );
			Console.ResetColor( );
			Console.Error.WriteLine( " switch." );

			Console.Error.WriteLine( "         The program will ask for confirmation before changing the file's" );

			Console.Error.Write( "         timestamp, unless the " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "/Y" );
			Console.ResetColor( );
			Console.Error.WriteLine( " switch is used." );

			Console.Error.Write( "         Return code (\"errorlevel\") is -1 in case of errors, or with " );
			Console.ForegroundColor = ConsoleColor.White;
			Console.Error.Write( "/S" );
			Console.ResetColor( );
			Console.Error.WriteLine( " it" );

			Console.Error.WriteLine( "         equals the number of files renamed, or 0 otherwise." );

			Console.Error.WriteLine( );

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

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

			#endregion Display Help


			return -1;
		}

		#endregion Error handling

	}
}