// Copyright (C) 2026 SharpEmu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later

using System.Buffers.Binary;
using SharpEmu.HLE;
using SharpEmu.Libs.Kernel;
using SharpEmu.Libs.LibcStdio;
using Xunit;

namespace SharpEmu.Libs.Tests.LibcStdio;

public sealed class LibcStdioExportsTests
{
    private const ulong BaseAddress = 0x1_0000_0000;
    private const ulong PathAddress = BaseAddress + 0x100;
    private const ulong ModeAddress = BaseAddress + 0x200;
    private const ulong PositionAddress = BaseAddress + 0x300;
    private const ulong DataAddress = BaseAddress + 0x400;
    private const ulong TlsAddress = BaseAddress + 0x800;
    private const ulong ErrnoAddress = TlsAddress + 0x40;

    [Fact]
    public void Fopen_RejectsEmptyPath()
    {
        var context = CreateContext(out var memory);
        memory.WriteCString(PathAddress, string.Empty);
        memory.WriteCString(ModeAddress, "rb");
        context[CpuRegister.Rdi] = PathAddress;
        context[CpuRegister.Rsi] = ModeAddress;

        var result = LibcStdioExports.Fopen(context);

        Assert.Equal((int)OrbisGen2Result.ORBIS_GEN2_ERROR_NOT_FOUND, result);
        Assert.Equal(0UL, context[CpuRegister.Rax]);
        Assert.Equal(2, ReadErrno(memory));
    }

    [Fact]
    public void Fopen_RejectsInvalidMode()
    {
        var context = CreateContext(out var memory);
        memory.WriteCString(PathAddress, "/app0/file.bin");
        memory.WriteCString(ModeAddress, "invalid");
        context[CpuRegister.Rdi] = PathAddress;
        context[CpuRegister.Rsi] = ModeAddress;

        var result = LibcStdioExports.Fopen(context);

        Assert.Equal((int)OrbisGen2Result.ORBIS_GEN2_ERROR_INVALID_ARGUMENT, result);
        Assert.Equal(0UL, context[CpuRegister.Rax]);
        Assert.Equal(22, ReadErrno(memory));
    }

    [Fact]
    public void Fopen_RejectsUnreadablePathPointer()
    {
        var context = CreateContext(out var memory);
        memory.WriteCString(ModeAddress, "rb");
        context[CpuRegister.Rdi] = BaseAddress + 0x2000;
        context[CpuRegister.Rsi] = ModeAddress;

        var result = LibcStdioExports.Fopen(context);

        Assert.Equal((int)OrbisGen2Result.ORBIS_GEN2_ERROR_MEMORY_FAULT, result);
        Assert.Equal(0UL, context[CpuRegister.Rax]);
        Assert.Equal(14, ReadErrno(memory));
    }

    [Fact]
    public void Fopen_UnresolvedGuestPathSetsEnoent()
    {
        var context = CreateContext(out var memory);
        memory.WriteCString(PathAddress, "/sharpemu-unregistered/file.bin");
        memory.WriteCString(ModeAddress, "rb");
        context[CpuRegister.Rdi] = PathAddress;
        context[CpuRegister.Rsi] = ModeAddress;

        var result = LibcStdioExports.Fopen(context);

        Assert.Equal((int)OrbisGen2Result.ORBIS_GEN2_ERROR_NOT_FOUND, result);
        Assert.Equal(0UL, context[CpuRegister.Rax]);
        Assert.Equal(2, ReadErrno(memory));
    }

    [Fact]
    public void Freopen_RejectsEmptyPath()
    {
        var context = CreateContext(out var memory);
        memory.WriteCString(PathAddress, string.Empty);
        memory.WriteCString(ModeAddress, "rb");
        context[CpuRegister.Rdi] = PathAddress;
        context[CpuRegister.Rsi] = ModeAddress;
        context[CpuRegister.Rdx] = 0x1234;

        var result = LibcStdioExports.Freopen(context);

        Assert.Equal((int)OrbisGen2Result.ORBIS_GEN2_ERROR_NOT_FOUND, result);
        Assert.Equal(0UL, context[CpuRegister.Rax]);
        Assert.Equal(2, ReadErrno(memory));
    }

    [Fact]
    public void Fgetpos_WritesSdkFposLayoutAndFileOffset()
    {
        var fixture = OpenTemporaryFile("rb", new byte[] { 1, 2, 3, 4, 5 });
        try
        {
            fixture.Context[CpuRegister.Rdi] = fixture.Handle;
            fixture.Context[CpuRegister.Rsi] = 0;
            fixture.Context[CpuRegister.Rdx] = 2;
            Assert.Equal((int)OrbisGen2Result.ORBIS_GEN2_OK, LibcStdioExports.Fseek(fixture.Context));

            fixture.Context[CpuRegister.Rdi] = fixture.Handle;
            fixture.Context[CpuRegister.Rsi] = PositionAddress;
            Assert.Equal((int)OrbisGen2Result.ORBIS_GEN2_OK, LibcStdioExports.Fgetpos(fixture.Context));

            Span<byte> position = stackalloc byte[24];
            Assert.True(fixture.Memory.TryRead(PositionAddress, position));
            Assert.Equal(5L, BinaryPrimitives.ReadInt64LittleEndian(position));
            Assert.True(position[8..].SequenceEqual(new byte[16]));
        }
        finally
        {
            fixture.Dispose();
        }
    }

    [Fact]
    public void Fsetpos_SeeksToSdkFposOffset()
    {
        var fixture = OpenTemporaryFile("rb", new byte[] { 10, 20, 30, 40 });
        try
        {
            Span<byte> position = stackalloc byte[24];
            position.Clear();
            BinaryPrimitives.WriteInt64LittleEndian(position, 2);
            Assert.True(fixture.Memory.TryWrite(PositionAddress, position));

            fixture.Context[CpuRegister.Rdi] = fixture.Handle;
            fixture.Context[CpuRegister.Rsi] = PositionAddress;
            Assert.Equal((int)OrbisGen2Result.ORBIS_GEN2_OK, LibcStdioExports.Fsetpos(fixture.Context));

            fixture.Context[CpuRegister.Rdi] = DataAddress;
            fixture.Context[CpuRegister.Rsi] = 1;
            fixture.Context[CpuRegister.Rdx] = 2;
            fixture.Context[CpuRegister.Rcx] = fixture.Handle;
            Assert.Equal((int)OrbisGen2Result.ORBIS_GEN2_OK, LibcStdioExports.Fread(fixture.Context));

            Span<byte> bytes = stackalloc byte[2];
            Assert.True(fixture.Memory.TryRead(DataAddress, bytes));
            Assert.True(bytes.SequenceEqual(new byte[] { 30, 40 }));
        }
        finally
        {
            fixture.Dispose();
        }
    }

    [Fact]
    public void Fgetpos_RejectsUnwritablePosition()
    {
        var fixture = OpenTemporaryFile("rb", new byte[] { 1 });
        try
        {
            fixture.Context[CpuRegister.Rdi] = fixture.Handle;
            fixture.Context[CpuRegister.Rsi] = 0x7FFF_FFFF_FFFF_F000;

            var result = LibcStdioExports.Fgetpos(fixture.Context);

            Assert.Equal((int)OrbisGen2Result.ORBIS_GEN2_ERROR_MEMORY_FAULT, result);
            Assert.Equal(unchecked((ulong)(int)-1), fixture.Context[CpuRegister.Rax]);
            Assert.Equal(14, ReadErrno(fixture.Memory));
        }
        finally
        {
            fixture.Dispose();
        }
    }

    [Fact]
    public void Setvbuf_NoBufferingFlushesEachWrite()
    {
        var fixture = OpenTemporaryFile("wb", Array.Empty<byte>());
        try
        {
            fixture.Context[CpuRegister.Rdi] = fixture.Handle;
            fixture.Context[CpuRegister.Rsi] = 0;
            fixture.Context[CpuRegister.Rdx] = 2;
            fixture.Context[CpuRegister.Rcx] = 0;
            Assert.Equal((int)OrbisGen2Result.ORBIS_GEN2_OK, LibcStdioExports.Setvbuf(fixture.Context));

            fixture.Context[CpuRegister.Rdi] = 0x5A;
            fixture.Context[CpuRegister.Rsi] = fixture.Handle;
            Assert.Equal((int)OrbisGen2Result.ORBIS_GEN2_OK, LibcStdioExports.Fputc(fixture.Context));

            using var reader = new FileStream(
                fixture.HostPath,
                FileMode.Open,
                FileAccess.Read,
                FileShare.ReadWrite);
            Assert.Equal(0x5A, reader.ReadByte());
        }
        finally
        {
            fixture.Dispose();
        }
    }

    [Fact]
    public void Setvbuf_RejectsUnknownMode()
    {
        var fixture = OpenTemporaryFile("rb", new byte[] { 1 });
        try
        {
            fixture.Context[CpuRegister.Rdi] = fixture.Handle;
            fixture.Context[CpuRegister.Rdx] = 3;

            var result = LibcStdioExports.Setvbuf(fixture.Context);

            Assert.Equal((int)OrbisGen2Result.ORBIS_GEN2_ERROR_INVALID_ARGUMENT, result);
            Assert.Equal(unchecked((ulong)(int)-1), fixture.Context[CpuRegister.Rax]);
            Assert.Equal(22, ReadErrno(fixture.Memory));
        }
        finally
        {
            fixture.Dispose();
        }
    }

    [Fact]
    public void Fread_BlocksConcurrentSeekUntilTheReadCompletes()
    {
        var contents = Enumerable.Range(0, 64).Select(value => (byte)value).ToArray();
        var fixture = OpenTemporaryFile("rb", contents);
        using var writeEntered = new ManualResetEventSlim();
        using var releaseWrite = new ManualResetEventSlim();
        StdioTestWorker? readWorker = null;
        StdioTestWorker? seekWorker = null;
        try
        {
            fixture.Memory.BeforeWrite = (address, _) =>
            {
                if (address != DataAddress)
                {
                    return;
                }

                writeEntered.Set();
                Assert.True(releaseWrite.Wait(StdioTestWorker.Timeout), "The test did not release the blocked read.");
            };

            var readContext = CreateContext(fixture.Memory);
            readContext[CpuRegister.Rdi] = DataAddress;
            readContext[CpuRegister.Rsi] = 1;
            readContext[CpuRegister.Rdx] = 32;
            readContext[CpuRegister.Rcx] = fixture.Handle;
            readWorker = new StdioTestWorker(() => LibcStdioExports.Fread(readContext));

            Assert.True(writeEntered.Wait(StdioTestWorker.Timeout), "The read did not reach the guest-memory write.");

            var seekContext = CreateContext(fixture.Memory);
            seekContext[CpuRegister.Rdi] = fixture.Handle;
            seekContext[CpuRegister.Rsi] = 48;
            seekContext[CpuRegister.Rdx] = 0;
            seekWorker = new StdioTestWorker(() => LibcStdioExports.Fseek(seekContext));

            seekWorker.AssertBlocked("Seek did not block behind the active read.");
            releaseWrite.Set();

            Assert.Equal((int)OrbisGen2Result.ORBIS_GEN2_OK, readWorker.Result);
            Assert.Equal((int)OrbisGen2Result.ORBIS_GEN2_OK, seekWorker.Result);
            var actual = new byte[32];
            Assert.True(fixture.Memory.TryRead(DataAddress, actual));
            Assert.True(actual.SequenceEqual(contents.AsSpan(0, 32)));
        }
        finally
        {
            releaseWrite.Set();
            StdioTestWorker.JoinAll(readWorker, seekWorker);
            fixture.Memory.BeforeWrite = null;
            fixture.Dispose();
        }
    }

    [Fact]
    public void Fclose_WaitsForAnInFlightReadAndRejectsLaterReads()
    {
        var fixture = OpenTemporaryFile("rb", Enumerable.Range(0, 64).Select(value => (byte)value).ToArray());
        using var writeEntered = new ManualResetEventSlim();
        using var releaseWrite = new ManualResetEventSlim();
        StdioTestWorker? readWorker = null;
        StdioTestWorker? closeWorker = null;
        try
        {
            fixture.Memory.BeforeWrite = (address, _) =>
            {
                if (address != DataAddress)
                {
                    return;
                }

                writeEntered.Set();
                Assert.True(releaseWrite.Wait(StdioTestWorker.Timeout), "The test did not release the blocked read.");
            };

            var readContext = CreateContext(fixture.Memory);
            readContext[CpuRegister.Rdi] = DataAddress;
            readContext[CpuRegister.Rsi] = 1;
            readContext[CpuRegister.Rdx] = 32;
            readContext[CpuRegister.Rcx] = fixture.Handle;
            readWorker = new StdioTestWorker(() => LibcStdioExports.Fread(readContext));

            Assert.True(writeEntered.Wait(StdioTestWorker.Timeout), "The read did not reach the guest-memory write.");

            var closeContext = CreateContext(fixture.Memory);
            closeContext[CpuRegister.Rdi] = fixture.Handle;
            closeWorker = new StdioTestWorker(() => LibcStdioExports.Fclose(closeContext));

            closeWorker.AssertBlocked("Close did not block behind the active read.");
            releaseWrite.Set();

            Assert.Equal((int)OrbisGen2Result.ORBIS_GEN2_OK, readWorker.Result);
            Assert.Equal((int)OrbisGen2Result.ORBIS_GEN2_OK, closeWorker.Result);

            var lateReadContext = CreateContext(fixture.Memory);
            lateReadContext[CpuRegister.Rdi] = DataAddress;
            lateReadContext[CpuRegister.Rsi] = 1;
            lateReadContext[CpuRegister.Rdx] = 1;
            lateReadContext[CpuRegister.Rcx] = fixture.Handle;
            Assert.Equal(
                (int)OrbisGen2Result.ORBIS_GEN2_ERROR_INVALID_ARGUMENT,
                LibcStdioExports.Fread(lateReadContext));
            Assert.Equal(0UL, lateReadContext[CpuRegister.Rax]);
        }
        finally
        {
            releaseWrite.Set();
            StdioTestWorker.JoinAll(readWorker, closeWorker);
            fixture.Memory.BeforeWrite = null;
            fixture.Dispose();
        }
    }

    private sealed class StdioTestWorker
    {
        public static readonly TimeSpan Timeout = TimeSpan.FromSeconds(30);
        private readonly Thread _thread;
        private readonly TaskCompletionSource<int> _result = new(TaskCreationOptions.RunContinuationsAsynchronously);

        public int Result
        {
            get
            {
                // These operations run on dedicated threads. Join them directly so
                // thread-pool load cannot delay a continuation until its timer expires.
                Assert.True(_thread.Join(Timeout), "The file-operation worker did not complete.");
                return _result.Task.GetAwaiter().GetResult();
            }
        }

        public StdioTestWorker(Func<int> operation)
        {
            _thread = new Thread(() =>
            {
                try
                {
                    _result.SetResult(operation());
                }
                catch (Exception exception)
                {
                    _result.SetException(exception);
                }
            }) { IsBackground = true };
            _thread.Start();
        }

        public void AssertBlocked(string message)
        {
            // The worker has no test-side waits; blocking occurs inside the file operation.
            Assert.True(SpinWait.SpinUntil(() => _result.Task.IsCompleted ||
                (_thread.ThreadState & ThreadState.WaitSleepJoin) != 0, Timeout), message);
            Assert.False(_result.Task.IsCompleted, message);
        }

        public static void JoinAll(params StdioTestWorker?[] workers)
        {
            var allStopped = true;
            foreach (var worker in workers)
                allStopped &= worker is null || worker._thread.Join(Timeout);
            Assert.True(allStopped, "A file-operation worker did not stop during cleanup.");
        }
    }

    private static CpuContext CreateContext(out FakeCpuMemory memory)
    {
        memory = new FakeCpuMemory(BaseAddress, 0x1000);
        return new CpuContext(memory, Generation.Gen5)
        {
            FsBase = TlsAddress,
        };
    }

    private static CpuContext CreateContext(StdioCpuMemory memory) =>
        new(memory, Generation.Gen5)
        {
            FsBase = TlsAddress,
        };

    private static int ReadErrno(ICpuMemory memory)
    {
        Span<byte> value = stackalloc byte[sizeof(int)];
        Assert.True(memory.TryRead(ErrnoAddress, value));
        return BinaryPrimitives.ReadInt32LittleEndian(value);
    }

    private static TemporaryFileFixture OpenTemporaryFile(string mode, byte[] contents)
    {
        var mountPoint = $"/stdio-{Guid.NewGuid():N}";
        var hostRoot = Path.Combine(Path.GetTempPath(), $"sharpemu-stdio-{Guid.NewGuid():N}");
        Directory.CreateDirectory(hostRoot);
        var hostPath = Path.Combine(hostRoot, "data.bin");
        File.WriteAllBytes(hostPath, contents);
        KernelMemoryCompatExports.RegisterGuestPathMount(mountPoint, hostRoot);

        var memory = new StdioCpuMemory(BaseAddress, 0x1000);
        var context = new CpuContext(memory, Generation.Gen5)
        {
            FsBase = TlsAddress,
        };
        memory.WriteCString(PathAddress, $"{mountPoint}/data.bin");
        memory.WriteCString(ModeAddress, mode);
        context[CpuRegister.Rdi] = PathAddress;
        context[CpuRegister.Rsi] = ModeAddress;
        var result = LibcStdioExports.Fopen(context);
        Assert.Equal((int)OrbisGen2Result.ORBIS_GEN2_OK, result);
        Assert.NotEqual(0UL, context[CpuRegister.Rax]);
        return new TemporaryFileFixture(
            context,
            memory,
            context[CpuRegister.Rax],
            mountPoint,
            hostRoot,
            hostPath);
    }

    private sealed class TemporaryFileFixture(
        CpuContext context,
        StdioCpuMemory memory,
        ulong handle,
        string mountPoint,
        string hostRoot,
        string hostPath) : IDisposable
    {
        public CpuContext Context { get; } = context;
        public StdioCpuMemory Memory { get; } = memory;
        public ulong Handle { get; } = handle;
        public string HostPath { get; } = hostPath;

        public void Dispose()
        {
            Context[CpuRegister.Rdi] = Handle;
            _ = LibcStdioExports.Fclose(Context);
            KernelMemoryCompatExports.UnregisterGuestPathMount(mountPoint);
            Directory.Delete(hostRoot, recursive: true);
        }
    }

    private sealed class StdioCpuMemory : ICpuMemory, IGuestAddressSpace
    {
        private readonly ulong _baseAddress;
        private readonly byte[] _storage;
        private readonly Dictionary<ulong, byte[]> _allocations = new();

        public Action<ulong, int>? BeforeWrite { get; set; }

        public StdioCpuMemory(ulong baseAddress, int size)
        {
            _baseAddress = baseAddress;
            _storage = new byte[size];
        }

        public bool TryRead(ulong virtualAddress, Span<byte> destination)
        {
            if (!TryResolve(virtualAddress, destination.Length, out var storage, out var offset))
            {
                return false;
            }

            storage.AsSpan(offset, destination.Length).CopyTo(destination);
            return true;
        }

        public bool TryWrite(ulong virtualAddress, ReadOnlySpan<byte> source)
        {
            BeforeWrite?.Invoke(virtualAddress, source.Length);
            if (!TryResolve(virtualAddress, source.Length, out var storage, out var offset))
            {
                return false;
            }

            source.CopyTo(storage.AsSpan(offset, source.Length));
            return true;
        }

        public bool TryAllocateGuestMemory(ulong size, ulong alignment, out ulong address) =>
            TryAllocateAtOrAbove(_baseAddress + (ulong)_storage.Length, size, false, alignment, out address);

        public bool TryFreeGuestMemory(ulong address) => _allocations.Remove(address);

        public ulong AllocateAt(
            ulong desiredAddress,
            ulong size,
            bool executable = true,
            bool allowAlternative = true)
        {
            if (TryAllocateAtOrAbove(desiredAddress, size, executable, 0x1000, out var address))
            {
                return address;
            }

            return 0;
        }

        public bool TryBackFixedRange(ulong address, ulong size, bool executable) =>
            AllocateAt(address, size, executable, allowAlternative: false) == address;

        public bool TryAllocateAtOrAbove(
            ulong desiredAddress,
            ulong size,
            bool executable,
            ulong alignment,
            out ulong actualAddress)
        {
            actualAddress = 0;
            if (size == 0 || size > int.MaxValue || alignment == 0 || (alignment & (alignment - 1)) != 0)
            {
                return false;
            }

            var minimum = _baseAddress + (ulong)_storage.Length;
            var candidate = Math.Max(desiredAddress, minimum);
            candidate = (candidate + alignment - 1) & ~(alignment - 1);
            while (_allocations.Any(pair => RangesOverlap(candidate, size, pair.Key, (ulong)pair.Value.Length)))
            {
                candidate += alignment;
            }

            _allocations[candidate] = new byte[(int)size];
            actualAddress = candidate;
            return true;
        }

        public bool TryEnsureRangeCommitted(ulong address, ulong size) =>
            TryResolve(address, checked((int)size), out _, out _);

        public bool TryProtect(ulong address, ulong size, GuestPageProtection protection) =>
            TryEnsureRangeCommitted(address, size);

        public ulong WriteCString(ulong virtualAddress, string text)
        {
            var bytes = System.Text.Encoding.UTF8.GetBytes(text);
            Assert.True(TryWrite(virtualAddress, bytes));
            Assert.True(TryWrite(virtualAddress + (ulong)bytes.Length, stackalloc byte[] { 0 }));
            return virtualAddress;
        }

        private bool TryResolve(
            ulong virtualAddress,
            int length,
            out byte[] storage,
            out int offset)
        {
            if (TryResolveInRegion(virtualAddress, length, _baseAddress, _storage, out offset))
            {
                storage = _storage;
                return true;
            }

            foreach (var pair in _allocations)
            {
                if (TryResolveInRegion(virtualAddress, length, pair.Key, pair.Value, out offset))
                {
                    storage = pair.Value;
                    return true;
                }
            }

            storage = Array.Empty<byte>();
            offset = 0;
            return false;
        }

        private static bool TryResolveInRegion(
            ulong address,
            int length,
            ulong regionAddress,
            byte[] region,
            out int offset)
        {
            offset = 0;
            if (address < regionAddress)
            {
                return false;
            }

            var relative = address - regionAddress;
            if (relative + (ulong)length > (ulong)region.Length)
            {
                return false;
            }

            offset = (int)relative;
            return true;
        }

        private static bool RangesOverlap(ulong left, ulong leftSize, ulong right, ulong rightSize) =>
            left < right + rightSize && right < left + leftSize;
    }
}