/*
** 2015 October 7
**
** The author disclaims copyright to this source code. In place of
** a legal notice, here is a blessing:
**
** May you do good and not evil.
** May you find forgiveness for yourself and forgive others.
** May you share freely, never taking more than you give.
**
*************************************************************************
** This file contains C# code to download a single file based on a URI.
*/

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Threading;

///////////////////////////////////////////////////////////////////////////////

#region Assembly Metadata
[assembly: AssemblyTitle("GetFile Tool")]
[assembly: AssemblyDescription("Download a single file based on a URI.")]
[assembly: AssemblyCompany("SQLite Development Team")]
[assembly: AssemblyProduct("SQLite")]
[assembly: AssemblyCopyright("Public Domain")]
[assembly: ComVisible(false)]
[assembly: Guid("5c4b3728-1693-4a33-a218-8e6973ca15a6")]
[assembly: AssemblyVersion("1.0.*")]

#if DEBUG
[assembly: AssemblyConfiguration("Debug")]
#else
[assembly: AssemblyConfiguration("Release")]
#endif
#endregion

///////////////////////////////////////////////////////////////////////////////

namespace GetFile
{
 /// <summary>
 /// This enumeration is used to represent all the possible exit codes from
 /// this tool.
 /// </summary>
 internal enum ExitCode
 {
 /// <summary>
 /// The file download was a success.
 /// </summary>
 Success = 0,

 /// <summary>
 /// The command line arguments are missing (i.e. null). Generally,
 /// this should not happen.
 /// </summary>
 MissingArgs = 1,

 /// <summary>
 /// The wrong number of command line arguments was supplied.
 /// </summary>
 WrongNumArgs = 2,

 /// <summary>
 /// The URI specified on the command line could not be parsed as a
 /// supported absolute URI.
 /// </summary>
 BadUri = 3,

 /// <summary>
 /// The file name portion of the URI specified on the command line
 /// could not be extracted from it.
 /// </summary>
 BadFileName = 4,

 /// <summary>
 /// The temporary directory is either invalid (i.e. null) or does not
 /// represent an available directory.
 /// </summary>
 BadTempPath = 5,

 /// <summary>
 /// An exception was caught in <see cref="Main" />. Generally, this
 /// should not happen.
 /// </summary>
 Exception = 6,

 /// <summary>
 /// The file download was canceled. This tool does not make use of
 /// the <see cref="WebClient.CancelAsync" /> method; therefore, this
 /// should not happen.
 /// </summary>
 DownloadCanceled = 7,

 /// <summary>
 /// The file download encountered an error. Further information about
 /// this error should be displayed on the console.
 /// </summary>
 DownloadError = 8
 }

 ///////////////////////////////////////////////////////////////////////////

 internal static class Program
 {
 #region Private Data
 /// <summary>
 /// This is used to synchronize multithreaded access to the
 /// <see cref="previousPercent" /> and <see cref="exitCode"/>
 /// fields.
 /// </summary>
 private static readonly object syncRoot = new object();

 ///////////////////////////////////////////////////////////////////////

 /// <summary>
 /// This event will be signed when the file download has completed,
 /// even if the file download itself was canceled or unsuccessful.
 /// </summary>
 private static EventWaitHandle doneEvent;

 ///////////////////////////////////////////////////////////////////////

 /// <summary>
 /// The previous file download completion percentage seen by the
 /// <see cref="DownloadProgressChanged" /> event handler. This value
 /// is never decreased, nor is it ever reset to zero.
 /// </summary>
 private static int previousPercent = 0;

 ///////////////////////////////////////////////////////////////////////

 /// <summary>
 /// This will be the exit code returned by this tool after the file
 /// download completes, successfully or otherwise. This value is only
 /// changed by the <see cref="DownloadFileCompleted" /> event handler.
 /// </summary>
 private static ExitCode exitCode = ExitCode.Success;
 #endregion

 ///////////////////////////////////////////////////////////////////////

 #region Private Support Methods
 /// <summary>
 /// This method displays an error message to the console and/or
 /// displays the command line usage information for this tool.
 /// </summary>
 /// <param name="message">
 /// The error message to display, if any.
 /// </param>
 /// <param name="usage">
 /// Non-zero to display the command line usage information.
 /// </param>
 private static void Error(
 string message,
 bool usage
 )
 {
 if (message != null)
 Console.WriteLine(message);

 string fileName = Path.GetFileName(
 Process.GetCurrentProcess().MainModule.FileName);

 Console.WriteLine(String.Format(
 "usage: {0} <uri> [fileName]", fileName));
 }

 ///////////////////////////////////////////////////////////////////////

 /// <summary>
 /// This method attempts to determine the file name portion of the
 /// specified URI.
 /// </summary>
 /// <param name="uri">
 /// The URI to process.
 /// </param>
 /// <returns>
 /// The file name portion of the specified URI -OR- null if it cannot
 /// be determined.
 /// </returns>
 private static string GetFileName(
 Uri uri
 )
 {
 if (uri == null)
 return null;

 string pathAndQuery = uri.PathAndQuery;

 if (String.IsNullOrEmpty(pathAndQuery))
 return null;

 int index = pathAndQuery.LastIndexOf('/');

 if ((index < 0) || (index == pathAndQuery.Length))
 return null;

 return pathAndQuery.Substring(index + 1);
 }
 #endregion

 ///////////////////////////////////////////////////////////////////////

 #region Private Event Handlers
 /// <summary>
 /// This method is an event handler that is called when the file
 /// download completion percentage changes. It will display progress
 /// on the console. Special care is taken to make sure that progress
 /// events are not displayed out-of-order, even if duplicate and/or
 /// out-of-order events are received.
 /// </summary>
 /// <param name="sender">
 /// The source of the event.
 /// </param>
 /// <param name="e">
 /// Information for the event being processed.
 /// </param>
 private static void DownloadProgressChanged(
 object sender,
 DownloadProgressChangedEventArgs e
 )
 {
 if (e != null)
 {
 int percent = e.ProgressPercentage;

 lock (syncRoot)
 {
 if (percent > previousPercent)
 {
 Console.Write('.');

 if ((percent % 10) == 0)
 Console.Write(" {0}% ", percent);

 previousPercent = percent;
 }
 }
 }
 }

 ///////////////////////////////////////////////////////////////////////

 /// <summary>
 /// This method is an event handler that is called when the file
 /// download has completed, successfully or otherwise. It will
 /// display the overall result of the file download on the console,
 /// including any <see cref="Exception" /> information, if applicable.
 /// The <see cref="exitCode" /> field is changed by this method to
 /// indicate the overall result of the file download and the event
 /// within the <see cref="doneEvent" /> field will be signaled.
 /// </summary>
 /// <param name="sender">
 /// The source of the event.
 /// </param>
 /// <param name="e">
 /// Information for the event being processed.
 /// </param>
 private static void DownloadFileCompleted(
 object sender,
 AsyncCompletedEventArgs e
 )
 {
 if (e != null)
 {
 lock (syncRoot)
 {
 if (previousPercent < 100)
 Console.Write(' ');
 }

 if (e.Cancelled)
 {
 Console.WriteLine("Canceled");

 lock (syncRoot)
 {
 exitCode = ExitCode.DownloadCanceled;
 }
 }
 else
 {
 Exception error = e.Error;

 if (error != null)
 {
 Console.WriteLine("Error: {0}", error);

 lock (syncRoot)
 {
 exitCode = ExitCode.DownloadError;
 }
 }
 else
 {
 Console.WriteLine("Done");
 }
 }
 }

 if (doneEvent != null)
 doneEvent.Set();
 }
 #endregion

 ///////////////////////////////////////////////////////////////////////

 #region Program Entry Point
 /// <summary>
 /// This is the entry-point for this tool. It handles processing the
 /// command line arguments, setting up the web client, downloading the
 /// file, and saving it to the file system.
 /// </summary>
 /// <param name="args">
 /// The command line arguments.
 /// </param>
 /// <returns>
 /// Zero upon success; non-zero on failure. This will be one of the
 /// values from the <see cref="ExitCode" /> enumeration.
 /// </returns>
 private static int Main(
 string[] args
 )
 {
 //
 // NOTE: Sanity check the command line arguments.
 //
 if (args == null)
 {
 Error(null, true);
 return (int)ExitCode.MissingArgs;
 }

 if ((args.Length < 1) || (args.Length > 2))
 {
 Error(null, true);
 return (int)ExitCode.WrongNumArgs;
 }

 //
 // NOTE: Attempt to convert the first (and only) command line
 // argument to an absolute URI.
 //
 Uri uri;

 if (!Uri.TryCreate(args[0], UriKind.Absolute, out uri))
 {
 Error("Could not create absolute URI from argument.", false);
 return (int)ExitCode.BadUri;
 }

 //
 // NOTE: If a file name was specified on the command line, try to
 // use it (without its directory name); otherwise, fallback
 // to using the file name portion of the URI.
 //
 string fileName = (args.Length == 2) ?
 Path.GetFileName(args[1]) : null;

 if (String.IsNullOrEmpty(fileName))
 {
 //
 // NOTE: Attempt to extract the file name portion of the URI
 // we just created.
 //
 fileName = GetFileName(uri);

 if (fileName == null)
 {
 Error("Could not extract file name from URI.", false);
 return (int)ExitCode.BadFileName;
 }
 }

 //
 // NOTE: Grab the temporary path setup for this process. If it is
 // unavailable, we will not continue.
 //
 string directory = Path.GetTempPath();

 if (String.IsNullOrEmpty(directory) ||
 !Directory.Exists(directory))
 {
 Error("Temporary directory is invalid or unavailable.", false);
 return (int)ExitCode.BadTempPath;
 }

 try
 {
 //
 // HACK: For use of the TLS 1.2 security protocol because some
 // web servers fail without it. In order to support the
 // .NET Framework 2.0+ at compilation time, must use its
 // integer constant here.
 //
 ServicePointManager.SecurityProtocol =
 (SecurityProtocolType)0xC00;

 using (WebClient webClient = new WebClient())
 {
 //
 // NOTE: Create the event used to signal completion of the
 // file download.
 //
 doneEvent = new ManualResetEvent(false);

 //
 // NOTE: Hookup the event handlers we care about on the web
 // client. These are necessary because the file is
 // downloaded asynchronously.
 //
 webClient.DownloadProgressChanged +=
 new DownloadProgressChangedEventHandler(
 DownloadProgressChanged);

 webClient.DownloadFileCompleted +=
 new AsyncCompletedEventHandler(
 DownloadFileCompleted);

 //
 // NOTE: Build the fully qualified path and file name,
 // within the temporary directory, where the file to
 // be downloaded will be saved.
 //
 fileName = Path.Combine(directory, fileName);

 //
 // NOTE: If the file name already exists (in the temporary)
 // directory, delete it.
 //
 // TODO: Perhaps an error should be raised here instead?
 //
 if (File.Exists(fileName))
 File.Delete(fileName);

 //
 // NOTE: After kicking off the asynchronous file download
 // process, wait [forever] until the "done" event is
 // signaled.
 //
 Console.WriteLine(
 "Downloading \"{0}\" to \"{1}\"...", uri, fileName);

 webClient.DownloadFileAsync(uri, fileName);
 doneEvent.WaitOne();
 }

 lock (syncRoot)
 {
 return (int)exitCode;
 }
 }
 catch (Exception e)
 {
 //
 // NOTE: An exception was caught. Report it via the console
 // and return failure.
 //
 Error(e.ToString(), false);
 return (int)ExitCode.Exception;
 }
 }
 #endregion
 }
}