// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

// ============================================= THIS FILE IS AUTOGENERATED ============================================
// =============================== Please make any edits in eng/pointergen/Generator.cs! ===============================
// ============================================= THIS FILE IS AUTOGENERATED ============================================

using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;

namespace Silk.NET.Core;

/// <summary>
/// A single dimension pointer wrapper
/// </summary>
public readonly ref struct MUT
{
    /// <summary>
    /// Creates a pointer with the given underlying ref.
    /// </summary>
    /// <param name="Ref">The underlying ref.</param>
    public MUT(ref byte @Ref)
    {
        this.Ref = ref @Ref;
    }

    /// <summary>
    /// The underlying reference.
    /// </summary>
    public readonly ref byte Ref;

    /// <summary>
    /// Gets the item at the given offset from this pointer.
    /// </summary>
    /// <param name="index">The index.</param>
    public ref byte this[nuint index]
    {
        [MethodImpl(
        MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization
    )]
        get => ref Unsafe.Add(ref Ref, index);
    }

    /// <summary>
    /// Creates a string from this <see cref="MUT"/> as a c-style string
    /// </summary>
    /// <returns>the string</returns>
    public unsafe string ReadToString()
    {
        int len = 0;

        byte* ptr = (byte*)Unsafe.AsPointer(ref Ref);
        while (*ptr != 0 && len != int.MaxValue)
        {
            ptr++;
            len++;
        }

        return ReadToString(len);
    }

    /// <summary>
    /// Creates a string from this <see cref="MUT"/> with the given length
    /// </summary>
    /// <param name="length">length of the string</param>
    /// <returns>the string</returns>
    public unsafe string ReadToString(int length) => Encoding.UTF8.GetString(AsSpan(length));

    /// <summary>
    /// Gets the underlying reference.
    /// </summary>
    /// <returns>The underlying reference.</returns>
    /// <remarks>
    /// This function allows a <see cref="MUT"/> to be used in a <c>fixed</c> statement.
    /// </remarks>
    public ref byte GetPinnableReference() => ref Ref;

    /// <summary>
    /// Creates a span with the given length from this pointer.
    /// </summary>
    /// <param name="length">the span length</param>
    /// <returns>the span</returns>
    public ReadOnlySpan<byte> AsSpan(int length) => MemoryMarshal.CreateReadOnlySpan(ref Ref, length);

    /// <summary>
    /// Determines if this <see cref="MUT"/> equals another object
    /// </summary>
    /// <param name="obj"></param>
    /// <returns>Whether this object is the same as </returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
    public override bool Equals([NotNullWhen(true)] object? obj) => this == obj;

    /// <inheritdoc />
    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
    public override int GetHashCode() => Ref.GetHashCode();

    /// <summary>
    /// Determines if two <see cref="MUT"/> objects are equivalent
    /// </summary>
    /// <param name="lh"></param>
    /// <param name="rh"></param>
    /// <returns>Whether the pointers are equal</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
    public unsafe static bool operator ==(MUT lh, MUT rh) => (void*)lh == (void*)rh;

    /// <summary>
    /// Determines if two <see cref="MUT"/> objects are not equivalent
    /// </summary>
    /// <param name="lh"></param>
    /// <param name="rh"></param>
    /// <returns>Whether the pointers are not equal</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
    public unsafe static bool operator !=(MUT lh, MUT rh) => (void*)lh != (void*)rh;

    /// <summary>
    /// Determines whether a pointer and an object are equal
    /// </summary>
    /// <param name="lh"></param>
    /// <param name="rh"></param>
    /// <returns>Whether the pointer and object are equal</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
    public unsafe static bool operator ==(MUT lh, object? rh) => rh == null ? (void*)lh == null : false;

    /// <summary>
    /// Determines whether a pointer and an object are not equal
    /// </summary>
    /// <param name="lh"></param>
    /// <param name="rh"></param>
    /// <returns>Whether the pointer and object are not equal</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
    public unsafe static bool operator !=(MUT lh, object? rh) => rh == null ? (void*)lh != null : true;

    /// <summary>
    /// Determines whether an object and a pointer are equal
    /// </summary>
    /// <param name="lh"></param>
    /// <param name="rh"></param>
    /// <returns>Whether the object and pointer are equal</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
    public unsafe static bool operator ==(object? lh, MUT rh) => lh == null ? (void*)rh == null : false;

    /// <summary>
    /// Determines whether an object and a pointer are not equal
    /// </summary>
    /// <param name="lh"></param>
    /// <param name="rh"></param>
    /// <returns>Whether the object and pointer are not equal</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
    public unsafe static bool operator !=(object? lh, MUT rh) => lh == null ? (void*)rh != null : true;

    /// <summary>
    /// Creates a <see cref="MUT"/> from a Nullptr
    /// </summary>
    /// <param name="ptr"></param>
    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
    public unsafe static implicit operator MUT(NullPtr ptr) => (void*)ptr;

    /// <summary>
    /// Determines whether a <see cref="MUT"/> and a NullPtr are equal
    /// </summary>
    /// <param name="lh"></param>
    /// <param name="rh"></param>
    /// <returns>Whether the <see cref="MUT"/> and NullPtr are equal</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
    public static bool operator ==(MUT lh, NullPtr rh) => lh == (MUT)rh;

    /// <summary>
    /// Determines whether a <see cref="MUT"/> and a NullPtr are not equal
    /// </summary>
    /// <param name="lh"></param>
    /// <param name="rh"></param>
    /// <returns>Whether the <see cref="MUT"/> and NullPtr are not equal</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
    public static bool operator !=(MUT lh, NullPtr rh) => lh != (MUT)rh;

    /// <summary>
    /// Determines whether a NullPtr and a <see cref="MUT"/> are equal
    /// </summary>
    /// <param name="lh"></param>
    /// <param name="rh"></param>
    /// <returns>Whether the NullPtr and <see cref="MUT"/> are equal</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
    public static bool operator ==(NullPtr lh, MUT rh) => (MUT)lh == rh;

    /// <summary>
    /// Determines whether a NullPtr and a <see cref="MUT"/> are not equal
    /// </summary>
    /// <param name="lh"></param>
    /// <param name="rh"></param>
    /// <returns>Whether the NullPtr and <see cref="MUT"/> are not equal</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
    public static bool operator !=(NullPtr lh, MUT rh) => (MUT)lh != rh;

    /// <summary>
    /// Creates a <see cref="MUT"/> from a span
    /// </summary>
    /// <param name="span"></param>
    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
    public static implicit operator MUT(Span<byte> span) => new(ref span.GetPinnableReference());

    /// <summary>
    /// Creates a <see cref="MUT"/> from a ReadOnlySpan
    /// </summary>
    /// <param name="span"></param>
    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
    public static implicit operator MUT(ReadOnlySpan<byte> span) => new(in span.GetPinnableReference());

    /// <summary>
    /// Creates a <see cref="MUT"/> from a byte pointer
    /// </summary>
    /// <param name="ptr"></param>
    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
    public unsafe static implicit operator MUT(byte* ptr) => new(in Unsafe.AsRef<byte>(ptr));

    /// <summary>
    /// Creates a <see cref="MUT"/> from a void pointer
    /// </summary>
    /// <param name="ptr"></param>
    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
    public unsafe static implicit operator MUT(void* ptr) => new(in Unsafe.AsRef<byte>(ptr));

    /// <summary>
    /// Creates a byte pointer from a <see cref="MUT"/>
    /// </summary>
    /// <param name="ptr"></param>
    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
    public unsafe static implicit operator byte*(MUT ptr) => (byte*)Unsafe.AsPointer(ref ptr.Ref);

    /// <summary>
    /// Creates a void pointer from a <see cref="MUT"/>
    /// </summary>
    /// <param name="ptr"></param>
    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
    public unsafe static implicit operator void*(MUT ptr) => Unsafe.AsPointer(ref ptr.Ref);

    /// <summary>
    /// Creates a string from a <see cref="MUT"/>
    /// </summary>
    /// <param name="ptr"></param>
    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
    public static explicit operator string(MUT ptr) => ptr.ReadToString();

    /// <summary>
    /// creates a <see cref="MUT"/> from an array
    /// </summary>
    /// <param name="array"></param>
    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
    public static implicit operator MUT(byte[] array) => array.AsSpan();

    /// <summary>
    /// creates a <see cref="MUT"/> from a 2D array
    /// </summary>
    /// <param name="array"></param>
    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
    public static implicit operator MUT(byte[,] array) => MemoryMarshal.CreateSpan(ref array[0, 0], array.Length);

    /// <summary>
    /// creates a <see cref="MUT"/> from a 3D array
    /// </summary>
    /// <param name="array"></param>
    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
    public static implicit operator MUT(byte[,,] array) => MemoryMarshal.CreateSpan(ref array[0, 0, 0], array.Length);
}