using DominionBase;
using DominionBase.Cards;
using DominionBase.Enums;
using DominionBase.Piles;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;
using Visibility = System.Windows.Visibility;

namespace Dominion.NET_WPF.Controls
{
	/// <summary>
	/// Interaction logic for ucCardIcon.xaml
	/// </summary>
	public partial class ucCardIcon : UserControl, IDisposable
	{
		public static readonly DependencyProperty SizeProperty =
			DependencyProperty.Register("Size", typeof(CardSize), typeof(ucCardIcon), new PropertyMetadata(CardSize.SmallText));
		public CardSize Size
		{
			get { return (CardSize)GetValue(SizeProperty); }
			set
			{
				SetValue(SizeProperty, value);

				switch (value)
				{ 
					case CardSize.SmallText:
						dpName.Height = 16;
						lName.Margin = new Thickness(0, 0, 2, 0);
						lName.Padding = new Thickness(0);
						Padding = new Thickness(0);
						break;
					case CardSize.Text:
						dpName.Height = double.NaN;
						lName.Margin = new Thickness(0, 0, 5, 0);
						lName.Padding = new Thickness(0, 2, 0, 2);
						Padding = new Thickness(5);
						break;
				}
			}
		}

		private IDisplayable _card;
		private int _count;

		private Settings _containee;
		private WeakucCardIcon _weakContainer;

		public int Count
		{
			get { return _count; }
			set
			{
				_count = value;
				if (_count < 0)
					_count = 0;

				if (_count > 1)
				{
					lCount.Visibility = Visibility.Visible;
					lCount.Content = $"{_count}x";
				}
				else
				{
					lCount.Visibility = Visibility.Collapsed;
				}
			}
		}

		public ucCardIcon()
		{
			InitializeComponent();

			if (WMain.Settings != null)
			{
				Settings = WMain.Settings;
				Settings_SettingsChanged(WMain.Settings, null);
			}
		}

		#region IDisposable variables, properties, & methods
		// Track whether Dispose has been called.
		private bool _disposed;

		public void Dispose()
		{
			Dispose(true);
			GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool disposing)
		{
			// Check to see if Dispose has already been called.
			if (!_disposed)
			{
				// If disposing equals true, dispose all managed
				// and unmanaged resources.
				if (disposing)
				{
					// Dispose managed resources.
				}

				// Call the appropriate methods to clean up
				// unmanaged resources here.
				// If disposing is false,
				// only the following code is executed.
				_card = null;
				//memoryLeak = null;
				if (WMain.Settings != null)
				{
					WMain.Settings.SettingsChanged -= Settings_SettingsChanged;
				}

				// Note disposing has been done.
				_disposed = true;
			}
		}

		~ucCardIcon()
		{
			Dispose(false);
		}
		#endregion

		public Settings Settings
		{
			get { return _containee; }
			set
			{
				if (_weakContainer == null)
					_weakContainer = new WeakucCardIcon(this);

				// unsubscribe old
				if (_containee != null)
					_containee.SettingsChanged -= _weakContainer.Settings_SettingsChanged;

				_containee = value;
				// subscribe new
				if (_containee != null)
					_containee.SettingsChanged += _weakContainer.Settings_SettingsChanged;
			}
		}

		protected virtual void Settings_SettingsChanged(object sender, SettingsChangedEventArgs e)
		{
			var settings = sender as Settings;

			if (settings != null)
			{
				if (settings.ToolTipShowDuration == ToolTipShowDuration.Off)
					ToolTipService.SetIsEnabled(this, false);
				else
				{
					ToolTipService.SetIsEnabled(this, true);
					ToolTipService.SetShowDuration(this, (int)settings.ToolTipShowDuration);
				}
			}
		}

		private class WeakucCardIcon : WeakReference
		{
			public WeakucCardIcon(ucCardIcon target) : base(target) { }

			public void Settings_SettingsChanged(object sender, SettingsChangedEventArgs e)
			{
				var b = (ucCardIcon)Target;
				if (b != null)
					b.Settings_SettingsChanged(sender, e);
				else
				{
					var c = sender as Settings;
					if (c != null)
					{
						c.SettingsChanged -= Settings_SettingsChanged;
					}
				}
			}
		}

		public IDisplayable Card
		{
			get { return _card; }
			set
			{
				_card = value;
				if (_card != null)
				{
					Title = _card.Name;

					var category = Card.Category;
				    var card = Card as Card;
				    if (card != null)
						category = card.PhysicalCategory;

					lName.Background = Caching.BrushRepository.GetBackgroundBrush(category);
					lName.Foreground = Caching.BrushRepository.GetForegroundBrush(category);
					// Flip the foreground/background for Events
					if (category.HasFlag(Categories.Event))
					{
						var t = lName.Foreground;
						lName.Foreground = lName.Background;
						lName.Background = t;
					}

					if (category.HasFlag(Categories.Reaction))
						tbName.Effect = Caching.DropShadowRepository.GetDSE(8, Colors.White, 1d);

					Count = 1;
				}
				else
				{
					Title = string.Empty;

					Count = 0;
				}

				ttcCard.Card = Card;
			}
		}

		public string Title
		{
			get { return tbName.Text; }
			private set
			{
			    tbName.Text = value;
			    lName.Visibility = string.IsNullOrEmpty(value) ? Visibility.Hidden : Visibility.Visible;
			}
		}

		private void UserControl_MouseDown(object sender, MouseButtonEventArgs e)
		{
		    if (WMain.Settings == null || ((ToolTip as ToolTip)?.Content as ToolTipIDisplayable)?.Card == null ||
		        (((ToolTip) ToolTip).Content as ToolTipIDisplayable)?.Card.Type == DominionBase.Cards.Universal.TypeClass.Dummy ||
		        (((ToolTip) ToolTip).Content as ToolTipIDisplayable)?.Card.Type == DominionBase.Cards.Universal.TypeClass.DummyRed ||
		        (((ToolTip) ToolTip).Content as ToolTipIDisplayable)?.Card.Type == DominionBase.Cards.Universal.TypeClass.Blank)
		        return;

			if (WMain.Settings.ShowToolTipOnRightClick && e.ChangedButton == MouseButton.Right && e.ButtonState == MouseButtonState.Pressed)
			{
				CaptureMouse();
				((ToolTip) ToolTip).IsOpen = true;
				e.Handled = true;
			}
		}

		private void UserControl_MouseUp(object sender, MouseButtonEventArgs e)
		{
			if (WMain.Settings == null || ToolTip == null)
				return;

			if (WMain.Settings.ShowToolTipOnRightClick && e.ChangedButton == MouseButton.Right && e.ButtonState == MouseButtonState.Released)
			{
				ReleaseMouseCapture();
			    var toolTip = ToolTip as ToolTip;
			    if (toolTip != null) toolTip.IsOpen = false;
			    e.Handled = true;
			}
		}

		private void UserControl_IsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e)
		{
		    var toolTip = ToolTip as ToolTip;
		    if (toolTip != null && toolTip.IsOpen)
				((ToolTip) ToolTip).IsOpen = false;
		}

		private void UserControl_MouseEnter(object sender, MouseEventArgs e)
		{
			CardHover.RaiseCardHoverEvent(this, new CardHoverEventArgs(Card?.DisplayCard));
		}

		private void UserControl_StylusEnter(object sender, StylusEventArgs e)
		{
			CardHover.RaiseCardHoverEvent(this, new CardHoverEventArgs(Card?.DisplayCard));
		}

		private void UserControl_TouchEnter(object sender, TouchEventArgs e)
		{
			CardHover.RaiseCardHoverEvent(this, new CardHoverEventArgs(Card?.DisplayCard));
		}

	}

	public class CardIconUtilities
	{

		public static IEnumerable<UserControl> CreateCardIcons(IEnumerable<IDisplayable> cards)
		{
			var list = new List<UserControl>();

		    var cardsList = cards as IList<IDisplayable> ?? cards.ToList();
		    if (!cardsList.Any())
				return list;

			ucCardIcon icon;
			var previousIndex = -1;
			for (var c = 0; c < cardsList.Count; c++)
			{
				if (previousIndex < 0)
				{
					previousIndex = c;
					continue;
				}

				if (cardsList.ElementAt(previousIndex).Type != cardsList.ElementAt(c).Type)
				{
				    icon = new ucCardIcon
				    {
				        Card = cardsList.ElementAt(previousIndex),
				        Count = c - previousIndex
				    };

				    var card = icon.Card as Supply;
				    if (card != null && card.Tokens.Any(t => t.Name == "BaneToken"))
						list.Add(new ucTokenIcon { Token = card.Tokens.First(t => t.Name == "BaneToken"), Size = CardSize.SmallText });

					list.Add(icon);

					previousIndex = c;
				}
			}

		    icon = new ucCardIcon
		    {
		        Card = cardsList.Last(),
		        Count = cardsList.Count - previousIndex
		    };

		    var supply = icon.Card as Supply;
		    if (supply != null && supply.Tokens.Any(t => t.Name == "BaneToken"))
				list.Add(new ucTokenIcon { Token = supply.Tokens.First(t => t.Name == "BaneToken"), Size = CardSize.SmallText });

			list.Add(icon);

			return list;
		}

		public static ucCardIcon CreateCardIcon(IDisplayable card)
		{
		    var icon = new ucCardIcon
		    {
		        Card = card,
		        Count = 1
		    };

		    return icon;
		}
	}

}