public void Restack(IStackableBase stackableBase, int totalQuantity)
    {
        Inventory.RemoveAll(item => item.Base == (ItemBase)stackableBase);

        if (stackableBase.MaxStack == 0)
        {
            Debug.LogError("Max Stack is 0");
            return;
        }

        while (totalQuantity > 0)
        {
            var instance  = ItemInstanceBuilder.BuildInstance(stackableBase.ItemBase);
            var stackable = instance as IStackable;
            if (totalQuantity > stackableBase.MaxStack)
            {
                stackable.Quantity = stackableBase.MaxStack;
                totalQuantity     -= stackableBase.MaxStack;
            }
            else
            {
                stackable.Quantity = totalQuantity;
                totalQuantity      = 0;
            }
            Inventory.Add(instance);
        }
    }
    public void Restack(IStackableBase stackableBase)
    {
        var totalCount = Inventory.Where(item => item.Base == stackableBase.ItemBase).Cast <IStackable>()
                         .Select(stackable => stackable.Quantity).Sum();

        Restack(stackableBase, totalCount);
    }
    private int GetQuantityOfStackable(IStackableBase stackableBase)
    {
        var stacks     = Inventory.Where(item => item.Base == (ItemBase)stackableBase).Cast <IStackable>().ToArray();
        int totalCount = 0;

        stacks.ForEach(stack => { totalCount += stack.Quantity; });
        return(totalCount);
    }
    public void RemoveStackableBaseFromInventory(IStackableBase stackableBase, int amount)
    {
        var allStacks = Inventory.FindAll(item => item.Base == (ItemBase)stackableBase);

        var totalCount = 0;

        allStacks.ForEach(item => totalCount += (item as IStackable).Quantity);

        Restack(stackableBase, totalCount - amount);
    }
    public void AddStackableBaseToInventory(IStackableBase stackableBase, int quantity)
    {
        if (quantity == 0)
        {
            return;
        }

        if (stackableBase.MaxStack == 0)
        {
            Debug.LogError("Max Stack is 0");
            return;
        }

        var instancesOfStackable = Inventory.Where(item => item.Base == stackableBase.ItemBase);

        if (!instancesOfStackable.Any())
        {
            while (quantity > 0)
            {
                var instance  = ItemInstanceBuilder.BuildInstance(stackableBase.ItemBase);
                var stackable = instance as IStackable;
                if (quantity > stackableBase.MaxStack)
                {
                    stackable.Quantity = stackableBase.MaxStack;
                    quantity          -= stackableBase.MaxStack;
                }
                else
                {
                    stackable.Quantity = quantity;
                    quantity           = 0;
                }
                Inventory.Add(instance);
            }
        }
        else
        {
            //Restack
            int totalQuantity = quantity;
            foreach (var instanceOfStackable in instancesOfStackable)
            {
                var stackable = instanceOfStackable as IStackable;
                totalQuantity += stackable.Quantity;
            }

            Inventory.RemoveAll(item => instancesOfStackable.Contains(item));

            Debug.Log("Total Quantity = " + totalQuantity);

            Restack(stackableBase, totalQuantity);
        }
    }