using System;
using System.Collections.Specialized;
using System.IO;
using System.Text.RegularExpressions;
using Exortech.NetReflector;
using ThoughtWorks.CruiseControl.Core.Sourcecontrol;
using ThoughtWorks.CruiseControl.Core.Util;

namespace ThoughtWorks.CruiseControl.Core.label
{
	/// <summary>
	/// Labeller for (<a href="www.accurev.com">AccuRev Inc.'s</a> eponymous source code control product.
	/// </summary>
	/// <remarks>
	/// This code is based on code\sourcecontrol\AccuRev.cs and re-uses code\sourcecontrol\AccuRevHistoryParser.cs.
	/// </remarks>
	[ReflectorType("accurevLabeller")]
	public class AccuRevLabeller : ILabeller
	{
		#region Properties

		/// <summary>
		/// Name of the AccuRev CLI command.  
		/// </summary>
		/// <remarks>
		/// Optional, defaults to "accurev.exe".
		/// <remarks>
		[ReflectorProperty("executable", Required = false)]
		public string Executable = "accurev.exe";

		/// <summary>
		/// The location of the AccuRev home directory, either absolute or relative to the project artifact 
		/// directory.  If not specified, AccuRev will follow its rules for determining the location.  The 
		/// home directory itself is always called ".accurev", and AccuRev will create it if there isn't 
		/// already one present in the home directory.
		/// </summary>
		/// <remarks>
		/// Optional, default is to let AccuRev decide where the home directory is.
		/// </remarks>
		[ReflectorProperty("homeDir", Required = false)]
		public string AccuRevHomeDir = null;

		/// <summary>
		/// If true, log in to AccuRev using the specified principal and password.
		/// </summary>
		/// <remarks>
		/// Optional, default is not to log in.  If set to true, "principal" and "password" must also be set.
		/// </remarks>
		[ReflectorProperty("login", Required = false)]
		public bool LogIn = false;

		/// <summary>
		/// The password for the AccuRev "principal" (userid).
		/// </summary>
		/// <remarks>
		/// Optional, default is no password.  Only necessary if "login" is set to "true".
		/// </remarks> 
		[ReflectorProperty("password", Required = false)]
		public string AccuRevPassword = null;

		/// <summary>
		/// The AccuRev "principal" (userid) to run under.  If not specified, AccuRev will follow its rules
		/// for determining the principal.
		/// </summary>
		/// <remarks>
		/// Optional, default is to let AccuRev decide who the principal is.  Must be specified if "login" is
		/// set to "true".
		/// </remarks>
		[ReflectorProperty("principal", Required = false)]
		public string AccuRevPrincipal = null;

		/// <summary>
		/// Pathname of the root of the AccuRev workspace to update and/or check, either absolute or relative
		/// to the project working directory.
		/// </summary>
		/// <remarks>
		/// Optional, defaults to the project working directory.
		/// <remarks>
		[ReflectorProperty("workspace", Required = false)]
		public string Workspace = string.Empty;

		#endregion

		private readonly ProcessExecutor _executor;
		private readonly IHistoryParser _historyParser;

		internal static readonly string HISTORY_COMMAND_FORMAT_LAST_TRAN = @"hist -a -k promote -s ""{0}"" -t HIGHEST";

		public AccuRevLabeller() : this(new AccuRevHistoryParser(), new ProcessExecutor()) {}

		public AccuRevLabeller(IHistoryParser historyParser, ProcessExecutor executor)
		{
			_historyParser = historyParser;
			_executor = executor;
			if (LogIn & ((AccuRevPrincipal == null) || (AccuRevPassword == null)))
			{
				Log.Error("login=true requires principal= and password= to be specified.");
			}
		}

		public string Generate(IIntegrationResult integrationResult)
		{
			PossiblyLogIn(integrationResult);
			string args = string.Format(HISTORY_COMMAND_FORMAT_LAST_TRAN, GetBasisStreamName(integrationResult));
			ProcessInfo histCommand = PrepCommand(args, integrationResult);
			ProcessResult pResult = Execute(histCommand);
			Modification[] mods = _historyParser.Parse(new StringReader(pResult.StandardOutput), DateTime.MinValue, DateTime.MaxValue);
			if (mods.Length == 0)
				return makeDefaultVersion();
			else
				return mods[0].ChangeNumber.ToString();
		}

		public void Run(IIntegrationResult result)
		{
			result.Label = Generate(result);
		}

		private static string makeDefaultVersion()
		{
			return "0";
		}

		/// <summary>
		/// Determine the AccuRev basis stream name for the specified workspace directory.
		/// </summary>
		/// <param name="result">the IIntegrationResult object contaiing the directory name 
		/// of the workspace</param>
		/// <returns>the name of the basis stream</returns>
		private string GetBasisStreamName(IIntegrationResult result)
		{
			string line;
			Regex findBasisRegex = new Regex(@"^\s*Basis:\s+(.+)$");
			PossiblyLogIn(result);
			ProcessResult cmdResults = RunCommand("info", result);
			StringReader infoStdOut = new StringReader(cmdResults.StandardOutput);
			while ((line = infoStdOut.ReadLine()) != null)
			{
				Match parsed = findBasisRegex.Match(line);
				if (parsed.Success)
					return parsed.Groups[1].ToString().Trim();
				// Format is: "Basis:          __stream_name__"
			}
			Log.Error(string.Format("No \"Basis:\" line found in output from AccuRev \"accurev info\": {0}", cmdResults.StandardOutput));
			return "";
		}

		/// <summary>
		/// Log in to AccuRev if we're supposed to do so.
		/// </summary>
		/// <param name="result">IntegrationResult for which the command will be run</param>
		private void PossiblyLogIn(IIntegrationResult result)
		{
			if (!LogIn)
				return;		// Nothing to do.
			if ((AccuRevPrincipal == null) || (AccuRevPassword == null))
			{
				Log.Error("login=true requires principal= and password= to be specified.");
				return;
			}
			RunCommand(string.Format("login {0} \"{1}\"", AccuRevPrincipal, AccuRevPassword), result);
		}

		/// <summary>
		/// Prepare an AccuRev command for execution.
		/// </summary>
		/// <param name="args">arguments for the "accurev" command</param>
		/// <param name="result">IntegrationResult for which the command will be run</param>
		/// <returns>a ProcessInfo object primed to execute the specified command</returns>
		private ProcessInfo PrepCommand(string args, IIntegrationResult result)
		{
			Log.Debug(string.Format("Preparing to run AccuRev command: {0} {1}", Executable, args));
			ProcessInfo command = new ProcessInfo(Executable, args, result.BaseFromWorkingDirectory(Workspace));
			SetEnvironmentVariables(command.EnvironmentVariables, result);
			return command;
		}

		/// <summary>
		/// Execute an AccuRev command and check the results.
		/// </summary>
		/// <param name="args">arguments for the "accurev" command</param>
		/// <param name="result">IntegrationResult for which the command is being run</param>
		/// <returns>a ProcessResult object with the results from the command</returns>
		private ProcessResult RunCommand(string args, IIntegrationResult result)
		{
			ProcessInfo command = PrepCommand(args, result);
			ProcessResult cmdResults = Execute(command);
			if (cmdResults.Failed)
			{
				Log.Error(string.Format("AccuRev command \"{0} {1}\" failed with RC={2}",
					Executable, args, cmdResults.ExitCode));
				if ((cmdResults.StandardError != null) && (cmdResults.StandardError != ""))
					Log.Error(string.Format("\tError output: {0}", cmdResults.StandardError));
			}
			return cmdResults;
		}

		/// <summary>
		///  Make sure this IIntegrationResult object has our environment variables set in it.
		///  </summary>
		///  <param name="environmentVariables">The collection of environment variables to be updated.</param>
		/// <param name="result">IntegrationResult for the command whose variables we are updating.</param>
		private void SetEnvironmentVariables(StringDictionary environmentVariables, IIntegrationResult result)
		{
			if (!StringUtil.IsBlank(AccuRevHomeDir))
				environmentVariables["ACCUREV_HOME"] = result.BaseFromArtifactsDirectory(AccuRevHomeDir);
			if (!StringUtil.IsBlank(AccuRevPrincipal))
				environmentVariables["ACCUREV_PRINCIPAL"] = AccuRevPrincipal;
		}

		private ProcessResult Execute(ProcessInfo processInfo)
		{
			processInfo.TimeOut = 30000;
			ProcessResult result = _executor.Execute(processInfo);

			if (result.TimedOut)
			{
				throw new CruiseControlException("Source control operation has timed out.");
			}
			else if (result.Failed)
			{
				throw new CruiseControlException(string.Format("Source control operation failed: {0}. Process command: {1} {2}",
															   result.StandardError, processInfo.FileName, processInfo.Arguments));
			}
			else if (result.HasErrorOutput)
			{
				Log.Warning(string.Format("Source control wrote output to stderr: {0}", result.StandardError));
			}
			return result;
		}
	}
}