using System;
using AcDream.App.Rendering.Gpu;
using AcDream.Core.Lighting;

namespace AcDream.App.Rendering;

/// <summary>
/// Publishes the SceneLighting UBO each frame so every shader sampling
/// <c>uLights[]</c> / <c>uFogColor</c> / etc reads consistent data without
/// per-shader re-upload.
///
/// <para>The raw-GL arm this used to have alongside it — a global uniform
/// binding point kept live by a per-flight-slot buffer pool — was deleted at
/// Campaign V slice V11. Vulkan has no such global binding point: a
/// descriptor set is bound per draw, so the upload is a frame ring slice
/// PUBLISHED on <see cref="WorldFrameSections.SceneLighting"/>, and each world
/// renderer binds it inside the pass after its own binds (plan §5.5.14 item
/// 2). Every allocation within a frame is already distinct memory that lives
/// until the frame retires, which is the property the deleted buffer pool
/// existed to provide when the world, portal-space and paperdoll draws each
/// upload different lighting.</para>
/// </summary>
public sealed unsafe class SceneLightingUboBinding : IDisposable
{
    private readonly ICurrentGpuFrameSource _frames;
    private readonly WorldFrameSections _sections;
    private bool _frameStarted;

    /// <summary>
    /// The GL arm's per-flight-slot buffer pool this used to report on was
    /// deleted at Campaign V slice V11: every allocation now comes from a ring
    /// that lives until its frame retires, so there is no persistent
    /// dynamic-buffer pool left to size.
    /// </summary>
    internal int DynamicBufferCount => 0;

    internal SceneLightingUboBinding(
        ICurrentGpuFrameSource frames,
        WorldFrameSections sections)
    {
        _frames = frames ?? throw new ArgumentNullException(nameof(frames));
        _sections = sections ?? throw new ArgumentNullException(nameof(sections));
    }

    /// <summary>
    /// Resets the lighting-submission cursor for a GPU-fenced frame slot.
    /// World, portal-space, and paperdoll draws can each upload different
    /// lighting in one frame, so every upload receives distinct storage.
    /// </summary>
    public void BeginFrame(int frameSlot)
    {
        ArgumentOutOfRangeException.ThrowIfNegative(frameSlot);
        _frameStarted = true;
    }

    /// <summary>
    /// Push the current frame's UBO contents to the GPU. Cheap (576 bytes)
    /// so fine to call unconditionally every frame.
    /// </summary>
    public void Upload(SceneLightingUbo data)
    {
        if (!_frameStarted)
            throw new InvalidOperationException("BeginFrame must be called before uploading scene lighting.");

        IGpuFrame frame = _frames.CurrentFrame
            ?? throw new InvalidOperationException(
                "Scene lighting requires an open IGpuFrame (see GpuDeviceFrameLifetime).");
        GpuRingAllocation allocation = frame.AllocateRing(
            SceneLightingUbo.SizeInBytes,
            GpuRingUsage.Uniform);
        new ReadOnlySpan<byte>(&data, SceneLightingUbo.SizeInBytes)
            .CopyTo(allocation.Data);
        _sections.SceneLighting = new GpuBufferSection(
            allocation.Buffer,
            allocation.OffsetBytes,
            (uint)SceneLightingUbo.SizeInBytes);
    }

    /// <summary>
    /// No-op: this binding owns no GPU resource of its own on the RHI arm — the
    /// deleted GL arm's per-flight buffer pool was the only thing to release.
    /// Kept as a method so callers that hold this behind an <see cref="IDisposable"/>
    /// reference (composition's acquisition scope) don't need a special case.
    /// </summary>
    public void Dispose()
    {
    }
}