ModernUO/Projects/Server.Tests/Tests/Maps/ItemByDistanceEnumeratorTests.cs

using System;
using System.Collections.Generic;
using Xunit;

namespace Server.Tests.Maps;

[Collection("Sequential Server Tests")]
public class ItemByDistanceEnumeratorTests
{
    [Fact]
    public void ItemByDistanceEnumerator_ReturnsNearbyItems()
    {
        var map = Map.Felucca;
        var center = new Point3D(100, 100, 0);
        const int range = 5;

        var Items = new TestItem[3];
        try
        {
            Items[0] = CreateItem(map, new Point3D(102, 102, 0)); // Within range
            Items[1] = CreateItem(map, new Point3D(98, 98, 0));   // Within range
            Items[2] = CreateItem(map, new Point3D(110, 110, 0)); // Outside range

            var found = new List<Item>();
            foreach (var (Item, _) in map.GetItemsInRangeByDistance(center, range))
            {
                found.Add(Item);
            }

            Assert.Equal(2, found.Count);
            Assert.Contains(Items[0], found);
            Assert.Contains(Items[1], found);
            Assert.DoesNotContain(Items[2], found);
        }
        finally
        {
            DeleteAll(Items);
        }
    }

    [Fact]
    public void ItemByDistanceEnumerator_MapNullYieldsEmpty()
    {
        var center = new Point2D(0, 0);
        var bounds = new Rectangle2D(center.m_X - 10, center.m_Y - 10, 21, 21);
        var enumerator = new Map.ItemDistanceEnumerable<Item>(null, bounds, center, false).GetEnumerator();
        Assert.False(enumerator.MoveNext());
    }

    [Fact]
    public void ItemByDistanceEnumerator_ThrowsOnVersionChange()
    {
        var map = Map.Felucca;
        var center = new Point3D(500, 500, 0);
        const int range = 5;

        var Items = new[]
        {
            CreateItem(map, new Point3D(502, 502, 0)),
            CreateItem(map, new Point3D(503, 502, 0))
        };

        try
        {
            var enumerator = map.GetItemsInRangeByDistance(center, range).GetEnumerator();
            Assert.True(enumerator.MoveNext());

            Items[1].Delete();

            // Ref structs cannot be captured in lambdas, so we test the exception directly
            var exceptionThrown = false;
            try
            {
                enumerator.MoveNext();
            }
            catch (InvalidOperationException)
            {
                exceptionThrown = true;
            }

            Assert.True(exceptionThrown, "Expected InvalidOperationException when collection version changes");
        }
        finally
        {
            DeleteAll(Items);
        }
    }

    [Fact]
    public void ItemByDistanceEnumerator_ZeroRangeReturnsOnlyCenter()
    {
        var map = Map.Felucca;
        var center = new Point3D(600, 600, 0);
        const int range = 0;

        var Items = new TestItem[2];
        try
        {
            Items[0] = CreateItem(map, center);              // Exact center
            Items[1] = CreateItem(map, new Point3D(601, 600, 0)); // 1 tile away

            var found = new List<Item>();
            foreach (var (Item, _) in map.GetItemsInRangeByDistance(center, range))
            {
                found.Add(Item);
            }

            Assert.Single(found);
            Assert.Equal(Items[0], found[0]);
        }
        finally
        {
            DeleteAll(Items);
        }
    }

    [Fact]
    public void ItemByDistanceEnumerator_FiltersByType()
    {
        var map = Map.Felucca;
        var center = new Point3D(700, 700, 0);
        const int range = 5;

        var testItem2 = new TestItem2(World.NewItem);
        var testItem = new TestItem(World.NewItem);

        try
        {
            testItem2.MoveToWorld(new Point3D(702, 702, 0), map);
            testItem.MoveToWorld(new Point3D(703, 702, 0), map);

            var foundPlayers = new List<TestItem2>();
            foreach (var (Item, _) in map.GetItemsInRangeByDistance<TestItem2>(center, range))
            {
                foundPlayers.Add(Item);
            }

            Assert.Single(foundPlayers);
            Assert.Equal(testItem2, foundPlayers[0]);
        }
        finally
        {
            testItem2.Delete();
            testItem.Delete();
        }
    }

    [Fact]
    public void ItemByDistanceEnumerator_RingTraversal()
    {
        var map = Map.Felucca;
        var center = new Point3D(900, 900, 0);
        const int range = Map.SectorSize * 2;

        var Items = new TestItem[4];
        try
        {
            // Place Items in different rings around the center
            Items[0] = CreateItem(map, center); // Ring 0 (center sector)
            Items[1] = CreateItem(map, new Point3D(center.X + Map.SectorSize, center.Y, 0)); // Ring 1
            Items[2] = CreateItem(map, new Point3D(center.X, center.Y + Map.SectorSize, 0)); // Ring 1
            Items[3] = CreateItem(map, new Point3D(center.X + Map.SectorSize * 2 - 1, center.Y, 0)); // Ring 2

            var found = new List<Item>();
            var distances = new List<int>();
            foreach (var (Item, minDistance) in map.GetItemsInRangeByDistance(center, range))
            {
                found.Add(Item);
                distances.Add(minDistance);
            }

            // All Items should be found
            Assert.Equal(4, found.Count);
            Assert.Contains(Items[0], found);
            Assert.Contains(Items[1], found);
            Assert.Contains(Items[2], found);
            Assert.Contains(Items[3], found);

            // Items should be processed by sector distance (ring-based)
            // The center Item should have distance 0
            var centerIndex = found.IndexOf(Items[0]);
            Assert.Equal(0, distances[centerIndex]);
        }
        finally
        {
            DeleteAll(Items);
        }
    }

    [Fact]
    public void ItemByDistanceEnumerator_MapBoundsAreClamped()
    {
        var map = Map.Felucca;
        var width = map.Width;
        var height = map.Height;

        var center = new Point3D(width - 2, height - 2, 0);
        const int range = Map.SectorSize * 2;

        var Items = new TestItem[1];
        try
        {
            Items[0] = CreateItem(map, center);

            var found = new List<Item>();
            foreach (var (Item, _) in map.GetItemsInRangeByDistance(center, range))
            {
                found.Add(Item);
            }

            Assert.Single(found);
            Assert.Equal(Items[0], found[0]);
        }
        finally
        {
            DeleteAll(Items);
        }
    }

    [Fact]
    public void ItemByDistanceEnumerator_NegativeRangeIsZero()
    {
        var map = Map.Felucca;
        var center = new Point3D(1000, 1000, 0);
        const int range = -5;

        var Items = new TestItem[2];
        try
        {
            Items[0] = CreateItem(map, center);
            Items[1] = CreateItem(map, new Point3D(1001, 1000, 0)); // 1 tile away

            var found = new List<Item>();
            foreach (var (Item, _) in map.GetItemsInRangeByDistance(center, range))
            {
                found.Add(Item);
            }

            // With negative range creating a 1x1 bounds, only exact center matches
            Assert.Single(found);
            Assert.Equal(Items[0], found[0]);
        }
        finally
        {
            DeleteAll(Items);
        }
    }

    [Fact]
    public void ItemByDistanceEnumerator_MatchesBoundsEnumeratorAtMapEdge()
    {
        var map = Map.Felucca;
        var center = new Point3D(5, 5, 0);
        const int range = 18;

        // Off-map items live in the shared invalid sector, which ring cells past the map edge resolve to
        var items = new TestItem[1];
        try
        {
            items[0] = CreateItem(map, new Point3D(3, -2, 0));

            var byDistance = new List<Item>();
            foreach (var (item, _) in map.GetItemsInRangeByDistance(center, range))
            {
                byDistance.Add(item);
            }

            var inRange = new List<Item>();
            foreach (var item in map.GetItemsInRange(center, range))
            {
                inRange.Add(item);
            }

            Assert.Equal(inRange, byDistance);
        }
        finally
        {
            DeleteAll(items);
        }
    }

    private static TestItem CreateItem(Map map, Point3D location)
    {
        var Item = new TestItem(World.NewItem);
        Item.MoveToWorld(location, map);
        return Item;
    }

    private static void DeleteAll(TestItem[] Items)
    {
        for (var i = 0; i < Items.Length; i++)
        {
            Items[i]?.Delete();
        }
    }

    [Fact]
    public void ItemByDistanceEnumerator_Bounds_FindsItemsInBounds()
    {
        var map = Map.Felucca;
        var bounds = new Rectangle2D(100, 100, 50, 50);

        var Items = new TestItem[3];
        try
        {
            // Item inside bounds
            Items[0] = CreateItem(map, new Point3D(120, 120, 0));
            // Item at edge of bounds
            Items[1] = CreateItem(map, new Point3D(149, 149, 0));
            // Item outside bounds
            Items[2] = CreateItem(map, new Point3D(200, 200, 0));

            var found = new List<Item>();
            foreach (var (Item, _) in map.GetItemsInBoundsByDistance<Item>(bounds))
            {
                found.Add(Item);
            }

            Assert.Equal(2, found.Count);
            Assert.Contains(Items[0], found);
            Assert.Contains(Items[1], found);
            Assert.DoesNotContain(Items[2], found);
        }
        finally
        {
            DeleteAll(Items);
        }
    }

    [Fact]
    public void ItemByDistanceEnumerator_Bounds_MakeBoundsInclusive()
    {
        var map = Map.Felucca;
        var bounds = new Rectangle2D(100, 100, 50, 50);

        var Items = new TestItem[2];
        try
        {
            // Item at edge (inclusive)
            Items[0] = CreateItem(map, new Point3D(149, 149, 0));
            // Item just outside edge (will be included with makeBoundsInclusive)
            Items[1] = CreateItem(map, new Point3D(150, 150, 0));

            var foundWithoutInclusive = new List<Item>();
            foreach (var (Item, _) in map.GetItemsInBoundsByDistance<Item>(bounds))
            {
                foundWithoutInclusive.Add(Item);
            }

            var foundWithInclusive = new List<Item>();
            foreach (var (Item, _) in map.GetItemsInBoundsByDistance<Item>(bounds, true))
            {
                foundWithInclusive.Add(Item);
            }

            Assert.Single(foundWithoutInclusive);
            Assert.Contains(Items[0], foundWithoutInclusive);

            Assert.Equal(2, foundWithInclusive.Count);
            Assert.Contains(Items[0], foundWithInclusive);
            Assert.Contains(Items[1], foundWithInclusive);
        }
        finally
        {
            DeleteAll(Items);
        }
    }

    [Fact]
    public void ItemByDistanceEnumerator_Bounds_OrdersByProximityToCenter()
    {
        var map = Map.Felucca;
        var bounds = new Rectangle2D(500, 500, 64, 64);

        var Items = new TestItem[3];
        try
        {
            // Place Items at different distances from center
            Items[0] = CreateItem(map, new Point3D(532, 532, 0)); // At center
            Items[1] = CreateItem(map, new Point3D(548, 532, 0)); // 16 tiles away
            Items[2] = CreateItem(map, new Point3D(563, 563, 0)); // Far corner

            var found = new List<(Item, int)>();
            foreach (var result in map.GetItemsInBoundsByDistance<Item>(bounds))
            {
                found.Add(result);
            }

            Assert.Equal(3, found.Count);

            // Verify ordering by distance - closer Items should be found earlier (lower minDistance)
            var Item0Index = found.FindIndex(x => x.Item1 == Items[0]);
            var Item1Index = found.FindIndex(x => x.Item1 == Items[1]);
            var Item2Index = found.FindIndex(x => x.Item1 == Items[2]);

            // The minDistance should increase (or stay the same) as we go through the list
            Assert.True(found[Item0Index].Item2 <= found[Item1Index].Item2);
            Assert.True(found[Item1Index].Item2 <= found[Item2Index].Item2);
        }
        finally
        {
            DeleteAll(Items);
        }
    }

    // Test implementation of Item
    private class TestItem : Item
    {
        public TestItem(Serial serial) : base(serial)
        {
        }
    }

    private class TestItem2 : Item
    {
        public TestItem2(Serial serial) : base(serial)
        {
        }
    }
}