using Common.Infrastructure.Commands;
using Common.Infrastructure.Ioc;
using Common.Infrastructure.Messaging;
using GalaSoft.MvvmLight;
using GalaSoft.MvvmLight.Command;
using System;
using System.Windows.Forms;
using System.Windows.Input;
using mag = Magellan.Framework;


namespace Common.Infrastructure.ViewModels
{
	public abstract class CoreViewModel : ViewModelBase, ISupportMessageTokens, mag.IViewAware
	{
		private IMessengerCore _messenger;
		public IMessengerCore Messenger
		{
			get
			{
				if (_messenger == null)
				{
					_messenger = TypeResolver.Get<IMessengerCore>();
				}
				return _messenger;
			}
			set
			{
				_messenger = value;
			}
		}

		protected virtual ICommand FileDialog(string dialogTitle, Action<string> handleFileName)
		{
			return new FileDialogCommand(dialogTitle, handleFileName);
		}
		#region DoWork
		public void DoWork(Action activity)
		{
			Action onComplete = null;
			Action<Exception> onError = null;
			DoWork(activity, onComplete, onError);
		}
		public void DoWork(Action activity, Action onComplete, Action<Exception> onError)
		{
			var cmd = WorkCommand(activity, null, onComplete, onError);
			cmd.Execute(null);
		}
		#endregion

		#region WorkCommand
		public ICommand WorkCommand<TCommandParameter>(Action<TCommandParameter> activity)
		{
			Predicate<TCommandParameter> canExecute = null;
			Action<TCommandParameter> onComplete = null;
			Action<Exception> onError = null;
			return WorkCommand<TCommandParameter>(activity, canExecute, onComplete, onError);
		}
		public ICommand WorkCommand<TCommandParameter>(Action<TCommandParameter> activity, Predicate<TCommandParameter> canExecute)
		{
			Action<TCommandParameter> onComplete = null;
			Action<Exception> onError = null;
			return WorkCommand<TCommandParameter>(activity, canExecute, onComplete, onError);
		}
		public ICommand WorkCommand<TCommandParameter>(Action<TCommandParameter> activity, Predicate<TCommandParameter> canExecute, Action<TCommandParameter> onComplete, Action<Exception> onError)
		{
			var key = Guid.NewGuid().ToString();
			var internalActivity = new Action<TCommandParameter>(
				p =>
				{
					Messenger.Send<BusyMessage>(new BusyMessage(key, true), MessageToken);
					activity(p);
				});
			var internalOnComplete = new Action<TCommandParameter>(
				p =>
				{
					if (onComplete != null) onComplete(p);
					Messenger.Send<BusyMessage>(new BusyMessage(key, false), MessageToken);
				});
			return new AsynchronousCommand<TCommandParameter>(internalActivity, canExecute, internalOnComplete, onError);
		}
		public ICommand WorkCommand(Action activity, Action onComplete)
		{
			Func<bool> canExecute = null;
			Action<Exception> onError = null;
			return WorkCommand(activity, canExecute, onComplete, onError);
		}
		public ICommand WorkCommand(Action activity)
		{
			Func<bool> canExecute = null;
			Action onComplete = null;
			Action<Exception> onError = null;
			return WorkCommand(activity, canExecute, onComplete, onError);
		}
		public ICommand WorkCommand(Action activity, Func<bool> canExecute)
		{
			Action onComplete = null;
			Action<Exception> onError = null;
			return WorkCommand(activity, canExecute, onComplete, onError);
		}
		public ICommand WorkCommand(Action activity, Func<bool> canExecute, Action onComplete, Action<Exception> onError)
		{
			var key = Guid.NewGuid().ToString();
			var internalActivity = new Action(
				() =>
				{
					Messenger.Send<BusyMessage>(new BusyMessage(key, true), MessageToken);
					activity();
				});
			var internalOnComplete = new Action(
				() =>
				{
					if (onComplete != null) onComplete();
					Messenger.Send<BusyMessage>(new BusyMessage(key, false), MessageToken);
				});
			return new AsynchronousCommand(internalActivity, canExecute, internalOnComplete, onError);
		}
		#endregion


		/// <summary>
		/// Represents a confirm dialog displayed to the user.
		/// </summary>
		/// <param name="message">The message displayed to the user.</param>
		/// <param name="yesAction">The action to perform when the user choose Yes in the confirm dialog and looks like this: () => DoSomething()</param>
		/// <returns></returns>
		public ICommand ConfirmCommand(string message, Action yesAction)
		{
			//var internalYesAction = new Action(() => DoWork(yesAction));
			return new ConfirmCommand(MessageToken, message, yesAction);
		}
		public void MessageBox(string content)
		{
			new MessageBoxCommand(content, MessageToken).Execute(null);
		}
		public ICommand MessageBoxCommand(string content)
		{
			return new MessageBoxCommand(content, MessageToken);
		}

		public ICommand DialogCommand(string content)
		{
			return new MessageBoxCommand(content, MessageToken);
		}

		protected virtual ICommand NavigateCommand<TCommandParameter>(Func<TCommandParameter, NavigationMessage> message, Predicate<TCommandParameter> canExecute)
		{
			return new NavigateCommand<TCommandParameter>(MessageToken, message, canExecute);
		}

		protected virtual ICommand NavigateCommand<TCommandParameter>(string controller, string action, object routeValues, NavigationDirections direction, Predicate<TCommandParameter> canExecute)
		{
			return new NavigateCommand<TCommandParameter>(MessageToken, controller, action, routeValues, direction, canExecute);
		}


		protected virtual void Navigate(string controller, string action)
		{
			new NavigateCommand(controller, action, null, NavigationDirections.Forward, MessageToken).Execute(null);
		}

		/// <summary>
		/// Navigates the command.
		/// </summary>
		/// <param name="controller">The controller.</param>
		/// <param name="action">The action.</param>
		/// <param name="canExecute">
		/// Defines the method that determines whether the command can execute in its current state.
		/// Returns true if this command can be executed; otherwise, false.
		/// </param>
		/// <returns></returns>
		protected virtual ICommand NavigateCommand(string controller, string action, Func<bool> canExecute)
		{
			var msg = new NavigationMessage(controller, action, MessageToken);
			return new NavigateCommand(msg, canExecute);
		}

		/// <summary>
		/// Creates a new instance of a <see cref="NavigateCommand"></see>.  
		/// The <see cref="NavigateDirections"></see> defaults to NavigateDirections.Forward.
		/// This command is disabled if the target controller/action do not exist.
		/// </summary>
		/// <param name="controller">The controller.</param>
		/// <param name="action">The action.</param>
		/// <returns></returns>
		protected virtual ICommand NavigateCommand(string controller, string action)
		{
			object routeValues = null;
			return NavigateCommand(controller, action, routeValues);
		}
		/// <summary>
		/// Creates a new instance of a <see cref="NavigateCommand"></see>.  
		/// This command is disabled if the target controller/action do not exist.
		/// The <see cref="NavigateDirections"/> defaults to NavigateDirections.Forward.
		/// </summary>
		/// <param name="controller">The controller.</param>
		/// <param name="action">The action.</param>
		/// <param name="routeValues">
		/// The route values passed along the request.
		/// Expressed as an anonymous type, looks like this:
		/// new { routeValue1 = "Whatever", routeValue2 = someVariable }
		/// </param>
		/// <returns></returns>
		protected virtual ICommand NavigateCommand(string controller, string action, object routeValues)
		{
			var direction = NavigationDirections.Forward;
			return NavigateCommand(controller, action, routeValues, direction);
		}

		/// <summary>
		/// Creates a new instance of a <see cref="NavigateCommand"/>.
		/// This command is disabled if the target controller/action do not exist.
		/// </summary>
		/// <param name="controller">The controller.</param>
		/// <param name="action">The action.</param>
		/// <param name="routeValues">
		/// The route values passed along the request.
		/// Expressed as an anonymous type, looks like this:
		/// new { routeValue1 = "Whatever", routeValue2 = someVariable }
		/// </param>
		/// <param name="direction">
		/// The direction being navigated.
		/// This affects the transition used during navigation.
		/// </param>
		/// <returns></returns>
		protected virtual ICommand NavigateCommand(string controller, string action, object routeValues, NavigationDirections direction)
		{
			return new NavigateCommand(controller, action, routeValues, direction, MessageToken);
		}


		/// <summary>
		/// Sends a message indicating the modal window should be closed.
		/// DialogResult is set to Cancel.
		/// </summary>
		public void CloseModal()
		{
			DialogResult dialogResult = DialogResult.Cancel;
			object result = null;
			CloseModal(dialogResult, result);
		}

		/// <summary>
		/// Sends a message indicating the modal window should be closed.
		/// </summary>
		/// <param name="dialogResult">The dialog result.</param>
		/// <param name="result">The result, any data that needs to be sent back to whatever opened the modal.</param>
		protected void CloseModal(DialogResult dialogResult, object result)
		{
			Messenger.Send<CloseModalMessage>(new CloseModalMessage(dialogResult, result));
		}


		public ICommand ModalCommand<TModalResult>(string controller, string action, Action<ModalWindowResult<TModalResult>> processModalResult)
		{
			Func<bool> canExecute = null;
			object routeValues = null;
			return ModalCommand<TModalResult>(controller, action, routeValues, canExecute, processModalResult);
		}

		public ICommand ModalCommand<TModalResult>(string controller, string action, object routeValues, Func<bool> canExecute, Action<ModalWindowResult<TModalResult>> processModalResult)
		{
			return new ModalWindowCommand<TModalResult>(controller, action, canExecute, routeValues, processModalResult);
		}

		/// <summary>
		/// A command which sends out a request message to open a modal window.
		/// </summary>
		/// <typeparam name="TModalResult">
		/// The type of data returned by the modal window.
		/// This also doubles as the type for the CommandParameter.
		/// </typeparam>
		/// <param name="controller">The controller.</param>
		/// <param name="action">The action.</param>
		/// <param name="routeValuesBuilder">
		/// The method used to create route values to be passed along a request.
		/// The method is passed an instance of type TCommandParameter.
		/// The method should return an anonymous type in a dictionary format(i.e. name/value pairs).
		/// </param>
		/// <param name="processModalResult">
		/// Method used to process the results passed back from the modal window.
		/// </param>
		/// <returns></returns>
		public ICommand ModalCommand<TModalResult>(string controller, string action, Func<TModalResult, object> routeValuesFinder, Action<ModalWindowResult<TModalResult>> processModalResult)
		{
			Predicate<TModalResult> canExecute = null;
			return ModalCommand<TModalResult>(controller, action, routeValuesFinder, canExecute, processModalResult);
		}

		/// <summary>
		/// A command which sends out a request message to open a modal window.
		/// </summary>
		/// <typeparam name="TModalResult">
		/// The type of data returned by the modal window.
		/// This also doubles as the type for the CommandParameter.
		/// </typeparam>
		/// <param name="controller">The controller.</param>
		/// <param name="action">The action.</param>
		/// <param name="routeValuesBuilder">
		/// The method used to create route values to be passed along a request.
		/// The method is passed an instance of type TCommandParameter.
		/// The method should return an anonymous type in a dictionary format(i.e. name/value pairs).
		/// </param>
		/// <param name="canExecute">
		/// Defines the method that determines whether the command can execute in its current state.
		/// This method is passed data of type TModalResult and can be used by the command.
		/// </param>
		/// <param name="processModalResult">
		/// Method used to process the results passed back from the modal window.
		/// </param>
		/// <returns></returns>
		public ICommand ModalCommand<TModalResult>(string controller, string action, Func<TModalResult, object> routeValuesFinder, Predicate<TModalResult> canExecute, Action<ModalWindowResult<TModalResult>> processModalResult)
		{
			return new ModalWindowCommand<TModalResult, TModalResult>(controller, action, routeValuesFinder, canExecute, processModalResult);
		}



		/// <summary>
		/// A command which sends out a request message to open a modal window.
		/// </summary>
		/// <typeparam name="TCommandParameter">The type of the command parameter.</typeparam>
		/// <typeparam name="TModalResult">The type of the modal result.</typeparam>
		/// <param name="controller">The controller.</param>
		/// <param name="action">The action.</param>
		/// <param name="routeValuesBuilder">
		/// The method used to create route values to be passed along a request.
		/// The method is passed an instance of type TCommandParameter.
		/// The method should return an anonymous type in a dictionary format(i.e. name/value pairs).
		/// </param>
		/// <param name="canExecute">The method used to indicate whether the command can be executed.</param>
		/// <param name="processModalResult">
		/// The method used to process whatever is returned from the modal window.
		/// </param>
		/// <returns></returns>
		public ICommand ModalCommand<TCommandParameter, TModalResult>(string controller, string action, Func<TCommandParameter, object> routeValuesBuilder, Predicate<TCommandParameter> canExecute, Action<ModalWindowResult<TModalResult>> processModalResult)
		{
			return new ModalWindowCommand<TCommandParameter, TModalResult>(controller, action, routeValuesBuilder, canExecute, processModalResult);
		}






		public ICommand ModalCommand(string controller, string action)
		{
			object routeValues = null;
			Action<object> processModalResult = null;
			return ModalCommand(controller, action, routeValues, processModalResult);
		}

		public ICommand ModalCommand(string controller, string action, object routeValues, Action<object> processModalResult)
		{
			return new RelayCommand(
				() => Messenger.Send<ModalMessage>(new ModalMessage(controller, action, routeValues, processModalResult))
			);
		}



		//protected virtual ILogger Logger
		//{
		//	get
		//	{
		//		return LoggerService.GetLogger("Main");
		//	}
		//}


		#region ISupportMessageTokens
		private string _messageToken;
		public string MessageToken
		{
			get
			{
				if (String.IsNullOrEmpty(_messageToken))
				{
					throw new InvalidOperationException("MessageToken is null.  MessageToken must be set using SetMessageToken");
				}
				return _messageToken;
			}
		}
		public void SetMessageToken(string messageToken)
		{
			if (String.IsNullOrEmpty(messageToken))
				throw new ArgumentException("messageToken is null or empty.", "messageToken");

			_messageToken = messageToken;
		}
		#endregion


		/// <summary>
		/// Initializes this instance.
		/// Subclassers can override this method to provide anything that needs to be done when this ViewModel is loaded in a <see cref="NavHostControl"/>.
		/// This method does nothing by default.
		/// Made this public to aid in testing.
		/// </summary>
		public virtual void Initialize()
		{

		}

		#region IViewAware
		/// <summary>
		/// Notifies the target that the view has been loaded.
		/// Explicitly implemented so the interface to the ViewModel doesn't get cluttered.
		/// Used only by infrastructure.
		/// </summary>
		void mag.IViewAware.Loaded()
		{
			//do nothing for now
		}

		/// <summary>
		/// Notifies the target that a view has been attached.
		/// Explicitly implemented so the interface to the ViewModel doesn't get cluttered.
		/// Used only by infrastructure.
		/// </summary>
		/// <param name="view">The view.</param>
		void mag.IViewAware.ViewAttached(object view)
		{
			lock (this)
			{
				if (_initialized)
					return;

				_initialized = true;
				Initialize();
			}
		}
		private bool _initialized = false;
		#endregion
	}

}