using System;

using System.Buffers;

using System.Buffers.Binary;

using System.Diagnostics;

using System.Diagnostics.CodeAnalysis;

using System.IO;

using System.Runtime.CompilerServices;

using System.Runtime.InteropServices;

using System.Text;

using System.Threading;

using System.Threading.Tasks;

using Npgsql.Internal.Postgres;

namespace Npgsql.Internal;

enum FlushMode

interface IStreamingWriter<T>: IBufferWriter<T>

sealed class NpgsqlBufferWriter(NpgsqlWriteBuffer buffer) : IStreamingWriter<byte>

public sealed class PgWriter

readonly IBufferWriter<byte> _writer;

byte[]? _buffer;

int _offset;

int _pos;

int _length;

int _totalBytesWritten;

ValueMetadata _current;

NpgsqlDatabaseInfo? _typeCatalog;

internal PgWriter(IBufferWriter<byte> writer) => _writer = writer;

internal PgWriter Init(NpgsqlDatabaseInfo typeCatalog, FlushMode flushMode = FlushMode.None)

}

[MethodImpl(MethodImplOptions.NoInlining)]

void RequestBuffer(int count)

}

internal FlushMode FlushMode { get; private set; }

internal void RefreshBuffer() => RequestBuffer(count: 0);

internal PgWriter WithFlushMode(FlushMode mode)

}

void Ensure(int count = 1)

}

Span<byte> Span => _buffer.AsSpan(_pos, _length - _pos);

int Remaining => _length - _pos;

void Advance(int count) => _pos += count;

internal void Commit(int? expectedByteCount = null)

}

internal ValueTask BeginWrite(bool async, ValueMetadata current, CancellationToken cancellationToken)

}

public ValueMetadata Current => _current;

internal Size CurrentBufferRequirement => _current.BufferRequirement;

// When we don't know the size during writing we're using the writer buffer as a sizing mechanism.

internal bool BufferingWrite => Current.Size.Kind is SizeKind.Unknown;

// This method lives here to remove the chances oids will be cached on converters inadvertently when data type names should be used.

// Such a mapping (for instance for array element oids) should be done per operation to ensure it is done in the context of a specific backend.

public void WriteAsOid(PgTypeId pgTypeId)

}

public void WriteByte(byte value)

}

public void WriteInt16(short value)

}

public void WriteInt32(int value)

}

public void WriteInt64(long value)

}

public void WriteUInt16(ushort value)

}

public void WriteUInt32(uint value)

}

public void WriteUInt64(ulong value)

}

public void WriteFloat(float value)

}

public void WriteDouble(double value)

}

public void WriteChars(ReadOnlySpan<char> data, Encoding encoding)

}

public ValueTask WriteCharsAsync(ReadOnlyMemory<char> data, Encoding encoding, CancellationToken cancellationToken = default)

}

public void WriteBytes(ReadOnlySpan<byte> buffer)

=> WriteBytes(allowMixedIO: false, buffer);

internal void WriteBytes(bool allowMixedIO, ReadOnlySpan<byte> buffer)

}

public ValueTask WriteBytesAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default)

=> WriteBytesAsync(allowMixedIO: false, buffer, cancellationToken);

internal ValueTask WriteBytesAsync(bool allowMixedIO, ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken)

}

/// <summary>

/// Gets a <see cref="Stream"/> that can be used to write to the underlying buffer.

/// </summary>

/// <param name="allowMixedIO">Blocking flushes during writes that were expected to be non-blocking and vice versa cause an exception to be thrown unless allowMixedIO is set to true, false by default.</param>

/// <returns>The stream.</returns>

public Stream GetStream(bool allowMixedIO = false)

=> new PgWriterStream(this, allowMixedIO);

public bool ShouldFlush(Size bufferRequirement)

=> ShouldFlush(bufferRequirement is { Kind: SizeKind.UpperBound }

? Math.Min(Current.Size.Value, bufferRequirement.Value)

: bufferRequirement.GetValueOrDefault());

public bool ShouldFlush(int byteCount) => Remaining < byteCount && FlushMode is not FlushMode.None;

public void Flush(TimeSpan timeout = default)

=> Flush(allowWhenNonBlocking: false, timeout);

void Flush(bool allowWhenNonBlocking, TimeSpan timeout = default)

}

public ValueTask FlushAsync(CancellationToken cancellationToken = default)

=> FlushAsync(allowWhenBlocking: false, cancellationToken);

async ValueTask FlushAsync(bool allowWhenBlocking, CancellationToken cancellationToken = default)

}

internal ValueTask Flush(bool async, CancellationToken cancellationToken = default)

}

internal ValueTask<NestedWriteScope> BeginNestedWrite(bool async, Size bufferRequirement, int byteCount, object? state, CancellationToken cancellationToken)

}

public NestedWriteScope BeginNestedWrite(Size bufferRequirement, int byteCount, object? state)

=> BeginNestedWrite(async: false, bufferRequirement, byteCount, state, CancellationToken.None).GetAwaiter().GetResult();

public ValueTask<NestedWriteScope> BeginNestedWriteAsync(Size bufferRequirement, int byteCount, object? state, CancellationToken cancellationToken = default)

=> BeginNestedWrite(async: true, bufferRequirement, byteCount, state, cancellationToken);

sealed class PgWriterStream : Stream

{

readonly PgWriter _writer;

readonly bool _allowMixedIO;

internal PgWriterStream(PgWriter writer, bool allowMixedIO)

}

public override void Write(byte[] buffer, int offset, int count)

=> Write(async: false, buffer: buffer, offset: offset, count: count, CancellationToken.None).GetAwaiter().GetResult();

public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)

=> Write(async: true, buffer: buffer, offset: offset, count: count, cancellationToken: cancellationToken);

Task Write(bool async, byte[] buffer, int offset, int count, CancellationToken cancellationToken)

{

ArgumentNullException.ThrowIfNull(buffer);

ArgumentOutOfRangeException.ThrowIfNegative(offset);

ArgumentOutOfRangeException.ThrowIfNegative(count);

if (buffer.Length - offset < count)

ThrowHelper.ThrowArgumentException("Offset and length were out of bounds for the array or count is greater than the number of elements from index to the end of the source collection.");

if (async)

{

if (cancellationToken.IsCancellationRequested)

return Task.FromCanceled(cancellationToken);

return _writer.WriteBytesAsync(_allowMixedIO, buffer.AsMemory(offset, count), cancellationToken).AsTask();

}

_writer.WriteBytes(_allowMixedIO, new Span<byte>(buffer, offset, count));

return Task.CompletedTask;

}

public override void Write(ReadOnlySpan<byte> buffer) => _writer.WriteBytes(_allowMixedIO, buffer);

public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default)

{

if (cancellationToken.IsCancellationRequested)

return new(Task.FromCanceled(cancellationToken));

return _writer.WriteBytesAsync(buffer, cancellationToken);

}

public override void Flush()

=> _writer.Flush();

public override Task FlushAsync(CancellationToken cancellationToken)

=> _writer.FlushAsync(cancellationToken).AsTask();

public override bool CanRead => false;

public override bool CanWrite => true;

public override bool CanSeek => false;

public override int Read(byte[] buffer, int offset, int count)

=> throw new NotSupportedException();

public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)

=> throw new NotSupportedException();

public override long Length => throw new NotSupportedException();

public override void SetLength(long value)

=> throw new NotSupportedException();

public override long Position

{

get => throw new NotSupportedException();

set => throw new NotSupportedException();

}

public override long Seek(long offset, SeekOrigin origin)

=> throw new NotSupportedException();

}

public struct NestedWriteScope : IDisposable

public void Dispose()

{

}