using AcDream.App.Streaming;
using AcDream.App.Rendering;
using AcDream.App.Rendering.Wb;
using AcDream.Core.World;
using DatReaderWriter.DBObjs;
using System.Collections.Immutable;

namespace AcDream.App.Tests.Streaming;

public sealed class StreamingControllerReadinessTests
{
    [Fact]
    public void RenderNeighborhoodResident_RequiresEveryPublishedLandblockInRing()
    {
        var state = new GpuWorldState();
        StreamingController controller = CreateController(state);

        for (int dx = -1; dx <= 1; dx++)
        for (int dy = -1; dy <= 1; dy++)
        {
            if (dx == 1 && dy == 1)
                continue;
            AddPublished(state, 0x12 + dx, 0x36 + dy);
        }

        Assert.False(controller.IsRenderNeighborhoodResident(0x12360022u, 1));

        AddPublished(state, 0x13, 0x37);

        Assert.True(controller.IsRenderNeighborhoodResident(0x12360022u, 1));
    }

    [Fact]
    public void RenderNeighborhoodResident_RadiusZeroAcceptsEnvCellId()
    {
        var state = new GpuWorldState();
        StreamingController controller = CreateController(state);
        AddPublished(state, 0x8C, 0x04);

        Assert.True(controller.IsRenderNeighborhoodResident(0x8C0401ADu, 0));
        Assert.False(controller.IsRenderNeighborhoodResident(0x8D0401ADu, 0));
    }

    [Fact]
    public void RenderNeighborhoodResident_SkipsOffMapNeighborsLikePhysicsGate()
    {
        var state = new GpuWorldState();
        StreamingController controller = CreateController(state);
        AddPublished(state, 0, 0);
        AddPublished(state, 0, 1);
        AddPublished(state, 1, 0);
        AddPublished(state, 1, 1);

        Assert.True(controller.IsRenderNeighborhoodResident(0x00000001u, 1));
    }

    [Fact]
    public void RenderNeighborhoodResident_RejectsNegativeRadius()
    {
        StreamingController controller = CreateController(new GpuWorldState());

        Assert.Throws<ArgumentOutOfRangeException>(
            () => controller.IsRenderNeighborhoodResident(0x1236FFFFu, -1));
    }

    [Theory]
    [InlineData(0xFF0401ADu)]
    [InlineData(0x04FF01ADu)]
    [InlineData(0x12360000u)]
    [InlineData(0x12360041u)]
    [InlineData(0x1236FFFEu)]
    public void RenderNeighborhoodResident_RejectsInvalidMapEdgeDestination(uint cellId)
    {
        StreamingController controller = CreateController(new GpuWorldState());

        Assert.False(controller.IsRenderNeighborhoodResident(cellId, 0));
    }

    [Fact]
    public void RenderNeighborhoodResident_WaitsForActualMeshUpload()
    {
        var meshes = new ReadinessMeshAdapter();
        var state = new GpuWorldState(new LandblockSpawnAdapter(meshes));
        StreamingController controller = CreateController(state);
        uint id = 0x1236FFFFu;
        const ulong envCellGeometryId = 0x2_0000_1234ul;
        var entity = new WorldEntity
        {
            Id = 1,
            ServerGuid = 0,
            SourceGfxObjOrSetupId = 0x01000010u,
            Position = System.Numerics.Vector3.Zero,
            Rotation = System.Numerics.Quaternion.Identity,
            MeshRefs = new[] { new MeshRef(0x01000010u, System.Numerics.Matrix4x4.Identity) },
        };
        state.AddLandblock(
            new LoadedLandblock(id, new LandBlock(), new[] { entity }),
            new[] { envCellGeometryId });

        Assert.False(controller.IsRenderNeighborhoodResident(id, 0));
        meshes.ReadyIds.Add(0x01000010ul);
        Assert.False(controller.IsRenderNeighborhoodResident(id, 0));
        meshes.ReadyIds.Add(envCellGeometryId);
        Assert.True(controller.IsRenderNeighborhoodResident(id, 0));
    }

    [Fact]
    public void RenderNeighborhoodResident_PreservesShellGateWhenPromotionPrecedesBaseLoad()
    {
        var meshes = new ReadinessMeshAdapter();
        var state = new GpuWorldState(new LandblockSpawnAdapter(meshes));
        StreamingController controller = CreateController(state);
        uint id = 0x1236FFFFu;
        const ulong envCellGeometryId = 0x2_0000_1234ul;

        state.AddEntitiesToExistingLandblock(
            id,
            Array.Empty<WorldEntity>(),
            new[] { envCellGeometryId });
        state.AddLandblock(new LoadedLandblock(id, new LandBlock(), Array.Empty<WorldEntity>()));

        Assert.True(state.IsNearTier(id));
        Assert.False(controller.IsRenderNeighborhoodResident(id, 0));
        meshes.ReadyIds.Add(envCellGeometryId);
        Assert.True(controller.IsRenderNeighborhoodResident(id, 0));
    }

    [Fact]
    public void RenderNeighborhoodResident_FarTerrainDoesNotSatisfyPortalGate()
    {
        var meshes = new ReadinessMeshAdapter();
        var state = new GpuWorldState(new LandblockSpawnAdapter(meshes));
        StreamingController controller = CreateController(state);
        uint id = 0x1236FFFFu;
        const ulong envCellGeometryId = 0x2_0000_1234ul;
        state.AddLandblock(
            new LoadedLandblock(id, new LandBlock(), Array.Empty<WorldEntity>()),
            tier: LandblockStreamTier.Far);

        Assert.False(controller.IsRenderNeighborhoodResident(id, 0));

        state.AddEntitiesToExistingLandblock(
            id,
            Array.Empty<WorldEntity>(),
            new[] { envCellGeometryId });
        Assert.False(controller.IsRenderNeighborhoodResident(id, 0));
        meshes.ReadyIds.Add(envCellGeometryId);
        Assert.True(controller.IsRenderNeighborhoodResident(id, 0));
    }

    [Fact]
    public void StaleFarPublication_DoesNotReplaceNearEntitiesOrReadiness()
    {
        var meshes = new ReadinessMeshAdapter();
        var state = new GpuWorldState(new LandblockSpawnAdapter(meshes));
        StreamingController controller = CreateController(state);
        uint id = 0x1236FFFFu;
        const ulong envCellGeometryId = 0x2_0000_1234ul;
        var entity = new WorldEntity
        {
            Id = 1,
            ServerGuid = 0,
            SourceGfxObjOrSetupId = 0x01000010u,
            Position = System.Numerics.Vector3.Zero,
            Rotation = System.Numerics.Quaternion.Identity,
            MeshRefs = [new MeshRef(0x01000010u, System.Numerics.Matrix4x4.Identity)],
        };
        meshes.ReadyIds.UnionWith([0x01000010ul, envCellGeometryId]);
        state.AddLandblock(
            new LoadedLandblock(id, new LandBlock(), new[] { entity }),
            new[] { envCellGeometryId },
            LandblockStreamTier.Near);
        Assert.True(controller.IsRenderNeighborhoodResident(id, 0));

        state.AddLandblock(
            new LoadedLandblock(id, new LandBlock(), Array.Empty<WorldEntity>()),
            tier: LandblockStreamTier.Far);

        Assert.True(state.IsNearTier(id));
        Assert.Contains(entity, state.Entities);
        Assert.True(controller.IsRenderNeighborhoodResident(id, 0));
    }

    [Fact]
    public void EnvCellPublication_RearmsSpecializedPreparationAfterPin()
    {
        uint id = 0x1236FFFFu;
        const ulong geometryId = 0x2_0000_1234ul;
        var meshes = new ReadinessMeshAdapter();
        var state = new GpuWorldState(new LandblockSpawnAdapter(meshes));
        var outbox = new Queue<LandblockStreamResult>();
        int ensureCalls = 0;
        var shell = new EnvCellShellPlacement(
            0x12360001u,
            geometryId,
            0x0D000001u,
            2,
            ImmutableArray.Create<ushort>(3, 4),
            System.Numerics.Vector3.Zero,
            System.Numerics.Quaternion.Identity,
            System.Numerics.Matrix4x4.Identity,
            new WbBoundingBox(System.Numerics.Vector3.Zero, System.Numerics.Vector3.One),
            new WbBoundingBox(System.Numerics.Vector3.Zero, System.Numerics.Vector3.One));
        var envCells = new EnvCellLandblockBuild(
            id,
            Array.Empty<LoadedCell>(),
            new[] { shell });
        var build = new LandblockBuild(
            new LoadedLandblock(id, new LandBlock(), Array.Empty<WorldEntity>()),
            envCells);
        outbox.Enqueue(new LandblockStreamResult.Loaded(
            id,
            LandblockStreamTier.Near,
            build,
            new AcDream.Core.Terrain.LandblockMeshData(
                Array.Empty<AcDream.Core.Terrain.TerrainVertex>(),
                Array.Empty<uint>())));
        var controller = new StreamingController(
            enqueueLoad: (_, _) => { },
            enqueueUnload: _ => { },
            drainCompletions: max =>
            {
                var batch = new List<LandblockStreamResult>();
                while (batch.Count < max && outbox.Count > 0) batch.Add(outbox.Dequeue());
                return batch;
            },
            applyTerrain: (_, _) => { },
            state: state,
            nearRadius: 0,
            farRadius: 0,
            ensureEnvCellMeshes: completed =>
            {
                // The specialized request is replayed only after the synthetic
                // id is pinned, closing existing-at-schedule -> evicted-before-
                // publication without falling through generic GfxObj decode.
                Assert.Equal(1, meshes.ReferenceCounts[geometryId]);
                Assert.Equal(shell, Assert.Single(completed.Shells));
                ensureCalls++;
            });

        controller.Tick(0x12, 0x36);

        Assert.Equal(1, ensureCalls);
    }

    [Fact]
    public void PromotionWithoutBase_PublishesSelfContainedNearAndPinsBeforeReplay()
    {
        uint id = 0x1236FFFFu;
        const ulong geometryId = 0x2_0000_5678ul;
        var meshes = new ReadinessMeshAdapter();
        var state = new GpuWorldState(new LandblockSpawnAdapter(meshes));
        var outbox = new Queue<LandblockStreamResult>();
        int ensureCalls = 0;
        var shell = new EnvCellShellPlacement(
            0x12360001u,
            geometryId,
            0x0D000001u,
            2,
            ImmutableArray.Create<ushort>(3, 4),
            System.Numerics.Vector3.Zero,
            System.Numerics.Quaternion.Identity,
            System.Numerics.Matrix4x4.Identity,
            new WbBoundingBox(System.Numerics.Vector3.Zero, System.Numerics.Vector3.One),
            new WbBoundingBox(System.Numerics.Vector3.Zero, System.Numerics.Vector3.One));
        var envCells = new EnvCellLandblockBuild(
            id,
            Array.Empty<LoadedCell>(),
            new[] { shell });
        var nearBuild = new LandblockBuild(
            new LoadedLandblock(id, new LandBlock(), Array.Empty<WorldEntity>()),
            envCells);
        var mesh = new AcDream.Core.Terrain.LandblockMeshData(
            Array.Empty<AcDream.Core.Terrain.TerrainVertex>(),
            Array.Empty<uint>());
        outbox.Enqueue(new LandblockStreamResult.Promoted(id, nearBuild, mesh));
        var controller = new StreamingController(
            enqueueLoad: (_, _) => { },
            enqueueUnload: _ => { },
            drainCompletions: max =>
            {
                var batch = new List<LandblockStreamResult>();
                while (batch.Count < max && outbox.Count > 0) batch.Add(outbox.Dequeue());
                return batch;
            },
            applyTerrain: (_, _) => { },
            state: state,
            nearRadius: 0,
            farRadius: 0,
            ensureEnvCellMeshes: completed =>
            {
                Assert.Equal(1, meshes.ReferenceCounts[geometryId]);
                Assert.Equal(shell, Assert.Single(completed.Shells));
                ensureCalls++;
            });

        controller.Tick(0x12, 0x36);

        Assert.Equal(1, ensureCalls);
        Assert.Equal(1, meshes.ReferenceCounts[geometryId]);
        Assert.True(state.IsNearTier(id));

        // A Far job that had already started may still finish after the
        // self-contained promotion. It must not replace or replay the Near tier.
        var farBase = new LandblockBuild(
            new LoadedLandblock(id, new LandBlock(), Array.Empty<WorldEntity>()));
        outbox.Enqueue(new LandblockStreamResult.Loaded(
            id,
            LandblockStreamTier.Far,
            farBase,
            mesh));

        controller.Tick(0x12, 0x36);

        Assert.Equal(1, ensureCalls);
        Assert.Equal(1, meshes.ReferenceCounts[geometryId]);
        Assert.True(state.IsNearTier(id));
    }

    [Fact]
    public void PromotionBeforeBase_DemotedBeforeBase_DropsPendingNearPresentation()
    {
        uint id = 0x1236FFFFu;
        const ulong geometryId = 0x2_0000_9ABCul;
        var meshes = new ReadinessMeshAdapter();
        var state = new GpuWorldState(new LandblockSpawnAdapter(meshes));
        var outbox = new Queue<LandblockStreamResult>();
        int ensureCalls = 0;
        var appliedBuilds = new List<LandblockBuild>();
        var demotedWhileStaticPresent = new List<uint>();
        var shell = new EnvCellShellPlacement(
            0x12360001u,
            geometryId,
            0x0D000001u,
            2,
            ImmutableArray.Create<ushort>(3, 4),
            System.Numerics.Vector3.Zero,
            System.Numerics.Quaternion.Identity,
            System.Numerics.Matrix4x4.Identity,
            new WbBoundingBox(System.Numerics.Vector3.Zero, System.Numerics.Vector3.One),
            new WbBoundingBox(System.Numerics.Vector3.Zero, System.Numerics.Vector3.One));
        var envCells = new EnvCellLandblockBuild(
            id,
            Array.Empty<LoadedCell>(),
            new[] { shell });
        var staticEntity = new WorldEntity
        {
            Id = 1,
            ServerGuid = 0,
            SourceGfxObjOrSetupId = 0x01000010u,
            Position = System.Numerics.Vector3.Zero,
            Rotation = System.Numerics.Quaternion.Identity,
            MeshRefs = [new MeshRef(0x01000010u, System.Numerics.Matrix4x4.Identity)],
        };
        var nearBuild = new LandblockBuild(
            new LoadedLandblock(id, new LandBlock(), new[] { staticEntity }),
            envCells);
        var mesh = new AcDream.Core.Terrain.LandblockMeshData(
            Array.Empty<AcDream.Core.Terrain.TerrainVertex>(),
            Array.Empty<uint>());
        outbox.Enqueue(new LandblockStreamResult.Promoted(id, nearBuild, mesh));
        var controller = new StreamingController(
            enqueueLoad: (_, _) => { },
            enqueueUnload: _ => { },
            drainCompletions: max =>
            {
                var batch = new List<LandblockStreamResult>();
                while (batch.Count < max && outbox.Count > 0) batch.Add(outbox.Dequeue());
                return batch;
            },
            applyTerrain: (build, _) => appliedBuilds.Add(build),
            state: state,
            nearRadius: 0,
            farRadius: 3,
            demoteNearLayer: demotedId =>
            {
                Assert.Contains(staticEntity, state.Entities);
                demotedWhileStaticPresent.Add(demotedId);
            },
            ensureEnvCellMeshes: _ => ensureCalls++);

        controller.Tick(0x12, 0x36); // self-contained promotion publishes Near.
        Assert.Single(appliedBuilds);
        Assert.NotNull(appliedBuilds[0].EnvCells);
        controller.Tick(0x12, 0x39); // normal Near->Far demotion retires presentation.

        var farBase = new LandblockBuild(
            new LoadedLandblock(id, new LandBlock(), Array.Empty<WorldEntity>()));
        outbox.Enqueue(new LandblockStreamResult.Loaded(
            id,
            LandblockStreamTier.Far,
            farBase,
            mesh));
        controller.Tick(0x12, 0x39);

        Assert.Equal(1, ensureCalls);
        Assert.DoesNotContain(geometryId, meshes.ReferenceCounts);
        Assert.DoesNotContain(staticEntity, state.Entities);
        Assert.Equal(new[] { id }, demotedWhileStaticPresent);
        Assert.True(state.IsLoaded(id));
        Assert.False(state.IsNearTier(id));
        Assert.Equal(2, appliedBuilds.Count);
        Assert.Null(appliedBuilds[1].EnvCells);
        Assert.Empty(appliedBuilds[1].Landblock.Entities);
    }

    private static StreamingController CreateController(GpuWorldState state)
        => new(
            (_, _) => { },
            _ => { },
            _ => Array.Empty<LandblockStreamResult>(),
            (_, _) => { },
            state,
            nearRadius: 1,
            farRadius: 2);

    private static void AddPublished(GpuWorldState state, int x, int y)
    {
        uint id = ((uint)x << 24) | ((uint)y << 16) | 0xFFFFu;
        state.AddLandblock(new LoadedLandblock(id, new LandBlock(), Array.Empty<WorldEntity>()));
    }

    private sealed class ReadinessMeshAdapter : IWbMeshAdapter
    {
        public HashSet<ulong> ReadyIds { get; } = new();
        public Dictionary<ulong, int> ReferenceCounts { get; } = new();
        public void IncrementRefCount(ulong id) =>
            ReferenceCounts[id] = ReferenceCounts.GetValueOrDefault(id) + 1;
        public void DecrementRefCount(ulong id)
        {
            int next = ReferenceCounts.GetValueOrDefault(id) - 1;
            if (next <= 0) ReferenceCounts.Remove(id);
            else ReferenceCounts[id] = next;
        }
        public bool IsRenderDataReady(ulong id) => ReadyIds.Contains(id);
    }
}