Hell.Tests

using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;

[TestFixture]
class Tests
{
    private const int itemStrengthBonus = 1;
    private const int itemAgilityBonus = 2;
    private const int itemIntelligenceBonus = 3;
    private const int itemHitPointsBonus = 4;
    private const int itemDamageBonus = 5;

    private IInventory inventory;

    [SetUp]
    public void Start()
    {
        this.inventory = new HeroInventory();
    }

    [Test]
    public void AddCommonItem()
    {
        IItem item = new CommonItem("commonItem", itemStrengthBonus, itemAgilityBonus, itemIntelligenceBonus, itemHitPointsBonus, itemDamageBonus);

        int initualCommonItemCount = this.TakeCommonItemsCount();
        int initualRecipeItemCount = this.TakeRecipeItemsCount();
        Assert.AreEqual(0, initualCommonItemCount);
        Assert.AreEqual(0, initualRecipeItemCount);

        this.inventory.AddCommonItem(item);

        int currentCommonItemCount = this.TakeCommonItemsCount();
        int currentRecipeItemCount = this.TakeRecipeItemsCount();

        Assert.AreEqual(currentCommonItemCount, 1);
        Assert.AreEqual(0, currentRecipeItemCount);

        IItem commonItem = this.TakeFirstCommonItem();

        bool areEqual = this.CompareTwoCommonItems(item, commonItem);

        Assert.True(areEqual);
    }

    private bool CompareTwoCommonItems(IItem item, IItem commonItem)
    {
        int cmp = item.Name.CompareTo(commonItem.Name);

        if (cmp == 0)
        {
            cmp = item.StrengthBonus.CompareTo(commonItem.StrengthBonus);

            if (cmp == 0)
            {
                cmp = item.AgilityBonus.CompareTo(commonItem.AgilityBonus);

                if (cmp == 0)
                {
                    cmp = item.IntelligenceBonus.CompareTo(commonItem.IntelligenceBonus);

                    if (cmp == 0)
                    {
                        cmp = item.HitPointsBonus.CompareTo(commonItem.HitPointsBonus);

                        if (cmp == 0)
                        {
                            cmp = item.DamageBonus.CompareTo(commonItem.DamageBonus);
                        }
                    }
                }
            }
        }

        return cmp == 0;
    }

    private IItem TakeFirstCommonItem()
    {
        Type type = this.inventory.GetType();

        FieldInfo fieldsToInject = type.GetFields(BindingFlags.Instance | BindingFlags.NonPublic).Where(f => f.CustomAttributes.Any(a => a.AttributeType == typeof(ItemAttribute))).First();

        var itemCollection = (IDictionary<string, IItem>)fieldsToInject.GetValue(this.inventory);

        var items = itemCollection.Values.ToList();

        var item = items.First();

        return item;
    }

    [Test]
    public void AddRecipeItem()
    {
        IRecipe item = new RecipeItem("recipeItem", itemStrengthBonus, itemAgilityBonus, itemIntelligenceBonus, itemHitPointsBonus, itemDamageBonus, new List<string>() { "no existing" });

        int initualCommonItemCount = this.TakeCommonItemsCount();
        int initualRecipeItemCount = this.TakeRecipeItemsCount();
        Assert.AreEqual(0, initualCommonItemCount);
        Assert.AreEqual(0, initualRecipeItemCount);

        this.inventory.AddRecipeItem(item);

        int currentCommonItemCount = this.TakeCommonItemsCount();
        int currentRecipeItemCount = this.TakeRecipeItemsCount();

        Assert.AreEqual(0, currentCommonItemCount);
        Assert.AreEqual(1, currentRecipeItemCount);

        IRecipe recipeItem = this.TakeFirstRecipeItem();

        bool areEqual = this.CompareTwoRecipeItems(item, recipeItem);

        Assert.True(areEqual);
    }

    private bool CompareTwoRecipeItems(IRecipe item, IRecipe recipeItem)
    {
        bool commonCompare = this.CompareTwoCommonItems(item, recipeItem);

        if (!commonCompare) return commonCompare;

        var itemRequiredItems = item.RequiredItems;

        var recipeRequiredItems = recipeItem.RequiredItems;

        int cmp = itemRequiredItems.Count.CompareTo(recipeRequiredItems.Count);

        if (cmp == 0)
        {
            for (int i = 0; i < itemRequiredItems.Count; i++)
            {
                cmp = itemRequiredItems[i].CompareTo(recipeRequiredItems[i]);

                if (cmp != 0) break;
            }
        }

        return cmp == 0;
    }

    private IRecipe TakeFirstRecipeItem()
    {
        Type type = this.inventory.GetType();

        FieldInfo fieldsToInject = type.GetFields(BindingFlags.Instance | BindingFlags.NonPublic).Where(f => f.CustomAttributes.All(a => a.AttributeType != typeof(ItemAttribute))).First();

        var itemCollection = (IDictionary<string, IRecipe>)fieldsToInject.GetValue(this.inventory);

        var items = itemCollection.Values.ToList();

        var item = items.First();

        return item;
    }

    [Test]
    public void AddRecipeItemWithEmptyListMustChangeCommonItemsCount()
    {
        IRecipe item = new RecipeItem("recipeItem", itemStrengthBonus, itemAgilityBonus, itemIntelligenceBonus, itemHitPointsBonus, itemDamageBonus, new List<string>() { });

        int initualCommonItemCount = this.TakeCommonItemsCount();
        int initualRecipeItemCount = this.TakeRecipeItemsCount();
        Assert.AreEqual(0, initualCommonItemCount);
        Assert.AreEqual(0, initualRecipeItemCount);

        this.inventory.AddRecipeItem(item);

        int currentCommonItemCount = this.TakeCommonItemsCount();
        int currentRecipeItemCount = this.TakeRecipeItemsCount();

        Assert.AreEqual(1, currentCommonItemCount);
        Assert.AreEqual(1, currentRecipeItemCount);
    }

    [Test]
    [TestCase(5)]
    [TestCase(10)]
    [TestCase(33)]
    public void AddRecipeItemMustReduceCommonItemsCount(int count)
    {
        this.CreateCommonSomeItems(count);

        int initualCommonItemCount = this.TakeCommonItemsCount();
        int initualRecipeItemCount = this.TakeRecipeItemsCount();
        Assert.AreEqual(count, initualCommonItemCount);
        Assert.AreEqual(0, initualRecipeItemCount);

        IRecipe item = this.CreateRecipe(count / 2);

        this.inventory.AddRecipeItem(item);

        int currentCommonItemsCount = this.TakeCommonItemsCount();
        int currentRecipeCount = this.TakeRecipeItemsCount();

        int requiredItemsCount = count / 2;

        Assert.AreEqual(initualCommonItemCount - requiredItemsCount + 1, currentCommonItemsCount);
        Assert.AreEqual(1, currentRecipeCount);

        IRecipe secondItem = new RecipeItem("", itemStrengthBonus, itemAgilityBonus, itemIntelligenceBonus, itemHitPointsBonus, itemDamageBonus, item.RequiredItems.ToList());

        this.inventory.AddRecipeItem(secondItem);

        int secondCommonItemsCount = this.TakeCommonItemsCount();
        int secondRecipeCount = this.TakeRecipeItemsCount();

        Assert.AreEqual(currentCommonItemsCount, secondCommonItemsCount);
        Assert.AreEqual(2, secondRecipeCount);
    }

    private IDictionary<string, IItem> GetCommonItems()
    {
        Type type = this.inventory.GetType();

        FieldInfo fieldsToInject = type.GetFields(BindingFlags.Instance | BindingFlags.NonPublic).Where(f => f.CustomAttributes.Any(a => a.AttributeType == typeof(ItemAttribute))).First();

        var itemCollection = (IDictionary<string, IItem>)fieldsToInject.GetValue(this.inventory);
        return itemCollection;
    }

    private int TakeRecipeItemsCount()
    {
        Type type = this.inventory.GetType();

        FieldInfo fieldsToInject = type.GetFields(BindingFlags.Instance | BindingFlags.NonPublic).Where(f => f.CustomAttributes.All(a => a.AttributeType != typeof(ItemAttribute))).First();

        var itemCollection = (IDictionary<string, IRecipe>)fieldsToInject.GetValue(this.inventory);

        var items = itemCollection.Values.ToList();

        int itemsCount = items.Count;

        return itemsCount;
    }

    private int TakeCommonItemsCount()
    {
        Type type = this.inventory.GetType();

        FieldInfo fieldsToInject = type.GetFields(BindingFlags.Instance | BindingFlags.NonPublic).Where(f => f.CustomAttributes.Any(a => a.AttributeType == typeof(ItemAttribute))).First();

        var itemCollection = (IDictionary<string, IItem>)fieldsToInject.GetValue(this.inventory);

        var items = itemCollection.Values.ToList();

        int itemsCount = items.Count;

        return itemsCount;
    }

    private IRecipe CreateRecipe(int count)
    {
        List<string> args = new List<string>();

        for (int i = 0; i < count; i++)
        {
            args.Add(i.ToString());
        }

        return new RecipeItem("recipeItem", itemStrengthBonus, itemAgilityBonus, itemIntelligenceBonus, itemHitPointsBonus, itemDamageBonus, args);
    }

    private void CreateCommonSomeItems(int count)
    {
        for (int i = 0; i < count; i++)
        {
            IItem item = new CommonItem($"{i}", itemStrengthBonus, itemAgilityBonus, itemIntelligenceBonus, itemHitPointsBonus, itemDamageBonus);

            this.inventory.AddCommonItem(item);
        }
    }

    [Test]
    [TestCase(0)]
    [TestCase(5)]
    [TestCase(10)]
    [TestCase(33)]
    public void TotalBonuses(int count)
    {
        this.CreateCommonSomeItems(count);

        IRecipe recipe = new RecipeItem("recipeItem", itemStrengthBonus, itemAgilityBonus, itemIntelligenceBonus, itemHitPointsBonus, itemDamageBonus, new List<string>() { "no existing" });

        this.inventory.AddRecipeItem(recipe);

        IDictionary<string, IItem> itemCollection = this.GetCommonItems();

        long strengthBonus = 0L;
        long agilityBonus = 0L;
        long intelligenceBonus = 0L;
        long hitPointsBonus = 0L;
        long damageBonus = 0L;

        foreach (var item in itemCollection.Values)
        {
            strengthBonus += item.StrengthBonus;
            agilityBonus += item.AgilityBonus;
            intelligenceBonus += item.IntelligenceBonus;
            hitPointsBonus += item.HitPointsBonus;
            damageBonus += item.DamageBonus;
        }

        Assert.AreEqual(this.inventory.TotalStrengthBonus, strengthBonus);

        Assert.AreEqual(this.inventory.TotalAgilityBonus, agilityBonus);

        Assert.AreEqual(this.inventory.TotalIntelligenceBonus, intelligenceBonus);

        Assert.AreEqual(this.inventory.TotalHitPointsBonus, hitPointsBonus);

        Assert.AreEqual(this.inventory.TotalDamageBonus, damageBonus);

        Assert.AreEqual(this.inventory.TotalStrengthBonus, (long)count * itemStrengthBonus);

        Assert.AreEqual(this.inventory.TotalAgilityBonus, (long)count * itemAgilityBonus);

        Assert.AreEqual(this.inventory.TotalIntelligenceBonus, (long)count * itemIntelligenceBonus);

        Assert.AreEqual(this.inventory.TotalHitPointsBonus, (long)count * itemHitPointsBonus);

        Assert.AreEqual(this.inventory.TotalDamageBonus, (long)count * itemDamageBonus);
    }
}