using System;

using System.Diagnostics.CodeAnalysis;

using System.Runtime.CompilerServices;

namespace Npgsql.Internal;

[Experimental(NpgsqlDiagnostics.ConvertersExperimental)]

public readonly struct BufferRequirements : IEquatable<BufferRequirements>

{

readonly Size _read;

readonly Size _write;

BufferRequirements(Size read, Size write)

{

_read = read;

_write = write;

}

public Size Read => _read;

public Size Write => _write;

/// Streaming

public static BufferRequirements None => new(Size.Unknown, Size.Unknown);

/// Entire value should be buffered

public static BufferRequirements Value => new(Size.CreateUpperBound(int.MaxValue), Size.CreateUpperBound(int.MaxValue));

/// Fixed size value should be buffered

public static BufferRequirements CreateFixedSize(int byteCount) => new(byteCount, byteCount);

/// Custom requirements

public static BufferRequirements Create(Size value) => new(value, value);

public static BufferRequirements Create(Size read, Size write) => new(read, write);

public BufferRequirements Combine(Size read, Size write)

=> new(_read.Combine(read), _write.Combine(write));

public BufferRequirements Combine(BufferRequirements other)

=> Combine(other._read, other._write);

public BufferRequirements Combine(int byteCount)

=> Combine(CreateFixedSize(byteCount));

public bool Equals(BufferRequirements other) => _read.Equals(other._read) && _write.Equals(other._write);

public override bool Equals(object? obj) => obj is BufferRequirements other && Equals(other);

public override int GetHashCode() => HashCode.Combine(_read, _write);

public static bool operator ==(BufferRequirements left, BufferRequirements right) => left.Equals(right);

public static bool operator !=(BufferRequirements left, BufferRequirements right) => !left.Equals(right);

[MethodImpl(MethodImplOptions.AggressiveInlining)]

internal static int GetMinimumBufferByteCount(Size bufferRequirement, int valueSize)

{

ArgumentOutOfRangeException.ThrowIfNegative(valueSize);

var reqByteCount = bufferRequirement.GetValueOrDefault();

switch (bufferRequirement.Kind)

{

case SizeKind.Exact:

if (reqByteCount != valueSize)

ThrowExactMismatch(reqByteCount, valueSize);

goto default;

case SizeKind.UpperBound:

return Math.Min(valueSize, reqByteCount);

default:

return reqByteCount;

}

static void ThrowExactMismatch(int expected, int actual)

=> throw new ArgumentOutOfRangeException(nameof(bufferRequirement),

$"Exact buffer requirement size ({expected} bytes) does not match the value size ({actual} bytes).");

}

}