using PkmnLib.Dynamic.Libraries;
using PkmnLib.Plugin.Gen7.Common;
using PkmnLib.Static.Utils;

namespace PkmnLib.Plugin.Gen7.Tests.DataTests;

/// <summary>
/// Validates that the source-generated constant classes stay in sync with the data files: every
/// generated constant must resolve in the loaded library, and every library entry must have a
/// generated constant.
/// </summary>
public class GeneratedConstantsTests
{
    private static readonly IDynamicLibrary Library = LibraryHelpers.LoadLibrary();

    private static HashSet<StringKey> ConstantsOf(Type type) => type.GetFields()
        .Where(x => x is { IsStatic: true, IsPublic: true } && x.FieldType == typeof(StringKey))
        .Select(x => (StringKey)x.GetValue(null)!).ToHashSet();

    [Test]
    public async Task MoveNamesMatchMoveLibrary()
    {
        var constants = ConstantsOf(typeof(MoveNames));
        var libraryNames = Library.StaticLibrary.Moves.Select(x => x.Name).ToHashSet();
        await Assert.That(constants.Where(x => !libraryNames.Contains(x))).IsEmpty();
        await Assert.That(libraryNames.Where(x => !constants.Contains(x))).IsEmpty();
    }

    [Test]
    public async Task AbilityNamesMatchAbilityLibrary()
    {
        var constants = ConstantsOf(typeof(AbilityNames));
        var libraryNames = Library.StaticLibrary.Abilities.Select(x => x.Name).ToHashSet();
        await Assert.That(constants.Where(x => !libraryNames.Contains(x))).IsEmpty();
        await Assert.That(libraryNames.Where(x => !constants.Contains(x))).IsEmpty();
    }

    [Test]
    public async Task ItemNamesMatchItemLibrary()
    {
        var constants = ConstantsOf(typeof(ItemNames));
        var libraryNames = Library.StaticLibrary.Items.Select(x => x.Name).ToHashSet();
        await Assert.That(constants.Where(x => !libraryNames.Contains(x))).IsEmpty();
        await Assert.That(libraryNames.Where(x => !constants.Contains(x))).IsEmpty();
    }

    [Test]
    public async Task SpeciesNamesMatchSpeciesLibrary()
    {
        var constants = ConstantsOf(typeof(SpeciesNames));
        var libraryNames = Library.StaticLibrary.Species.Select(x => x.Name).ToHashSet();
        await Assert.That(constants.Where(x => !libraryNames.Contains(x))).IsEmpty();
        await Assert.That(libraryNames.Where(x => !constants.Contains(x))).IsEmpty();
    }

    [Test]
    public async Task FormNamesMatchSpeciesForms()
    {
        var constants = ConstantsOf(typeof(FormNames));
        var libraryNames = Library.StaticLibrary.Species.SelectMany(x => x.Forms.Keys).ToHashSet();
        await Assert.That(constants.Where(x => !libraryNames.Contains(x))).IsEmpty();
        await Assert.That(libraryNames.Where(x => !constants.Contains(x))).IsEmpty();
    }

    [Test]
    public async Task NatureNamesMatchNatureLibrary()
    {
        var constants = ConstantsOf(typeof(NatureNames));
        var libraryNames = Library.StaticLibrary.Natures.Select(x => x.Name).ToHashSet();
        await Assert.That(constants.Where(x => !libraryNames.Contains(x))).IsEmpty();
        await Assert.That(libraryNames.Where(x => !constants.Contains(x))).IsEmpty();
    }

    [Test]
    public async Task TypeNamesMatchTypeLibrary()
    {
        var constants = ConstantsOf(typeof(TypeNames));
        var libraryNames = new HashSet<StringKey>();
        for (byte index = 1; Library.StaticLibrary.Types.TryGetTypeIdentifierFromIndex(index, out var type); index++)
        {
            libraryNames.Add(type.Name);
        }
        await Assert.That(constants.Where(x => !libraryNames.Contains(x))).IsEmpty();
        await Assert.That(libraryNames.Where(x => !constants.Contains(x))).IsEmpty();
    }

    [Test]
    public async Task MoveFlagsMatchMoveData()
    {
        var constants = ConstantsOf(typeof(MoveFlags));
        var libraryNames = Library.StaticLibrary.Moves.SelectMany(x => x.Flags).ToHashSet();
        await Assert.That(constants.Where(x => !libraryNames.Contains(x))).IsEmpty();
        await Assert.That(libraryNames.Where(x => !constants.Contains(x))).IsEmpty();
    }

    [Test]
    public async Task MoveEffectNamesMatchMoveData()
    {
        var constants = ConstantsOf(typeof(MoveEffectNames));
        var libraryNames = Library.StaticLibrary.Moves.Where(x => x.SecondaryEffect != null)
            .Select(x => x.SecondaryEffect!.Name).ToHashSet();
        await Assert.That(constants.Where(x => !libraryNames.Contains(x))).IsEmpty();
        await Assert.That(libraryNames.Where(x => !constants.Contains(x))).IsEmpty();
    }
}