using UnityEngine;

using Unity.Mathematics;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;


public static class ExtensionMethods_NativeArray
{

    public unsafe static NativeArray<DST> GetNativeArray <SRC,DST> ( this SRC[] source ) where SRC : unmanaged where DST : unmanaged
	{
        //ASSERTION: sizeof(SRC)==sizeof(DST)

		// create a destination NativeArray to hold the vertices
		var nativeArray = new NativeArray<DST>( source.Length , Allocator.Persistent , NativeArrayOptions.UninitializedMemory );

		// pin the mesh's vertex buffer in place...
		fixed( void* bufferPointer = source)
		{
			// ...and use memcpy to copy the Vector3[] into a NativeArray<floar3> without casting. whould be fast!
			UnsafeUtility.MemCpy(
                NativeArrayUnsafeUtility.GetUnsafeBufferPointerWithoutChecks(nativeArray) ,
				bufferPointer ,
                source.Length * (long)UnsafeUtility.SizeOf<SRC>()
            );
		}
		// we only hve to fix the .net array in place, the NativeArray is allocated in the C++ side of the engine and
		// wont move arround unexpectedly. We have a pointer to it not a reference! thats basically what fixed does,
		// we create a scope where its 'safe' to get a pointer and directly manipulate the array

		return nativeArray;
	}
    public unsafe static NativeArray<T> GetNativeArray <T> ( this T[] source ) where T : unmanaged
	{
		// create a destination NativeArray to hold the vertices
		var nativeArray = new NativeArray<T>( source.Length , Allocator.Persistent , NativeArrayOptions.UninitializedMemory );

		// pin the mesh's vertex buffer in place...
		fixed( void* bufferPointer = source)
		{
			// ...and use memcpy to copy the Vector3[] into a NativeArray<floar3> without casting. whould be fast!
			UnsafeUtility.MemCpy(
                NativeArrayUnsafeUtility.GetUnsafeBufferPointerWithoutChecks(nativeArray) ,
				bufferPointer ,
                source.Length * (long)UnsafeUtility.SizeOf<T>()
            );
		}
		// we only hve to fix the .net array in place, the NativeArray is allocated in the C++ side of the engine and
		// wont move arround unexpectedly. We have a pointer to it not a reference! thats basically what fixed does,
		// we create a scope where its 'safe' to get a pointer and directly manipulate the array

		return nativeArray;
	}
	public unsafe static NativeArray<float3> GetNativeArray ( this Vector3[] source )
	{
		NativeArray<float3> verts = new NativeArray<float3>( source.Length , Allocator.Persistent , NativeArrayOptions.UninitializedMemory );
		fixed( void* vertexBufferPointer = source)
		{
			UnsafeUtility.MemCpy(
                NativeArrayUnsafeUtility.GetUnsafeBufferPointerWithoutChecks(verts) ,
				vertexBufferPointer ,
                source.Length * (long)UnsafeUtility.SizeOf<float3>()
            );
		}
		return verts;
	}
	public unsafe static NativeArray<int> GetNativeArray ( this int[] source )
	{
		NativeArray<int> verts = new NativeArray<int>(source.Length, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);

		fixed( void* vertexBufferPointer = source )
		{
			UnsafeUtility.MemCpy(
                NativeArrayUnsafeUtility.GetUnsafeBufferPointerWithoutChecks(verts) ,
				vertexBufferPointer ,
                source.Length * (long)UnsafeUtility.SizeOf<int>()
            );
		}
		return verts;
	}
	public unsafe static NativeArray<float2> GetNativeArray ( this Vector2[] source )
	{
		NativeArray<float2> verts = new NativeArray<float2>( source.Length , Allocator.Persistent , NativeArrayOptions.UninitializedMemory );

		fixed( void* vertexBufferPointer = source )
		{
			UnsafeUtility.MemCpy(
                NativeArrayUnsafeUtility.GetUnsafeBufferPointerWithoutChecks(verts) ,
				vertexBufferPointer ,
                source.Length * (long)UnsafeUtility.SizeOf<float2>()
            );
		}
		return verts;
	}
	public unsafe static NativeArray<float4> GetNativeArray ( this Vector4[] source )
	{
		NativeArray<float4> verts = new NativeArray<float4>( source.Length , Allocator.Persistent , NativeArrayOptions.UninitializedMemory );

		fixed( void* vertexBufferPointer = source )
		{
			UnsafeUtility.MemCpy(
                NativeArrayUnsafeUtility.GetUnsafeBufferPointerWithoutChecks(verts) ,
				vertexBufferPointer ,
                source.Length * (long)UnsafeUtility.SizeOf<float4>()
            );
		}
		return verts;
	}

    public unsafe static void MemCpy <SRC,DST> ( this NativeArray<SRC> source , DST[] target ) where SRC : unmanaged where DST : unmanaged
	{
        //ASSERTION: sizeof(SRC)==sizeof(DST)
		fixed( void* arrayPointer = target )
		{
			UnsafeUtility.MemCpy(
                arrayPointer ,
				NativeArrayUnsafeUtility.GetUnsafeBufferPointerWithoutChecks(source) ,
				target.Length * (long)UnsafeUtility.SizeOf<SRC>()
            );
		}
	}

    public unsafe static void MemCpy <SRC,DST> ( this SRC[] src , NativeArray<DST> dst ) where SRC : unmanaged where DST : unmanaged
	{
        //ASSERTION: sizeof(SRC)==sizeof(DST)
        //ASSERTION: dst.IsCreated==true
		fixed( void* bufferPointer = src )
		{
			UnsafeUtility.MemCpy(
                NativeArrayUnsafeUtility.GetUnsafeBufferPointerWithoutChecks(dst) ,
				bufferPointer ,
                src.Length * (long)UnsafeUtility.SizeOf<SRC>()
            );
		}
	}

}