using WhiteMagic.Assembly;

namespace WhiteMagicTest;

/// <summary>
/// Tests for <see cref="StubAssembler"/> emit primitives (<see cref="StubAssembler.EmitU8"/>,
/// <see cref="StubAssembler.EmitU32"/>, <see cref="StubAssembler.EmitU64"/>) and
/// calling-convention stub encoding.
/// </summary>
public class StubAssemblerTests
{
    private static StubAssembler Create() => new();

    // ── Emit primitives ────────────────────────────────────────────────────

    [Fact]
    public void EmitU8_appends_a_single_byte()
    {
        var sut = Create();
        var buffer = new List<byte>();
        sut.EmitU8(buffer, 0xAB);
        Assert.Equal([0xAB], buffer);
    }

    [Fact]
    public void EmitU32_appends_little_endian()
    {
        var sut = Create();
        var buffer = new List<byte>();
        sut.EmitU32(buffer, 0x11223344);
        Assert.Equal([0x44, 0x33, 0x22, 0x11], buffer);
    }

    [Fact]
    public void EmitU32_appends_zero()
    {
        var sut = Create();
        var buffer = new List<byte>();
        sut.EmitU32(buffer, 0);
        Assert.Equal([0x00, 0x00, 0x00, 0x00], buffer);
    }

    [Fact]
    public void EmitU64_appends_little_endian()
    {
        var sut = Create();
        var buffer = new List<byte>();
        sut.EmitU64(buffer, 0x1122334455667788);
        byte[] expected = [0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11];
        Assert.Equal(expected, buffer);
    }

    [Fact]
    public void EmitU64_appends_high_bits()
    {
        var sut = Create();
        var buffer = new List<byte>();
        sut.EmitU64(buffer, 0xDEADBEEF_CAFEBABE);
        byte[] expected = [0xBE, 0xBA, 0xFE, 0xCA, 0xEF, 0xBE, 0xAD, 0xDE];
        Assert.Equal(expected, buffer);
    }

    // ── IAssembler interface ───────────────────────────────────────────────

    [Fact]
    public void StubAssembler_is_an_IAssembler()
    {
        var sut = Create();
        Assert.IsAssignableFrom<IAssembler>(sut);
    }

    [Fact]
    public void Assemble_from_StubAssembler_throws_NotSupported()
    {
        var sut = Create();
        Assert.Throws<NotSupportedException>(() => sut.Assemble("nop", 0));
    }

    // ── Calling convention: x86 cdecl ──────────────────────────────────────

    [Fact]
    public void Cdecl_stub_with_zero_args_is_call_then_ret()
    {
        var sut = Create();
        IntPtr stubAddr = (IntPtr)0x10000000;
        IntPtr target = (IntPtr)0x12345678;
        uint[] args = [];

        uint rel32 = (uint)target - ((uint)stubAddr + 5);
        byte[] stub = sut.BuildCallStub(stubAddr, target, args, 4, CallingConvention.Cdecl);

        Assert.Equal(6, stub.Length);
        Assert.Equal(0xE8, stub[0]);                           // call
        Assert.Equal(rel32, BitConverter.ToUInt32(stub, 1));   // rel32
        Assert.Equal(0xC3, stub[5]);                           // ret
    }

    [Fact]
    public void Cdecl_stub_one_arg_reverse_push_then_call_then_cleanup()
    {
        var sut = Create();
        IntPtr stubAddr = (IntPtr)0x10000000;
        IntPtr target = (IntPtr)0x12345678;
        uint[] args = [0xAABBCCDD];

        uint callAddr = (uint)stubAddr + 5;
        uint rel32 = (uint)target - (callAddr + 5);
        byte[] stub = sut.BuildCallStub(stubAddr, target, args, 4, CallingConvention.Cdecl);

        byte[] expected = [
            0x68, 0xDD, 0xCC, 0xBB, 0xAA, // push 0xAABBCCDD
            0xE8,
            (byte)rel32, (byte)(rel32 >> 8), (byte)(rel32 >> 16), (byte)(rel32 >> 24),
            0x83, 0xC4, 0x04,              // add esp, 4
            0xC3                            // ret
        ];
        Assert.Equal(expected, stub);
    }

    [Fact]
    public void Cdecl_stub_two_args_reverse_order()
    {
        var sut = Create();
        IntPtr stubAddr = (IntPtr)0x10000000;
        IntPtr target = (IntPtr)0x12345678;
        uint[] args = [0x11111111, 0x22222222];

        uint callAddr = (uint)stubAddr + 10;
        uint rel32 = (uint)target - (callAddr + 5);
        byte[] stub = sut.BuildCallStub(stubAddr, target, args, 4, CallingConvention.Cdecl);

        byte[] expected = [
            0x68, 0x22, 0x22, 0x22, 0x22, // push arg1 (reverse order)
            0x68, 0x11, 0x11, 0x11, 0x11, // push arg0
            0xE8,
            (byte)rel32, (byte)(rel32 >> 8), (byte)(rel32 >> 16), (byte)(rel32 >> 24),
            0x83, 0xC4, 0x08,              // add esp, 8
            0xC3
        ];
        Assert.Equal(expected, stub);
    }
}