using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

using DominionBase;
using DominionBase.Piles;
using DominionBase.Players;

namespace Dominion.NET_WPF.Controls
{
	/// <summary>
	/// Interaction logic for ucPlayerDisplay.xaml
	/// </summary>
	public partial class ucPlayerDisplay : UserControl
	{
		private Player.PhaseChangedEventHandler _PhaseChangedEventHandler = null;
		private Player.TurnStartedEventHandler _TurnStartedEventHandler = null;
		private Player.TurnEndedEventHandler _TurnEndedEventHandler = null;

		private Pile.PileChangedEventHandler _DeckEventHandler = null;
		private Dictionary<Type, Deck.PileChangedEventHandler> _MatEventHandlers = new Dictionary<Type, Pile.PileChangedEventHandler>();
		private CardMats.CardMatsChangedEventHandler _MatChangedEventHandler = null;
		private TokenCollections.TokenCollectionsChangedEventHandler _TokenCollectionsChangedEventHandler = null;
		private Player _Player = null;
		private Boolean _IsActive = false;
		private Color _ColorFocus = Colors.Transparent;

		public Color ColorFocus
		{
			get { return _ColorFocus; }
			set
			{
				ColorHls hlsValue = HLSColor.RgbToHls(value);

				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));
				lStageText.Background = lStage.Background = new SolidColorBrush(HLSColor.HlsToRgb(hlsValue.H, hlsValue.L * 0.95, hlsValue.S, hlsValue.A));
			}
		}

		public Player Player
		{
			get { return _Player; }
			set
			{
				if (_Player != null)
				{
					if (_PhaseChangedEventHandler != null)
						_Player.PhaseChanged -= _PhaseChangedEventHandler;
					if (_TurnStartedEventHandler != null)
						_Player.TurnStarted -= _TurnStartedEventHandler;
					if (_TurnEndedEventHandler != null)
						_Player.TurnEnded -= _TurnEndedEventHandler;
					if (_MatChangedEventHandler != null)
						_Player.PlayerMats.CardMatsChanged -= _MatChangedEventHandler;
					if (_TokenCollectionsChangedEventHandler != null)
						_Player.TokenPiles.TokenCollectionsChanged -= _TokenCollectionsChangedEventHandler;
				}
				
				_Player = value;

				if (_Player != null)
				{
					_PhaseChangedEventHandler = new Player.PhaseChangedEventHandler(_Player_PhaseChangedEvent);
					_Player.PhaseChanged += _PhaseChangedEventHandler;

					_TurnStartedEventHandler = new DominionBase.Players.Player.TurnStartedEventHandler(_Player_TurnStarted);
					_Player.TurnStarted += _TurnStartedEventHandler;

					_TurnEndedEventHandler = new DominionBase.Players.Player.TurnEndedEventHandler(_Player_TurnEnded);
					_Player.TurnEnded += _TurnEndedEventHandler;

					_MatChangedEventHandler = new CardMats.CardMatsChangedEventHandler(PlayerMats_DecksChanged);
					_Player.PlayerMats.CardMatsChanged += _MatChangedEventHandler;

					_TokenCollectionsChangedEventHandler = new TokenCollections.TokenCollectionsChangedEventHandler(TokenPiles_TokenCollectionsChanged);
					_Player.TokenPiles.TokenCollectionsChanged += _TokenCollectionsChangedEventHandler;

					_Player_PhaseChangedEvent(null, new PhaseChangedEventArgs(_Player, _Player.Phase));
				}

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

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

		void TokenPiles_TokenCollectionsChanged(object sender, TokenCollectionsChangedEventArgs e)
		{
			if (this.Dispatcher.CheckAccess())
			{
				if (e.Count > 0)
				{
					if (e.TokenCollection[0].GetType() == DominionBase.Cards.Seaside.TypeClass.PirateShipToken)
					{
						Label lPirateShipTokenValue = dpStuff.Children.OfType<Label>().SingleOrDefault(l => l.Name == "lPirateShipTokenValue");
						if (lPirateShipTokenValue == null)
						{
							if (dpStuff.Children.Count > 0)
							{
								Border bDiv = new Border();
								bDiv.BorderThickness = new Thickness(1);
								bDiv.BorderBrush = Brushes.Black;
								Panel.SetZIndex(bDiv, 1);
								DockPanel.SetDock(bDiv, Dock.Left);
								dpStuff.Children.Add(bDiv);
							}

							Label lPirateShipToken = new Label();
							lPirateShipToken.Content = "Pirate Ship Tokens:";
							lPirateShipToken.FontSize = 16d;
							lPirateShipToken.FontWeight = FontWeights.Bold;
							lPirateShipToken.HorizontalContentAlignment = System.Windows.HorizontalAlignment.Right;
							lPirateShipToken.Background = Caching.BrushRepository.GetBrush(DominionBase.Cards.Category.Treasure);
							DockPanel.SetDock(lPirateShipToken, Dock.Left);
							dpStuff.Children.Add(lPirateShipToken);

							lPirateShipTokenValue = new Label();
							lPirateShipTokenValue.Name = "lPirateShipTokenValue";
							lPirateShipTokenValue.FontWeight = FontWeights.Bold;
							lPirateShipTokenValue.VerticalAlignment = System.Windows.VerticalAlignment.Stretch;
							lPirateShipTokenValue.VerticalContentAlignment = System.Windows.VerticalAlignment.Center;
							lPirateShipTokenValue.Background = Caching.BrushRepository.GetBrush(DominionBase.Cards.Category.Treasure);
							lPirateShipTokenValue.Padding = new Thickness(0, 0, 5, 0);
							lPirateShipTokenValue.BorderThickness = new Thickness(0, 0, 1, 0);
							DockPanel.SetDock(lPirateShipTokenValue, Dock.Left);
							dpStuff.Children.Add(lPirateShipTokenValue);
						}
						lPirateShipTokenValue.Content = e.Count;
					}

					else if (e.TokenCollection[0].GetType() == DominionBase.Cards.Prosperity.TypeClass.VictoryToken)
					{
						Label lVictoryTokenValue = dpStuff.Children.OfType<Label>().SingleOrDefault(l => l.Name == "lVictoryTokenValue");
						if (lVictoryTokenValue == null)
						{
							if (dpStuff.Children.Count > 0)
							{
								Border bDiv = new Border();
								bDiv.BorderThickness = new Thickness(1);
								bDiv.BorderBrush = Brushes.Black;
								Panel.SetZIndex(bDiv, 1);
								DockPanel.SetDock(bDiv, Dock.Left);
								dpStuff.Children.Add(bDiv);
							}

							Label lVictoryToken = new Label();
							lVictoryToken.Content = "Victory Tokens:";
							lVictoryToken.FontSize = 16d;
							lVictoryToken.FontWeight = FontWeights.Bold;
							lVictoryToken.HorizontalContentAlignment = System.Windows.HorizontalAlignment.Right;
							lVictoryToken.Background = Caching.BrushRepository.GetBrush(DominionBase.Cards.Category.Victory);
							DockPanel.SetDock(lVictoryToken, Dock.Left);
							dpStuff.Children.Add(lVictoryToken);

							lVictoryTokenValue = new Label();
							lVictoryTokenValue.Name = "lVictoryTokenValue";
							lVictoryTokenValue.FontWeight = FontWeights.Bold;
							lVictoryTokenValue.VerticalAlignment = System.Windows.VerticalAlignment.Stretch;
							lVictoryTokenValue.VerticalContentAlignment = System.Windows.VerticalAlignment.Center;
							lVictoryTokenValue.Background = Caching.BrushRepository.GetBrush(DominionBase.Cards.Category.Victory);
							lVictoryTokenValue.Padding = new Thickness(0, 0, 5, 0);
							lVictoryTokenValue.BorderThickness = new Thickness(0, 0, 1, 0);
							DockPanel.SetDock(lVictoryTokenValue, Dock.Left);
							dpStuff.Children.Add(lVictoryTokenValue);
						}
						lVictoryTokenValue.Content = Utilities.RenderText(String.Format("{0}{1}", e.Count, e.TokenCollection[0].DisplayString), NET_WPF.RenderSize.Tiny, false)[0];
					}
				}
			}
			else
			{
				this.Dispatcher.BeginInvoke(new EventHandler<TokenCollectionsChangedEventArgs>(TokenPiles_TokenCollectionsChanged), System.Windows.Threading.DispatcherPriority.Normal, sender, e);
			}
		}

		void PlayerMats_DecksChanged(object sender, CardMatsChangedEventArgs e)
		{
			_Player_PileChanged(e.CardMat, new PileChangedEventArgs(PileChangedEventArgs.Operation.Reset));
		}

		private void _Player_TurnStarted(object sender, DominionBase.Players.TurnStartedEventArgs e)
		{
			if (cardHand.Dispatcher.CheckAccess())
			{
				if (this.IsUIPlayer)
					cardHand.IsClickable = true;
				else
					cardHand.IsClickable = false;
			}
			else
			{
				cardHand.Dispatcher.BeginInvoke(new EventHandler<DominionBase.Players.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;
			}
			else
			{
				cardHand.Dispatcher.BeginInvoke(new EventHandler<DominionBase.Players.TurnEndedEventArgs>(_Player_TurnEnded), System.Windows.Threading.DispatcherPriority.Normal, sender, e);
			}
		}

		private void _Player_PhaseChangedEvent(object sender, PhaseChangedEventArgs e)
		{
			if (this.Dispatcher.CheckAccess())
			{
				lStage.Content = e.CurrentPlayer.Phase.ToString();

				if (this.IsUIPlayer)
				{
					if (e.CurrentPlayer.Phase == DominionBase.Players.PhaseEnum.Starting ||
						e.CurrentPlayer.Phase == DominionBase.Players.PhaseEnum.Waiting ||
						e.CurrentPlayer.Phase == DominionBase.Players.PhaseEnum.Endgame ||
						e.CurrentPlayer.Phase == DominionBase.Players.PhaseEnum.Cleanup ||
						e.CurrentPlayer.Phase == DominionBase.Players.PhaseEnum.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)
				{
					cardDiscard.Visibility = bDeckDiscardDivider.Visibility = cardDeck.Visibility = bDeckHandDivider.Visibility = System.Windows.Visibility.Collapsed;
					bHandTableauDivider.Visibility = dpTableau.Visibility = bTableauMatsDivider.Visibility = dpMatsandPiles.Visibility = System.Windows.Visibility.Collapsed;
					bVictoryPointsDivider.Visibility = lVictoryPointsTitle.Visibility = lVictoryPoints.Visibility = System.Windows.Visibility.Visible;
					svPlayerDisplay.HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled;
				}
			}
			else
			{
				this.Dispatcher.BeginInvoke(new EventHandler<PhaseChangedEventArgs>(_Player_PhaseChangedEvent), System.Windows.Threading.DispatcherPriority.Normal, sender, e);
			}
		}
		public Boolean IsUIPlayer { get; set; }
		public Boolean IsActive
		{
			get { return _IsActive; }
			set
			{
				if (_IsActive != value)
				{
					if (_Player != null)
					{
						_Player.Hand.PileChanged -= _DeckEventHandler;
						_Player.Revealed.PileChanged -= _DeckEventHandler;
						_Player.Tableau.PileChanged -= _DeckEventHandler;
						_Player.PreviousTableau.PileChanged -= _DeckEventHandler;
						_Player.DrawPile.PileChanged -= _DeckEventHandler;
						_Player.DiscardPile.PileChanged -= _DeckEventHandler;
						_Player.Private.PileChanged -= _DeckEventHandler;

						foreach (Type matType in _MatEventHandlers.Keys)
							_Player.PlayerMats[matType].PileChanged -= _MatEventHandlers[matType];
					}
					_DeckEventHandler = null;
					_MatEventHandlers.Clear();

					_IsActive = value;

					if (_IsActive && _Player != null)
					{
						PileChangedEventArgs pcea = new PileChangedEventArgs(_Player, PileChangedEventArgs.Operation.Added);

						_DeckEventHandler = new Deck.PileChangedEventHandler(_Player_PileChanged);
						_Player.Hand.PileChanged += _DeckEventHandler;
						_Player_PileChanged(_Player.Hand, pcea);

						_Player.Revealed.PileChanged += _DeckEventHandler;
						_Player_PileChanged(_Player.Revealed, pcea);

						_Player.Tableau.PileChanged += _DeckEventHandler;
						_Player.PreviousTableau.PileChanged += _DeckEventHandler;
						_Player_PileChanged(_Player.Tableau, pcea);
						_Player_PileChanged(_Player.PreviousTableau, pcea);

						_Player.DrawPile.PileChanged += _DeckEventHandler;
						_Player_PileChanged(_Player.DrawPile, pcea);

						_Player.DiscardPile.PileChanged += _DeckEventHandler;
						_Player_PileChanged(_Player.DiscardPile, pcea);

						_Player.Private.PileChanged += _DeckEventHandler;
						_Player_PileChanged(_Player.Private, pcea);

						if (_Player.PlayerMats.ContainsKey(DominionBase.Cards.Seaside.TypeClass.IslandMat))
						{
							_MatEventHandlers[DominionBase.Cards.Seaside.TypeClass.IslandMat] = new Pile.PileChangedEventHandler(_Player_PileChanged);
							_Player.PlayerMats[DominionBase.Cards.Seaside.TypeClass.IslandMat].PileChanged += _MatEventHandlers[DominionBase.Cards.Seaside.TypeClass.IslandMat];
							_Player_PileChanged(_Player.PlayerMats[DominionBase.Cards.Seaside.TypeClass.IslandMat], pcea);
						}

						if (_Player.PlayerMats.ContainsKey(DominionBase.Cards.Seaside.TypeClass.NativeVillageMat))
						{
							_MatEventHandlers[DominionBase.Cards.Seaside.TypeClass.NativeVillageMat] = new Pile.PileChangedEventHandler(_Player_PileChanged);
							_Player.PlayerMats[DominionBase.Cards.Seaside.TypeClass.NativeVillageMat].PileChanged += _MatEventHandlers[DominionBase.Cards.Seaside.TypeClass.NativeVillageMat];
							_Player_PileChanged(_Player.PlayerMats[DominionBase.Cards.Seaside.TypeClass.NativeVillageMat], pcea);
						}
					}
				}
			}
		}

		public ucPlayerDisplay()
		{
			InitializeComponent();

			cardHand.PileName = "Hand";
			cardRevealed.PileName = "Revealed";
			cardTableau.PileName = "Tableau";
			cardPreviousTableau.PileName = "Previous Tableau";
			cardDeck.PileName = "Deck";
			cardDiscard.PileName = "Discard Pile";
			cardPrivate.PileName = "Looking At";
		}

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

		private void _Player_PileChanged(object sender, PileChangedEventArgs e)
		{
			if (this.Dispatcher.CheckAccess())
			{

				// This sometimes has an Enumeration exception -- can't figure out how to Lock it properly
				if (e.Player != null)
					try { lVictoryPoints.Content = e.Player.VictoryPoints.ToString(); }
					catch { lVictoryPoints.Content = "0"; }

				Deck deck = sender as Deck;
				Boolean visible = this.IsUIPlayer || (e.Player != null && e.Player.Phase == DominionBase.Players.PhaseEnum.Endgame);

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

					case DeckLocation.Revealed:
						cardRevealed.ExactCount = true;
						cardRevealed.IsCardsVisible = true;
						cardRevealed.Phase = PhaseEnum.Waiting;
						cardRevealed.CardSize = CardSize.Small;
						if (e.Player.Revealed.Count > 0)
							bTableauRevealedDivider.Visibility = cardRevealed.Visibility = System.Windows.Visibility.Visible;
						else
							bTableauRevealedDivider.Visibility = cardRevealed.Visibility = System.Windows.Visibility.Collapsed;
						cardRevealed.Pile = deck;
						break;

					case DeckLocation.Tableau:
						cardTableau.ExactCount = true;
						cardTableau.IsCardsVisible = true;
						cardTableau.Phase = PhaseEnum.Waiting;
						cardTableau.CardSize = CardSize.Small;
						//if (tiTableau.IsVisible)
						cardTableau.Pile = deck;
						//else
						//    cardTableau.Pile = null;
						if (e.Player != _Player && e.Player.Phase != DominionBase.Players.PhaseEnum.Endgame)
							svPlayerDisplay.ScrollToVerticalOffset(cardHand.ActualHeight + cardDiscard.ActualHeight);

						break;

					case DeckLocation.PreviousTableau:
						cardPreviousTableau.ExactCount = true;
						cardPreviousTableau.IsCardsVisible = true;
						cardPreviousTableau.Phase = PhaseEnum.Waiting;
						cardPreviousTableau.CardSize = CardSize.Small;
						if (deck.Count > 0)
							bTableauPreviousDivider.Visibility = cardPreviousTableau.Visibility = System.Windows.Visibility.Visible;
						else
							bTableauPreviousDivider.Visibility = cardPreviousTableau.Visibility = System.Windows.Visibility.Collapsed;
						cardPreviousTableau.Pile = deck;

						break;

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

					case DeckLocation.Discard:
						cardDiscard.ExactCount = false;
						cardDiscard.IsCardsVisible = true;
						cardDiscard.Phase = PhaseEnum.Waiting;
						cardDiscard.CardSize = CardSize.Small;
						if (e.Player.DiscardPile.Count > 0)
							bDeckDiscardDivider.Visibility = cardDiscard.Visibility = System.Windows.Visibility.Visible;
						else
							bDeckDiscardDivider.Visibility = cardDiscard.Visibility = System.Windows.Visibility.Collapsed;
						cardDiscard.Pile = deck;
						break;

					case DeckLocation.Private:
						cardPrivate.ExactCount = true;
						cardPrivate.IsCardsVisible = visible;
						cardPrivate.Phase = PhaseEnum.Waiting;
						cardPrivate.CardSize = CardSize.Small;
						if (e.Player.Private.Count > 0)
							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.GetType() == DominionBase.Cards.Seaside.TypeClass.IslandMat)
						{
							CardCollectionControl cccIsland = dpMatsandPiles.Children.OfType<CardCollectionControl>().SingleOrDefault(ccc => ccc.Name == "cardIsland");
							if (cccIsland == null)
							{
								if (dpMatsandPiles.Children.Count > 0)
								{
									Border bDiv = new Border();
									bDiv.BorderThickness = new Thickness(2);
									bDiv.BorderBrush = Brushes.Black;
									DockPanel.SetDock(bDiv, Dock.Left);
									dpMatsandPiles.Children.Add(bDiv);
								}
								cccIsland = new CardCollectionControl();
								cccIsland.Name = "cardIsland";
								cccIsland.Padding = new Thickness(0);
								DockPanel.SetDock(cccIsland, Dock.Left);
								//cccIsland.Background = Brushes.AliceBlue;
								cccIsland.PileName = "Island Mat";
								cccIsland.CardSize = CardSize.Text;
								dpMatsandPiles.Children.Add(cccIsland);
							}
							cccIsland.ExactCount = true;
							cccIsland.IsCardsVisible = true;
							cccIsland.Phase = PhaseEnum.Waiting;
							cccIsland.Pile = deck;
						}
						else if (sender.GetType() == DominionBase.Cards.Seaside.TypeClass.NativeVillageMat)
						{
							CardCollectionControl cccNativeVillage = dpMatsandPiles.Children.OfType<CardCollectionControl>().SingleOrDefault(ccc => ccc.Name == "cardNativeVillage");
							if (cccNativeVillage == null)
							{
								if (dpMatsandPiles.Children.Count > 0)
								{
									Border bDiv = new Border();
									bDiv.BorderThickness = new Thickness(2);
									bDiv.BorderBrush = Brushes.Black;
									DockPanel.SetDock(bDiv, Dock.Left);
									dpMatsandPiles.Children.Add(bDiv);
								}
								cccNativeVillage = new CardCollectionControl();
								cccNativeVillage.Name = "cardNativeVillage";
								cccNativeVillage.Padding = new Thickness(0);
								DockPanel.SetDock(cccNativeVillage, Dock.Left);
								//cccNativeVillage.Background = Brushes.AliceBlue;
								cccNativeVillage.PileName = "Native Village Mat";
								cccNativeVillage.CardSize = CardSize.Text;
								dpMatsandPiles.Children.Add(cccNativeVillage);
							}
							cccNativeVillage.ExactCount = true;
							cccNativeVillage.IsCardsVisible = visible;
							cccNativeVillage.Phase = PhaseEnum.Waiting;
							cccNativeVillage.Pile = deck;
						}

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

		private void svPlayerDisplay_ScrollChanged(object sender, ScrollChangedEventArgs e)
		{
			ScrollViewer 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);
		}
	}
}