// <copyright file="BotEquipmentHandlerTest.cs" company="MUnique">
// Licensed under the MIT License. See LICENSE file in the project root for full license information.
// </copyright>

namespace MUnique.OpenMU.Tests;

using Moq;
using MUnique.OpenMU.DataModel;
using MUnique.OpenMU.DataModel.Configuration;
using MUnique.OpenMU.DataModel.Configuration.Items;
using MUnique.OpenMU.DataModel.Entities;
using MUnique.OpenMU.GameLogic;
using MUnique.OpenMU.GameLogic.Attributes;
using MUnique.OpenMU.GameLogic.Bots;

/// <summary>
/// Tests which gear a bot considers an upgrade (<see cref="BotEquipmentHandler.IsUpgradeFor"/>, also
/// the pickup filter of the offline <see cref="MUnique.OpenMU.GameLogic.Offline.ItemPickupHandler"/>)
/// and the hand rule it shares with the engine (<see cref="ItemExtensions.ConflictsWithEquippedHands"/>).
/// </summary>
[TestFixture]
public class BotEquipmentHandlerTest
{
    private const byte StaffGroup = 5;
    private const byte ShieldGroup = 6;
    private const byte ArmorGroup = 8;

    /// <summary>
    /// A better weapon of the bot's own fighting style is an upgrade worth picking up. The test player's
    /// class is energy-based, so its style is the staff (see <see cref="BotProgression.IsPreferredWeaponGroup"/>).
    /// </summary>
    [Test]
    public async ValueTask BetterWeaponIsAnUpgradeAsync()
    {
        var player = await PlayerTestHelper.CreatePlayerAsync().ConfigureAwait(false);
        await WearAsync(player, CreateDefinition(player, StaffGroup, 1, dropLevel: 10), InventoryConstants.LeftHandSlot).ConfigureAwait(false);
        var better = CreateItem(CreateDefinition(player, StaffGroup, 2, dropLevel: 40));

        Assert.That(BotEquipmentHandler.IsUpgradeFor(player, better), Is.True);
    }

    /// <summary>
    /// A two-handed weapon needs the other hand: while a shield is worn, it is only worth it if it beats
    /// the weapon AND the shield it displaces. Without counting the shield, the bot took its gear off,
    /// had the equip refused by the engine (a two-hander needs the hand free), put the old weapon back on
    /// and started over - hundreds of swaps an hour, unarmed half of the time.
    /// </summary>
    [Test]
    public async ValueTask TwoHandedWeaponIsNoUpgradeWhenItLosesToWeaponAndShieldAsync()
    {
        var player = await PlayerTestHelper.CreatePlayerAsync().ConfigureAwait(false);
        await WearAsync(player, CreateDefinition(player, StaffGroup, 1, dropLevel: 50), InventoryConstants.LeftHandSlot).ConfigureAwait(false);
        await WearAsync(player, CreateDefinition(player, ShieldGroup, 1, dropLevel: 40, slot: InventoryConstants.RightHandSlot), InventoryConstants.RightHandSlot).ConfigureAwait(false);

        var twoHanded = CreateItem(CreateDefinition(player, StaffGroup, 3, dropLevel: 60, width: 2));

        Assert.That(BotEquipmentHandler.IsUpgradeFor(player, twoHanded), Is.False);
    }

    /// <summary>
    /// A two-handed weapon which beats the worn weapon and shield together is worth the swap - the bot
    /// frees the hand for it, like a player would.
    /// </summary>
    [Test]
    public async ValueTask TwoHandedWeaponIsAnUpgradeWhenItBeatsWeaponAndShieldAsync()
    {
        var player = await PlayerTestHelper.CreatePlayerAsync().ConfigureAwait(false);
        await WearAsync(player, CreateDefinition(player, StaffGroup, 1, dropLevel: 50), InventoryConstants.LeftHandSlot).ConfigureAwait(false);
        await WearAsync(player, CreateDefinition(player, ShieldGroup, 1, dropLevel: 40, slot: InventoryConstants.RightHandSlot), InventoryConstants.RightHandSlot).ConfigureAwait(false);

        var twoHanded = CreateItem(CreateDefinition(player, StaffGroup, 3, dropLevel: 120, width: 2));

        Assert.That(BotEquipmentHandler.IsUpgradeFor(player, twoHanded), Is.True);
    }

    /// <summary>
    /// Without a shield in the way, the same two-handed weapon is a welcome upgrade.
    /// </summary>
    [Test]
    public async ValueTask TwoHandedWeaponIsAnUpgradeWithFreeOffHandAsync()
    {
        var player = await PlayerTestHelper.CreatePlayerAsync().ConfigureAwait(false);
        await WearAsync(player, CreateDefinition(player, StaffGroup, 1, dropLevel: 10), InventoryConstants.LeftHandSlot).ConfigureAwait(false);

        var twoHanded = CreateItem(CreateDefinition(player, StaffGroup, 3, dropLevel: 60, width: 2));

        Assert.That(BotEquipmentHandler.IsUpgradeFor(player, twoHanded), Is.True);
    }

    /// <summary>
    /// A weapon never goes into the free off-hand: a bot dual-wielding the junk weapons it happens to be
    /// qualified for is neither useful nor a sight a real character offers.
    /// </summary>
    [Test]
    public async ValueTask JunkWeaponIsNoUpgradeForTheFreeOffHandAsync()
    {
        var player = await PlayerTestHelper.CreatePlayerAsync().ConfigureAwait(false);
        await WearAsync(player, CreateDefinition(player, StaffGroup, 1, dropLevel: 50), InventoryConstants.LeftHandSlot).ConfigureAwait(false);

        var junk = CreateItem(CreateDefinition(player, StaffGroup, 2, dropLevel: 5));

        Assert.That(BotEquipmentHandler.IsUpgradeFor(player, junk), Is.False);
    }

    /// <summary>
    /// Gear the bot's class cannot wear is no upgrade, however good it is.
    /// </summary>
    [Test]
    public async ValueTask UnqualifiedGearIsNoUpgradeAsync()
    {
        var player = await PlayerTestHelper.CreatePlayerAsync().ConfigureAwait(false);
        var definition = CreateDefinition(player, ArmorGroup, 1, dropLevel: 80, slot: InventoryConstants.ArmorSlot);
        definition.QualifiedCharacters.Clear();

        Assert.That(BotEquipmentHandler.IsUpgradeFor(player, CreateItem(definition)), Is.False);
    }

    /// <summary>
    /// An empty armor slot takes any qualified piece - that is what makes a naked bot dress itself.
    /// </summary>
    [Test]
    public async ValueTask ArmorForAnEmptySlotIsAnUpgradeAsync()
    {
        var player = await PlayerTestHelper.CreatePlayerAsync().ConfigureAwait(false);
        var armor = CreateItem(CreateDefinition(player, ArmorGroup, 1, dropLevel: 20, slot: InventoryConstants.ArmorSlot));

        Assert.That(BotEquipmentHandler.IsUpgradeFor(player, armor), Is.True);
    }

    private static ItemDefinition CreateDefinition(Player player, byte group, short number, byte dropLevel, byte width = 1, int? slot = null)
    {
        var definitionMock = new Mock<ItemDefinition>();
        definitionMock.SetupAllProperties();
        definitionMock.Setup(d => d.QualifiedCharacters).Returns(new List<CharacterClass>());
        definitionMock.Setup(d => d.PossibleItemOptions).Returns(new List<ItemOptionDefinition>());
        definitionMock.Setup(d => d.BasePowerUpAttributes).Returns(new List<ItemBasePowerUpDefinition>());
        definitionMock.Setup(d => d.Requirements).Returns(new List<AttributeRequirement>());

        var slotTypeMock = new Mock<ItemSlotType>();
        var targetSlot = slot ?? InventoryConstants.LeftHandSlot;
        var slots = targetSlot == InventoryConstants.LeftHandSlot && group <= ShieldGroup && width < 2
            ? new List<int> { InventoryConstants.LeftHandSlot, InventoryConstants.RightHandSlot }
            : new List<int> { targetSlot };
        slotTypeMock.Setup(s => s.ItemSlots).Returns(slots);
        definitionMock.Setup(d => d.ItemSlot).Returns(slotTypeMock.Object);

        var definition = definitionMock.Object;
        definition.Group = group;
        definition.Number = number;
        definition.Width = width;
        definition.Height = 2;
        definition.Durability = 100;
        definition.DropLevel = dropLevel;
        definition.QualifiedCharacters.Add(player.SelectedCharacter!.CharacterClass!);
        player.GameContext.Configuration.Items.Add(definition);
        return definition;
    }

    private static Item CreateItem(ItemDefinition definition)
    {
        var itemMock = new Mock<Item>();
        itemMock.SetupAllProperties();
        itemMock.Setup(i => i.ItemOptions).Returns(new List<ItemOptionLink>());
        itemMock.Setup(i => i.ItemSetGroups).Returns(new List<ItemOfItemSet>());
        var item = itemMock.Object;
        item.Definition = definition;
        item.Durability = definition.Durability;
        return item;
    }

    private static async ValueTask<Item> WearAsync(Player player, ItemDefinition definition, byte slot)
    {
        var item = CreateItem(definition);
        await player.Inventory!.AddItemAsync(slot, item).ConfigureAwait(false);
        return item;
    }
}