using System;
using System.Windows;
using System.Windows.Documents;
using System.Windows.Input;

namespace Yahoo.SharedWPF
{
	/// <summary>
	/// this is a class used primarily to work around a bug in
	/// WPF 3.0 where, if you have a custom command on a Hyperlink
	/// and you try to use ApplicationCommands.Copy the link, you
	/// get a crash because it tries to serialize the custom command
	/// and it is disallowed in the source.  the workaround is to
	/// simply use this class to define the command rather than the
	/// Hyperlink.Command and everything else stays the same.
	/// </summary>
	public class HyperlinkHelper : DependencyObject
	{
		/// <summary>
		/// make the attached prop accessible from XAML
		/// </summary>
		/// <param name="obj"></param>
		/// <returns></returns>
		public static ICommand GetCommand(DependencyObject obj)
		{
			return (ICommand)obj.GetValue(CommandProperty);
		}

		/// <summary>
		/// make the attached prop accessible from XAML
		/// </summary>
		/// <param name="obj"></param>
		/// <param name="value"></param>
		/// <returns></returns>
		public static void SetCommand(DependencyObject obj, ICommand value)
		{
			obj.SetValue(CommandProperty, value);
		}

		/// <summary>
		/// DP for HyperlinkHelper.Command
		/// </summary>
		public static readonly DependencyProperty CommandProperty =
			DependencyProperty.RegisterAttached
			(
				"Command",
				typeof(ICommand),
				typeof(HyperlinkHelper),
				new UIPropertyMetadata
				(
					null,
					delegate(DependencyObject obj, DependencyPropertyChangedEventArgs args)
					{
						Hyperlink link = (obj as Hyperlink);
						if (link != null)
						{
							ICommand command = (args.NewValue as ICommand);
							if (command != null)
							{
								AddHandlers(link);
							}
							else
							{
								RemoveHandlers(link);
							}
						}
					}
				)
			);

		/// <summary>
		/// add the Click and Unloaded handlers
		/// </summary>
		/// <param name="link"></param>
		static void AddHandlers(Hyperlink link)
		{
			if (link != null)
			{
				// remove handlers in case we get called twice
				RemoveHandlers(link);

				// add handlers
				link.Unloaded += link_Unloaded;
				link.Click += link_Click;
			}
		}

		/// <summary>
		/// remove the Click and Unloaded handlers
		/// </summary>
		/// <param name="link"></param>
		static void RemoveHandlers(Hyperlink link)
		{
			if (link != null)
			{
				link.Unloaded -= link_Unloaded;
				link.Click -= link_Click;
			}
		}

		/// <summary>
		/// make sure we clean up when we are unloaded
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="e"></param>
		static void link_Unloaded(object sender, RoutedEventArgs e)
		{
			RemoveHandlers(sender as Hyperlink);
		}

		/// <summary>
		/// when the link is clicked, simply check whether the command
		/// can execute and execute if so
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="e"></param>
		static void link_Click(object sender, RoutedEventArgs e)
		{
			Hyperlink link = (sender as Hyperlink);
			ICommand command = GetCommand(link);

			if (command != null)
			{
				if (command is RoutedCommand)
				{
					RoutedCommand rcmd = command as RoutedCommand;

					IInputElement target = link.CommandTarget;
					if (target == null)
					{
						target = link;
					}

					if (rcmd.CanExecute(link.CommandParameter, target))
					{
						rcmd.Execute(link.CommandParameter, target);
					}
				}
				else if (command.CanExecute(link.CommandParameter))
				{
					command.Execute(link.CommandParameter);
				}
			}
		}
	}
}