using System.Collections.Generic;
using NUnit.Framework;
using pflib_net.characters;
using pflib_net.characters.internals.proficiencies;
using pflib_net.characters.internals.stats;
using pflib_net.Tests.damage;

namespace pflib_net.Tests.characters;

[TestFixture]
[TestOf(typeof(PlayerCharacter))]
public class PlayerCharacterTest
{

    [Test]
    public void DamageReducesHp()
    {
        var creature = CreateCharacter();
        var damage = DamageUtils.CreateDamage();
        creature.ResolveAttack(20, damage);
        Assert.That(creature.GetHp(), Is.LessThan(50));
    }
    
    [Test]
    public void AttackFailsOnMiss()
    {
        var creature = CreateCharacter();
        var damage = DamageUtils.CreateDamage();
        creature.ResolveAttack(0, damage);
        Assert.That(creature.GetHp(), Is.EqualTo(50));
    }

    [Test]
    public void ImmunitiesApplyNoDamage()
    {
        var immunities = new HashSet<string>
        {
            "fire"
        };
        var creature = CreateCharacter(immunities: immunities);
        creature.ResolveAttack(1000, DamageUtils.CreateDamage());
        Assert.That(creature.GetHp(), Is.Positive);
    }

    [Test]
    public void ResistancesReduceDamage()
    {
        var resistances = new Dictionary<string, int>
        {
            { "fire", 5 }
        };
        var creature1 = CreateCharacter();
        creature1.ResolveAttack(20, DamageUtils.CreateDamage());
        var creature2 = CreateCharacter(resistances: resistances);
        creature2.ResolveAttack(20, DamageUtils.CreateDamage());
        Assert.That(creature2.GetHp() - creature1.GetHp(), Is.EqualTo(5));
    }
    
    [Test]
    public void WeaknessIncreaseDamage()
    {
        var weaknesses = new Dictionary<string, int>
        {
            { "fire", 5 }
        };
        var creature1 = CreateCharacter();
        creature1.ResolveAttack(20, DamageUtils.CreateDamage());
        var creature2 = CreateCharacter(weaknesses: weaknesses);
        creature2.ResolveAttack(20, DamageUtils.CreateDamage());
        Assert.That(creature1.GetHp() - creature2.GetHp(), Is.EqualTo(5));
    }

    [Test]
    public void CannotTakeNegativeAmountsOfDamage()
    {
        var resistances = new Dictionary<string, int>
        {
            { "fire", 45 }
        };
        var creature = CreateCharacter(hp: 20, resistances: resistances);
        var damage = DamageUtils.CreateDamage();
        creature.ResolveAttack(20, damage);
        Assert.That(creature.GetHp(), Is.EqualTo(20));
    }

    private ICharacter CreateCharacter(
        int hp = 50,
        Stats stats = null,
        int level = 5,
        ArmorProficiency armorProficiency = null,
        ISet<string> immunities = null,
        Dictionary<string, int> resistances = null,
        Dictionary<string, int> weaknesses = null
        )
    {
        stats ??= new Stats(0, 0, 0, 0, 0, 0);
        var armorValues = new Dictionary<ProficiencyType, ProficiencyValue>
        {
            { ProficiencyType.Unarmored, ProficiencyValue.Expert },
            { ProficiencyType.LightArmor, ProficiencyValue.None },
            { ProficiencyType.MediumArmor, ProficiencyValue.None },
            { ProficiencyType.HeavyArmor, ProficiencyValue.None }
        };
        armorProficiency ??= new ArmorProficiency(armorValues);
        immunities ??= new HashSet<string>();
        resistances ??= new Dictionary<string, int>();
        weaknesses ??= new Dictionary<string, int>();

        return new PlayerCharacter(
            hp,
            stats,
            level,
            armorProficiency,
            immunities,
            resistances,
            weaknesses
        );
    }
}