using System.Collections.Immutable;
using System.Linq;
using System.Numerics;
using AcDream.Content;
using AcDream.Core.Physics;
using AcDream.Core.World;
using DatReaderWriter.DBObjs;
using DatReaderWriter.Types;

namespace AcDream.Content.Tests;

/// <summary>
/// AP-155 parity (route independence) for the second static publication site,
/// <see cref="LandblockPhysicsContentBuilder.PublishStaticCollision"/>. A
/// Setup carrying only authored Spheres (no CylSpheres) must register the
/// SAME shapes — type, local position, radius, scale — as
/// <see cref="ShadowShapeBuilder.FromSetup"/>, the LIVE path. Before the fix
/// this site emitted a height-capped Cylinder instead (base = origin - r*ẑ,
/// height = 2r), identically to <c>LandblockPhysicsPublisher</c>'s copy of
/// the same bug — see that class's tests
/// (<c>LandblockPhysicsPublisherTests.CompletePublication_SphereOnlySetup_*</c>)
/// for the dispatch-level (Cylinder-vs-Sphere narrow phase) proof; the two
/// sites share the SAME <c>ShadowObjectRegistry</c>/<c>TransitionTypes</c>
/// query code; this class only needs to prove ITS emission is correct.
/// </summary>
public sealed class LandblockPhysicsContentBuilderStaticSphereTests
{
    private const uint LandblockId = 0xA9B40000u;
    private const uint SetupId = 0x02000042u;

    [Fact]
    public void PublishStaticCollision_SphereOnlySetup_MatchesFromSetupShapeForShape()
    {
        var setup = new Setup();
        setup.Spheres.Add(new Sphere
        {
            Origin = new Vector3(0.3f, -0.2f, 0.9f),
            Radius = 0.55f,
        });
        setup.Spheres.Add(new Sphere
        {
            Origin = new Vector3(-0.1f, 0.4f, 1.4f),
            Radius = 0.25f,
        });
        FlatSetupCollision flatSetup = FlatCollisionAssetBuilder.FlattenSetup(setup);

        const float entScale = 1.3f;
        var entity = new WorldEntity
        {
            Id = 0x80A9B401u,
            SourceGfxObjOrSetupId = SetupId,
            Position = Vector3.Zero,
            Rotation = Quaternion.Identity,
            Scale = entScale,
            MeshRefs = Array.Empty<MeshRef>(),
        };
        var landblock = new LoadedLandblock(
            LandblockId,
            new LandBlock { Terrain = new TerrainInfo[81], Height = new byte[81] },
            new[] { entity });
        var collisions = new LandblockCollisionBuild(
            ImmutableDictionary<uint, FlatGfxObjCollisionAsset>.Empty,
            ImmutableDictionary<uint, FlatSetupCollision>.Empty.Add(SetupId, flatSetup),
            ImmutableDictionary<uint, FlatCellStructureCollisionAsset>.Empty,
            ImmutableDictionary<uint, FlatEnvCellTopology>.Empty,
            ImmutableArray<uint>.Empty,
            ImmutableArray.Create(SetupId),
            ImmutableArray<uint>.Empty);

        var engine = new PhysicsEngine();
        var cache = new PhysicsDataCache();
        LandblockPhysicsContentBuilder.CachePreparedObjects(cache, collisions);

        LandblockPhysicsContentBuilder.StaticCollisionPublication publication =
            LandblockPhysicsContentBuilder.PublishStaticCollision(
                engine, cache, landblock, collisions, origin: Vector3.Zero);

        Assert.Equal(1, publication.SetupOwnerCount);
        Assert.Equal(0, publication.BspOwnerCount);
        Assert.Equal(0, publication.NoCollisionCount);

        // The LIVE-path oracle for the SAME Setup/scale.
        var expected = ShadowShapeBuilder.FromSetup(setup, entScale, _ => false);
        Assert.Equal(2, expected.Count);
        Assert.All(
            expected,
            shape => Assert.Equal(ShadowCollisionType.Sphere, shape.CollisionType));

        ShadowShape[] expectedOrdered = expected.OrderBy(shape => shape.Radius).ToArray();
        // Entity registered at world origin with identity rotation, so
        // RegisterMultiPart's world composition (entityWorldPos +
        // Transform(shape.LocalPosition, entityWorldRot)) reduces to exactly
        // shape.LocalPosition — the static entry's world Position is directly
        // comparable to FromSetup's LocalPosition.
        ShadowEntry[] entries = engine.ShadowObjects.AllEntriesForDebug()
            .Where(entry => entry.EntityId == entity.Id)
            .OrderBy(entry => entry.Radius)
            .ToArray();

        Assert.Equal(expectedOrdered.Length, entries.Length);
        for (int i = 0; i < entries.Length; i++)
        {
            Assert.Equal(ShadowCollisionType.Sphere, entries[i].CollisionType);
            Assert.Equal(expectedOrdered[i].LocalPosition, entries[i].Position);
            Assert.Equal(expectedOrdered[i].Radius, entries[i].Radius);
            Assert.Equal(expectedOrdered[i].Scale, entries[i].Scale);
            // Review F4 (2026-08-07): assert, don't infer — the C4 lesson.
            Assert.Equal(expectedOrdered[i].CylHeight, entries[i].CylHeight);
        }
    }
}