using DominionBase.Enums;
using DominionBase.Piles;
using DominionBase.Players;
using DominionBase.Properties;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Linq;

namespace DominionBase.Cards.Nocturne
{
	public class Deluded : State
	{
		private PhaseChangingEventHandler _phaseChangingEventHandler = null;
		private readonly Dictionary<ISupply, BuyCheckEventHandler> _buyCheckEventHandlers = new Dictionary<ISupply, BuyCheckEventHandler>();
		private TurnEndedEventHandler _turnEndedEventHandler;

		public Deluded()
			: base(Source.Nocturne, Traits.None)
		{
		}

		public override void TakenBy(IPlayer player)
		{
			Contract.Requires(player != null, "player cannot be null");
			base.TakenBy(player);

			_phaseChangingEventHandler = new PhaseChangingEventHandler(Player_PhaseChanging);
			player.PhaseChanging += _phaseChangingEventHandler;
		}

		public override void ReturnedBy(IPlayer player)
		{
			Contract.Requires(player != null, "player cannot be null");
			base.ReturnedBy(player);

			if (_phaseChangingEventHandler != null)
				player.PhaseChanging -= _phaseChangingEventHandler;
		}

		private void Player_PhaseChanging(object sender, PhaseChangingEventArgs e)
		{
			var player = sender as IPlayer;
			if (e.NewPhase != PhaseEnum.BuyTreasure || e.HandledBy.Contains(TypeClass.Deluded))
				return;

			e.Resolvers[TypeClass.Deluded] = new PhaseChangingResolver(this, Resource.ResolveCard.Replace("{card}", ToString()), Player_SetupBuyRestrictions, true);
		}

		internal void Player_SetupBuyRestrictions(IPlayer player, ref PhaseChangingEventArgs e)
		{
			player.Return(Type);

			foreach (var supply in player._Game.Table.TableEntities.Values.OfType<ISupply>())
			{
				_buyCheckEventHandlers[supply] = new BuyCheckEventHandler(Supply_BuyCheck);
				supply.BuyCheck += _buyCheckEventHandlers[supply];
			}

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

			_turnEndedEventHandler = new TurnEndedEventHandler(Player_TurnEnded);
			player.TurnEnded += _turnEndedEventHandler;

			e.HandledBy.Add(TypeClass.Deluded);
		}

		public override void TearDown(IGame game)
		{
			Contract.Requires(game != null, "game cannot be null");
			foreach (var supply in _buyCheckEventHandlers.Keys)
				supply.BuyCheck -= _buyCheckEventHandlers[supply];
			_buyCheckEventHandlers.Clear();

			if (_phaseChangingEventHandler != null)
				foreach (var player in game.Players)
					player.PhaseChanging -= _phaseChangingEventHandler;

			if (_turnEndedEventHandler != null)
				foreach (var player in game.Players)
					player.TurnEnded -= _turnEndedEventHandler;
			_turnEndedEventHandler = null;

			base.TearDown(game);
		}

		private void Supply_BuyCheck(object sender, BuyCheckEventArgs e)
		{
			// Already been cancelled -- don't need to process this one
			if (e.Cancelled)
				return;

			if (((ISupply)sender).TopCard.Category.HasFlag(Categories.Action))
				e.Cancelled = true;
		}

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

			foreach (var supply in _buyCheckEventHandlers.Keys)
				supply.BuyCheck -= _buyCheckEventHandlers[supply];
			_buyCheckEventHandlers.Clear();

			if (_phaseChangingEventHandler != null)
				player.PhaseChanging -= _phaseChangingEventHandler;
			_phaseChangingEventHandler = null;

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