using DominionBase;
using DominionBase.Cards;
using DominionBase.Cards.Empires;
using DominionBase.Enums;
using DominionBase.Players;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;
using System;
using System.Linq;

namespace DominionBaseUnitTest.Cards
{
	[TestClass]
	public class UnitTestEmpires : UnitTestCards
	{
		[TestMethod]
		public void Test_Archive_Basic()
		{
			using (var card = new Archive())
			{
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Actions);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Duration, card.Category);
			}
		}
		[TestMethod]
		public void Test_Archive_Only_One_Trigger_At_TurnStarted()
		{
			using (var card = new Archive())
			{
				var card1 = new Crown();
				var card2 = new CrumblingCastle();
				var card3 = new Engineer();
				mockPlayer.Setup(_ => _.RetrieveCardsFrom(DeckLocation.Deck, It.IsAny<Predicate<Card>>(), 3))
					.Returns(new ItemCollection<Card> { card1, card2, card3 });
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.Cards.Count() == 3)))
					.Returns(new ChoiceResult(new ItemCollection<Card> { card2 }));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.Cards.Count() == 2)))
					.Returns(new ChoiceResult(new ItemCollection<Card> { card1 }));
				mockPlayer.Setup(_ => _.MakeChoice(It.Is<Choice>(c => c.Cards.Count() == 1)))
					.Returns(new ChoiceResult(new ItemCollection<Card> { card3 }));

				// Set up the card to be in play
				card.FollowInstructions(mockPlayer.Object);

				mockPlayer.Raise(_ => _.TurnEnded += null, new TurnEndedEventArgs(mockPlayer.Object));
				var tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);
				Assert.AreEqual(1, tseArgs.Resolvers.Count);

				var key = tseArgs.Resolvers.Keys.First();
				tseArgs.Resolvers[key].Method(mockPlayer.Object, ref tseArgs);

				Assert.AreEqual(1, tseArgs.HandledBy.Count);

				var handledBy = tseArgs.HandledBy;
				tseArgs = new TurnStartedEventArgs(mockPlayer.Object);
				tseArgs.HandledBy.AddRange(handledBy);

				mockPlayer.Raise(_ => _.TurnStarted += null, tseArgs);

				Assert.AreEqual(0, tseArgs.Resolvers.Count);
			}
		}
		[TestMethod]
		public void Test_BustlingVillage_Basic()
		{
			using (var card = new BustlingVillage())
			{
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Cards);
				Assert.AreEqual(3, card.Benefit.Actions);
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
			}
		}
		[TestMethod]
		public void Test_Capital_Basic()
		{
			using (var card = new Capital())
			{
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(new Currency(6), card.Benefit.Currency);
				Assert.AreEqual(1, card.Benefit.Buys);
				Assert.AreEqual(Categories.Card | Categories.Treasure, card.Category);
			}
		}
		[TestMethod]
		public void Test_Castles_Basic()
		{
			using (var card = new Castles())
			{
				Assert.AreEqual(new Cost(3), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Victory | Categories.Castle, card.Category);
			}
		}
		[TestMethod]
		public void Test_CatapultRocks_Basic()
		{
			using (var card = new CatapultRocks())
			{
				Assert.AreEqual(new Cost(3), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Attack, card.Category);
			}
		}
		[TestMethod]
		public void Test_Catapult_Basic()
		{
			using (var card = new Catapult())
			{
				Assert.AreEqual(new Cost(3), card.BaseCost);
				Assert.AreEqual(new Currency(1), card.Benefit.Currency);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Attack, card.Category);
			}
		}
		[TestMethod]
		public void Test_ChariotRace_Basic()
		{
			using (var card = new ChariotRace())
			{
				Assert.AreEqual(new Cost(3), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Actions);
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
			}
		}
		[TestMethod]
		public void Test_Charm_Basic()
		{
			using (var card = new Charm())
			{
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.IsTrue(card.Benefit.Currency.IsVariable);
				Assert.AreEqual(Categories.Card | Categories.Treasure, card.Category);
			}
		}
		[TestMethod]
		public void Test_CityQuarter_Basic()
		{
			using (var card = new CityQuarter())
			{
				Assert.AreEqual(new Cost(debtCost: 8), card.BaseCost);
				Assert.AreEqual(2, card.Benefit.Actions);
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
			}
		}
		[TestMethod]
		public void Test_Crown_Basic()
		{
			using (var card = new Crown())
			{
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Treasure, card.Category);
			}
		}
		[TestMethod]
		public void Test_CrumblingCastle_Basic()
		{
			using (var card = new CrumblingCastle())
			{
				Assert.AreEqual(new Cost(4), card.BaseCost);
				Assert.AreEqual(1, card.VictoryPoints);
				Assert.AreEqual(Categories.Card | Categories.Victory | Categories.Castle, card.Category);
			}
		}
		[TestMethod]
		public void Test_Emporium_Basic()
		{
			using (var card = new Emporium())
			{
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Cards);
				Assert.AreEqual(1, card.Benefit.Actions);
				Assert.AreEqual(new Currency(1), card.Benefit.Currency);
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
			}
		}
		[TestMethod]
		public void Test_EncampmentPlunder_Basic()
		{
			using (var card = new EncampmentPlunder())
			{
				Assert.AreEqual(new Cost(2), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
			}
		}
		[TestMethod]
		public void Test_Encampment_Basic()
		{
			using (var card = new Encampment())
			{
				Assert.AreEqual(new Cost(2), card.BaseCost);
				Assert.AreEqual(2, card.Benefit.Cards);
				Assert.AreEqual(2, card.Benefit.Actions);
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
			}
		}
		[TestMethod]
		public void Test_Enchantress_Basic()
		{
			using (var card = new Enchantress())
			{
				Assert.AreEqual(new Cost(3), card.BaseCost);
				Assert.AreEqual(2, card.DurationBenefit.Cards);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Attack | Categories.Duration, card.Category);
			}
		}
		[TestMethod]
		public void Test_Engineer_Basic()
		{
			using (var card = new Engineer())
			{
				Assert.AreEqual(new Cost(debtCost: 4), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
			}
		}
		[TestMethod]
		public void Test_FarmersMarket_Basic()
		{
			using (var card = new FarmersMarket())
			{
				Assert.AreEqual(new Cost(3), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Buys);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Gathering, card.Category);
			}
		}
		[TestMethod]
		public void Test_Fortune_Basic()
		{
			using (var card = new Fortune())
			{
				Assert.AreEqual(new Cost(8, debtCost: 8), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Buys);
				Assert.AreEqual(Categories.Card | Categories.Treasure, card.Category);
			}
		}
		[TestMethod]
		public void Test_Forum_Basic()
		{
			using (var card = new Forum())
			{
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(3, card.Benefit.Cards);
				Assert.AreEqual(1, card.Benefit.Actions);
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
			}
		}
		[TestMethod]
		public void Test_GladiatorFortune_Basic()
		{
			using (var card = new GladiatorFortune())
			{
				Assert.AreEqual(new Cost(3), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
			}
		}
		[TestMethod]
		public void Test_Gladiator_Basic()
		{
			using (var card = new Gladiator())
			{
				Assert.AreEqual(new Cost(3), card.BaseCost);
				Assert.AreEqual(new Currency(2), card.Benefit.Currency);
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
			}
		}
		[TestMethod]
		public void Test_GrandCastle_Basic()
		{
			using (var card = new GrandCastle())
			{
				Assert.AreEqual(new Cost(9), card.BaseCost);
				Assert.AreEqual(5, card.VictoryPoints);
				Assert.AreEqual(Categories.Card | Categories.Victory | Categories.Castle, card.Category);
			}
		}
		[TestMethod]
		public void Test_Groundskeeper_Basic()
		{
			using (var card = new Groundskeeper())
			{
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Cards);
				Assert.AreEqual(1, card.Benefit.Actions);
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
			}
		}
		[TestMethod]
		public void Test_HauntedCastle_Basic()
		{
			using (var card = new HauntedCastle())
			{
				Assert.AreEqual(new Cost(6), card.BaseCost);
				Assert.AreEqual(2, card.VictoryPoints);
				Assert.AreEqual(Categories.Card | Categories.Victory | Categories.Castle, card.Category);
			}
		}
		[TestMethod]
		public void Test_HumbleCastle_Basic()
		{
			using (var card = new HumbleCastle())
			{
				Assert.AreEqual(new Cost(3), card.BaseCost);
				Assert.AreEqual(new Currency(1), card.Benefit.Currency);
				Assert.AreEqual(Categories.Card | Categories.Treasure | Categories.Victory | Categories.Castle, card.Category);
			}
		}
		[TestMethod]
		public void Test_KingsCastle_Basic()
		{
			using (var card = new KingsCastle())
			{
				Assert.AreEqual(new Cost(10), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Victory | Categories.Castle, card.Category);
			}
		}
		[TestMethod]
		public void Test_Legionary_Basic()
		{
			using (var card = new Legionary())
			{
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(new Currency(3), card.Benefit.Currency);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Attack, card.Category);
			}
		}
		[TestMethod]
		public void Test_OpulentCastle_Basic()
		{
			using (var card = new OpulentCastle())
			{
				Assert.AreEqual(new Cost(7), card.BaseCost);
				Assert.AreEqual(3, card.VictoryPoints);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Victory | Categories.Castle, card.Category);
			}
		}
		[TestMethod]
		public void Test_Overlord_Basic()
		{
			using (var card = new Overlord())
			{
				Assert.AreEqual(new Cost(debtCost: 8), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
			}
		}
		[TestMethod]
		public void Test_PatricianEmporium_Basic()
		{
			using (var card = new PatricianEmporium())
			{
				Assert.AreEqual(new Cost(2), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
			}
		}
		[TestMethod]
		public void Test_Patrician_Basic()
		{
			using (var card = new Patrician())
			{
				Assert.AreEqual(new Cost(2), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Cards);
				Assert.AreEqual(1, card.Benefit.Actions);
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
			}
		}
		[TestMethod]
		public void Test_Plunder_Basic()
		{
			using (var card = new Plunder())
			{
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(new Currency(2), card.Benefit.Currency);
				Assert.AreEqual(1, card.Benefit.VictoryPoints);
				Assert.AreEqual(Categories.Card | Categories.Treasure, card.Category);
			}
		}
		[TestMethod]
		public void Test_Rocks_Basic()
		{
			using (var card = new Rocks())
			{
				Assert.AreEqual(new Cost(4), card.BaseCost);
				Assert.AreEqual(new Currency(1), card.Benefit.Currency);
				Assert.AreEqual(Categories.Card | Categories.Treasure, card.Category);
			}
		}
		[TestMethod]
		public void Test_RoyalBlacksmith_Basic()
		{
			using (var card = new RoyalBlacksmith())
			{
				Assert.AreEqual(new Cost(debtCost: 8), card.BaseCost);
				Assert.AreEqual(5, card.Benefit.Cards);
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
			}
		}
		[TestMethod]
		public void Test_Sacrifice_Basic()
		{
			using (var card = new Sacrifice())
			{
				Assert.AreEqual(new Cost(4), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
			}
		}
		[TestMethod]
		public void Test_SettlersBustlingVillage_Basic()
		{
			using (var card = new SettlersBustlingVillage())
			{
				Assert.AreEqual(new Cost(2), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
			}
		}
		[TestMethod]
		public void Test_Settlers_Basic()
		{
			using (var card = new Settlers())
			{
				Assert.AreEqual(new Cost(2), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Cards);
				Assert.AreEqual(1, card.Benefit.Actions);
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
			}
		}
		[TestMethod]
		public void Test_SmallCastle_Basic()
		{
			using (var card = new SmallCastle())
			{
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(2, card.VictoryPoints);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Victory | Categories.Castle, card.Category);
			}
		}
		[TestMethod]
		public void Test_SprawlingCastle_Basic()
		{
			using (var card = new SprawlingCastle())
			{
				Assert.AreEqual(new Cost(8), card.BaseCost);
				Assert.AreEqual(4, card.VictoryPoints);
				Assert.AreEqual(Categories.Card | Categories.Victory | Categories.Castle, card.Category);
			}
		}
		[TestMethod]
		public void Test_Temple_Basic()
		{
			using (var card = new Temple())
			{
				Assert.AreEqual(new Cost(4), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.VictoryPoints);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Gathering, card.Category);
			}
		}
		[TestMethod]
		public void Test_Villa_Basic()
		{
			using (var card = new Villa())
			{
				Assert.AreEqual(new Cost(4), card.BaseCost);
				Assert.AreEqual(2, card.Benefit.Actions);
				Assert.AreEqual(1, card.Benefit.Buys);
				Assert.AreEqual(new Currency(1), card.Benefit.Currency);
				Assert.AreEqual(Categories.Card | Categories.Action, card.Category);
			}
		}
		[TestMethod]
		public void Test_WildHunt_Basic()
		{
			using (var card = new WildHunt())
			{
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(Categories.Card | Categories.Action | Categories.Gathering, card.Category);
			}
		}
		[TestMethod]
		public void Test_Advance_Basic()
		{
			using (var card = new Advance())
			{
				Assert.AreEqual(new Cost(0), card.BaseCost);
				Assert.AreEqual(Categories.Event, card.Category);
			}
		}
		[TestMethod]
		public void Test_Annex_Basic()
		{
			using (var card = new Annex())
			{
				Assert.AreEqual(new Cost(debtCost: 8), card.BaseCost);
				Assert.AreEqual(Categories.Event, card.Category);
			}
		}
		[TestMethod]
		public void Test_Banquet_Basic()
		{
			using (var card = new Banquet())
			{
				Assert.AreEqual(new Cost(3), card.BaseCost);
				Assert.AreEqual(Categories.Event, card.Category);
			}
		}
		[TestMethod]
		public void Test_Conquest_Basic()
		{
			using (var card = new Conquest())
			{
				Assert.AreEqual(new Cost(6), card.BaseCost);
				Assert.AreEqual(Categories.Event, card.Category);
			}
		}
		[TestMethod]
		public void Test_Delve_Basic()
		{
			using (var card = new Delve())
			{
				Assert.AreEqual(new Cost(2), card.BaseCost);
				Assert.AreEqual(1, card.Benefit.Buys);
				Assert.AreEqual(Categories.Event, card.Category);
			}
		}
		[TestMethod]
		public void Test_Dominate_Basic()
		{
			using (var card = new Dominate())
			{
				Assert.AreEqual(new Cost(14), card.BaseCost);
				Assert.AreEqual(Categories.Event, card.Category);
			}
		}
		[TestMethod]
		public void Test_Donate_Basic()
		{
			using (var card = new Donate())
			{
				Assert.AreEqual(new Cost(debtCost: 8), card.BaseCost);
				Assert.AreEqual(Categories.Event, card.Category);
			}
		}
		[TestMethod]
		public void Test_Ritual_Basic()
		{
			using (var card = new Ritual())
			{
				Assert.AreEqual(new Cost(4), card.BaseCost);
				Assert.AreEqual(Categories.Event, card.Category);
			}
		}
		[TestMethod]
		public void Test_SaltTheEarth_Basic()
		{
			using (var card = new SaltTheEarth())
			{
				Assert.AreEqual(new Cost(4), card.BaseCost);
				Assert.AreEqual(Categories.Event, card.Category);
			}
		}
		[TestMethod]
		public void Test_Tax_Basic()
		{
			using (var card = new Tax())
			{
				Assert.AreEqual(new Cost(2), card.BaseCost);
				Assert.AreEqual(Categories.Event, card.Category);
			}
		}
		[TestMethod]
		public void Test_Triumph_Basic()
		{
			using (var card = new Triumph())
			{
				Assert.AreEqual(new Cost(debtCost: 5), card.BaseCost);
				Assert.AreEqual(Categories.Event, card.Category);
			}
		}
		[TestMethod]
		public void Test_Wedding_Basic()
		{
			using (var card = new Wedding())
			{
				Assert.AreEqual(new Cost(4, debtCost: 3), card.BaseCost);
				Assert.AreEqual(Categories.Event, card.Category);
			}
		}
		[TestMethod]
		public void Test_Windfall_Basic()
		{
			using (var card = new Windfall())
			{
				Assert.AreEqual(new Cost(5), card.BaseCost);
				Assert.AreEqual(Categories.Event, card.Category);
			}
		}
		[TestMethod]
		public void Test_Aqueduct_Basic()
		{
			using (var card = new Aqueduct())
			{
				Assert.AreEqual(Categories.Landmark, card.Category);
			}
		}
		[TestMethod]
		public void Test_Arena_Basic()
		{
			using (var card = new Arena())
			{
				Assert.AreEqual(Categories.Landmark, card.Category);
			}
		}
		[TestMethod]
		public void Test_BanditFort_Basic()
		{
			using (var card = new BanditFort())
			{
				Assert.AreEqual(Categories.Landmark, card.Category);
			}
		}
		[TestMethod]
		public void Test_Basilica_Basic()
		{
			using (var card = new Basilica())
			{
				Assert.AreEqual(Categories.Landmark, card.Category);
			}
		}
		[TestMethod]
		public void Test_Baths_Basic()
		{
			using (var card = new Baths())
			{
				Assert.AreEqual(Categories.Landmark, card.Category);
			}
		}
		[TestMethod]
		public void Test_Battlefield_Basic()
		{
			using (var card = new Battlefield())
			{
				Assert.AreEqual(Categories.Landmark, card.Category);
			}
		}
		[TestMethod]
		public void Test_Colonnade_Basic()
		{
			using (var card = new Colonnade())
			{
				Assert.AreEqual(Categories.Landmark, card.Category);
			}
		}
		[TestMethod]
		public void Test_DefiledShrine_Basic()
		{
			using (var card = new DefiledShrine())
			{
				Assert.AreEqual(Categories.Landmark, card.Category);
			}
		}
		[TestMethod]
		public void Test_Fountain_Basic()
		{
			using (var card = new Fountain())
			{
				Assert.AreEqual(Categories.Landmark, card.Category);
			}
		}
		[TestMethod]
		public void Test_Keep_Basic()
		{
			using (var card = new Keep())
			{
				Assert.AreEqual(Categories.Landmark, card.Category);
			}
		}
		[TestMethod]
		public void Test_Labyrinth_Basic()
		{
			using (var card = new Labyrinth())
			{
				Assert.AreEqual(Categories.Landmark, card.Category);
			}
		}
		[TestMethod]
		public void Test_MountainPass_Basic()
		{
			using (var card = new MountainPass())
			{
				Assert.AreEqual(Categories.Landmark, card.Category);
			}
		}
		[TestMethod]
		public void Test_Museum_Basic()
		{
			using (var card = new Museum())
			{
				Assert.AreEqual(Categories.Landmark, card.Category);
			}
		}
		[TestMethod]
		public void Test_Obelisk_Basic()
		{
			using (var card = new Obelisk())
			{
				Assert.AreEqual(Categories.Landmark, card.Category);
			}
		}
		[TestMethod]
		public void Test_Orchard_Basic()
		{
			using (var card = new Orchard())
			{
				Assert.AreEqual(Categories.Landmark, card.Category);
			}
		}
		[TestMethod]
		public void Test_Palace_Basic()
		{
			using (var card = new Palace())
			{
				Assert.AreEqual(Categories.Landmark, card.Category);
			}
		}
		[TestMethod]
		public void Test_Tomb_Basic()
		{
			using (var card = new Tomb())
			{
				Assert.AreEqual(Categories.Landmark, card.Category);
			}
		}
		[TestMethod]
		public void Test_Tower_Basic()
		{
			using (var card = new Tower())
			{
				Assert.AreEqual(Categories.Landmark, card.Category);
			}
		}
		[TestMethod]
		public void Test_TriumphalArch_Basic()
		{
			using (var card = new TriumphalArch())
			{
				Assert.AreEqual(Categories.Landmark, card.Category);
			}
		}
		[TestMethod]
		public void Test_Wall_Basic()
		{
			using (var card = new Wall())
			{
				Assert.AreEqual(Categories.Landmark, card.Category);
			}
		}
		[TestMethod]
		public void Test_WolfDen_Basic()
		{
			using (var card = new WolfDen())
			{
				Assert.AreEqual(Categories.Landmark, card.Category);
			}
		}
	}
}