using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Shapes;

using DominionBase;
using DominionBase.Enums;
using DominionBase.Piles;
using DominionBase.Players;
using DominionBase.Utilities;

namespace Dominion.NET_WPF.Controls
{
	/// <summary>
	/// Interaction logic for ucPlayerDisplay.xaml
	/// </summary>
	public partial class UcPlayerDisplay : UserControl
	{
		private IPlayer _player;
		private bool _isActive;
		private readonly Color _colorFocus = Colors.Transparent;
		private ImageBrush _backgroundFocus;
		private Brush _foregroundFocus;

		private static readonly List<Type> Playermats = new List<Type> {
			DominionBase.Cards.Seaside.TypeClass.IslandMat,
			DominionBase.Cards.Seaside.TypeClass.NativeVillageMat,
			DominionBase.Cards.Promotional.TypeClass.PrinceSetAside,
			DominionBase.Cards.Promotional.TypeClass.SummonSetAside,
			DominionBase.Cards.Adventures.TypeClass.InheritanceSetAside,
			DominionBase.Cards.Adventures.TypeClass.SaveSetAside,
			DominionBase.Cards.Adventures.TypeClass.TavernMat,
			DominionBase.Cards.Menagerie.TypeClass.DelaySetAside,
			DominionBase.Cards.Menagerie.TypeClass.ReapSetAside,
			DominionBase.Cards.Menagerie.TypeClass.WayOfTheMouseSetAside,
			DominionBase.Cards.Menagerie.TypeClass.WayOfTheTurtleSetAside,
			DominionBase.Cards.Menagerie.TypeClass.Exile,
		};

		[Bindable(true)]
		public bool DisplayVictoryPoints
		{
			get { return (bool)GetValue(DisplayVictoryPointsProperty); }
			set
			{
				SetValue(DisplayVictoryPointsProperty, value);
				UpdateVictoryPoints();
			}
		}

		public static readonly DependencyProperty DisplayVictoryPointsProperty =
			DependencyProperty.Register("DisplayVictoryPoints", typeof(bool), typeof(UcPlayerDisplay));

		[Bindable(true)]
		public Brush HighlightBrush
		{
			get { return (Brush)GetValue(HighlightBrushProperty); }
			set { SetValue(HighlightBrushProperty, value); }
		}

		public static readonly DependencyProperty HighlightBrushProperty =
			DependencyProperty.Register("HighlightBrush", typeof(Brush), typeof(UcPlayerDisplay));

		public Color ColorFocus
		{
			get { return _colorFocus; }
			set
			{
				var hlsValue = HlsColor.RgbToHls(value);

				var colorBorder = HlsColor.HlsToRgb(hlsValue.H, hlsValue.L * 0.25, hlsValue.S * 1.05, hlsValue.A);
				if (Math.Abs(hlsValue.A) < 0.001)
					colorBorder = HlsColor.HlsToRgb(0d, hlsValue.L * 0.25, 0d, 1d);

				HighlightBrush = new SolidColorBrush(colorBorder);

				var cPlayer = HlsColor.HlsToRgb(hlsValue.H, hlsValue.L * 1.125, hlsValue.S * 0.95, hlsValue.A);
				var gsc = new GradientStopCollection
				{
					new GradientStop(value, 0),
					new GradientStop(cPlayer, 0.1),
					new GradientStop(cPlayer, 0.9),
					new GradientStop(value, 1)
				};
				gsc.Freeze();
				Background = new LinearGradientBrush(gsc, 0);

				var db = new DrawingBrush();
				var gd = new GeometryDrawing(
					new SolidColorBrush(cPlayer),
					null,
					new RectangleGeometry(new Rect(0, 0, 100, 100))
					);
				var gg = new GeometryGroup();
				gg.Children.Add(new RectangleGeometry(new Rect(0, 0, 50, 50)));
				gg.Children.Add(new RectangleGeometry(new Rect(50, 50, 50, 50)));
				var lgb = new LinearGradientBrush();
				lgb.GradientStops.Add(new GradientStop(value, 0.0));
				lgb.GradientStops.Add(new GradientStop(cPlayer, 1.0));
				var gd2 = new GeometryDrawing(new SolidColorBrush(value), null, gg);
				var dg = new DrawingGroup();
				dg.Children.Add(gd);
				dg.Children.Add(gd2);
				db.Drawing = dg;
				db.ViewportUnits = BrushMappingMode.Absolute;
				db.Viewport = new Rect(0, 0, 20, 20);
				db.TileMode = TileMode.Tile;
				gPlayerArea.Fill = db;


				//this.Background = new SolidColorBrush(HLSColor.HlsToRgb(hlsValue.H, Math.Min(1d, hlsValue.L * 1.125), hlsValue.S * 0.95, hlsValue.A));
				dpStuff.Background = new SolidColorBrush(HlsColor.HlsToRgb((hlsValue.H + 10) % 360, hlsValue.L * 0.8, hlsValue.S, hlsValue.A));
				lPhaseText.Background = lPhase.Background = new SolidColorBrush(HlsColor.HlsToRgb(hlsValue.H, hlsValue.L * 0.95, hlsValue.S, hlsValue.A));
			}
		}

		public ImageBrush BackgroundFocus
		{
			get { return _backgroundFocus; }
			set
			{
				if (value == null)
				{
					_backgroundFocus = null;
					gPlayerArea.Fill = _backgroundFocus;
				}
				else
				{
					_backgroundFocus = value; //.Clone();

					_backgroundFocus.Stretch = Stretch.Fill;
					_backgroundFocus.TileMode = TileMode.Tile;
					_backgroundFocus.ViewportUnits = BrushMappingMode.Absolute;
					_backgroundFocus.Viewport = new Rect(0, 0, _backgroundFocus.ImageSource.Height / 2, _backgroundFocus.ImageSource.Width / 2);
					gPlayerArea.Fill = _backgroundFocus;
					gCardTakens.Fill = _backgroundFocus;
				}
			}
		}

		public Brush ForegroundFocus
		{
			get { return _foregroundFocus; }
			set
			{
				_foregroundFocus = value;
				cardDiscard.Foreground = cardDeck.Foreground = cardHand.Foreground = cardInPlay.Foreground = cardSetAside.Foreground = cardRevealed.Foreground = cardPrivate.Foreground = boonTaken.Foreground = cardStates.Foreground = value;
				// This might not be needed??
				foreach (var ccc in dpMatsandPiles.Children.OfType<CardCollectionControl>())
					ccc.Foreground = value;
				foreach (var cmc in dpMatsandPiles.Children.OfType<CardMatControl>())
					cmc.Foreground = value;
			}
		}

		public IPlayer Player
		{
			get { return _player; }
			set
			{
				if (_player != null)
				{
					_player.PhaseChangedFinished -= Player_PhaseChangedEvent;
					_player.PlayerModeChanged -= Player_PlayerModeChangedEvent;
					_player.TurnStarted -= Player_TurnStarted;
					_player.TurnEnded -= Player_TurnEnded;
					_player.PlayerMats.CardMatsChanged -= PlayerMats_DecksChanged;
					_player.TokenPiles.TokenCollectionsChanged -= TokenPiles_TokenCollectionsChanged;
				}

				_player = value;
				cardDiscard.Player = cardDeck.Player = cardHand.Player = cardInPlay.Player = cardSetAside.Player = cardRevealed.Player = cardPrivate.Player = cardEndgame.Player = boonTaken.Player = cardStates.Player = _player;

				if (_player != null)
				{
					_player.PhaseChangedFinished += Player_PhaseChangedEvent;
					_player.PlayerModeChanged += Player_PlayerModeChangedEvent;
					_player.TurnStarted += Player_TurnStarted;
					_player.TurnEnded += Player_TurnEnded;
					_player.PlayerMats.CardMatsChanged += PlayerMats_DecksChanged;
					_player.TokenPiles.TokenCollectionsChanged += TokenPiles_TokenCollectionsChanged;

					// Fire off each event to get things rolling
					Player_PhaseChangedEvent(null, new PhaseChangedEventArgs(_player, _player.Phase));
					Player_PlayerModeChangedEvent(null, new PlayerModeChangedEventArgs(_player, _player.PlayerMode));
					foreach (var cardMat in _player.PlayerMats.Values)
						PlayerMats_DecksChanged(null, new CardMatsChangedEventArgs(cardMat, CardMatsChangedEventArgs.Operation.Reset));
					foreach (var tokenPile in _player.TokenPiles.Values)
						TokenPiles_TokenCollectionsChanged(null, new TokenCollectionsChangedEventArgs(tokenPile, TokenCollectionsChangedEventArgs.Operation.Reset));
				}

				// Force reset of IsActive
				IsActive = IsActive;
			}
		}

		public void TearDown()
		{
			IsActive = false;
			Player = null;
		}

		internal Control FindGameObject(IGameObject gameObject)
		{
			var fe = cardDeck.FindGameObject(gameObject);
			if (fe != null) return fe;
			fe = cardDiscard.FindGameObject(gameObject);
			if (fe != null) return fe;
			fe = cardHand.FindGameObject(gameObject);
			if (fe != null) return fe;
			fe = cardRevealed.FindGameObject(gameObject);
			if (fe != null) return fe;
			fe = cardPrivate.FindGameObject(gameObject);
			if (fe != null) return fe;
			fe = cardInPlay.FindGameObject(gameObject);
			if (fe != null) return fe;
			fe = cardSetAside.FindGameObject(gameObject);
			if (fe != null) return fe;
			// This might not be needed??
			foreach (var mat in dpMatsandPiles.Children.OfType<CardCollectionControl>())
			{
				fe = mat.FindGameObject(gameObject);
				if (fe != null) return fe;
			}
			foreach (var mat in dpMatsandPiles.Children.OfType<CardMatControl>())
			{
				fe = mat.FindGameObject(gameObject);
				if (fe != null) return fe;
			}
			fe = boonTaken.FindGameObject(gameObject);
			if (fe != null) return fe;
			fe = cardStates.FindGameObject(gameObject);
			if (fe != null) return fe;

			return null;
		}

		private void UpdateVictoryPoints()
		{
			if (DisplayVictoryPoints)
			{
				lVictoryPoints.Content = Player.CountVictoryPoints();
				bVictoryPointsDivider.Visibility =
					lVictoryPointsTitle.Visibility = lVictoryPoints.Visibility = System.Windows.Visibility.Visible;
			}
			else
			{
				bVictoryPointsDivider.Visibility =
					lVictoryPointsTitle.Visibility = lVictoryPoints.Visibility = System.Windows.Visibility.Collapsed;
				lVictoryPoints.Content = "?";
			}
		}

		private void TokenPiles_TokenCollectionsChanged(object sender, TokenCollectionsChangedEventArgs e)
		{
			if (Dispatcher.CheckAccess())
			{
				Token token;
				if (e.TokenCollection.Any())
					token = e.TokenCollection[0];
				else if (e.AddedTokens.Any())
					token = e.AddedTokens[0];
				else if (e.RemovedTokens.Any())
					token = e.RemovedTokens[0];
				else
					return;

				var tokenType = token.GetType();

				string tokenName = $"l{tokenType.Name}";
				var lTokenValue = dpTokens.Children.OfType<Label>().SingleOrDefault(l => l.Name == tokenName);

				if (tokenType == DominionBase.Cards.Seaside.TypeClass.PirateShipToken)
				{
					if (lTokenValue == null)
					{
						var lPirateShipToken = new Label
						{
							Content = "Pirate Ship Tokens:",
							FontSize = 16d,
							FontWeight = FontWeights.Bold,
							HorizontalContentAlignment = HorizontalAlignment.Right,
							Background = Caching.BrushRepository.GetBackgroundBrush(Categories.Treasure)
						};
						DockPanel.SetDock(lPirateShipToken, Dock.Left);
						dpTokens.Children.Add(lPirateShipToken);

						lTokenValue = new Label
						{
							Name = tokenName,
							FontWeight = FontWeights.Bold,
							VerticalAlignment = VerticalAlignment.Stretch,
							VerticalContentAlignment = VerticalAlignment.Center,
							Background = Caching.BrushRepository.GetBackgroundBrush(Categories.Treasure),
							Padding = new Thickness(5, 0, 5, 0),
							BorderThickness = new Thickness(0, 0, 1, 0)
						};
						DockPanel.SetDock(lTokenValue, Dock.Left);
						dpTokens.Children.Add(lTokenValue);

						var bDiv = new Border
						{
							BorderThickness = new Thickness(1),
							BorderBrush = HighlightBrush
						};
						Panel.SetZIndex(bDiv, 1);
						DockPanel.SetDock(bDiv, Dock.Left);
						dpTokens.Children.Add(bDiv);
					}
					lTokenValue.Content = e.Count;
				}

				else if (tokenType == DominionBase.Cards.Prosperity.TypeClass.VictoryToken
					|| tokenType == DominionBase.Cards.Guilds.TypeClass.Coffer
					|| tokenType == DominionBase.Cards.Empires.TypeClass.DebtToken
					|| tokenType == DominionBase.Cards.Renaissance.TypeClass.Villager
					)
				{
					if (lTokenValue == null)
					{
						lTokenValue = new Label
						{
							Name = tokenName,
							FontWeight = FontWeights.Bold,
							VerticalAlignment = VerticalAlignment.Stretch,
							VerticalContentAlignment = VerticalAlignment.Center,
							HorizontalContentAlignment = HorizontalAlignment.Right,
							Padding = new Thickness(5, 0, 5, 0),
							BorderThickness = new Thickness(0, 0, 1, 0),
							MinWidth = 40
						};
						DockPanel.SetDock(lTokenValue, Dock.Left);
						dpTokens.Children.Add(lTokenValue);

						var bDiv = new Border
						{
							BorderThickness = new Thickness(1),
							BorderBrush = HighlightBrush
						};
						Panel.SetZIndex(bDiv, 1);
						DockPanel.SetDock(bDiv, Dock.Left);
						dpTokens.Children.Add(bDiv);
					}
					lTokenValue.Content = Utilities.RenderText($"{e.Count}{token.DisplayString}", NET_WPF.RenderSize.Tiny, false)[0];
					lTokenValue.ToolTip = StringUtility.Plural(token.LongDisplayString, e.Count);
					// For example, if a Villager is played, the UI needs to be updated
					cardHand.UpdateCardDisplay();
				}

				else if (tokenType == DominionBase.Cards.Adventures.TypeClass.JourneyToken ||
					tokenType == DominionBase.Cards.Adventures.TypeClass.MinusOneCardToken ||
					tokenType == DominionBase.Cards.Adventures.TypeClass.MinusOneCoinToken)
				{
					if (lTokenValue == null)
					{
						lTokenValue = new Label
						{
							Name = tokenName,
							FontWeight = FontWeights.Bold,
							VerticalAlignment = VerticalAlignment.Stretch,
							VerticalContentAlignment = VerticalAlignment.Center,
							Padding = new Thickness(5, 0, 5, 0),
							BorderThickness = new Thickness(0, 0, 1, 0),
							MinWidth = 40
						};
						DockPanel.SetDock(lTokenValue, Dock.Left);
						dpTokens.Children.Add(lTokenValue);

						var bDiv = new Border
						{
							BorderThickness = new Thickness(1),
							BorderBrush = HighlightBrush
						};
						Panel.SetZIndex(bDiv, 1);
						DockPanel.SetDock(bDiv, Dock.Left);
						dpTokens.Children.Add(bDiv);
					}
					if (e.Count > 0)
					{
						if (tokenType == DominionBase.Cards.Adventures.TypeClass.JourneyToken)
						{
							var repo = Caching.ImageRepository.Acquire();
							var face = ((DominionBase.Cards.Adventures.JourneyToken)token).FaceShowing;
							var bmp = repo.GetBitmapImage("journey_" + (face == DominionBase.Cards.Adventures.TokenFaceShowing.FaceUp ? "up" : "down"), string.Empty);
							var iJourney = new Image { Source = bmp };
							if (bmp != null)
							{
								iJourney.Width = bmp.PixelWidth;
								iJourney.Height = bmp.PixelHeight;
							}
							Caching.ImageRepository.Release();
							lTokenValue.Content = iJourney;
							lTokenValue.ToolTip = $"{EnumUtility.GetEnumDescription(face)} {token.LongDisplayString}";
						}
						else if (tokenType == DominionBase.Cards.Adventures.TypeClass.MinusOneCardToken ||
								 tokenType == DominionBase.Cards.Adventures.TypeClass.MinusOneCoinToken)
						{
							lTokenValue.Content = Utilities.RenderText(token.DisplayString, NET_WPF.RenderSize.Medium, false)[0];
							lTokenValue.ToolTip = Utilities.RenderText(token.LongDisplayString, NET_WPF.RenderSize.Tiny, true)[0];
						}
					}
					else
					{
						lTokenValue.Content = lTokenValue.ToolTip = string.Empty;
					}
				}
			}
			else
			{
				Dispatcher.BeginInvoke(new EventHandler<TokenCollectionsChangedEventArgs>(TokenPiles_TokenCollectionsChanged), System.Windows.Threading.DispatcherPriority.Normal, sender, e);
			}
		}

		private void PlayerMats_DecksChanged(object sender, CardMatsChangedEventArgs e)
		{
			Player_PileChanged(e.CardMat, new PileChangedEventArgs<IRandomizable>(Operation.Refresh));
		}

		private void Player_TurnStarted(object sender, TurnStartedEventArgs e)
		{
			if (cardHand.Dispatcher.CheckAccess())
			{
				cardHand.IsClickable = IsUIPlayer;
				UpdateVictoryPoints();
			}
			else
			{
				cardHand.Dispatcher.BeginInvoke(new EventHandler<TurnStartedEventArgs>(Player_TurnStarted), System.Windows.Threading.DispatcherPriority.Normal, sender, e);
			}
		}

		private void Player_TurnEnded(object sender, TurnEndedEventArgs e)
		{
			if (cardHand.Dispatcher.CheckAccess())
			{
				cardHand.IsClickable = false;
				UpdateVictoryPoints();
			}
			else
			{
				cardHand.Dispatcher.BeginInvoke(new EventHandler<TurnEndedEventArgs>(Player_TurnEnded), System.Windows.Threading.DispatcherPriority.Normal, sender, e);
			}
		}

		private void Player_PhaseChangedEvent(object sender, PhaseChangedEventArgs e)
		{
			if (Dispatcher.CheckAccess())
			{
				DisplayStage(e.CurrentPlayer.Phase, e.CurrentPlayer.PlayerMode);

				if (IsUIPlayer)
				{
					if (e.CurrentPlayer.Phase == PhaseEnum.Setup ||
						e.CurrentPlayer.Phase == PhaseEnum.Starting ||
						e.CurrentPlayer.Phase == PhaseEnum.Waiting ||
						e.CurrentPlayer.Phase == PhaseEnum.Cleanup ||
						e.CurrentPlayer.Phase == PhaseEnum.Endgame ||
						e.CurrentPlayer.PlayerMode == PlayerMode.Waiting ||
						e.CurrentPlayer.PlayerMode == PlayerMode.Choosing)
						cardHand.IsClickable = false;
					else
						cardHand.IsClickable = true;

					if (e.CurrentPlayer == _player)
						cardHand.Phase = e.NewPhase;
				}
				else
					cardHand.IsClickable = false;

				if (e.NewPhase == PhaseEnum.Endgame)
				{
					cardEndgame.SplitAt = c => !c.HasVPs;
					cardHand.Visibility = System.Windows.Visibility.Collapsed;
					cardDiscard.Visibility = cardDeck.Visibility = System.Windows.Visibility.Collapsed;
					wpEndgame.Visibility = System.Windows.Visibility.Visible;
					bHandInPlayDivider.Visibility = dpInPlay.Visibility = bInPlayMatsDivider.Visibility = dpMatsandPiles.Visibility = System.Windows.Visibility.Collapsed;
					DisplayVictoryPoints = true;
					svPlayerDisplay.HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled;
				}
			}
			else
			{
				Dispatcher.BeginInvoke(new EventHandler<PhaseChangedEventArgs>(Player_PhaseChangedEvent), System.Windows.Threading.DispatcherPriority.Normal, sender, e);
			}
		}
		private void Player_PlayerModeChangedEvent(object sender, PlayerModeChangedEventArgs e)
		{
			if (Dispatcher.CheckAccess())
			{
				DisplayStage(e.CurrentPlayer.Phase, e.CurrentPlayer.PlayerMode);

				if (IsUIPlayer)
				{
					if (e.CurrentPlayer.Phase == PhaseEnum.Setup ||
						e.CurrentPlayer.Phase == PhaseEnum.Starting ||
						e.CurrentPlayer.Phase == PhaseEnum.Waiting ||
						e.CurrentPlayer.Phase == PhaseEnum.Cleanup ||
						e.CurrentPlayer.Phase == PhaseEnum.Endgame ||
						e.CurrentPlayer.PlayerMode == PlayerMode.Waiting ||
						e.CurrentPlayer.PlayerMode == PlayerMode.Choosing)
						cardHand.IsClickable = false;
					else
						cardHand.IsClickable = true;

					if (e.CurrentPlayer == _player)
						cardHand.PlayerMode = e.NewPlayerMode;
				}
				else
					cardHand.IsClickable = false;
			}
			else
			{
				Dispatcher.BeginInvoke(new EventHandler<PlayerModeChangedEventArgs>(Player_PlayerModeChangedEvent), System.Windows.Threading.DispatcherPriority.Normal, sender, e);
			}
		}
		private void DisplayStage(PhaseEnum phase, PlayerMode playerMode)
		{
			var sbStage = new StringBuilder();
			switch (phase)
			{
				case PhaseEnum.ActionTreasure:
					sbStage.Append("Action (Treasure)");
					break;
				case PhaseEnum.BuyTreasure:
					sbStage.Append("Buy (Treasure)");
					break;
				default:
					sbStage.Append(phase);
					break;
			}
			switch (playerMode)
			{
				case PlayerMode.Playing:
				case PlayerMode.Buying:
				case PlayerMode.Choosing:
					sbStage.AppendFormat(" - {0}", playerMode);
					break;
			}

			lPhase.Content = sbStage.ToString();
		}
		public bool IsUIPlayer { get; set; }
		public bool IsActive
		{
			get { return _isActive; }
			set
			{
				if (_isActive != value)
				{
					if (_player != null)
					{
						_player.Hand.PileChanged -= Player_PileChanged;
						_player.Revealed.PileChanged -= Player_PileChanged;
						_player.InPlay.PileChanged -= Player_PileChanged;
						_player.SetAside.PileChanged -= Player_PileChanged;
						_player.DrawPile.PileChanged -= Player_PileChanged;
						_player.DiscardPile.PileChanged -= Player_PileChanged;
						_player.Private.PileChanged -= Player_PileChanged;
						_player.TakeablesChanged -= Player_TakeablesChanged;
						_player.PlayerMats.CardMatsChanged -= PlayerMats_CardMatsChanged;

						foreach (var matType in _player.PlayerMats.Keys)
							_player.PlayerMats[matType].PileChanged -= Player_PileChanged;
					}

					_isActive = value;

					if (_isActive && _player != null)
					{
						var pcea = new PileChangedEventArgs<IRandomizable>(_player, Operation.Refresh);

						_player.Hand.PileChanged += Player_PileChanged;
						Player_PileChanged(_player.Hand, pcea);

						_player.Revealed.PileChanged += Player_PileChanged;
						Player_PileChanged(_player.Revealed, pcea);

						_player.InPlay.PileChanged += Player_PileChanged;
						Player_PileChanged(_player.InPlay, pcea);
						_player.SetAside.PileChanged += Player_PileChanged;
						Player_PileChanged(_player.SetAside, pcea);

						_player.DrawPile.PileChanged += Player_PileChanged;
						Player_PileChanged(_player.DrawPile, pcea);

						_player.DiscardPile.PileChanged += Player_PileChanged;
						Player_PileChanged(_player.DiscardPile, pcea);

						_player.Private.PileChanged += Player_PileChanged;
						Player_PileChanged(_player.Private, pcea);

						_player.BoonsChanged += Player_BoonsChanged;
						Player_BoonsChanged(_player.TakenBoons, new BoonEventArgs(_player, BoonAction.Refresh));

						var dccea = new PointsCollectionChangedEventArgs(PointsCollectionChangedEventArgs.Operation.Reset);
						_player.EndgamePile.PointsCollectionChanged += Player_LandmarkChanged;
						Player_LandmarkChanged(_player.EndgamePile, dccea);

						var scea = new TakeableEventArgs(_player, TakeableAction.Refresh);
						_player.TakeablesChanged += Player_TakeablesChanged;
						Player_TakeablesChanged(_player.Takeables, scea);

						_player.PlayerMats.CardMatsChanged += PlayerMats_CardMatsChanged;
						foreach (var type in Playermats.Where(t => _player.PlayerMats.ContainsKey(t)))
						{
							_player.PlayerMats[type].PileChanged += Player_PileChanged;
							Player_PileChanged(_player.PlayerMats[type], pcea);
						}
					}
				}
			}
		}

		private void PlayerMats_CardMatsChanged(object sender, CardMatsChangedEventArgs e)
		{
			if (Dispatcher.CheckAccess())
			{
				//if (e.OperationPerformed == CardMatsChangedEventArgs.Operation.Created)
				//{
				//	e.CardMat.PileChanged += Player_PileChanged;
				Player_PileChanged(e.CardMat, new PileChangedEventArgs<IRandomizable>(_player, Operation.Refresh));
				//}
			}
			else
			{
				Dispatcher.BeginInvoke(new EventHandler<CardMatsChangedEventArgs>(PlayerMats_CardMatsChanged), System.Windows.Threading.DispatcherPriority.Normal, sender, e);
			}
		}

		public UcPlayerDisplay()
		{
			InitializeComponent();
		}

		private void CardCollectionControl_CardCollectionControlClick(object sender, RoutedEventArgs e)
		{
		}

		private void Player_PileChanged(object sender, PileChangedEventArgs<IRandomizable> e)
		{
			if (Dispatcher.CheckAccess())
			{
				var visible = IsUIPlayer || (e.Player != null && e.Player.Phase == PhaseEnum.Endgame);

				if (!(sender is Deck deck)) return;
				switch (deck.DeckLocation)
				{
					case DeckLocation.Hand:
						cardHand.ExactCount = true;
						cardHand.IsCardsVisible = visible;
						cardHand.Phase = e.Player.Phase;
						cardHand.PlayerMode = e.Player.PlayerMode;
						cardHand.CardSize = e.Player.Phase == PhaseEnum.Endgame ? CardSize.Text : CardSize.Medium;
						cardHand.IsVPsVisible = e.Player.Phase == PhaseEnum.Endgame;
						cardHand.Pile = deck;
						if (visible)
							svPlayerDisplay.ScrollToTop();
						break;

					case DeckLocation.Revealed:
						cardRevealed.ExactCount = true;
						cardRevealed.IsCardsVisible = true;
						cardRevealed.Phase = PhaseEnum.Action;
						cardRevealed.PlayerMode = PlayerMode.Waiting;
						cardRevealed.CardSize = CardSize.Small;
						if (e.Player.Revealed.Any())
							bInPlayRevealedDivider.Visibility = cardRevealed.Visibility = System.Windows.Visibility.Visible;
						else
							bInPlayRevealedDivider.Visibility = cardRevealed.Visibility = System.Windows.Visibility.Collapsed;
						cardRevealed.Pile = deck;
						break;

					case DeckLocation.InPlay:
						cardInPlay.ExactCount = true;
						cardInPlay.IsCardsVisible = true;
						cardInPlay.Phase = PhaseEnum.Action;
						cardInPlay.PlayerMode = PlayerMode.Waiting;
						cardInPlay.CardSize = CardSize.Small;
						cardInPlay.Pile = deck;
						if (e.Player.PlayerUniqueId != _player.UniqueId && e.Player.Phase != PhaseEnum.Endgame)
							svPlayerDisplay.ScrollToVerticalOffset(cardHand.ActualHeight + cardDiscard.ActualHeight);

						break;

					case DeckLocation.SetAside:
						cardSetAside.ExactCount = true;
						cardSetAside.IsCardsVisible = true;
						cardSetAside.Phase = PhaseEnum.Action;
						cardSetAside.PlayerMode = PlayerMode.Waiting;
						cardSetAside.CardSize = CardSize.Small;
						if (deck.Any())
							bSetAsideDivider.Visibility = cardSetAside.Visibility = System.Windows.Visibility.Visible;
						else
							bSetAsideDivider.Visibility = cardSetAside.Visibility = System.Windows.Visibility.Collapsed;
						cardSetAside.Pile = deck;

						break;

					case DeckLocation.Deck:
						cardDeck.ExactCount = IsUIPlayer;
						cardDeck.IsCardsVisible = false;
						cardDeck.Phase = PhaseEnum.Action;
						cardDeck.PlayerMode = PlayerMode.Waiting;
						cardDeck.CardSize = CardSize.Small;
						cardDeck.Pile = deck;
						break;

					case DeckLocation.Discard:
						cardDiscard.ExactCount = false;
						cardDiscard.IsCardsVisible = true;
						cardDiscard.Phase = PhaseEnum.Action;
						cardDiscard.PlayerMode = PlayerMode.Waiting;
						cardDiscard.CardSize = CardSize.Small;
						cardDiscard.Pile = deck;
						break;

					case DeckLocation.Private:
						cardPrivate.ExactCount = true;
						cardPrivate.IsCardsVisible = visible;
						cardPrivate.Phase = PhaseEnum.Action;
						cardPrivate.PlayerMode = PlayerMode.Waiting;
						cardPrivate.CardSize = CardSize.Small;
						if (e.Player.Private.Any())
							bRevealedLookingAtDivider.Visibility = cardPrivate.Visibility = System.Windows.Visibility.Visible;
						else
							bRevealedLookingAtDivider.Visibility = cardPrivate.Visibility = System.Windows.Visibility.Collapsed;
						cardPrivate.Pile = deck;
						break;

					case DeckLocation.PlayerMat:

						if (
							sender is DominionBase.Cards.Seaside.NativeVillageMat nvMat
							)
						{
							var controlName = $"card{sender.GetType().Name}";
							var cmcCardMat = dpMatsandPiles.Children.OfType<CardMatControl>().SingleOrDefault(ccc => ccc.Name == controlName);
							if (cmcCardMat == null)
							{
								if (dpMatsandPiles.Children.Count > 0)
								{
									var bDiv = new Border
									{
										BorderThickness = new Thickness(2),
										BorderBrush = Brushes.Black
									};
									DockPanel.SetDock(bDiv, Dock.Left);
									dpMatsandPiles.Children.Add(bDiv);
								}
								cmcCardMat = new CardMatControl
								{
									Foreground = _foregroundFocus,
									Name = controlName,
									Padding = new Thickness(0)
								};
								DockPanel.SetDock(cmcCardMat, Dock.Left);
								cmcCardMat.PileName = nvMat.Name;
								cmcCardMat.CardSize = CardSize.Text;
								dpMatsandPiles.Children.Add(cmcCardMat);
							}
							cmcCardMat.ExactCount = true;
							cmcCardMat.IsCardsVisible = nvMat.VisibilityTo == VisibilityTo.All ? true : visible;
							cmcCardMat.Phase = PhaseEnum.Action;
							cmcCardMat.PlayerMode = PlayerMode.Waiting;
							cmcCardMat.CardMat = nvMat;
						}
						else if (
							sender is DominionBase.Cards.Seaside.IslandMat
							|| sender is DominionBase.Cards.Promotional.PrinceSetAside
							|| sender is DominionBase.Cards.Promotional.SummonSetAside
							|| sender is DominionBase.Cards.Adventures.InheritanceSetAside
							|| sender is DominionBase.Cards.Adventures.SaveSetAside
							|| sender is DominionBase.Cards.Adventures.TavernMat
							|| sender is DominionBase.Cards.Menagerie.DelaySetAside
							|| sender is DominionBase.Cards.Menagerie.ReapSetAside
							|| sender is DominionBase.Cards.Menagerie.WayOfTheMouseSetAside
							|| sender is DominionBase.Cards.Menagerie.WayOfTheTurtleSetAside
							|| sender is DominionBase.Cards.Menagerie.Exile
							)
						{
							CardMat mat = sender as CardMat;
							var controlName = $"card{sender.GetType().Name}";
							var cmcCardMat = dpMatsandPiles.Children.OfType<CardMatControl>().SingleOrDefault(ccc => ccc.Name == controlName);
							if (cmcCardMat == null)
							{
								if (dpMatsandPiles.Children.Count > 0)
								{
									var bDiv = new Border
									{
										BorderThickness = new Thickness(2),
										BorderBrush = Brushes.Black
									};
									DockPanel.SetDock(bDiv, Dock.Left);
									dpMatsandPiles.Children.Add(bDiv);
								}
								cmcCardMat = new CardMatControl
								{
									IsDisplaySorted = true,
									Foreground = _foregroundFocus,
									Name = controlName,
									Padding = new Thickness(0)
								};
								DockPanel.SetDock(cmcCardMat, Dock.Left);
								cmcCardMat.PileName = mat.Name;
								cmcCardMat.CardSize = CardSize.Text;
								dpMatsandPiles.Children.Add(cmcCardMat);
							}
							cmcCardMat.ExactCount = true;
							cmcCardMat.IsCardsVisible = true;
							cmcCardMat.CardSize = CardSize.Small;
							cmcCardMat.Phase = PhaseEnum.Action;
							cmcCardMat.PlayerMode = PlayerMode.Waiting;
							cmcCardMat.CardMat = mat;
						}

						break;
				}
			}
			else
			{
				Dispatcher.BeginInvoke(new EventHandler<PileChangedEventArgs<IRandomizable>>(Player_PileChanged), System.Windows.Threading.DispatcherPriority.Normal, sender, e);
			}
		}

		private void Player_BoonsChanged(object sender, BoonEventArgs e)
		{
			if (Dispatcher.CheckAccess())
			{
				if (_player == null)
					return;

				boonTaken.Pile = e.Player.TakenBoons;
				if (e.Player.TakenBoons.Any())
					bLookingAtTakenDivider.Visibility = boonTaken.Visibility = System.Windows.Visibility.Visible;
				else
					bLookingAtTakenDivider.Visibility = boonTaken.Visibility = System.Windows.Visibility.Collapsed;
			}
			else
			{
				Dispatcher.BeginInvoke(new EventHandler<BoonEventArgs>(Player_BoonsChanged), System.Windows.Threading.DispatcherPriority.Normal, sender, e);
			}
		}

		private void Player_TakeablesChanged(object sender, TakeableEventArgs e)
		{
			if (Dispatcher.CheckAccess())
			{
				if (_player == null)
					return;

				cardStates.Pile = e.Player.Takeables;
				if (e.Player.Takeables.Any())
				{
					eStates.Visibility = System.Windows.Visibility.Visible;
					eStatesCount.Content = $"({e.Player.Takeables.Count})";
				}
				else
				{
					eStates.IsExpanded = false;
					eStates.Visibility = System.Windows.Visibility.Collapsed;
				}
			}
			else
			{
				Dispatcher.BeginInvoke(new EventHandler<TakeableEventArgs>(Player_TakeablesChanged), System.Windows.Threading.DispatcherPriority.Normal, sender, e);
			}
		}

		private void Player_LandmarkChanged(object sender, PointsCollectionChangedEventArgs e)
		{
			if (Dispatcher.CheckAccess())
			{
				if (_player == null)
					return;

				var collection = sender as PointsCollection;

				cardEndgame.Phase = _player.Phase;
				cardEndgame.PlayerMode = _player.PlayerMode;
				if (_player.Phase == PhaseEnum.Endgame)
					cardEndgame.SplitAt = c => !c.HasVPs;
				cardEndgame.Pile = collection;
				svPlayerDisplay.ScrollToTop();
			}
			else
			{
				Dispatcher.BeginInvoke(new EventHandler<PointsCollectionChangedEventArgs>(Player_LandmarkChanged), System.Windows.Threading.DispatcherPriority.Normal, sender, e);
			}
		}

		private void SvPlayerDisplay_ScrollChanged(object sender, ScrollChangedEventArgs e)
		{
			var sv = sender as ScrollViewer;
			bHorizontal.Width = sv.ViewportWidth * sv.ViewportWidth / sv.ExtentWidth;
			bVertical.Height = sv.ViewportHeight * sv.ViewportHeight / sv.ExtentHeight;

			bHorizontal.Margin = new Thickness(sv.ViewportWidth * sv.HorizontalOffset / sv.ExtentWidth, 0, 0, 0);
			bVertical.Margin = new Thickness(0, sv.ViewportHeight * sv.VerticalOffset / sv.ExtentHeight, 0, 0);

			bOpacityLayerLeft.Visibility = bOpacityLayerRight.Visibility = System.Windows.Visibility.Visible;
			if (bHorizontal.Width >= sv.ViewportWidth)
				bOpacityLayerLeft.Visibility = bOpacityLayerRight.Visibility = System.Windows.Visibility.Collapsed;
			else if (bHorizontal.Margin.Left <= 0)
				bOpacityLayerLeft.Visibility = System.Windows.Visibility.Collapsed;
			else if (bHorizontal.Margin.Left + bHorizontal.Width >= sv.ViewportWidth)
				bOpacityLayerRight.Visibility = System.Windows.Visibility.Collapsed;

			bOpacityLayerTop.Visibility = bOpacityLayerBottom.Visibility = System.Windows.Visibility.Visible;
			if (bVertical.Height >= sv.ViewportHeight)
				bOpacityLayerTop.Visibility = bOpacityLayerBottom.Visibility = System.Windows.Visibility.Collapsed;
			else if (bVertical.Margin.Top <= 0)
				bOpacityLayerTop.Visibility = System.Windows.Visibility.Collapsed;
			else if (bVertical.Margin.Top + bVertical.Height >= sv.ViewportHeight)
				bOpacityLayerBottom.Visibility = System.Windows.Visibility.Collapsed;
		}

		private void Grid_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
		{
			var g = (Grid)sender;
			g.CaptureMouse();
			g.Cursor = Cursors.ScrollNS;
			svPlayerDisplay.ScrollToVerticalOffset(e.GetPosition(g).Y / g.ActualHeight * svPlayerDisplay.ExtentHeight);
		}

		private void Grid_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
		{
			var g = (Grid)sender;
			g.ReleaseMouseCapture();
			g.Cursor = Cursors.Arrow;
		}

		private void Grid_MouseMove(object sender, MouseEventArgs e)
		{
			var g = (Grid)sender;
			if (g.IsMouseCaptured)
				svPlayerDisplay.ScrollToVerticalOffset(e.GetPosition(g).Y / g.ActualHeight * svPlayerDisplay.ExtentHeight);
		}

		private void Grid_MouseLeftButtonDown_1(object sender, MouseButtonEventArgs e)
		{
			var g = (Grid)sender;
			g.CaptureMouse();
			g.Cursor = Cursors.ScrollWE;
			svPlayerDisplay.ScrollToHorizontalOffset(e.GetPosition(g).X / g.ActualWidth * svPlayerDisplay.ExtentWidth);
		}

		private void Grid_MouseMove_1(object sender, MouseEventArgs e)
		{
			var g = (Grid)sender;
			if (g.IsMouseCaptured)
				svPlayerDisplay.ScrollToHorizontalOffset(e.GetPosition(g).X / g.ActualWidth * svPlayerDisplay.ExtentWidth);
		}

		private void EStates_Expanded(object sender, RoutedEventArgs e)
		{
			eStatesHeader.Visibility = System.Windows.Visibility.Collapsed;
			cardStates.Visibility = System.Windows.Visibility.Visible;
		}

		private void EStates_Collapsed(object sender, RoutedEventArgs e)
		{
			eStatesHeader.Visibility = System.Windows.Visibility.Visible;
			//eStatesHeader.Effect = Caching.DropShadowRepository.GetDSE(10, Colors.White, 1, true);
			cardStates.Visibility = System.Windows.Visibility.Collapsed;
		}
	}
}