namespace DeepDrftContent.Processors;

/// <summary>
/// Bounded-buffer streaming primitives shared by the audio processors on the store path. None of
/// these hold the whole file in memory: copies move a fixed window at a time, and the header read
/// caps its allocation regardless of file size.
/// </summary>
internal static class AudioStoreStream
{
    private const int CopyBufferSize = 81920; // 80 KB — matches the controller staging copy.

    /// <summary>
    /// Bounded disk-to-disk copy of <paramref name="sourcePath"/> into <paramref name="destination"/>.
    /// Used for passthrough formats whose stored bytes equal the source bytes. Hand-rolled rather than
    /// <see cref="Stream.CopyToAsync(Stream)"/> because <c>FileStream</c>'s override writes in 128 KB
    /// blocks; this keeps every write at or below <see cref="CopyBufferSize"/>, so peak managed memory
    /// is provably O(buffer), never O(filesize).
    /// </summary>
    public static async Task CopyFileAsync(string sourcePath, Stream destination, CancellationToken ct)
    {
        await using var src = new FileStream(
            sourcePath, FileMode.Open, FileAccess.Read, FileShare.Read,
            bufferSize: CopyBufferSize, useAsync: true);

        var buffer = new byte[CopyBufferSize];
        int read;
        while ((read = await src.ReadAsync(buffer, ct)) > 0)
        {
            await destination.WriteAsync(buffer.AsMemory(0, read), ct);
        }
    }

    /// <summary>
    /// Reads at most <paramref name="cap"/> bytes from the start of <paramref name="path"/> — enough
    /// for header/metadata parsing without loading the (potentially ~GB) body. Bounds the allocation
    /// at <c>min(cap, fileLength)</c>. Size-based metadata (e.g. average bitrate) must use the true
    /// file length, supplied separately, not the prefix length.
    /// </summary>
    public static async Task<byte[]> ReadPrefixAsync(string path, long cap, CancellationToken ct)
    {
        await using var fs = new FileStream(
            path, FileMode.Open, FileAccess.Read, FileShare.Read,
            bufferSize: CopyBufferSize, useAsync: true);

        var length = (int)Math.Min(cap, fs.Length);
        var buffer = new byte[length];
        var total = 0;
        while (total < length)
        {
            var read = await fs.ReadAsync(buffer.AsMemory(total, length - total), ct);
            if (read == 0)
                break;
            total += read;
        }

        return total == length ? buffer : buffer[..total];
    }
}