using Server.Engines.Pathing.Cache;
using Xunit;
using Xunit.Abstractions;

namespace Server.Tests.Pathfinding;

[Collection("Sequential Pathfinding Tests")]
public class StepProbeTests
{
    private readonly ITestOutputHelper _output;

    public StepProbeTests(ITestOutputHelper output)
    {
        _output = output;
    }

    [Fact]
    public void ComputeMaskAt_NullMap_ReturnsDefault()
    {
        var result = StepProbe.ComputeMaskAt(null, 100, 100, 0);

        Assert.Equal(0, result.WalkMask);
        for (var d = 0; d < 8; d++)
        {
            Assert.Equal(0, result.GetWalkZ((Direction)d));
        }
    }

    [Fact]
    public void ComputeMaskAt_InternalMap_ReturnsDefault()
    {
        var result = StepProbe.ComputeMaskAt(Map.Internal, 100, 100, 0);

        Assert.Equal(0, result.WalkMask);
        for (var d = 0; d < 8; d++)
        {
            Assert.Equal(0, result.GetWalkZ((Direction)d));
        }
    }

    [Fact]
    public void ComputeMaskAt_TopLeftCorner_OffMapDirectionsBlocked()
    {
        // From source (0, 0), these neighbor cells are off-map and MUST be blocked,
        // regardless of map content:
        //   N  = (0, -1)   bit 0
        //   NE = (1, -1)   bit 1
        //   SW = (-1, 1)   bit 5
        //   W  = (-1, 0)   bit 6
        //   NW = (-1, -1)  bit 7
        // Bits 2 (E), 3 (SE), 4 (S) depend on map content and aren't asserted.
        var map = Map.Maps[1];
        Assert.NotNull(map);

        var result = StepProbe.ComputeMaskAt(map, 0, 0, 0);

        Assert.False(result.IsWalkable(Direction.North), "N should be off-map");
        Assert.False(result.IsWalkable(Direction.Right), "NE should be off-map");
        Assert.False(result.IsWalkable(Direction.Left), "SW should be off-map");
        Assert.False(result.IsWalkable(Direction.West), "W should be off-map");
        Assert.False(result.IsWalkable(Direction.Up), "NW should be off-map");
    }

    [Fact]
    public void ComputeMaskAt_BottomRightCorner_OffMapDirectionsBlocked()
    {
        var map = Map.Maps[1];
        Assert.NotNull(map);

        var x = map.Width - 1;
        var y = map.Height - 1;
        var result = StepProbe.ComputeMaskAt(map, x, y, 0);

        // From the SE corner, S/SE/SW/E/NE all go off-map (only N/NW/W in-map).
        Assert.False(result.IsWalkable(Direction.Right), "NE should be off-map");
        Assert.False(result.IsWalkable(Direction.East), "E should be off-map");
        Assert.False(result.IsWalkable(Direction.Down), "SE should be off-map");
        Assert.False(result.IsWalkable(Direction.South), "S should be off-map");
        Assert.False(result.IsWalkable(Direction.Left), "SW should be off-map");
    }

    [Fact]
    public void ComputeMaskAt_UnderworldOpenPlain_HasFlatCellWithAllDirectionsWalkable()
    {
        // Invariant: somewhere in the open-plain region, there must be a fully-flat cell
        // whose mask is 0xFF and all 8 destZ values equal sourceZ (no slope).
        // This protects against a regression where the baker stops detecting flat cells.
        var map = Map.Maps[1];
        Assert.NotNull(map);

        var found = false;

        for (var x = 1500; x < 1532 && !found; x++)
        {
            for (var y = 1600; y < 1632 && !found; y++)
            {
                map.GetAverageZ(x, y, out _, out var avgZ, out _);
                var sourceZ = (sbyte)avgZ;
                var result = StepProbe.ComputeMaskAt(map, x, y, sourceZ);

                if (result.WalkMask != 0xFF)
                {
                    continue;
                }

                var allSameZ = true;
                for (var d = 0; d < 8; d++)
                {
                    if (result.GetWalkZ((Direction)d) != sourceZ)
                    {
                        allSameZ = false;
                        break;
                    }
                }

                if (allSameZ)
                {
                    found = true;
                    _output.WriteLine($"Flat-open cell found at ({x}, {y}, {sourceZ})");
                }
            }
        }

        Assert.True(found, "Expected at least one fully-flat open cell in (1500..1532, 1600..1632)");
    }

    [SkippableFact]
    public void ComputeMaskAt_BritainInnDense_HasCellWithBlockedDirections()
    {
        TileDataRequirement.SkipIfMissing();
        // Invariant: inside the dense Britain inn region, at least one cell must have
        // at least one direction blocked by a static. Protects against a regression
        // where the baker reports everything as walkable (the original false-pass bug).
        var map = Map.Maps[1];
        Assert.NotNull(map);

        var blockedCellCount = 0;

        for (var x = 1480; x < 1512; x++)
        {
            for (var y = 1610; y < 1642; y++)
            {
                map.GetAverageZ(x, y, out _, out var avgZ, out _);
                var sourceZ = (sbyte)avgZ;
                var result = StepProbe.ComputeMaskAt(map, x, y, sourceZ);

                if (result.WalkMask != 0xFF)
                {
                    blockedCellCount++;
                }
            }
        }

        _output.WriteLine($"Cells with at least one blocked direction: {blockedCellCount} / 1024");
        Assert.True(blockedCellCount > 0, "Expected at least one cell with a blocked direction in the dense region");
    }

    [Theory]
    [InlineData(1500, 1600)]
    [InlineData(1480, 1610)]
    [InlineData(0, 0)]
    public void ComputeMaskAt_IsDeterministic(int x, int y)
    {
        // Same inputs must always produce identical output. Catches accidental
        // statefulness in the baker (e.g., a static cache that gets corrupted).
        var map = Map.Maps[1];
        Assert.NotNull(map);

        map.GetAverageZ(x, y, out _, out var avgZ, out _);
        var sourceZ = (sbyte)avgZ;

        var first = StepProbe.ComputeMaskAt(map, x, y, sourceZ);
        var second = StepProbe.ComputeMaskAt(map, x, y, sourceZ);
        var third = StepProbe.ComputeMaskAt(map, x, y, sourceZ);

        Assert.Equal(first.WalkMask, second.WalkMask);
        Assert.Equal(first.WalkMask, third.WalkMask);
        for (var d = 0; d < 8; d++)
        {
            Assert.Equal(first.GetWalkZ((Direction)d), second.GetWalkZ((Direction)d));
            Assert.Equal(first.GetWalkZ((Direction)d), third.GetWalkZ((Direction)d));
        }
    }

    [SkippableFact]
    public void ComputeMaskAt_PinnedCell_UnderworldOpenPlainOrigin()
    {
        TileDataRequirement.SkipIfMissing();
        // PINNING test: locks specific output for Underworld (1500, 1600).
        // Cell at z=10 with mask 0xC1 (N + W + NW only walkable). The other five
        // directions are blocked by water (E/SE/S/SW are wet tiles, NE is shore).
        // If this changes, either the baker logic changed or the underlying tile
        // data changed; re-run the parity test to confirm before updating expected values.
        var map = Map.Maps[1];
        Assert.NotNull(map);

        map.GetAverageZ(1500, 1600, out _, out var avgZ, out _);
        var sourceZ = (sbyte)avgZ;

        var result = StepProbe.ComputeMaskAt(map, 1500, 1600, sourceZ);

        Assert.Equal((sbyte)10, sourceZ);
        Assert.Equal((byte)0xC1, result.WalkMask);

        Assert.True(result.IsWalkable(Direction.North));
        Assert.False(result.IsWalkable(Direction.Right));
        Assert.False(result.IsWalkable(Direction.East));
        Assert.False(result.IsWalkable(Direction.Down));
        Assert.False(result.IsWalkable(Direction.South));
        Assert.False(result.IsWalkable(Direction.Left));
        Assert.True(result.IsWalkable(Direction.West));
        Assert.True(result.IsWalkable(Direction.Up));

        Assert.Equal((sbyte)10, result.GetWalkZ(Direction.North));
        Assert.Equal((sbyte)10, result.GetWalkZ(Direction.West));
        Assert.Equal((sbyte)10, result.GetWalkZ(Direction.Up));
    }

    [SkippableFact]
    public void ComputeMaskAt_PinnedCell_BritainInnDenseOrigin()
    {
        TileDataRequirement.SkipIfMissing();
        // PINNING test: locks specific output for Underworld (1480, 1610).
        // Cell at z=20 with mask 0x3F (N/NE/E/SE/S/SW walkable, W/NW blocked by
        // a wall to the west). All walkable directions stay flat at z=20.
        var map = Map.Maps[1];
        Assert.NotNull(map);

        map.GetAverageZ(1480, 1610, out _, out var avgZ, out _);
        var sourceZ = (sbyte)avgZ;

        var result = StepProbe.ComputeMaskAt(map, 1480, 1610, sourceZ);

        Assert.Equal((sbyte)20, sourceZ);
        Assert.Equal((byte)0x3F, result.WalkMask);

        Assert.True(result.IsWalkable(Direction.North));
        Assert.True(result.IsWalkable(Direction.Right));
        Assert.True(result.IsWalkable(Direction.East));
        Assert.True(result.IsWalkable(Direction.Down));
        Assert.True(result.IsWalkable(Direction.South));
        Assert.True(result.IsWalkable(Direction.Left));
        Assert.False(result.IsWalkable(Direction.West));
        Assert.False(result.IsWalkable(Direction.Up));

        for (var d = 0; d < 6; d++)
        {
            Assert.Equal((sbyte)20, result.GetWalkZ((Direction)d));
        }
    }
}