using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using DominionBase.Cards;
using DominionBase.Players;

namespace DominionBase.Piles
{
	public class CardMatsChangedEventArgs : EventArgs
	{
		public enum Operation
		{
			Reset,
			Added,
			Removed
		}
		private Player _Player = null;
		private CardCollection _AddedCards;
		private CardCollection _RemovedCards;
		private Operation _OperationPerformed;
		public CardMat CardMat;
		public Player Player { get { return _Player; } }
		public CardCollection AddedCards { get { return _AddedCards; } }
		public CardCollection RemovedCards { get { return _RemovedCards; } }
		public Operation OperationPerformed { get { return _OperationPerformed; } }
		public CardMatsChangedEventArgs(CardMat cardMat, Operation operation)
		{
			this.CardMat = cardMat;
			_OperationPerformed = operation;
			_AddedCards = new CardCollection();
			_RemovedCards = new CardCollection();
		}
		public CardMatsChangedEventArgs(CardMat cardMat, Player player, Operation operation)
			: this(cardMat, operation)
		{
			_Player = player;
		}
		public CardMatsChangedEventArgs(CardMat cardMat, Player player, Operation operation, Card cardChanged)
			: this(cardMat, player, operation)
		{
			switch (operation)
			{
				case CardMatsChangedEventArgs.Operation.Added:
					_AddedCards.Add(cardChanged);
					break;
				case CardMatsChangedEventArgs.Operation.Removed:
					_RemovedCards.Add(cardChanged);
					break;
			}
		}
		public CardMatsChangedEventArgs(CardMat cardMat, Player player, Operation operation, IEnumerable<Card> cardsChanged)
			: this(cardMat, player, operation)
		{
			switch (operation)
			{
				case CardMatsChangedEventArgs.Operation.Added:
					_AddedCards.AddRange(cardsChanged);
					break;
				case CardMatsChangedEventArgs.Operation.Removed:
					_RemovedCards.AddRange(cardsChanged);
					break;
			}
		}
	}

	public class CardMat : Deck
	{
		private Boolean _IsObtainable = true;

		public Boolean IsObtainable
		{
			get { return _IsObtainable; }
			set { _IsObtainable = value; }
		}

		public CardMat()
			: base(Players.DeckLocation.PlayerMat)
		{
		}

		public CardMat(Visibility visibility, VisibilityTo visibilityTo)
			: base(Players.DeckLocation.PlayerMat, visibility, visibilityTo)
		{
		}

		public CardMat(Visibility visibility, VisibilityTo visibilityTo, IComparer<Cards.Card> comparer, Boolean collate)
			: base(Players.DeckLocation.PlayerMat, visibility, visibilityTo, comparer, collate)
		{
		}

		public static new CardMat CreateInstance(Type type)
		{
			return (CardMat)type.GetConstructor(Type.EmptyTypes).Invoke(null);
		}
	}

	public class CardMats : Dictionary<Type, CardMat>
	{
		public delegate void CardMatsChangedEventHandler(object sender, CardMatsChangedEventArgs e);
		public event CardMatsChangedEventHandler CardMatsChanged;

		public void Add(Player player, Type cardMatType, IEnumerable<Card> cards)
		{
			if (!this.ContainsKey(cardMatType))
				this[cardMatType] = CardMat.CreateInstance(cardMatType);
			this[cardMatType].AddRange(player, cards);

			if (CardMatsChanged != null)
			{
				CardMatsChangedEventArgs pcea = new CardMatsChangedEventArgs(this[cardMatType], player, CardMatsChangedEventArgs.Operation.Added, cards);
				CardMatsChanged(this, pcea);
			}
		}

		public CardCollection Retrieve(Player player, Type cardMatType, Predicate<Card> match, int count)
		{
			CardMat c = null;
			if (this.ContainsKey(cardMatType))
				c = this[cardMatType];
			else
				c = CardMat.CreateInstance(cardMatType);

			CardCollection cc = c.Retrieve(player, DeckPosition.Automatic, match, count);

			if (CardMatsChanged != null)
			{
				CardMatsChangedEventArgs pcea = new CardMatsChangedEventArgs(this[cardMatType], player, CardMatsChangedEventArgs.Operation.Removed, cc);
				CardMatsChanged(this, pcea);
			}

			return cc;
		}

		internal void TearDown()
		{
			foreach (CardMat mat in this.Values)
				mat.TearDown();
		}
	}
}