using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
using System.IO.Compression;
using System.Reflection.Metadata;

BenchmarkRunner.Run<PdbWriterBenchmark>();

[MemoryDiagnoser]
public class PdbWriterBenchmark
{
    public const int BlockSize = 16 << 10;

    private readonly BlobBuilder _data = new();

    [GlobalSetup]
    public void GlobalSetup()
    {
        using var f = File.OpenRead(@"C:\Users\teo\code\ephemeral\PdbWriterBenchmark\System.Private.CoreLib.pdb");
        _data.TryWriteBytes(f, (int)f.Length);
    }

    [Benchmark]
    public int Buffered()
    {
        var compressed = new BlobBuilder();
        var buffer = new MemoryStream();
        using (var compressor = new DeflateStream(buffer, CompressionLevel.Optimal, leaveOpen: true))
        {
            _data.WriteContentTo(compressor);
        }
        compressed.WriteBytes(buffer.GetBuffer(), 0, (int)buffer.Length);
        return compressed.Count;
    }

    [Benchmark]
    public int Unbuffered()
    {
        var compressed = new BlobBuilder();
        using (var compressor = new DeflateStream(new BlobBuilderStream(compressed), CompressionLevel.Optimal, leaveOpen: true))
        {
            _data.WriteContentTo(compressor);
        }
        return compressed.Count;
    }
}

internal sealed class BlobBuilderStream(BlobBuilder builder) : Stream
{
    public override bool CanRead => false;
    public override bool CanSeek => false;
    public override bool CanWrite => true;
    public override long Length => throw new NotSupportedException();
    public override long Position { get => throw new NotSupportedException(); set => throw new NotSupportedException(); }
    public override void Flush() { }
    public override int Read(byte[] buffer, int offset, int count) => throw new NotSupportedException();
    public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
    public override void SetLength(long value) => throw new NotSupportedException();
    public override void Write(byte[] buffer, int offset, int count) => builder.WriteBytes(buffer, offset, count);
    public override unsafe void Write(ReadOnlySpan<byte> buffer)
    {
        fixed (byte* ptr = buffer)
        {
            builder.WriteBytes(ptr, buffer.Length);
        }
    }
}