NdsImageLoader.cs

namespace NdsForge;

internal static class NdsImageLoader
{
    private const int BaseHeaderLength = 0x200;

    private const int DsiHeaderLength = 0x1000;

    public static async ValueTask<NdsImage> OpenPathAsync(
        string path,
        NdsReadOptions? options,
        CancellationToken cancellationToken)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(path);
        var source = new FileImageDataSource(path);
        try
        {
            return await LoadAsync(source, options, cancellationToken).ConfigureAwait(false);
        }
        catch
        {
            await source.DisposeAsync().ConfigureAwait(false);
            throw;
        }
    }

    public static NdsImage OpenStream(Stream stream, bool leaveOpen, NdsReadOptions? options)
    {
        var source = new StreamImageDataSource(stream, leaveOpen);
        try
        {
            return Load(source, options);
        }
        catch
        {
            source.Dispose();
            throw;
        }
    }

    public static async ValueTask<NdsImage> OpenStreamAsync(
        Stream stream,
        bool leaveOpen,
        NdsReadOptions? options,
        CancellationToken cancellationToken)
    {
        var source = new StreamImageDataSource(stream, leaveOpen);
        try
        {
            return await LoadAsync(source, options, cancellationToken).ConfigureAwait(false);
        }
        catch
        {
            await source.DisposeAsync().ConfigureAwait(false);
            throw;
        }
    }

    public static NdsImage LoadMemory(ReadOnlyMemory<byte> data, NdsReadOptions? options)
    {
        var source = new MemoryImageDataSource(data);
        try
        {
            return Load(source, options);
        }
        catch
        {
            source.Dispose();
            throw;
        }
    }

    private static NdsImage Load(IImageDataSource source, NdsReadOptions? options)
    {
        options ??= NdsReadOptions.Default;
        options.Validate();
        NdsHeader header = ReadHeader(source);
        DetectArm9Footer(source, header);
        NdsFileSystem fileSystem = NitroFileSystemParser.Parse(source, header, options);
        IReadOnlyList<NdsOverlay> arm9Overlays = NdsOverlayParser.Parse(
            source, header.Arm9OverlayTable, NdsProcessor.Arm9, fileSystem, options);
        IReadOnlyList<NdsOverlay> arm7Overlays = NdsOverlayParser.Parse(
            source, header.Arm7OverlayTable, NdsProcessor.Arm7, fileSystem, options);
        NdsBanner? banner = NdsBannerParser.Parse(source, header.BannerOffset, options);
        return new NdsImage(source, header, fileSystem, arm9Overlays, arm7Overlays, banner);
    }

    private static async ValueTask<NdsImage> LoadAsync(
        IImageDataSource source,
        NdsReadOptions? options,
        CancellationToken cancellationToken)
    {
        options ??= NdsReadOptions.Default;
        options.Validate();
        NdsHeader header = await ReadHeaderAsync(source, cancellationToken).ConfigureAwait(false);
        await DetectArm9FooterAsync(source, header, cancellationToken).ConfigureAwait(false);
        NdsFileSystem fileSystem = await NitroFileSystemParser.ParseAsync(
            source, header, options, cancellationToken).ConfigureAwait(false);
        IReadOnlyList<NdsOverlay> arm9Overlays = await NdsOverlayParser.ParseAsync(
            source, header.Arm9OverlayTable, NdsProcessor.Arm9, fileSystem, options, cancellationToken)
            .ConfigureAwait(false);
        IReadOnlyList<NdsOverlay> arm7Overlays = await NdsOverlayParser.ParseAsync(
            source, header.Arm7OverlayTable, NdsProcessor.Arm7, fileSystem, options, cancellationToken)
            .ConfigureAwait(false);
        NdsBanner? banner = await NdsBannerParser.ParseAsync(
            source, header.BannerOffset, options, cancellationToken).ConfigureAwait(false);
        return new NdsImage(source, header, fileSystem, arm9Overlays, arm7Overlays, banner);
    }

    private static NdsHeader ReadHeader(IImageDataSource source)
    {
        byte[] baseHeader = new byte[BaseHeaderLength];
        source.ReadExactly(0, baseHeader);
        int length = (baseHeader[0x12] & 2) == 0 ? BaseHeaderLength : DsiHeaderLength;
        if (length == BaseHeaderLength)
        {
            return new NdsHeader(baseHeader);
        }
 
        byte[] fullHeader = new byte[length];
        baseHeader.CopyTo(fullHeader, 0);
        source.ReadExactly(BaseHeaderLength, fullHeader.AsSpan(BaseHeaderLength));
        return new NdsHeader(fullHeader);
    }

    private static async ValueTask<NdsHeader> ReadHeaderAsync(
        IImageDataSource source,
        CancellationToken cancellationToken)
    {
        byte[] baseHeader = new byte[BaseHeaderLength];
        await source.ReadExactlyAsync(0, baseHeader, cancellationToken).ConfigureAwait(false);
        int length = (baseHeader[0x12] & 2) == 0 ? BaseHeaderLength : DsiHeaderLength;
        if (length == BaseHeaderLength)
        {
            return new NdsHeader(baseHeader);
        }
 
        byte[] fullHeader = new byte[length];
        baseHeader.CopyTo(fullHeader, 0);
        await source.ReadExactlyAsync(
            BaseHeaderLength,
            fullHeader.AsMemory(BaseHeaderLength),
            cancellationToken).ConfigureAwait(false);
        return new NdsHeader(fullHeader);
    }

    private static void DetectArm9Footer<TSource>(TSource source, NdsHeader header)
        where TSource : IImageDataSource
    {
        if (header.Arm9.Data.End > source.Length - 12)
        {
            return;
        }
 
        Span<byte> marker = stackalloc byte[4];
        source.ReadExactly(header.Arm9.Data.End, marker);
        if (NdsBinary.ReadUInt32(marker, 0) == 0xDEC00621)
        {
            header.Arm9.Footer = new(header.Arm9.Data.End, 12);
        }
    }

    private static async ValueTask DetectArm9FooterAsync<TSource>(
        TSource source,
        NdsHeader header,
        CancellationToken cancellationToken)
        where TSource : IImageDataSource
    {
        if (header.Arm9.Data.End > source.Length - 12)
        {
            return;
        }
 
        byte[] marker = new byte[4];
        await source.ReadExactlyAsync(header.Arm9.Data.End, marker, cancellationToken).ConfigureAwait(false);
        if (NdsBinary.ReadUInt32(marker, 0) == 0xDEC00621)
        {
            header.Arm9.Footer = new(header.Arm9.Data.End, 12);
        }
    }
}