using System.Security.Cryptography;
using System.Text;
using NewLife.Security;
using Xunit;

namespace XUnitTest.Security;

/// <summary>Murmur128哈希算法测试</summary>
public class Murmur128Tests
{
    [Fact(DisplayName = "相同输入产生相同哈希")]
    public void SameInputSameHash()
    {
        var data = Encoding.UTF8.GetBytes("Hello, Murmur128!");
        using var hasher1 = new Murmur128();
        using var hasher2 = new Murmur128();

        var hash1 = hasher1.ComputeHash(data);
        var hash2 = hasher2.ComputeHash(data);

        Assert.Equal(hash1, hash2);
    }

    [Fact(DisplayName = "哈希输出为16字节")]
    public void HashSizeIs128Bits()
    {
        var data = Encoding.UTF8.GetBytes("test");
        using var hasher = new Murmur128();

        var hash = hasher.ComputeHash(data);

        Assert.Equal(16, hash.Length);
        Assert.Equal(128, hasher.HashSize);
    }

    [Fact(DisplayName = "不同输入产生不同哈希")]
    public void DifferentInputDifferentHash()
    {
        using var hasher = new Murmur128();
        var hash1 = hasher.ComputeHash(Encoding.UTF8.GetBytes("input1"));
        hasher.Initialize();
        var hash2 = hasher.ComputeHash(Encoding.UTF8.GetBytes("input2"));

        Assert.NotEqual(hash1, hash2);
    }

    [Fact(DisplayName = "不同种子产生不同哈希")]
    public void DifferentSeedDifferentHash()
    {
        var data = Encoding.UTF8.GetBytes("same data");
        using var hasher1 = new Murmur128(0);
        using var hasher2 = new Murmur128(42);

        var hash1 = hasher1.ComputeHash(data);
        var hash2 = hasher2.ComputeHash(data);

        Assert.NotEqual(hash1, hash2);
    }

    [Fact(DisplayName = "空数据可以哈希")]
    public void EmptyDataHash()
    {
        using var hasher = new Murmur128();
        var hash = hasher.ComputeHash([]);

        Assert.Equal(16, hash.Length);
    }

    [Fact(DisplayName = "种子属性正确")]
    public void SeedProperty()
    {
        using var hasher = new Murmur128(12345);
        Assert.Equal((UInt32)12345, hasher.Seed);
    }

    [Fact(DisplayName = "Initialize重置状态")]
    public void InitializeResetsState()
    {
        var data = Encoding.UTF8.GetBytes("test data for reset");
        using var hasher = new Murmur128();

        var hash1 = hasher.ComputeHash(data);
        hasher.Initialize();
        var hash2 = hasher.ComputeHash(data);

        Assert.Equal(hash1, hash2);
    }

    [Fact(DisplayName = "大数据块哈希")]
    public void LargeDataHash()
    {
        // 大于16字节触发多块处理
        var data = new Byte[1024];
        new Random(42).NextBytes(data);
        using var hasher = new Murmur128();

        var hash = hasher.ComputeHash(data);

        Assert.Equal(16, hash.Length);
    }

    [Theory(DisplayName = "不同长度数据哈希")]
    [InlineData(1)]
    [InlineData(7)]
    [InlineData(15)]
    [InlineData(16)]
    [InlineData(17)]
    [InlineData(31)]
    [InlineData(32)]
    [InlineData(33)]
    [InlineData(255)]
    public void VariousLengthHash(Int32 length)
    {
        var data = new Byte[length];
        new Random(42).NextBytes(data);
        using var hasher = new Murmur128();

        var hash = hasher.ComputeHash(data);

        Assert.Equal(16, hash.Length);
    }

    [Fact(DisplayName = "通过CryptoStream使用")]
    public void UseThroughCryptoStream()
    {
        var data = Encoding.UTF8.GetBytes("Stream hashing test data that is longer than 16 bytes");
        using var hasher = new Murmur128();
        using var ms = new MemoryStream(data);
        var hash = hasher.ComputeHash(ms);

        Assert.Equal(16, hash.Length);
    }

    [Fact(DisplayName = "TryComputeHash与ComputeHash结果一致")]
    public void TryComputeHashMatchesComputeHash()
    {
        var data = Encoding.UTF8.GetBytes("Hello, Murmur128! 中文测试");
        using var hasher = new Murmur128();

        var hash = hasher.ComputeHash(data);
        var destination = new Byte[16];
        var ok = hasher.TryComputeHash(data, destination, out var written);

        Assert.True(ok);
        Assert.Equal(16, written);
        Assert.Equal(hash, destination);
    }

    [Theory(DisplayName = "不同长度TryComputeHash")]
    [InlineData(0)]
    [InlineData(1)]
    [InlineData(7)]
    [InlineData(15)]
    [InlineData(16)]
    [InlineData(17)]
    [InlineData(31)]
    [InlineData(255)]
    public void TryComputeHashVariousLength(Int32 length)
    {
        var data = new Byte[length];
        new Random(42).NextBytes(data);
        using var hasher = new Murmur128();

        var hash = hasher.ComputeHash(data);
        var destination = new Byte[16];

        Assert.True(hasher.TryComputeHash(data, destination, out var written));
        Assert.Equal(16, written);
        Assert.Equal(hash, destination);
    }

    [Fact(DisplayName = "TryComputeHash目标缓冲区过短返回false")]
    public void TryComputeHashShortDestination()
    {
        var data = Encoding.UTF8.GetBytes("short");
        using var hasher = new Murmur128();

        var destination = new Byte[15];
        Assert.False(hasher.TryComputeHash(data, destination, out var written));
        Assert.Equal(0, written);
    }

    [Theory(DisplayName = "黄金值锁定：ComputeHash与TryComputeHash逐位一致")]
    [InlineData("Hello, Murmur128!", "73FB55DF3C6DC70907DC9511AAE43133")]
    [InlineData("test", "9DE1BD74CC287DAC824DBDF93182129A")]
    [InlineData("The quick brown fox jumps over the lazy dog", "6C1B07BC7BBC4BE347939AC4A93C437A")]
    [InlineData("", "00000000000000000000000000000000")]
    public void GoldenValue(String text, String expected)
    {
        var data = Encoding.UTF8.GetBytes(text);
        using var hasher = new Murmur128();

        var hash = hasher.ComputeHash(data);
        Assert.Equal(expected, BitConverter.ToString(hash).Replace("-", ""));

        var destination = new Byte[16];
        Assert.True(hasher.TryComputeHash(data, destination, out _));
        Assert.Equal(expected, BitConverter.ToString(destination).Replace("-", ""));
    }

    [Theory(DisplayName = "黄金值锁定：不同种子")]
    [InlineData(42, "abc", "D6F7CFB39F08850D303D35422B711075")]
    [InlineData(42, "The quick brown fox jumps over the lazy dog", "D7D50BFE93CF0D748F5C70ECF46C54C4")]
    public void GoldenValueWithSeed(UInt32 seed, String text, String expected)
    {
        var data = Encoding.UTF8.GetBytes(text);
        using var hasher = new Murmur128(seed);

        var hash = hasher.ComputeHash(data);
        Assert.Equal(expected, BitConverter.ToString(hash).Replace("-", ""));

        var destination = new Byte[16];
        Assert.True(hasher.TryComputeHash(data, destination, out _));
        Assert.Equal(expected, BitConverter.ToString(destination).Replace("-", ""));
    }

    [Theory(DisplayName = "黄金值锁定：边界长度（整块与多块）")]
    [InlineData(16, 0, "2AEC68238A535C02E747611F7F7FB619")]
    [InlineData(32, 0, "FBB9B47C18F61A89EC1B6A68E20F4797")]
    [InlineData(1000, 0, "69582F2DA1B8F3C3657689592067AF81")]
    [InlineData(1000, 42, "7EF3E7D5493B89DA40F1B9D41247FF6D")]
    public void GoldenValueByPattern(Int32 length, UInt32 seed, String expected)
    {
        var data = new Byte[length];
        for (var i = 0; i < data.Length; i++) data[i] = (Byte)(i * 131 + 17);

        using var hasher = new Murmur128(seed);

        var hash = hasher.ComputeHash(data);
        Assert.Equal(expected, BitConverter.ToString(hash).Replace("-", ""));

        var destination = new Byte[16];
        Assert.True(hasher.TryComputeHash(data, destination, out _));
        Assert.Equal(expected, BitConverter.ToString(destination).Replace("-", ""));
    }

    [Fact(DisplayName = "分块流式哈希与一次性哈希结果一致")]
    public void ChunkedHashMatchesOneShot()
    {
        var data = new Byte[100];
        for (var i = 0; i < data.Length; i++) data[i] = (Byte)(i * 131 + 17);

        using var one = new Murmur128();
        var hash1 = one.ComputeHash(data);

        // 用 TransformBlock 分块喂入，覆盖跨 16 字节边界的流式路径
        using var chunked = new Murmur128();
        var buf = new Byte[7];
        var offset = 0;
        while (offset < data.Length)
        {
            var len = Math.Min(buf.Length, data.Length - offset);
            Array.Copy(data, offset, buf, 0, len);
            chunked.TransformBlock(buf, 0, len, null, 0);
            offset += len;
        }
        chunked.TransformFinalBlock([], 0, 0);
        var hash2 = chunked.Hash!;

        Assert.Equal(hash1, hash2);
    }

    [Fact(DisplayName = "ComputeHash(Stream)与ComputeHash(数组)结果一致")]
    public void StreamHashMatchesArrayHash()
    {
        var data = new Byte[1000];
        for (var i = 0; i < data.Length; i++) data[i] = (Byte)(i * 131 + 17);

        using var one = new Murmur128();
        var hash1 = one.ComputeHash(data);

        using var ms = new MemoryStream(data);
        using var stream = new Murmur128();
        var hash2 = stream.ComputeHash(ms);

        Assert.Equal(hash1, hash2);
    }

    [Fact(DisplayName = "TryComputeHash短缓冲失败后重算正确")]
    public void TryComputeHashFailureThenRecover()
    {
        var data = Encoding.UTF8.GetBytes("failure recovery test data");

        using var hasher = new Murmur128();
        var shortBuf = new Byte[15];
        Assert.False(hasher.TryComputeHash(data, shortBuf, out var written));
        Assert.Equal(0, written);

        // 失败后重新初始化再算，结果应正确
        hasher.Initialize();
        var dest = new Byte[16];
        Assert.True(hasher.TryComputeHash(data, dest, out written));
        Assert.Equal(16, written);

        using var once = new Murmur128();
        var expected = once.ComputeHash(data);
        Assert.Equal(expected, dest);
    }
}