using System.Diagnostics;

using Exortech.NetReflector;

using ThoughtWorks.CruiseControl.Core.Util;



namespace ThoughtWorks.CruiseControl.Core.Sourcecontrol

{

    /// <summary>

    /// <para>

    /// Uses RoboCopy as Source Control.

    /// </para>

    /// </summary>	

    /// <title>RoboCopy Source Control Block</title>

    /// <version>1.4.4</version>

    /// <key name="type">

    /// <description>The type of source control block.</description>

    /// <value>robocopy</value>

    /// </key>

    /// <example>

    /// <code>

    /// &lt;sourcecontrol type="robocopy"&gt;

    /// &lt;repositoryRoot&gt;C:\Somewhere&lt;/repositoryRoot&gt;

    /// &lt;/sourcecontrol&gt;

    /// </code>

    /// </example>

    [ReflectorType("robocopy")]

	public class RobocopySourceControl : ProcessSourceControl

	{

		private static int[] GenerateExitCodes()

		{

			int[] exitCodes = new int[4];



			exitCodes[0] = 0;			// All OK, nothing to do

			exitCodes[1] = 1;			// Some files copied

			exitCodes[2] = 2;			// Some extra files in destination tree

			exitCodes[3] = 3;			// Copied and some extra files in destination tree



			// Note that we COULD want to have 4-7 as valid success codes, but i've not been 

			// able to cause them to occur yet and so havent included them here.

			

			return exitCodes;

		}



		private static readonly int[] successExitCodes = GenerateExitCodes();



        /// <summary>

        /// Initializes a new instance of the <see cref="RobocopySourceControl" /> class.	

        /// </summary>

        /// <remarks></remarks>

		public RobocopySourceControl() : this(new RobocopyHistoryParser(), new ProcessExecutor())

		{}



        /// <summary>

        /// Initializes a new instance of the <see cref="RobocopySourceControl" /> class.	

        /// </summary>

        /// <param name="parser">The parser.</param>

        /// <param name="executor">The executor.</param>

        /// <remarks></remarks>

        public RobocopySourceControl(IHistoryParser parser, ProcessExecutor executor)

            : base(parser, executor)

        {

            this.Executable = "C:\\Windows\\System32\\robocopy.exe";

            this.AutoGetSource = false;

            this.WorkingDirectory = string.Empty;

            this.AdditionalArguments = string.Empty;

        }



        /// <summary>

        /// The executable location.

        /// </summary>

        /// <version>1.4.4</version>

        /// <default>C:\\Windows\\System32\\robocopy.exe</default>

        [ReflectorProperty("executable", Required = false)]

        public string Executable { get; set; }



        /// <summary>

        /// The repository root.

        /// </summary>

        /// <version>1.4.4</version>

        /// <default>n/a</default>

        [ReflectorProperty("repositoryRoot")]

        public string RepositoryRoot { get; set; }



        /// <summary>

        /// Whether to automatically get the source.

        /// </summary>

        /// <version>1.4.4</version>

        /// <default>false</default>

        [ReflectorProperty("autoGetSource", Required = false)]

        public bool AutoGetSource { get; set; }



        /// <summary>

        /// The working directory to use.

        /// </summary>

        /// <version>1.4.4</version>

        /// <default>Project Working Directory</default>

        [ReflectorProperty("workingDirectory", Required = false)]

        public string WorkingDirectory { get; set; }



        /// <summary>

        /// Any additional arguments.

        /// </summary>

        /// <version>1.4.4</version>

        /// <default>None</default>

        [ReflectorProperty("additionalArguments", Required = false)]

        public string AdditionalArguments { get; set; }



        /// <summary>

        /// Gets the modifications.	

        /// </summary>

        /// <param name="from">From.</param>

        /// <param name="to">To.</param>

        /// <returns></returns>

        /// <remarks></remarks>

		public override Modification[] GetModifications(IIntegrationResult from, IIntegrationResult to)

		{

			string destinationDirectory = from.BaseFromWorkingDirectory(WorkingDirectory);



			ProcessArgumentBuilder builder = new ProcessArgumentBuilder();



			AddStandardArguments(builder, destinationDirectory);



			builder.AddArgument("/L");



			Modification[] modifications = GetModifications(new ProcessInfo(Executable, builder.ToString(), null, ProcessPriorityClass.Normal, successExitCodes), from.StartTime, to.StartTime);



			return modifications;

		}



        /// <summary>

        /// Labels the source control.	

        /// </summary>

        /// <param name="result">The result.</param>

        /// <remarks></remarks>

		public override void LabelSourceControl(IIntegrationResult result)

		{}



        /// <summary>

        /// Gets the source.	

        /// </summary>

        /// <param name="result">The result.</param>

        /// <remarks></remarks>

		public override void GetSource(IIntegrationResult result)

		{

			if (AutoGetSource)

			{

				string destinationDirectory = result.BaseFromWorkingDirectory(WorkingDirectory);

		

				ProcessArgumentBuilder builder = new ProcessArgumentBuilder();



				AddStandardArguments(builder, destinationDirectory);



                Execute(new ProcessInfo(Executable, builder.ToString(), null, ProcessPriorityClass.Normal, successExitCodes));

			}

		}



		// /MIR - MIRror a directory tree (equivalent to /E plus /PURGE).

		// /NP	- No Progress - don't display % copied.

		// /X	- Report all eXtra files, not just those selected.

		// /TS	- Include source file Time Stamps in the output.

		// /FP	- Include Full Pathname of files in the output.

		// /NDL	- No Directory List - don't log directory names.

		// /NS	- No Size - don't log file sizes.

		// /NJH	- No Job Header.

		// /NJS	- No Job Summary.



		private readonly static string standardArguments = " /MIR /NP /X /TS /FP /NDL /NS /NJH /NJS ";



		private void AddStandardArguments(

			ProcessArgumentBuilder builder,

			string destinationDirectory)

		{

			builder.AddArgument(RepositoryRoot);

			builder.AddArgument(destinationDirectory);

			builder.Append(standardArguments);

			builder.Append(AdditionalArguments);

		}

	}

}