using NUnit.Framework;
using YachtDice.Inventory;
using YachtDice.Modifiers.Definition;
using YachtDice.Modifiers.Runtime;

namespace YachtDice.Tests
{
    public class InventoryModelTests
    {
        private ModifierRegistry _registry;
        private InventoryModel _inventory;

        [SetUp]
        public void SetUp()
        {
            _registry = new ModifierRegistry(3);
            _inventory = new InventoryModel(_registry);
        }

        private ModifierDefinition CreateTestDef(string id = "test",
            bool hasLimitedUses = false, int maxUses = 0)
        {
            return ModifierDefinition.CreateForTest(id, null,
                hasLimitedUses: hasLimitedUses, maxUses: maxUses);
        }

        /// <summary>
        /// Добавление модификатора увеличивает количество элементов в инвентаре.
        /// </summary>
        [Test]
        public void AddModifier_IncreasesCount()
        {
            _inventory.AddModifier(CreateTestDef());

            Assert.AreEqual(1, _inventory.OwnedModifiers.Count);
        }

        /// <summary>
        /// Активация модификатора проходит успешно, если есть свободные слоты.
        /// </summary>
        [Test]
        public void TryActivate_SucceedsWithinSlotLimit()
        {
            _inventory.AddModifier(CreateTestDef("a"));
            var mod = _inventory.OwnedModifiers[0];

            bool result = _inventory.TryActivate(mod);

            Assert.IsTrue(result);
            Assert.IsTrue(mod.IsActive);
            Assert.AreEqual(1, _inventory.ActiveCount);
        }

        /// <summary>
        /// Активация не выполняется, когда лимит активных слотов исчерпан.
        /// </summary>
        [Test]
        public void TryActivate_FailsWhenSlotsFull()
        {
            for (int i = 0; i < 3; i++)
            {
                _inventory.AddModifier(CreateTestDef($"m{i}"));
                _inventory.TryActivate(_inventory.OwnedModifiers[i]);
            }

            _inventory.AddModifier(CreateTestDef("extra"));
            var extra = _inventory.OwnedModifiers[3];
            bool result = _inventory.TryActivate(extra);

            Assert.IsFalse(result);
            Assert.IsFalse(extra.IsActive);
            Assert.AreEqual(3, _inventory.ActiveCount);
        }

        /// <summary>
        /// Деактивация модификатора освобождает активный слот.
        /// </summary>
        [Test]
        public void Deactivate_FreesSlot()
        {
            _inventory.AddModifier(CreateTestDef());
            var mod = _inventory.OwnedModifiers[0];
            _inventory.TryActivate(mod);

            _inventory.Deactivate(mod);

            Assert.IsFalse(mod.IsActive);
            Assert.AreEqual(0, _inventory.ActiveCount);
        }

        /// <summary>
        /// Удаление модификатора снимает его активность и убирает из инвентаря.
        /// </summary>
        [Test]
        public void RemoveModifier_DeactivatesAndRemoves()
        {
            _inventory.AddModifier(CreateTestDef());
            var mod = _inventory.OwnedModifiers[0];
            _inventory.TryActivate(mod);

            _inventory.RemoveModifier(mod);

            Assert.AreEqual(0, _inventory.OwnedModifiers.Count);
            Assert.AreEqual(0, _inventory.ActiveCount);
        }

        /// <summary>
        /// Расход использования уменьшает число оставшихся зарядов активного модификатора.
        /// </summary>
        [Test]
        public void ConsumeUseOnActive_DecrementsUses()
        {
            _inventory.AddModifier(CreateTestDef("ltd", hasLimitedUses: true, maxUses: 3));
            var mod = _inventory.OwnedModifiers[0];
            _inventory.TryActivate(mod);

            _inventory.ConsumeUseOnActive();

            Assert.AreEqual(2, mod.RemainingUses);
        }

        /// <summary>
        /// Модификатор удаляется из инвентаря после расхода последнего заряда.
        /// </summary>
        [Test]
        public void ConsumeUseOnActive_RemovesExpired()
        {
            _inventory.AddModifier(CreateTestDef("ltd", hasLimitedUses: true, maxUses: 1));
            var mod = _inventory.OwnedModifiers[0];
            _inventory.TryActivate(mod);

            _inventory.ConsumeUseOnActive();

            Assert.AreEqual(0, _inventory.OwnedModifiers.Count);
        }

        /// <summary>
        /// Постоянные модификаторы не расходуют заряды при использовании.
        /// </summary>
        [Test]
        public void ConsumeUseOnActive_IgnoresPermanent()
        {
            _inventory.AddModifier(CreateTestDef("perm"));
            var mod = _inventory.OwnedModifiers[0];
            _inventory.TryActivate(mod);

            _inventory.ConsumeUseOnActive();

            Assert.AreEqual(1, _inventory.OwnedModifiers.Count);
            Assert.IsTrue(mod.IsActive);
        }

        /// <summary>
        /// Список активных определений содержит только активированные модификаторы.
        /// </summary>
        [Test]
        public void GetActiveModifierDefinitions_ReturnsOnlyActive()
        {
            _inventory.AddModifier(CreateTestDef("a"));
            _inventory.AddModifier(CreateTestDef("b"));
            _inventory.TryActivate(_inventory.OwnedModifiers[0]);

            var active = _inventory.GetActiveModifierDefinitions();

            Assert.AreEqual(1, active.Count);
        }

        /// <summary>
        /// Изменение максимума активных слотов позволяет расширить лимит.
        /// </summary>
        [Test]
        public void SetMaxActiveSlots_AllowsExpansion()
        {
            _inventory.SetMaxActiveSlots(10);

            Assert.AreEqual(10, _inventory.MaxActiveSlots);
        }

        /// <summary>
        /// Событие изменения активных модификаторов срабатывает при активации.
        /// </summary>
        [Test]
        public void OnActiveModifiersChanged_FiredOnActivate()
        {
            bool fired = false;
            _inventory.OnActiveModifiersChanged += _ => fired = true;
            _inventory.AddModifier(CreateTestDef());

            _inventory.TryActivate(_inventory.OwnedModifiers[0]);

            Assert.IsTrue(fired);
        }
    }
}