#region License

// Copyright (c) 2010, Jasper Yeh.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification, 
// are permitted provided that the following conditions are met:
//
//    * Redistributions of source code must retain the above copyright notice, 
//      this list of conditions and the following disclaimer.
//    * Redistributions in binary form must reproduce the above copyright notice, 
//      this list of conditions and the following disclaimer in the documentation 
//      and/or other materials provided with the distribution.
//    * Neither the name of ClearCanvas Inc. nor the names of its contributors 
//      may be used to endorse or promote products derived from this software without 
//      specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, 
// OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 
// GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 
// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
// OF SUCH DAMAGE.

#endregion

using System;
using System.Reflection;
using ClearCanvas.Common;
using ClearCanvas.Common.Utilities;
using ClearCanvas.Desktop;
using ClearCanvas.Desktop.Actions;
using ClearCanvas.Desktop.Tools;
using log4net;
using log4net.Core;
using log4net.Repository.Hierarchy;

namespace Nullstack.ClearCanvasEx.DevTools.Logging
{
	/// <summary>
	/// Tools for changing the application log level.
	/// </summary>
	[MenuAction("debug", "global-menus/mnDebug/mnLogLevel/mnDebug", "SetDebug")]
	[CheckedStateObserver("debug", "IsDebug", "LogLevelChanged")]
	[GroupHint("debug", "Nullstack.ClearCanvasEx.DevTools.Logs.Level.0.Debug")]
	//
	[MenuAction("info", "global-menus/mnDebug/mnLogLevel/mnInfo", "SetInfo")]
	[CheckedStateObserver("info", "IsInfo", "LogLevelChanged")]
	[GroupHint("info", "Nullstack.ClearCanvasEx.DevTools.Logs.Level.1.Info")]
	//
	[MenuAction("warn", "global-menus/mnDebug/mnLogLevel/mnWarn", "SetWarn")]
	[CheckedStateObserver("warn", "IsWarn", "LogLevelChanged")]
	[GroupHint("warn", "Nullstack.ClearCanvasEx.DevTools.Logs.Level.2.Warn")]
	//
	[MenuAction("error", "global-menus/mnDebug/mnLogLevel/mnError", "SetError")]
	[CheckedStateObserver("error", "IsError", "LogLevelChanged")]
	[GroupHint("error", "Nullstack.ClearCanvasEx.DevTools.Logs.Level.3.Error")]
	//
	[MenuAction("fatal", "global-menus/mnDebug/mnLogLevel/mnFatal", "SetFatal")]
	[CheckedStateObserver("fatal", "IsFatal", "LogLevelChanged")]
	[GroupHint("fatal", "Nullstack.ClearCanvasEx.DevTools.Logs.Level.4.Fatal")]
	//
	[ExtensionOf(typeof (DesktopToolExtensionPoint))]
	public class ChangeLogLevelTool : Tool<IDesktopToolContext>
	{
		private static readonly FieldInfo _rfPlatformLog = typeof (Platform).GetField("_log", BindingFlags.NonPublic | BindingFlags.Static);

		private event EventHandler _logLevelChanged;
		private LogLevel _logLevel;

		public LogLevel LogLevel
		{
			get { return _logLevel; }
			set
			{
				if (_logLevel != value)
				{
					_logLevel = value;
					this.OnLogLevelChanged();
				}
			}
		}

		public event EventHandler LogLevelChanged
		{
			add { _logLevelChanged += value; }
			remove { _logLevelChanged -= value; }
		}

		protected virtual void OnLogLevelChanged()
		{
			Logger.Level = Convert(this.LogLevel);
			EventsHelper.Fire(_logLevelChanged, this, new EventArgs());
		}

		private static Logger Logger
		{
			get { return GetLogger(_rfPlatformLog.GetValue(null)); }
		}

		private static Logger GetLogger(object logger)
		{
			if (logger is Logger)
				return (Logger) logger;
			else if (logger is ILog)
				return GetLogger(((ILog) logger).Logger);
			return null;
		}

		private static LogLevel Convert(Level level)
		{
			if (level == Level.Debug)
				return LogLevel.Debug;
			else if (level == Level.Info)
				return LogLevel.Info;
			else if (level == Level.Warn)
				return LogLevel.Warn;
			else if (level == Level.Error)
				return LogLevel.Error;
			else if (level == Level.Fatal)
				return LogLevel.Fatal;
			return LogLevel.Debug;
		}

		private static Level Convert(LogLevel level)
		{
			switch (level)
			{
				case LogLevel.Debug:
					return Level.Debug;
				case LogLevel.Info:
					return Level.Info;
				case LogLevel.Warn:
					return Level.Warn;
				case LogLevel.Error:
					return Level.Error;
				case LogLevel.Fatal:
					return Level.Fatal;
				default:
					return Level.Debug;
			}
		}

		public override void Initialize()
		{
			base.Initialize();
			_logLevel = Convert(Logger.EffectiveLevel);
		}

		#region Internal Methods for Actions

		internal void SetDebug()
		{
			this.LogLevel = LogLevel.Debug;
		}

		internal void SetInfo()
		{
			this.LogLevel = LogLevel.Info;
		}

		internal void SetWarn()
		{
			this.LogLevel = LogLevel.Warn;
		}

		internal void SetError()
		{
			this.LogLevel = LogLevel.Error;
		}

		internal void SetFatal()
		{
			this.LogLevel = LogLevel.Fatal;
		}

		public bool IsDebug
		{
			get { return this.LogLevel == LogLevel.Debug; }
		}

		public bool IsInfo
		{
			get { return this.LogLevel == LogLevel.Info; }
		}

		public bool IsWarn
		{
			get { return this.LogLevel == LogLevel.Warn; }
		}

		public bool IsError
		{
			get { return this.LogLevel == LogLevel.Error; }
		}

		public bool IsFatal
		{
			get { return this.LogLevel == LogLevel.Fatal; }
		}

		#endregion
	}
}