namespace Microsoft.Toolkit.HighPerformance.Buffers
{
    public interface IBuffer<T> : IBufferWriter<T>
    {
        ReadOnlyMemory<T> WrittenMemory { get; }
        ReadOnlySpan<T> WrittenSpan { get; }
        int WrittenCount { get; }
        int Capacity { get; }
        int FreeCapacity { get; }
        void Clear();
    }

    public sealed class ArrayPoolBufferWriter<T> : IBuffer<T>, IMemoryOwner<T>
    {
        // Same as before, but now implementing IBuffer<T>
    }

    public sealed class MemoryBufferWriter<T> : IBuffer<T>
    {
        public MemoryBufferWriter(Memory<T> memory);
        public ReadOnlyMemory<T> WrittenMemory { get; }
        public ReadOnlySpan<T> WrittenSpan { get; }
        public int WrittenCount { get; }
        public int Capacity { get; }
        public int FreeCapacity { get; }
        public void Clear();
        public void Advance(int count);
        public Memory<T> GetMemory(int sizeHint = 0);
        public Span<T> GetSpan(int sizeHint = 0);
        public override string ToString();
    }
}

namespace Microsoft.Toolkit.HighPerformance.Extensions
{
    public static class BoolExtensions
    {
        public static int ToBitwiseMask32(this bool flag);
        public static long ToBitwiseMask64(this bool flag);
    }

    public static class IBufferWriterExtensions
    {
        public static void Write<T>(this IBufferWriter<byte> writer, T value)
            where T : unmanaged;
        public static void Write<T>(this IBufferWriter<T> writer, T value);        
        public static void Write<T>(this IBufferWriter<byte> writer, ReadOnlySpan<T> span)
            where T : unmanaged;
#if NETSTANDARD2_0
        public static void Write<T>(this IBufferWriter<T> writer, ReadOnlySpan<T> span);
#endif
    }

    public static class ObjectExtensions
    {
        public static IntPtr DangerousGetObjectDataByteOffset<T>(this object obj, ref T data);
        public static ref T DangerousGetObjectDataReferenceAt<T>(this object obj, IntPtr offset);
    }

    public static class ReadOnlySpanExtensions
    {
        public static ref readonly T DangerousGetLookupReferenceAt<T>(this ReadOnlySpan<T> span, int i);
    }

    public static class StreamExtensions
    {
#if NETSTANDARD2_0
        public static ValueTask<int> ReadAsync(this Stream stream, Memory<byte> buffer, CancellationToken cancellationToken = default);
        public static ValueTask WriteAsync(this Stream stream, ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default);
        public static int Read(this Stream stream, Span<byte> buffer);
        public static void Write(this Stream stream, ReadOnlySpan<byte> buffer);
#endif
        public static T Read<T>(this Stream stream)
            where T : unmanaged;
        public static void Write<T>(this Stream stream, in T value)
            where T : unmanaged;
    }
}

namespace Microsoft.Toolkit.HighPerformance.Helpers
{
    public static class BitHelper
    {
        public static bool HasLookupFlag(uint table, int x, int min = 0);
        public static uint ExtractRange(uint value, byte start, byte length);
        public static void SetRange(ref uint value, byte start, byte length, uint flags);
        public static uint SetRange(uint value, byte start, byte length, uint flags);
        public static bool HasLookupFlag(ulong table, int x, int min = 0);
        public static ulong ExtractRange(ulong value, byte start, byte length);
        public static void SetRange(ref ulong value, byte start, byte length, ulong flags);
        public static ulong SetRange(ulong value, byte start, byte length, ulong flags);
    }
}