using System.Runtime.CompilerServices;
using System.Security.Cryptography;

namespace NewLife.Security;

/// <summary>高性能低碰撞Murmur128哈希算法</summary>
/// <remarks>
/// Redis等大量使用，比MD5要好
/// </remarks>
public class Murmur128 : HashAlgorithm
{
    #region 属性
    const UInt64 C1 = 0x87c37b91114253d5;
    const UInt64 C2 = 0x4cf5ad432745937f;

    private readonly UInt32 _Seed;
    /// <summary>种子</summary>
    public UInt32 Seed => _Seed;

    /// <summary>哈希大小</summary>
    public override Int32 HashSize => 128;

    private Int32 _Length;
    private UInt64 _H1;
    private UInt64 _H2;
    #endregion

    #region 构造
    /// <summary>实例化</summary>
    /// <param name="seed"></param>
    public Murmur128(UInt32 seed = 0)
    {
        _Seed = seed;
        Reset();
    }
    #endregion

    #region 方法
    private void Reset()
    {
        // 初始化哈希值到种子
        _H1 = _H2 = Seed;

        // 重置长度为0
        _Length = 0;
    }

    /// <summary>初始化</summary>
    public override void Initialize() => Reset();

    /// <summary>哈希核心</summary>
    /// <param name="array"></param>
    /// <param name="ibStart"></param>
    /// <param name="cbSize"></param>
    protected override void HashCore(Byte[] array, Int32 ibStart, Int32 cbSize)
    {
        // 增加长度
        _Length += cbSize;
        Body(array, ibStart, cbSize);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private void Body(Byte[] data, Int32 start, Int32 length)
    {
        var remainder = length & 15;
        var alignedLength = start + (length - remainder);
        for (var i = start; i < alignedLength; i += 16)
        {
            _H1 ^= RotateLeft(data.ToUInt64(i) * C1, 31) * C2;
            _H1 = (RotateLeft(_H1, 27) + _H2) * 5 + 0x52dce729;

            _H2 ^= RotateLeft(data.ToUInt64(i + 8) * C2, 33) * C1;
            _H2 = (RotateLeft(_H2, 31) + _H1) * 5 + 0x38495ab5;
        }

        if (remainder > 0)
            Tail(data, alignedLength, remainder);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private void Tail(Byte[] tail, Int32 start, Int32 remaining)
    {
        // create our keys and initialize to 0
        UInt64 k1 = 0, k2 = 0;

        // determine how many bytes we have left to work with based on length
        switch (remaining)
        {
            case 15: k2 ^= (UInt64)tail[start + 14] << 48; goto case 14;
            case 14: k2 ^= (UInt64)tail[start + 13] << 40; goto case 13;
            case 13: k2 ^= (UInt64)tail[start + 12] << 32; goto case 12;
            case 12: k2 ^= (UInt64)tail[start + 11] << 24; goto case 11;
            case 11: k2 ^= (UInt64)tail[start + 10] << 16; goto case 10;
            case 10: k2 ^= (UInt64)tail[start + 9] << 8; goto case 9;
            case 9: k2 ^= (UInt64)tail[start + 8] << 0; goto case 8;
            case 8: k1 ^= (UInt64)tail[start + 7] << 56; goto case 7;
            case 7: k1 ^= (UInt64)tail[start + 6] << 48; goto case 6;
            case 6: k1 ^= (UInt64)tail[start + 5] << 40; goto case 5;
            case 5: k1 ^= (UInt64)tail[start + 4] << 32; goto case 4;
            case 4: k1 ^= (UInt64)tail[start + 3] << 24; goto case 3;
            case 3: k1 ^= (UInt64)tail[start + 2] << 16; goto case 2;
            case 2: k1 ^= (UInt64)tail[start + 1] << 8; goto case 1;
            case 1: k1 ^= (UInt64)tail[start] << 0; break;
        }

        _H2 ^= RotateLeft(k2 * C2, 33) * C1;
        _H1 ^= RotateLeft(k1 * C1, 31) * C2;
    }

    /// <summary>哈希结束</summary>
    /// <returns></returns>
    protected override Byte[] HashFinal()
    {
        var len = (UInt64)_Length;
        _H1 ^= len; _H2 ^= len;

        _H1 += _H2;
        _H2 += _H1;

        _H1 = FMix(_H1);
        _H2 = FMix(_H2);

        _H1 += _H2;
        _H2 += _H1;

        var result = new Byte[16];
        Array.Copy(BitConverter.GetBytes(_H1), 0, result, 0, 8);
        Array.Copy(BitConverter.GetBytes(_H2), 0, result, 8, 8);

        return result;
    }
    #endregion

    #region 辅助
    //[MethodImpl(MethodImplOptions.AggressiveInlining)]
    //private static UInt32 RotateLeft(UInt32 x, Byte r) => (x << r) | (x >> (32 - r));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static UInt64 RotateLeft(UInt64 x, Byte r) => (x << r) | (x >> (64 - r));

    //[MethodImpl(MethodImplOptions.AggressiveInlining)]
    //private static UInt32 FMix(UInt32 h)
    //{
    //    h = (h ^ (h >> 16)) * 0x85ebca6b;
    //    h = (h ^ (h >> 13)) * 0xc2b2ae35;
    //    return h ^ (h >> 16);
    //}

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static UInt64 FMix(UInt64 h)
    {
        h = (h ^ (h >> 33)) * 0xff51afd7ed558ccd;
        h = (h ^ (h >> 33)) * 0xc4ceb9fe1a85ec53;

        return (h ^ (h >> 33));
    }
    #endregion
}