NdsImageBuildContent.cs

using System.Buffers.Binary;
 
namespace NdsForge;

internal sealed record NdsImageBuildContent(
    NdsFileSystemBuildSnapshot FileSystem,
    ReadOnlyMemory<byte> Arm9Data,
    int Arm9DeclaredLength,
    ReadOnlyMemory<byte> Arm9TrailingData,
    ReadOnlyMemory<byte> Arm7Data,
    int Arm7DeclaredLength,
    ReadOnlyMemory<byte> Arm9iData,
    ReadOnlyMemory<byte> Arm7iData,
    ReadOnlyMemory<byte>[] Allocations,
    byte[] Arm9OverlayTable,
    byte[] Arm7OverlayTable);

internal static class NdsImageBuildContentPreparer
{
    public static NdsImageBuildContent Prepare(NdsImageBuilder builder, NdsImageBuildOptions options)
    {
        bool ndstoolProfile = options.Profile == NdsImageBuildProfile.Ndstool1503;
        if (ndstoolProfile && builder.Kind != NdsImageKind.NintendoDs)
        {
            throw new InvalidDataException("The ndstool 1.50.3 compatibility profile predates DSi image creation.");
        }
 
        int arm9PrivateCount = builder.Arm9Overlays.Count(static overlay => overlay.HasPrivateAllocation);
        int arm7PrivateCount = builder.Arm7Overlays.Count(static overlay => overlay.HasPrivateAllocation);
        if (ndstoolProfile &&
            builder.Arm9Overlays.Concat(builder.Arm7Overlays).Any(static overlay => !overlay.HasPrivateAllocation))
        {
            throw new InvalidDataException(
                "The ndstool 1.50.3 build profile requires one private payload per Overlay record; its CLI cannot represent named-file links.");
        }
 
        if (ndstoolProfile && builder.Banner is not null && builder.Banner.RawData.Length != 0x840)
        {
            throw new InvalidDataException(
                "The ndstool 1.50.3 build profile supports only the 0x840-byte version-one Banner layout.");
        }
 
        int hiddenFileCount = ndstoolProfile ? checked(arm9PrivateCount + arm7PrivateCount) : 0;
        NdsFileSystemBuildSnapshot fileSystem = builder.FileSystem.BuildSnapshot(hiddenFileCount);
        ReadOnlyMemory<byte>[] allocations = CollectAllocations(builder, fileSystem, ndstoolProfile);
        int arm9PrivateBase = ndstoolProfile
            ? 0
            : checked(fileSystem.FirstFileId + fileSystem.FilesInIdOrder.Count);
        int arm7PrivateBase = checked(arm9PrivateBase + arm9PrivateCount);
        byte[] arm9OverlayTable = BuildOverlayTable(builder.Arm9Overlays, fileSystem, arm9PrivateBase);
        byte[] arm7OverlayTable = BuildOverlayTable(builder.Arm7Overlays, fileSystem, arm7PrivateBase);
        (ReadOnlyMemory<byte> arm9Data, int arm9DeclaredLength) = PrepareProgram(
            builder.Arm9!,
            isArm9: true,
            ndstoolProfile);
        (ReadOnlyMemory<byte> arm7Data, int arm7DeclaredLength) = PrepareProgram(
            builder.Arm7!,
            isArm9: false,
            ndstoolProfile);
        ReadOnlyMemory<byte> arm9TrailingData = PrepareArm9TrailingData(
            builder.Arm9!,
            synthesizeNdstoolFooter: ndstoolProfile && arm9OverlayTable.Length > 0);
        ReadOnlyMemory<byte> arm9iData = builder.Arm9i?.Contents ?? ReadOnlyMemory<byte>.Empty;
        ReadOnlyMemory<byte> arm7iData = builder.Arm7i?.Contents ?? ReadOnlyMemory<byte>.Empty;
        return new(
            fileSystem,
            arm9Data,
            arm9DeclaredLength,
            arm9TrailingData,
            arm7Data,
            arm7DeclaredLength,
            arm9iData,
            arm7iData,
            allocations,
            arm9OverlayTable,
            arm7OverlayTable);
    }

    private static (ReadOnlyMemory<byte> Data, int DeclaredLength) PrepareProgram(
        NdsProgramDefinition program,
        bool isArm9,
        bool ndstoolProfile)
    {
        if (!ndstoolProfile)
        {
            return (program.Contents, program.Contents.Length);
        }
 
        bool alreadyHasSecureStubs = isArm9 &&
            program.Contents.Length >= 4 &&
            program.Contents.Span[0] == 0xFF &&
            program.Contents.Span[1] == 0xDE &&
            program.Contents.Span[2] == 0xFF &&
            program.Contents.Span[3] == 0xE7;
        int prefixLength = isArm9 && !alreadyHasSecureStubs ? 0x800 : 0;
        byte[] data = new byte[checked(program.Contents.Length + prefixLength)];
        for (int offset = 0; offset < prefixLength; offset += 4)
        {
            data[offset] = 0xFF;
            data[offset + 1] = 0xDE;
            data[offset + 2] = 0xFF;
            data[offset + 3] = 0xE7;
        }
 
        program.Contents.Span.CopyTo(data.AsSpan(prefixLength));
        int declaredLength = checked((data.Length + 3) & ~3);
        return (data, declaredLength);
    }

    private static ReadOnlyMemory<byte> PrepareArm9TrailingData(
        NdsProgramDefinition program,
        bool synthesizeNdstoolFooter)
    {
        if (!synthesizeNdstoolFooter)
        {
            return program.Footer;
        }
 
        byte[] trailing = new byte[checked(program.Footer.Length + 12)];
        program.Footer.Span.CopyTo(trailing);
        Span<byte> generated = trailing.AsSpan(program.Footer.Length, 12);
        BinaryPrimitives.WriteUInt32LittleEndian(generated, 0xDEC00621);
        BinaryPrimitives.WriteUInt32LittleEndian(generated[4..], 0x00000AD8);
        return trailing;
    }

    private static ReadOnlyMemory<byte>[] CollectAllocations(
        NdsImageBuilder builder,
        NdsFileSystemBuildSnapshot fileSystem,
        bool ndstoolProfile)
    {
        IEnumerable<ReadOnlyMemory<byte>> arm9 = builder.Arm9Overlays
            .Where(static overlay => overlay.HasPrivateAllocation)
            .Select(static overlay => overlay.Contents);
        IEnumerable<ReadOnlyMemory<byte>> arm7 = builder.Arm7Overlays
            .Where(static overlay => overlay.HasPrivateAllocation)
            .Select(static overlay => overlay.Contents);
        IEnumerable<ReadOnlyMemory<byte>> named = fileSystem.FilesInIdOrder.Select(static file => file.Contents);
        return (ndstoolProfile ? arm9.Concat(arm7).Concat(named) : named.Concat(arm9).Concat(arm7)).ToArray();
    }

    private static byte[] BuildOverlayTable(
        IReadOnlyList<NdsOverlayDefinition> overlays,
        NdsFileSystemBuildSnapshot fileSystem,
        int firstPrivateFileId)
    {
        Dictionary<string, int> namedFileIds = fileSystem.FilesInIdOrder
            .Select((file, index) => (file.Path, FileId: checked(fileSystem.FirstFileId + index)))
            .ToDictionary(static item => item.Path, static item => item.FileId, StringComparer.Ordinal);
        byte[] data = new byte[checked(overlays.Count * 32)];
        int nextPrivateFileId = firstPrivateFileId;
        for (int index = 0; index < overlays.Count; index++)
        {
            NdsOverlayDefinition overlay = overlays[index];
            string? linkedPath = overlay.EffectiveLinkedFilePath;
            int fileId = linkedPath is null
                ? nextPrivateFileId++
                : namedFileIds.TryGetValue(linkedPath, out int linkedId)
                    ? linkedId
                    : throw new InvalidDataException($"Overlay {overlay.Id} links missing NitroFS file '{linkedPath}'.");
            Span<byte> entry = data.AsSpan(index * 32, 32);
            NdsBinary.WriteUInt32(entry, 0x00, overlay.Id);
            NdsBinary.WriteUInt32(entry, 0x04, overlay.LoadAddress);
            NdsBinary.WriteUInt32(entry, 0x08, overlay.RamSize);
            NdsBinary.WriteUInt32(entry, 0x0C, overlay.BssSize);
            NdsBinary.WriteUInt32(entry, 0x10, overlay.StaticInitializerStart);
            NdsBinary.WriteUInt32(entry, 0x14, overlay.StaticInitializerEnd);
            NdsBinary.WriteUInt32(entry, 0x18, checked((uint)fileId));
            NdsBinary.WriteUInt32(entry, 0x1C, overlay.CompressedSize | ((uint)overlay.Flags << 24));
        }
 
        return data;
    }
}