using AcDream.Core.Net.Cryptography;

namespace AcDream.Core.Net.Tests.Cryptography;

public class Hash32Tests
{
    [Fact]
    public void Calculate_EmptyInput_ReturnsZero()
    {
        Assert.Equal(0u, Hash32.Calculate(ReadOnlySpan<byte>.Empty));
    }

    [Fact]
    public void Calculate_FourBytes_HandComputedValue()
    {
        // length=4 → seed = 4 << 16 = 0x00040000
        // word = LE(0x01,0x02,0x03,0x04) = 0x04030201
        // checksum = 0x00040000 + 0x04030201 = 0x04070201
        var data = new byte[] { 0x01, 0x02, 0x03, 0x04 };
        Assert.Equal(0x04070201u, Hash32.Calculate(data));
    }

    [Fact]
    public void Calculate_FiveBytes_TailByteGoesToHighNibble()
    {
        // length=5 → seed = 0x00050000
        // word0 = LE(0xAA,0xBB,0xCC,0xDD) = 0xDDCCBBAA
        // checksum after word = 0x00050000 + 0xDDCCBBAA = 0xDDD1BBAA
        // tail byte: data[4]=0xEE << 24 = 0xEE000000
        // checksum += 0xEE000000 → 0xDDD1BBAA + 0xEE000000 = 0xCBD1BBAA (wrap)
        var data = new byte[] { 0xAA, 0xBB, 0xCC, 0xDD, 0xEE };
        Assert.Equal(0xCBD1BBAAu, Hash32.Calculate(data));
    }

    [Fact]
    public void Calculate_SingleTailByte_ShiftsInto24()
    {
        // length=1 → seed = 0x00010000
        // tail: 0x42 << 24 = 0x42000000
        // checksum = 0x42010000
        var data = new byte[] { 0x42 };
        Assert.Equal(0x42010000u, Hash32.Calculate(data));
    }

    [Fact]
    public void Calculate_TwoTailBytes_ShiftInto24And16()
    {
        // length=2 → seed = 0x00020000
        // tail0 (0x42) << 24 = 0x42000000
        // tail1 (0x7F) << 16 = 0x007F0000
        // total = 0x42020000 + 0x007F0000 = 0x42810000
        // Wait — order matters. First tail byte shifts by 24 (most significant),
        // second by 16. So: seed + 0x42000000 + 0x007F0000 = 0x42810000
        var data = new byte[] { 0x42, 0x7F };
        Assert.Equal(0x42810000u, Hash32.Calculate(data));
    }

    [Fact]
    public void Calculate_ThreeTailBytes_ShiftInto24And16And8()
    {
        // length=3 → seed = 0x00030000
        // tail bytes (0x01, 0x02, 0x03) shifted by 24, 16, 8 respectively:
        //   0x01000000 + 0x00020000 + 0x00000300 = 0x01020300
        // total = 0x00030000 + 0x01020300 = 0x01050300
        var data = new byte[] { 0x01, 0x02, 0x03 };
        Assert.Equal(0x01050300u, Hash32.Calculate(data));
    }

    [Fact]
    public void Calculate_IsDeterministic()
    {
        var data = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        Assert.Equal(Hash32.Calculate(data), Hash32.Calculate(data));
    }
}