using DominionBase.Enums;
using DominionBase.Players;
using DominionBase.Properties;
using System.Diagnostics.Contracts;

namespace DominionBase.Cards.Nocturne
{
	public class FaithfulHound : Card
	{
		private CardsDiscardingEventHandler _CardsDiscardingEventHandler;
		private TurnEndedEventHandler _turnEndedEventHandler;

		public FaithfulHound()
			: base(Categories.Action | Categories.Reaction, Source.Nocturne, Location.Kingdom, Traits.NetCardDraw | Traits.PlusCard | Traits.ReactToDiscard | Traits.Terminal)
		{
			BaseCost = new Cost(2);
			Benefit.Cards = 2;

			OwnerChanged += new OwnerChangedEventHandler(FaithfulHound_OwnerChanged);
		}

		public override void TearDown(IGame game)
		{
			Contract.Requires(game != null, "game cannot be null");
			FaithfulHound_OwnerChanged(this, new OwnerChangedEventArgs(Owner, null));

			base.TearDown(game);

			OwnerChanged -= new OwnerChangedEventHandler(FaithfulHound_OwnerChanged);
			foreach (var player in game.Players)
				player.TurnEnded -= _turnEndedEventHandler;
		}

		private void FaithfulHound_OwnerChanged(object sender, OwnerChangedEventArgs e)
		{
			if (_CardsDiscardingEventHandler != null && e.OldOwner != null)
			{
				e.OldOwner.CardsDiscarding -= _CardsDiscardingEventHandler;
				_CardsDiscardingEventHandler = null;
			}

			if (e.NewOwner != null)
			{
				_CardsDiscardingEventHandler = new CardsDiscardingEventHandler(Player_CardsDiscarding);
				e.NewOwner.CardsDiscarding += _CardsDiscardingEventHandler;
			}
		}

		private void Player_CardsDiscarding(object sender, CardsDiscardEventArgs e)
		{
			var player = sender as IPlayer;

			// Already being processed or been handled -- don't need to process this one
			if (e.GetResolver(TypeClass.FaithfulHound) != null || e.HandledBy.Contains(this))
				return;

			if (e.Cards.Contains(PhysicalCard) && player.Phase != PhaseEnum.Cleanup)
				e.AddResolver(TypeClass.FaithfulHound, new CardsDiscardResolver(Owner, this, Resource.SetAsideCard.Replace("{card}", PhysicalCard.ToString()), Player_DiscardFaithfulHound));
		}

		internal void Player_DiscardFaithfulHound(IPlayer player, ref CardsDiscardEventArgs e)
		{
			player._Game.SendMessage(player, this, "SetAside");

			if (e.FromLocation == DeckLocation.PlayerMat)
				player.RetrieveCardFrom(e.FromMatType, this);
			else
				player.RetrieveCardFrom(e.FromLocation == DeckLocation.Deck ? DeckLocation.Revealed : e.FromLocation, this);

			player.AddCardInto(DeckLocation.SetAside, this);
			e.Cards.Remove(this);
			CanCleanUpPlayed.Add(false);

			if (_turnEndedEventHandler == null)
			{
				_turnEndedEventHandler = new TurnEndedEventHandler(Player_TurnEnded);
				player._Game.CurrentTurn.Player.TurnEnded += _turnEndedEventHandler;
			}

			e.HandledBy.Add(this);
		}

		private void Player_TurnEnded(object sender, TurnEndedEventArgs e)
		{
			var player = (IPlayer)sender;

			player._Game.SendMessage(Owner, this, "PutIntoHand");

			Owner.AddCardInto(DeckLocation.Hand, Owner.RetrieveCardFrom(DeckLocation.SetAside, this));

			if (_turnEndedEventHandler != null)
				player.TurnEnded -= _turnEndedEventHandler;
			_turnEndedEventHandler = null;

			CanCleanUpPlayed.Remove(false);
		}
	}
}