using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Configs;
using BenchmarkDotNet.Diagnosers;
using BenchmarkDotNet.Exporters;
using BenchmarkDotNet.Jobs;
using BenchmarkDotNet.Running;
using System;
using System.Runtime.CompilerServices;
using System.Text;

class Program
{
    static void Main(string[] args)
    {
        var switcher = new BenchmarkSwitcher(new[]
        {
            typeof(StandardBenchmark)
        });

        args = new string[] { "0" };

#if DEBUG
        var b = new StandardBenchmark();
#else
        switcher.Run(args);
#endif
    }
}

public class BenchmarkConfig : ManualConfig
{
    public BenchmarkConfig()
    {
        Add(MarkdownExporter.GitHub);
        Add(MemoryDiagnoser.Default);

        Add(Job.RyuJitX64.WithWarmupCount(1).WithLaunchCount(1).WithTargetCount(1),
            Job.LegacyJitX86.WithWarmupCount(1).WithLaunchCount(1).WithTargetCount(1));
    }
}

[Config(typeof(BenchmarkConfig))]
public class StandardBenchmark
{
    byte[] bytes = Encoding.UTF8.GetBytes("MyProperty1");
    byte[] to;

    public StandardBenchmark()
    {
        to = new byte[bytes.Length];
    }

    [Benchmark]
    public void ArrayCopy()
    {
        Array.Copy(bytes, 0, to, 0, to.Length);
    }

    [Benchmark(Baseline = true)]
    public void BlockCopy()
    {
        Buffer.BlockCopy(bytes, 0, to, 0, to.Length);
    }

    [Benchmark]
    public unsafe void MemoryCopy()
    {
        fixed (void* s = &bytes[0])
        fixed (void* p = &to[0])
        {
            Buffer.MemoryCopy(s, p, bytes.Length, to.Length);
        }
    }

    [Benchmark]
    public unsafe void UnsafeSimple()
    {
        fixed (byte* s = &bytes[0])
        fixed (byte* p = &to[0])
        {
            UnsafeUtility.ByteCopy(s, p, to.Length);
        }
    }

    [Benchmark]
    public unsafe void UnsafeBlock()
    {
        fixed (byte* s = &bytes[0])
        fixed (byte* p = &to[0])
        {
            UnsafeUtility.LongCopy(s, p, to.Length);
        }
    }

    [Benchmark]
    public unsafe void UnsafeOptimized()
    {
        fixed (byte* s = &bytes[0])
        fixed (byte* p = &to[0])
        {
            UnsafeUtility.Copy11(s, p);
        }
    }

    [Benchmark]
    public unsafe void CopyBlock()
    {
        fixed (void* s = &bytes[0])
        fixed (void* p = &to[0])
        {
            Unsafe.CopyBlock(p, s, (uint)bytes.Length);
        }
    }

    [Benchmark]
    public unsafe void CopyBlockUnaligned()
    {
        fixed (void* s = &bytes[0])
        fixed (void* p = &to[0])
        {
            Unsafe.CopyBlockUnaligned(p, s, (uint)bytes.Length);
        }
    }
}

public unsafe static class UnsafeUtility
{
    public static unsafe void ByteCopy(byte* src, byte* dst, int count)
    {
        for (int i = 0; i < count; i++)
        {
            *dst = *src;
            src++;
            dst++;
        }
    }

    public static unsafe void LongCopy(byte* src, byte* dst, int count)
    {
        while (count >= 8)
        {
            *(ulong*)dst = *(ulong*)src;
            dst += 8;
            src += 8;
            count -= 8;
        }
        if (count >= 4)
        {
            *(uint*)dst = *(uint*)src;
            dst += 4;
            src += 4;
            count -= 4;
        }
        if (count >= 2)
        {
            *(ushort*)dst = *(ushort*)src;
            dst += 2;
            src += 2;
            count -= 2;
        }
        if (count >= 1)
        {
            *dst = *src;
        }
    }

    // Optimized for count

    public static unsafe void Copy11(byte* src, byte* dst)
    {
        // 11 - 8 = 3
        *(ulong*)dst = *(ulong*)src;
        dst += 8;
        src += 8;

        // 3 - 2 = 1
        *(ushort*)dst = *(ushort*)src;
        dst += 2;
        src += 2;

        // 1 - 1 = 0
        *dst = *src;
    }
}