//
// ConsoleLogger.cs: Outputs to the console
//
// Author:
//   Marek Sieradzki (marek.sieradzki@gmail.com)
// 
// (C) 2005 Marek Sieradzki
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

using System;
using System.Runtime.InteropServices;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security;
using System.Text;
using Microsoft.Build.Framework;

#if MICROSOFT_BUILD_DLL
namespace Microsoft.Build.Logging
#else
namespace Microsoft.Build.BuildEngine
#endif
{
	public class ConsoleLogger : ILogger {
	
		string		parameters;
		LoggerVerbosity	verbosity;
		WriteHandler	writeHandler;
		bool		skipProjectStartedText;
		ConsoleColor errorColor, warningColor, eventColor, messageColor, highMessageColor;
		ColorSetter colorSet;
		ColorResetter colorReset;
		IEventSource eventSource;
		bool no_message_color, use_colors;
		ConsoleLoggerParameter config = new ConsoleLoggerParameter ();		
		
		public ConsoleLogger ()
			: this (LoggerVerbosity.Normal, null, null, null)
		{
		}

		public ConsoleLogger (LoggerVerbosity verbosity)
			: this (verbosity, null, null, null)
		{
		}
		
		public ConsoleLogger (LoggerVerbosity verbosity,
				      WriteHandler write,
				      ColorSetter colorSet,
				      ColorResetter colorReset)
		{
			this.verbosity = verbosity;
			if (write == null)
				this.writeHandler += new WriteHandler (WriteHandlerFunction);
			else
				this.writeHandler += write;
			this.skipProjectStartedText = false;
			this.colorSet = colorSet;
			this.colorReset = colorReset;

			//defaults
			errorColor = ConsoleColor.DarkRed;
			warningColor = ConsoleColor.DarkYellow;
			eventColor = ConsoleColor.DarkCyan;
			messageColor = ConsoleColor.DarkGray;
			highMessageColor = ConsoleColor.White;

			// if message color is not set via the env var,
			// then don't use any color for it.
			no_message_color = true;

			use_colors = false;
			if (colorSet == null || colorReset == null)
				return;

			// color support
			string config = Environment.GetEnvironmentVariable ("XBUILD_COLORS");
			if (config == null) {
				use_colors = true;
				return;
			}

			if (config == "disable")
				return;

			use_colors = true;
			string [] pairs = config.Split (new char[] {','}, StringSplitOptions.RemoveEmptyEntries);
			foreach (string pair in pairs) {
				string [] parts = pair.Split (new char[] {'='}, StringSplitOptions.RemoveEmptyEntries);
				if (parts.Length != 2)
					continue;

				if (parts [0] == "errors")
					TryParseConsoleColor (parts [1], ref errorColor);
				else if (parts [0] == "warnings")
					TryParseConsoleColor (parts [1], ref warningColor);
				else if (parts [0] == "events")
					TryParseConsoleColor (parts [1], ref eventColor);
				else if (parts [0] == "messages") {
					if (TryParseConsoleColor (parts [1], ref messageColor)) {
						highMessageColor = GetBrightColorFor (messageColor);
						no_message_color = false;
					}
				}
			}
		}
		
		private void WriteHandlerFunction (string message)
		{
			Console.WriteLine (message);
		}

		bool TryParseConsoleColor (string color_str, ref ConsoleColor color)
		{
			switch (color_str.ToLowerInvariant ()) {
			case "black": color = ConsoleColor.Black; break;

			case "blue": color = ConsoleColor.DarkBlue; break;
			case "green": color = ConsoleColor.DarkGreen; break;
			case "cyan": color = ConsoleColor.DarkCyan; break;
			case "red": color = ConsoleColor.DarkRed; break;
			case "magenta": color = ConsoleColor.DarkMagenta; break;
			case "yellow": color = ConsoleColor.DarkYellow; break;
			case "grey": color = ConsoleColor.DarkGray; break;

			case "brightgrey": color = ConsoleColor.Gray; break;
			case "brightblue": color = ConsoleColor.Blue; break;
			case "brightgreen": color = ConsoleColor.Green; break;
			case "brightcyan": color = ConsoleColor.Cyan; break;
			case "brightred": color = ConsoleColor.Red; break;
			case "brightmagenta": color = ConsoleColor.Magenta; break;
			case "brightyellow": color = ConsoleColor.Yellow; break;

			case "white":
			case "brightwhite": color = ConsoleColor.White; break;
			default: return false;
			}

			return true;
		}

		ConsoleColor GetBrightColorFor (ConsoleColor color)
		{
			switch (color) {
			case ConsoleColor.DarkBlue: return ConsoleColor.Blue;
			case ConsoleColor.DarkGreen: return ConsoleColor.Green;
			case ConsoleColor.DarkCyan: return ConsoleColor.Cyan;
			case ConsoleColor.DarkRed: return ConsoleColor.Red;
			case ConsoleColor.DarkMagenta: return ConsoleColor.Magenta;
			case ConsoleColor.DarkYellow: return ConsoleColor.Yellow;
			case ConsoleColor.DarkGray: return ConsoleColor.Gray;
			case ConsoleColor.Gray: return ConsoleColor.White;

			default: return color;
			}
		}
		
		class ConsoleLoggerParameter
		{
			public ConsoleLoggerParameter ()
			{
				ShowSummary = true;
			}
			public bool PerformanceSummary { get; set; }
			public bool ShowSummary { get; set; }
			public bool NoItemAndPropertyList { get; set; }
		}
		
		public void ApplyParameter (string parameterName,
					    string parameterValue)
		{
			switch (parameterName) {
				case "PerformanceSummary":
					config.PerformanceSummary = true;
					break;
				case "Summary":
					config.ShowSummary = true;
					break;
				case "NoSummary":
					config.ShowSummary = false;
					break;
				case "NoItemAndPropertyList":
					config.NoItemAndPropertyList = true;
					break;
				default:
					if (parameterName.StartsWith ("Verbosity="))
						ParseVerbosity (parameterName);
					break;
			}
		}

		void ParseVerbosity (string s)
		{
			string key, value;
			if (!TrySplitKeyValuePair (s, out key, out value))
				throw new LoggerException ("Unknown Verbosity, should be set as 'Verbosity=<verbosity>'");

			switch (value) {
			case "q":
			case "quiet":
				Verbosity = LoggerVerbosity.Quiet;
				break;
			case "m":
			case "minimal":
				Verbosity = LoggerVerbosity.Minimal;
				break;
			case "n":
			case "normal":
				Verbosity = LoggerVerbosity.Normal;
				break;
			case "d":
			case "detailed":
				Verbosity = LoggerVerbosity.Detailed;
				break;
			case "diag":
			case "diagnostic":
				Verbosity = LoggerVerbosity.Diagnostic;
				break;
			default:
				throw new LoggerException (String.Format ("Unknown verbosity - '{0}'", s));
			}
		}

		bool TrySplitKeyValuePair (string pair, out string key, out string value)
		{
			key = value = null;
			string[] parts = pair.Split ('=');
			if (parts.Length != 2)
				return false;

			key = parts [0];
			value = parts [1];
			return true;
		}

		public virtual void Initialize (IEventSource eventSource)
		{
			this.eventSource = eventSource;

			eventSource.BuildStarted += BuildStartedHandler;
			eventSource.BuildFinished += BuildFinishedHandler;

			eventSource.ProjectStarted += PushEvent;
			eventSource.ProjectFinished += PopEvent;

			eventSource.TargetStarted += PushEvent;
			eventSource.TargetFinished += PopEvent;

			eventSource.TaskStarted += PushEvent;
			eventSource.TaskFinished += PopEvent;

			eventSource.MessageRaised += MessageHandler;
			eventSource.WarningRaised += WarningHandler;
			eventSource.ErrorRaised += ErrorHandler;

			if (!String.IsNullOrEmpty (parameters))
				ParseParameters ();
		}
		
		ConcurrentDictionary<object,BuildRecord> build_records = new ConcurrentDictionary<object, BuildRecord> ();
		
		object dummy_key = new object ();
		
		BuildRecord GetBuildRecord (object sender)
		{
			BuildRecord r;
			// FIXME: our Microsoft.Build.Engine shouldn't give different "sender" object for each event
			// during the same build run. But it actually does.
			// It is problematic for parallel build because it is impossible to determine right "ongoing build"
			// record for the event without correct sender object.
			// Hence we expect sender as a valid object only if it is IBuildEngine4 -
			// only Microsoft.Build.Internal.BuildEngine4 implements it so far. 
			// (Used IBuildEngine3 because it needs to build for NET_4_0).
			var key = sender as IBuildEngine3 ?? dummy_key;
			return build_records.GetOrAdd (key, _ => new BuildRecord (this));
		}

		public void BuildStartedHandler (object sender, BuildStartedEventArgs args)
		{
			GetBuildRecord (sender).BuildStartedHandler (sender, args);
		}
		
		public void BuildFinishedHandler (object sender, BuildFinishedEventArgs args)
		{
			GetBuildRecord (sender).BuildFinishedHandler (args);
			((IDictionary) build_records).Remove (sender);
		}
		
		void PushEvent<T> (object sender, T args) where T: BuildStatusEventArgs
		{
			GetBuildRecord (sender).PushEvent (sender, args);
		}
		void PopEvent<T> (object sender, T args) where T: BuildStatusEventArgs
		{
			GetBuildRecord (sender).PopEvent (args);
		}
		public void ProjectStartedHandler (object sender, ProjectStartedEventArgs args)
		{
			GetBuildRecord (sender).ProjectStartedHandler (args);
		}
		public void ProjectFinishedHandler (object sender, ProjectFinishedEventArgs args)
		{
			GetBuildRecord (sender).ProjectFinishedHandler (args);
		}		
		public void TargetStartedHandler (object sender, TargetStartedEventArgs args)
		{
			GetBuildRecord (sender).TargetStartedHandler (args);
		}
		public void TargetFinishedHandler (object sender, TargetFinishedEventArgs args)
		{
			GetBuildRecord (sender).TargetFinishedHandler (args);
		}
		public void TaskStartedHandler (object sender, TaskStartedEventArgs args)
		{
			GetBuildRecord (sender).TaskStartedHandler (args);
		}
		public void TaskFinishedHandler (object sender, TaskFinishedEventArgs args)
		{
			GetBuildRecord (sender).TaskFinishedHandler (args);
		}
		public void MessageHandler (object sender, BuildMessageEventArgs args)
		{
			GetBuildRecord (sender).MessageHandler (args);
		}
		public void WarningHandler (object sender, BuildWarningEventArgs args)
		{
			GetBuildRecord (sender).WarningHandler (args);
		}
		public void ErrorHandler (object sender, BuildErrorEventArgs args)
		{
			GetBuildRecord (sender).ErrorHandler (args);
		}
		
		[MonoTODO]
		public void CustomEventHandler (object sender, CustomBuildEventArgs args)
		{
			build_records [sender].CustomHandler (args);
		}

		void SetColor (ConsoleColor color)
		{
			if (use_colors)
				colorSet (color);
		}

		void ResetColor ()
		{
			if (use_colors)
				colorReset ();
		}
		
		private void ParseParameters ()
		{
			string[] splittedParameters = parameters.Split (';');
			foreach (string s in splittedParameters )
				ApplyParameter (s, null);
		}
		
		public virtual void Shutdown ()
		{
			if (eventSource == null)
				return;

			eventSource.BuildStarted -= BuildStartedHandler;
			eventSource.BuildFinished -= BuildFinishedHandler;

			eventSource.ProjectStarted -= PushEvent;
			eventSource.ProjectFinished -= PopEvent;

			eventSource.TargetStarted -= PushEvent;
			eventSource.TargetFinished -= PopEvent;

			eventSource.TaskStarted -= PushEvent;
			eventSource.TaskFinished -= PopEvent;

			eventSource.MessageRaised -= MessageHandler;
			eventSource.WarningRaised -= WarningHandler;
			eventSource.ErrorRaised -= ErrorHandler;
		}

		public string Parameters {
			get {
				return parameters;
			}
			set {
				if (value == null)
					throw new ArgumentNullException ();
				parameters = value;
				ParseParameters ();
			}
		}
		
		public bool ShowSummary {
			get { return config.ShowSummary; }
			set { config.ShowSummary = value; }
		}
		
		public bool SkipProjectStartedText {
			get { return skipProjectStartedText; }
			set { skipProjectStartedText = value; }
		}

		public LoggerVerbosity Verbosity {
			get { return verbosity;	}
			set { verbosity = value; }
		}

		protected WriteHandler WriteHandler {
			get { return writeHandler; }
			set { writeHandler = value; }
		}
		
		class BuildRecord
		{
			readonly ConsoleLogger parent;
			
			readonly List<BuildEvent> events;
			readonly Dictionary<string, List<string>> errorsTable;
			readonly Dictionary<string, List<string>> warningsTable;
			readonly SortedDictionary<string, PerfInfo> targetPerfTable, tasksPerfTable;
			List<string> errors, warnings;
			int		indent;
			int		errorCount;
			int		warningCount;
			bool		projectFailed;
			DateTime		buildStart;
	
			string current_events_string;
			
			ConsoleColor eventColor {
				get { return parent.eventColor; }
			}
			LoggerVerbosity verbosity {
				get { return parent.Verbosity; }
			}
			
			public BuildRecord (ConsoleLogger parent)
			{
				this.parent = parent;
				
				this.indent = 0;
				this.errorCount = 0;
				this.warningCount = 0;
				errors = new List<string> ();
				warnings = new List<string> ();
				events = new List<BuildEvent> ();
				errorsTable = new Dictionary<string, List<string>> ();
				warningsTable = new Dictionary<string, List<string>> ();
				targetPerfTable = new SortedDictionary<string, PerfInfo> ();
				tasksPerfTable = new SortedDictionary<string, PerfInfo> ();
			}
	
			internal void PushEvent<T> (object sender, T args) where T: BuildStatusEventArgs
			{
				BuildEvent be = new BuildEvent {
					Sender = sender,
					EventArgs = args,
					StartHandlerHasExecuted = false,
					ConsoleLogger = this.parent
				};
	
				events.Add (be);
				current_events_string = null;
			}
	
			void PopEvent<T> (object sender, T finished_args) where T: BuildStatusEventArgs
			{
				PopEvent (finished_args);
			}
	
			internal void PopEvent<T> (T finished_args) where T: BuildStatusEventArgs
			{
				if (events.Count == 0)
					throw new InvalidOperationException ("INTERNAL ERROR: Trying to pop from an empty events stack");
	
				BuildEvent be = events [events.Count - 1];
				if (parent.config.PerformanceSummary || verbosity == LoggerVerbosity.Diagnostic) {
					var args = be.EventArgs;
					TargetStartedEventArgs tgt_args = args as TargetStartedEventArgs;
					if (tgt_args != null) {
						AddPerfInfo (tgt_args.TargetName, args.Timestamp, targetPerfTable);
					} else {
						TaskStartedEventArgs tsk_args = args as TaskStartedEventArgs;
						if (tsk_args != null)
							AddPerfInfo (tsk_args.TaskName, args.Timestamp, tasksPerfTable);
					}
				}
	
				be.ExecuteFinishedHandler (finished_args);
				events.RemoveAt (events.Count - 1);
				current_events_string = null;
			}
	
			public void ResetBuildState ()
			{
				// Reset
				events.Clear ();
				errorsTable.Clear ();
				warningsTable.Clear ();
				targetPerfTable.Clear ();
				tasksPerfTable.Clear ();
				errors.Clear ();
				warnings.Clear ();
	
				indent = 0;
				errorCount = 0;
				warningCount = 0;
				projectFailed = false;
			}
	
			void AddPerfInfo (string name, DateTime start, IDictionary<string, PerfInfo> perf_table)
			{
				PerfInfo pi;
				if (!perf_table.TryGetValue (name, out pi)) {
					pi = new PerfInfo ();
					perf_table [name] = pi;
				}
	
				pi.Time += DateTime.Now - start;
				pi.NumberOfCalls ++;
			}
	
			public void BuildStartedHandler (object sender, BuildStartedEventArgs args)
			{
				if (IsVerbosityGreaterOrEqual (LoggerVerbosity.Normal)) {
					WriteLine (String.Empty);
					WriteLine (String.Format ("Build started {0}.", args.Timestamp));
					WriteLine ("__________________________________________________");
				}
				buildStart = args.Timestamp;
	
				PushEvent (sender, args);
			}
			
			public void BuildFinishedHandler (BuildFinishedEventArgs args)
			{
				BuildFinishedHandlerActual (args);
				
				ResetBuildState ();
			}
	
			void BuildFinishedHandlerActual (BuildFinishedEventArgs args)
			{
				if (!IsVerbosityGreaterOrEqual (LoggerVerbosity.Normal)) {
					PopEvent (args);
					return;
				}
	
				TimeSpan timeElapsed = args.Timestamp - buildStart;
				if (parent.config.PerformanceSummary || verbosity == LoggerVerbosity.Diagnostic)
					DumpPerformanceSummary ();
	
				if (args.Succeeded == true && !projectFailed) {
					WriteLine ("Build succeeded.");
				} else {
					WriteLine ("Build FAILED.");
				}
				if (warnings.Count > 0) {
					WriteLine (Environment.NewLine + "Warnings:");
					SetColor (parent.warningColor);
	
					WriteLine (String.Empty);
					foreach (KeyValuePair<string, List<string>> pair in warningsTable) {
						if (!String.IsNullOrEmpty (pair.Key))
							WriteLine (pair.Key);
	
						string indent_str = String.IsNullOrEmpty (pair.Key) ? String.Empty : "\t";
						foreach (string msg in pair.Value)
							WriteLine (String.Format ("{0}{1}", indent_str, msg));
	
						WriteLine (String.Empty);
					}
	
					ResetColor ();
				}
	
				if (errors.Count > 0) {
					WriteLine ("Errors:");
					SetColor (parent.errorColor);
	
					WriteLine (String.Empty);
					foreach (KeyValuePair<string, List<string>> pair in errorsTable) {
						if (!String.IsNullOrEmpty (pair.Key))
							WriteLine (pair.Key);
	
						string indent_str = String.IsNullOrEmpty (pair.Key) ? String.Empty : "\t";
						foreach (string msg in pair.Value)
							WriteLine (String.Format ("{0}{1}", indent_str, msg));
	
						WriteLine (String.Empty);
					}
					ResetColor ();
				}
	
				if (parent.ShowSummary == true){
					WriteLine (String.Format ("\t {0} Warning(s)", warningCount));
					WriteLine (String.Format ("\t {0} Error(s)", errorCount));
					WriteLine (String.Empty);
					WriteLine (String.Format ("Time Elapsed {0}", timeElapsed));
				}
	
				PopEvent (args);
			}
	
			public void ProjectStartedHandler (ProjectStartedEventArgs args)
			{
				if (IsVerbosityGreaterOrEqual (LoggerVerbosity.Normal)) {
					SetColor (eventColor);
					WriteLine (String.Format ("Project \"{0}\" ({1} target(s)):", args.ProjectFile,
								String.IsNullOrEmpty (args.TargetNames) ? "default" : args.TargetNames));
					ResetColor ();
					DumpProperties (args.Properties);
					DumpItems (args.Items);
				}
			}
			
			public void ProjectFinishedHandler (ProjectFinishedEventArgs args)
			{
				if (IsVerbosityGreaterOrEqual (LoggerVerbosity.Normal)) {
					if (indent == 1)
						indent --;
					SetColor (eventColor);
					WriteLine (String.Format ("Done building project \"{0}\".{1}", args.ProjectFile,
								args.Succeeded ? String.Empty : "-- FAILED"));
					ResetColor ();
					WriteLine (String.Empty);
				}
				if (!projectFailed)
					// no project has failed yet, so update the flag
					projectFailed = !args.Succeeded;
			}
			
			public void TargetStartedHandler (TargetStartedEventArgs args)
			{
				if (IsVerbosityGreaterOrEqual (LoggerVerbosity.Normal)) {
					indent++;
					SetColor (eventColor);
					WriteLine (String.Empty);
					WriteLine (String.Format ("Target {0}:",args.TargetName));
					ResetColor ();
				}
			}
			
			public void TargetFinishedHandler (TargetFinishedEventArgs args)
			{
				if (IsVerbosityGreaterOrEqual (LoggerVerbosity.Detailed) ||
						(!args.Succeeded && IsVerbosityGreaterOrEqual (LoggerVerbosity.Normal))) {
					SetColor (eventColor);
					WriteLine (String.Format ("Done building target \"{0}\" in project \"{1}\".{2}",
						args.TargetName, args.ProjectFile,
						args.Succeeded ? String.Empty : "-- FAILED"));
					ResetColor ();
					WriteLine (String.Empty);
				}
				indent--;
			}
			
			public void TaskStartedHandler (TaskStartedEventArgs args)
			{
				if (IsVerbosityGreaterOrEqual (LoggerVerbosity.Detailed)) {
					SetColor (eventColor);
					WriteLine (String.Format ("Task \"{0}\"",args.TaskName));
					ResetColor ();
				}
				indent++;
			}
			
			public void TaskFinishedHandler (TaskFinishedEventArgs args)
			{
				indent--;
				if (IsVerbosityGreaterOrEqual (LoggerVerbosity.Detailed) ||
						(!args.Succeeded && IsVerbosityGreaterOrEqual (LoggerVerbosity.Normal))) {
					SetColor (eventColor);
					if (args.Succeeded)
						WriteLine (String.Format ("Done executing task \"{0}\"", args.TaskName));
					else
						WriteLine (String.Format ("Task \"{0}\" execution -- FAILED", args.TaskName));
					ResetColor ();
				}
			}
			
			public void MessageHandler (BuildMessageEventArgs args)
			{
				if (IsMessageOk (args)) {
					if (parent.no_message_color) {
						ExecutePendingEventHandlers ();
						WriteLine (args.Message);
					} else {
						ExecutePendingEventHandlers ();
						SetColor (args.Importance == MessageImportance.High ? parent.highMessageColor : parent.messageColor);
						WriteLine (args.Message);
						ResetColor ();
					}
				}
			}
			
			public void WarningHandler (BuildWarningEventArgs args)
			{
				string msg = FormatWarningEvent (args);
				if (IsVerbosityGreaterOrEqual (LoggerVerbosity.Quiet)) {
					ExecutePendingEventHandlers ();
					SetColor (parent.warningColor);
					WriteLineWithoutIndent (msg);
					ResetColor ();
				}
				warnings.Add (msg);
	
				List<string> list = null;
				if (!warningsTable.TryGetValue (EventsAsString, out list))
					warningsTable [EventsAsString] = list = new List<string> ();
				list.Add (msg);
	
				warningCount++;
			}
			
			public void ErrorHandler (BuildErrorEventArgs args)
			{
				string msg = FormatErrorEvent (args);
				if (IsVerbosityGreaterOrEqual (LoggerVerbosity.Quiet)) {
					ExecutePendingEventHandlers ();
					SetColor (parent.errorColor);
					WriteLineWithoutIndent (msg);
					ResetColor ();
				}
				errors.Add (msg);
	
				List<string> list = null;
				if (!errorsTable.TryGetValue (EventsAsString, out list))
					errorsTable [EventsAsString] = list = new List<string> ();
				list.Add (msg);
				errorCount++;
			}
			
			public void CustomHandler (CustomBuildEventArgs args)
			{
			}
			
			private bool IsVerbosityGreaterOrEqual (LoggerVerbosity v)
			{
				if (v == LoggerVerbosity.Diagnostic) {
					return LoggerVerbosity.Diagnostic <= verbosity;
				} else if (v == LoggerVerbosity.Detailed) {
					return LoggerVerbosity.Detailed <= verbosity;
				} else if (v == LoggerVerbosity.Normal) {
					return LoggerVerbosity.Normal <= verbosity;
				} else if (v == LoggerVerbosity.Minimal) {
					return LoggerVerbosity.Minimal <= verbosity;
				} else if (v == LoggerVerbosity.Quiet) {
					return true;
				} else
					return false;
			}
	
			void DumpItems (IEnumerable items)
			{
				if (parent.config.NoItemAndPropertyList || !IsVerbosityGreaterOrEqual (LoggerVerbosity.Diagnostic) || items == null)
					return;
	
				SetColor (eventColor);
				WriteLine (String.Empty);
				WriteLine ("Initial Items:");
				ResetColor ();
				if (items == null)
					return;
	
				var items_table = new SortedDictionary<string, List<ITaskItem>> ();
				foreach (DictionaryEntry de in items) {
					string key = (string)de.Key;
					if (!items_table.ContainsKey (key))
						items_table [key] = new List<ITaskItem> ();
	
					items_table [key].Add ((ITaskItem) de.Value);
				}
	
				foreach (string name in items_table.Keys) {
					WriteLine (name);
					indent ++;
					foreach (ITaskItem item in items_table [name])
						WriteLine (item.ItemSpec);
					indent--;
				}
			}
	
			string EventsAsString {
				get {
					if (current_events_string == null)
						current_events_string = EventsToString ();
					return current_events_string;
				}
			}
			
			private bool IsMessageOk (BuildMessageEventArgs bsea)
			{
				if (bsea.Importance == MessageImportance.High && IsVerbosityGreaterOrEqual (LoggerVerbosity.Minimal)) {
					return true;
				} else if (bsea.Importance == MessageImportance.Normal && IsVerbosityGreaterOrEqual (LoggerVerbosity.Normal)) {
					return true;
				} else if (bsea.Importance == MessageImportance.Low && IsVerbosityGreaterOrEqual (LoggerVerbosity.Detailed)) {
					return true;
				} else
					return false;
			}
	
			void DumpProperties (IEnumerable properties)
			{
				if (parent.config.NoItemAndPropertyList || !IsVerbosityGreaterOrEqual (LoggerVerbosity.Diagnostic))
					return;
	
				SetColor (eventColor);
				WriteLine (String.Empty);
				WriteLine ("Initial Properties:");
				ResetColor ();
	
				if (properties == null)
					return;
	
				var dict = new SortedDictionary<string, string> ();
				foreach (DictionaryEntry de in properties)
					dict [(string)de.Key] = (string)de.Value;
	
				foreach (KeyValuePair<string, string> pair in dict)
					WriteLine (String.Format ("{0} = {1}", pair.Key, pair.Value));
			}
	
			private void WriteLine (string message)
			{
				if (indent > 0) {
					StringBuilder sb = new StringBuilder ();
					for (int i = 0; i < indent; i++)
						sb.Append ('\t');
	
					string indent_str = sb.ToString ();
	
					foreach (string line in message.Split (new string[] {Environment.NewLine}, StringSplitOptions.RemoveEmptyEntries))
						parent.writeHandler (indent_str + line);
				} else {
					parent.writeHandler (message);
				}
			}
	
			void ExecutePendingEventHandlers ()
			{
				foreach (var be in events)
					be.ExecuteStartedHandler ();
			}
	
			string EventsToString ()
			{
				StringBuilder sb = new StringBuilder ();
	
				string last_imported_target_file = String.Empty;
				for (int i = 0; i < events.Count; i ++) {
					var args = events [i].EventArgs;
					ProjectStartedEventArgs pargs = args as ProjectStartedEventArgs;
					if (pargs != null) {
						sb.AppendFormat ("{0} ({1}) ->\n", pargs.ProjectFile,
								String.IsNullOrEmpty (pargs.TargetNames) ?
									"default targets" :
									pargs.TargetNames);
						last_imported_target_file = String.Empty;
						continue;
					}
	
					TargetStartedEventArgs targs = args as TargetStartedEventArgs;
					if (targs != null) {
						if (targs.TargetFile != targs.ProjectFile && targs.TargetFile != last_imported_target_file)
							// target from an imported file,
							// and it hasn't been mentioned as yet
							sb.AppendFormat ("{0} ", targs.TargetFile);
	
						last_imported_target_file = targs.TargetFile;
						sb.AppendFormat ("({0} target) ->\n", targs.TargetName);
					}
				}
	
				return sb.ToString ();
			}
	
			void DumpPerformanceSummary ()
			{
				SetColor (eventColor);
				WriteLine ("Target performance summary:");
				ResetColor ();
	
				foreach (var pi in targetPerfTable.OrderBy (pair => pair.Value.Time))
					WriteLine (String.Format ("{0,10:0.000} ms  {1,-50}  {2,5} calls", pi.Value.Time.TotalMilliseconds, pi.Key, pi.Value.NumberOfCalls));
	
				WriteLine (String.Empty);
	
				SetColor (eventColor);
				WriteLine ("Tasks performance summary:");
				ResetColor ();
	
				foreach (var pi in tasksPerfTable.OrderBy (pair => pair.Value.Time))
					WriteLine (String.Format ("{0,10:0.000} ms  {1,-50}  {2,5} calls", pi.Value.Time.TotalMilliseconds, pi.Key, pi.Value.NumberOfCalls));
	
				WriteLine (String.Empty);
			}
			
			private string FormatErrorEvent (BuildErrorEventArgs args)
			{
				// For some reason we get an 1-char empty string as Subcategory somtimes.
				string subprefix = args.Subcategory == null || args.Subcategory == "" || args.Subcategory == " " ? "" : " ";
				string subcat = subprefix == "" ? "" : args.Subcategory;
					
				if (args.LineNumber != 0){
					if (args.ColumnNumber != 0 && !InEmacs) 
						return String.Format ("{0}({1},{2}): {3}{4}error {5}: {6}",
								      args.File, args.LineNumber, args.ColumnNumber,
								      subprefix, subcat, args.Code, args.Message);
	
					return String.Format ("{0}({1}): {2}{3}error {4}: {5}",
							      args.File, args.LineNumber,
							      subprefix, subcat, args.Code, args.Message);
				} else {
					return String.Format ("{0}: {1}{2}error {3}: {4}", args.File, subprefix, subcat, args.Code,
						args.Message);
				}
			}
	
			static bool InEmacs = Environment.GetEnvironmentVariable ("EMACS") == "t";
	
			private string FormatWarningEvent (BuildWarningEventArgs args)
			{
				// For some reason we get an 1-char empty string as Subcategory somtimes.
				string subprefix = args.Subcategory == null || args.Subcategory == "" || args.Subcategory == " " ? "" : " ";
				string subcat = subprefix == "" ? "" : args.Subcategory;
	
				// FIXME: show more complicated args
				if (args.LineNumber != 0){
	
					if (args.ColumnNumber != 0 && !InEmacs) {
						return String.Format ("{0}({1},{2}): {3}{4}warning {5}: {6}",
								      args.File, args.LineNumber, args.ColumnNumber,
								      subprefix, subcat, args.Code, args.Message);
					}
					return String.Format ("{0}({1}): {2}{3}warning {4}: {5}",
							      args.File, args.LineNumber,
							      subprefix, subcat, args.Code, args.Message);
				} else {
					return String.Format ("{0}: {1} warning {2}: {3}", args.File, args.Subcategory, args.Code,
						args.Message);
				}
			}
	
			void SetColor (ConsoleColor color)
			{
				if (parent.use_colors)
					parent.colorSet (color);
			}
	
			void ResetColor ()
			{
				if (parent.use_colors)
					parent.colorReset ();
			}
			
			private void WriteLineWithoutIndent (string message)
			{
				parent.writeHandler (message);
			}
		}
	}

	class BuildEvent {
		public object Sender; 
		public BuildStatusEventArgs EventArgs;
		public bool StartHandlerHasExecuted;
		public ConsoleLogger ConsoleLogger;

		public void ExecuteStartedHandler ()
		{
			if (StartHandlerHasExecuted)
				return;

			if (EventArgs is ProjectStartedEventArgs)
				ConsoleLogger.ProjectStartedHandler (Sender, (ProjectStartedEventArgs)EventArgs);
			else if (EventArgs is TargetStartedEventArgs)
				ConsoleLogger.TargetStartedHandler (Sender, (TargetStartedEventArgs)EventArgs);
			else if (EventArgs is TaskStartedEventArgs)
				ConsoleLogger.TaskStartedHandler (Sender, (TaskStartedEventArgs)EventArgs);
			else if (!(EventArgs is BuildStartedEventArgs))
				throw new InvalidOperationException ("Unexpected event on the stack, type: " + EventArgs.GetType ());

			StartHandlerHasExecuted = true;
		}

		public void ExecuteFinishedHandler (BuildStatusEventArgs finished_args)
		{
			if (!StartHandlerHasExecuted)
				return;

			if (EventArgs is ProjectStartedEventArgs) {
				var pfa = finished_args as ProjectFinishedEventArgs;
				// FIXME: BuildFinishedHandlerActual sends us BuildFinishedEventArgs via PopEvent
				if (pfa == null)
					return;

				ConsoleLogger.ProjectFinishedHandler (Sender, pfa);
			} else if (EventArgs is TargetStartedEventArgs) {
				var fa = finished_args as TargetFinishedEventArgs;
				// FIXME: BuildFinishedHandlerActual sends us BuildFinishedEventArgs via PopEvent
				if (fa == null)
					return;

				ConsoleLogger.TargetFinishedHandler (Sender, fa);
			} else if (EventArgs is TaskStartedEventArgs) {
				// FIXME: BuildFinishedHandlerActual sends us BuildFinishedEventArgs via PopEvent
				if (!(finished_args is TaskFinishedEventArgs))
					return;

				ConsoleLogger.TaskFinishedHandler (Sender, (TaskFinishedEventArgs) finished_args);
			} else if (!(EventArgs is BuildStartedEventArgs))
				throw new InvalidOperationException ("Unexpected event on the stack, type: " + EventArgs.GetType ());
		}
	}

	class PerfInfo {
		public TimeSpan Time;
		public int NumberOfCalls;
	}
}