using DominionBase.Enums;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;

namespace Dominion.NET_WPF.Controls
{
	/// <summary>
	/// Interaction logic for ucCardConstraint.xaml
	/// </summary>
	public partial class ucCardConstraint : UserControl, IDisposable
	{
	    private DominionBase.Cards.Constraint _constraint;

		public DominionBase.Cards.Constraint Constraint
		{
			get { return _constraint; }
			set { 
				_constraint = value;

				cbMinimum.ItemsSource = Counts;
				cbMinimum.SelectedItem = _constraint.Minimum;

				cbMaximum.ItemsSource = Counts;
				cbMaximum.SelectedItem = _constraint.Maximum;

				cbCriteria.SelectedItem = _constraint.ConstraintType;
				cbValue.SelectedItem = _constraint.ConstraintValue;
			}
		}

		public static readonly RoutedEvent RemoveClickEvent = EventManager.RegisterRoutedEvent(
			"RemoveClick",
			RoutingStrategy.Bubble,
			typeof(RoutedEventHandler),
			typeof(ucCardConstraint));

		public event RoutedEventHandler RemoveClick
		{
			add { AddHandler(RemoveClickEvent, value); }
			remove { RemoveHandler(RemoveClickEvent, value); }
		}

		public static readonly DependencyProperty DisplayObjectsProperty =
			DependencyProperty.Register("DisplayObjects", typeof(DisplayObjects), typeof(ucCardConstraint),
			new PropertyMetadata(new DisplayObjects()));
		public DisplayObjects DisplayObjects
		{
			get { return (DisplayObjects)GetValue(DisplayObjectsProperty); }
			set
			{
				SetValue(DisplayObjectsProperty, value);
			}
		}

		private readonly List<int> _counts = new List<int>();
		public ObservableCollection<int> Counts
		{
			get
			{
				if (_counts.Count == 0)
				{
					for (var i = Constraint.RangeMin; i <= Constraint.RangeMax; i++)
						_counts.Add(i);
				}
				return new ObservableCollection<int>(_counts);
			}
		}

		public ucCardConstraint()
		{
			InitializeComponent();
			if (WMain.Settings != null)
			{
				WMain.Settings.SettingsChanged += Settings_SettingsChanged;
				Settings_SettingsChanged(WMain.Settings, null);
			}
		}

		public void Dispose()
		{
			if (WMain.Settings != null)
			{
				WMain.Settings.SettingsChanged -= Settings_SettingsChanged;
			}
		}

	    private void Settings_SettingsChanged(object sender, SettingsChangedEventArgs e)
		{
			var settings = sender as Settings;
			if (settings != null)
			{
				if (settings.ToolTipShowDuration == ToolTipShowDuration.Off)
					ToolTipService.SetIsEnabled(cbValue, false);
				else
				{
					ToolTipService.SetIsEnabled(cbValue, true);
					ToolTipService.SetShowDuration(cbValue, (int)settings.ToolTipShowDuration);
				}
			}
		}

		private void cbMinimum_SelectionChanged(object sender, SelectionChangedEventArgs e)
		{
			if (cbMinimum?.SelectedItem == null)
				return;
			Constraint.Minimum = (int)cbMinimum.SelectedItem;
			cbMaximum.SelectedItem = Constraint.Maximum;
		}

		private void cbMaximum_SelectionChanged(object sender, SelectionChangedEventArgs e)
		{
			if (cbMaximum?.SelectedItem == null)
				return;
			Constraint.Maximum = (int)cbMaximum.SelectedItem;
			cbMinimum.SelectedItem = Constraint.Minimum;
		}

		private void cbCriteria_SelectionChanged(object sender, SelectionChangedEventArgs e)
		{
			if (cbValue == null)
				return;

			if (e.AddedItems.Count > 0)
			{
				Constraint.ConstraintType = (DominionBase.Cards.ConstraintType)e.AddedItems[0];

				switch (Constraint.ConstraintType)
				{
					case DominionBase.Cards.ConstraintType.Unknown:
						break;

					case DominionBase.Cards.ConstraintType.SetIs:
						cbValue.ItemsSource = DisplayObjects.Sources;
						if (Constraint.ConstraintValue is Source cvSource)
						{
							foreach (var kvpSource in cbValue.Items.OfType<KeyValuePair<Source, int>>())
							{
							    if (kvpSource.Key != cvSource) continue;
							    cbValue.SelectedItem = kvpSource;
							    break;
							}
						}
						cbValue.Focus();
						break;

					case DominionBase.Cards.ConstraintType.CategoryContains:
						cbValue.ItemsSource = DisplayObjects.CategoriesContains;
						if (Constraint.ConstraintValue is Categories cvCategories)
						{
							foreach (var kvpCategory in cbValue.Items.OfType<KeyValuePair<Categories, int>>())
							{
							    if (kvpCategory.Key != cvCategories) continue;
							    cbValue.SelectedItem = kvpCategory;
							    break;
							}
						}
						cbValue.Focus();
						break;

					case DominionBase.Cards.ConstraintType.CardCosts:
						cbValue.ItemsSource = DisplayObjects.Costs;
						if (Constraint.ConstraintValue is DominionBase.Cards.Cost cvCost)
						{
							foreach (var kvpCost in cbValue.Items.OfType<KeyValuePair<DominionBase.Cards.Cost, int>>())
							{
							    if (kvpCost.Key != cvCost) continue;
							    cbValue.SelectedItem = kvpCost;
							    break;
							}
						}
						cbValue.Focus();
						break;

					case DominionBase.Cards.ConstraintType.CardDontUse:
						cbValue.ItemsSource = DisplayObjects.Cards;
						if (Constraint.ConstraintValue is string s)
						{
							foreach (var card in cbValue.Items.OfType<DominionBase.IDisplayable>())
							{
								if (card.Name != s) continue;
								cbValue.SelectedItem = card;
								break;
							}
						}
						cbValue.Focus();
						break;

					case DominionBase.Cards.ConstraintType.CardMustUse:
						cbValue.ItemsSource = DisplayObjects.Cards;
						if (Constraint.ConstraintValue is string value)
						{
							foreach (var card in cbValue.Items.OfType<DominionBase.IDisplayable>())
							{
								if (card.Name != value) continue;
								cbValue.SelectedItem = card;
								break;
							}
						}
						cbValue.Focus();
						break;

					case DominionBase.Cards.ConstraintType.HasTrait:
						cbValue.ItemsSource = DisplayObjects.Trait;
						if (Constraint.ConstraintValue is Traits cvTraits)
						{
							foreach (var kvpTrait in cbValue.Items.OfType<KeyValuePair<Traits, int>>())
							{
							    if (kvpTrait.Key != cvTraits) continue;
							    cbValue.SelectedItem = kvpTrait;
							    break;
							}
						}
						cbValue.Focus();
						break;

					default:
						break;
				}

				_counts.Clear();

				cbMinimum.ItemsSource = Counts;
				cbMinimum.SelectedItem = _constraint.Minimum;

				cbMaximum.ItemsSource = Counts;
				cbMaximum.SelectedItem = _constraint.Maximum;
			}
		}

		private void cbValue_SelectionChanged(object sender, SelectionChangedEventArgs e)
		{
			if (e.AddedItems.Count > 0)
			{
				if (Constraint.ConstraintType == DominionBase.Cards.ConstraintType.CardDontUse || Constraint.ConstraintType == DominionBase.Cards.ConstraintType.CardMustUse)
				{
					ttCard.Visibility = Visibility.Visible;
					ttcCard.Card = (DominionBase.IDisplayable)e.AddedItems[0];
					Constraint.ConstraintValue = ((DominionBase.IDisplayable)e.AddedItems[0]).Name;
				}
				else
				{
					ttCard.Visibility = Visibility.Collapsed;
					ttcCard.Card = null;
					Constraint.ConstraintValue = e.AddedItems[0];
				}
			}
		}

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

			if (WMain.Settings.ShowToolTipOnRightClick && e.ChangedButton == MouseButton.Right && e.ButtonState == MouseButtonState.Pressed)
			{
			    fe.CaptureMouse();
			    var toolTip = fe.ToolTip as ToolTip;
			    if (toolTip != null) toolTip.IsOpen = true;
			}
		}

		private void cbValue_MouseUp(object sender, MouseButtonEventArgs e)
		{
			var fe = sender as FrameworkElement;
			if (WMain.Settings == null || fe?.ToolTip == null)
				return;

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

		private void bRemove_Click(object sender, RoutedEventArgs e)
		{
		    var button = sender as Button;
		    if (button != null) button.IsEnabled = false;
		    RaiseEvent(new RoutedEventArgs(RemoveClickEvent));
		    if (button != null) button.IsEnabled = true;
		}

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

	}
}