using System.Runtime.Versioning;

namespace System.Runtime.CompilerServices;

public static class Unsafe
{
	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public unsafe static T Read<T>(void* source)
	{
		return Unsafe.Read<T>(source);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public unsafe static T ReadUnaligned<T>(void* source)
	{
		return Unsafe.ReadUnaligned<T>(source);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public static T ReadUnaligned<T>(ref byte source)
	{
		return Unsafe.ReadUnaligned<T>(ref source);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public unsafe static void Write<T>(void* destination, T value)
	{
		Unsafe.Write(destination, value);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public unsafe static void WriteUnaligned<T>(void* destination, T value)
	{
		Unsafe.WriteUnaligned(destination, value);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public static void WriteUnaligned<T>(ref byte destination, T value)
	{
		Unsafe.WriteUnaligned(ref destination, value);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public unsafe static void Copy<T>(void* destination, ref T source)
	{
		Unsafe.Write(destination, source);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public unsafe static void Copy<T>(ref T destination, void* source)
	{
		destination = Unsafe.Read<T>(source);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public unsafe static void* AsPointer<T>(ref T value)
	{
		return Unsafe.AsPointer(ref value);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public static void SkipInit<T>(out T value)
	{
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public static int SizeOf<T>()
	{
		return Unsafe.SizeOf<T>();
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public unsafe static void CopyBlock(void* destination, void* source, uint byteCount)
	{
		// IL cpblk instruction
		Unsafe.CopyBlock(destination, source, byteCount);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public static void CopyBlock(ref byte destination, ref byte source, uint byteCount)
	{
		// IL cpblk instruction
		Unsafe.CopyBlock(ref destination, ref source, byteCount);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public unsafe static void CopyBlockUnaligned(void* destination, void* source, uint byteCount)
	{
		// IL cpblk instruction
		Unsafe.CopyBlockUnaligned(destination, source, byteCount);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public static void CopyBlockUnaligned(ref byte destination, ref byte source, uint byteCount)
	{
		// IL cpblk instruction
		Unsafe.CopyBlockUnaligned(ref destination, ref source, byteCount);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public unsafe static void InitBlock(void* startAddress, byte value, uint byteCount)
	{
		// IL initblk instruction
		Unsafe.InitBlock(startAddress, value, byteCount);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public static void InitBlock(ref byte startAddress, byte value, uint byteCount)
	{
		// IL initblk instruction
		Unsafe.InitBlock(ref startAddress, value, byteCount);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public unsafe static void InitBlockUnaligned(void* startAddress, byte value, uint byteCount)
	{
		// IL initblk instruction
		Unsafe.InitBlockUnaligned(startAddress, value, byteCount);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public static void InitBlockUnaligned(ref byte startAddress, byte value, uint byteCount)
	{
		// IL initblk instruction
		Unsafe.InitBlockUnaligned(ref startAddress, value, byteCount);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public static T As<T>(object o) where T : class
	{
		return (T)o;
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public unsafe static ref T AsRef<T>(void* source)
	{
		return ref *(T*)source;
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public static ref T AsRef<T>(in T source)
	{
		return ref source;
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public static ref TTo As<TFrom, TTo>(ref TFrom source)
	{
		return ref Unsafe.As<TFrom, TTo>(ref source);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public static ref T Unbox<T>(object box) where T : struct
	{
		return ref (T)box;
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public static ref T Add<T>(ref T source, int elementOffset)
	{
		return ref Unsafe.Add(ref source, elementOffset);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public unsafe static void* Add<T>(void* source, int elementOffset)
	{
		return (byte*)source + (nint)elementOffset * (nint)Unsafe.SizeOf<T>();
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public static ref T Add<T>(ref T source, IntPtr elementOffset)
	{
		return ref Unsafe.Add(ref source, elementOffset);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	public static ref T Add<T>(ref T source, [System.Runtime.Versioning.NonVersionable] nuint elementOffset)
	{
		return ref Unsafe.Add(ref source, elementOffset);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public static ref T AddByteOffset<T>(ref T source, IntPtr byteOffset)
	{
		return ref Unsafe.AddByteOffset(ref source, byteOffset);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	public static ref T AddByteOffset<T>(ref T source, [System.Runtime.Versioning.NonVersionable] nuint byteOffset)
	{
		return ref Unsafe.AddByteOffset(ref source, byteOffset);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public static ref T Subtract<T>(ref T source, int elementOffset)
	{
		return ref Unsafe.Subtract(ref source, elementOffset);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public unsafe static void* Subtract<T>(void* source, int elementOffset)
	{
		return (byte*)source - (nint)elementOffset * (nint)Unsafe.SizeOf<T>();
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public static ref T Subtract<T>(ref T source, IntPtr elementOffset)
	{
		return ref Unsafe.Subtract(ref source, elementOffset);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	public static ref T Subtract<T>(ref T source, [System.Runtime.Versioning.NonVersionable] nuint elementOffset)
	{
		return ref Unsafe.Subtract(ref source, elementOffset);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public static ref T SubtractByteOffset<T>(ref T source, IntPtr byteOffset)
	{
		return ref Unsafe.SubtractByteOffset(ref source, byteOffset);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	public static ref T SubtractByteOffset<T>(ref T source, [System.Runtime.Versioning.NonVersionable] nuint byteOffset)
	{
		return ref Unsafe.SubtractByteOffset(ref source, byteOffset);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public static IntPtr ByteOffset<T>(ref T origin, ref T target)
	{
		return Unsafe.ByteOffset(target: ref target, origin: ref origin);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public static bool AreSame<T>(ref T left, ref T right)
	{
		return Unsafe.AreSame(ref left, ref right);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public static bool IsAddressGreaterThan<T>(ref T left, ref T right)
	{
		return Unsafe.IsAddressGreaterThan(ref left, ref right);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public static bool IsAddressLessThan<T>(ref T left, ref T right)
	{
		return Unsafe.IsAddressLessThan(ref left, ref right);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public unsafe static bool IsNullRef<T>(ref T source)
	{
		return Unsafe.AsPointer(ref source) == null;
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	[System.Runtime.Versioning.NonVersionable]
	public unsafe static ref T NullRef<T>()
	{
		return ref *(T*)null;
	}
}