NdsImageBuildImporter.cs

namespace NdsForge;

internal static class NdsImageBuildImporter
{
    public static async ValueTask<NdsImageBuilder> ImportAsync(
        NdsImage image,
        CancellationToken cancellationToken)
    {
        ArgumentNullException.ThrowIfNull(image);
        byte[] arm9 = await ReadRegionAsync(image, image.Header.Arm9.Data, cancellationToken).ConfigureAwait(false);
        byte[] arm7 = await ReadRegionAsync(image, image.Header.Arm7.Data, cancellationToken).ConfigureAwait(false);
        var arm9Definition = new NdsProgramDefinition(
            NdsProcessor.Arm9,
            arm9,
            image.Header.Arm9.LoadAddress,
            image.Header.Arm9.EntryAddress);
        if (image.Header.Arm9.Footer is not null)
        {
            arm9Definition.SetFooter(
                await ReadRegionAsync(image, image.Header.Arm9.Footer.Value, cancellationToken).ConfigureAwait(false));
        }
 
        NdsProgramDefinition? arm9iDefinition = await ImportDsiProgramAsync(
            image,
            image.Header.Arm9i,
            cancellationToken).ConfigureAwait(false);
        NdsProgramDefinition? arm7iDefinition = await ImportDsiProgramAsync(
            image,
            image.Header.Arm7i,
            cancellationToken).ConfigureAwait(false);
        NdsDsiBuildMetadata? dsiMetadata = image.Header.Dsi is null
            ? null
            : NdsDsiBuildMetadata.FromHeader(image.Header.Dsi);
        if (dsiMetadata is not null)
        {
            dsiMetadata.DsiFlags = image.Header.DsiFlags;
            dsiMetadata.AnchorModcryptAreas(
                new[] { image.Header.Arm9, image.Header.Arm7, image.Header.Arm9i, image.Header.Arm7i }
                    .OfType<NdsProgram>());
        }
 
        var builder = new NdsImageBuilder
        {
            Kind = image.Header.Kind,
            Title = image.Header.Title,
            GameCode = image.Header.GameCode,
            MakerCode = image.Header.MakerCode,
            Version = image.Header.Version,
            EncryptionSeedSelect = image.Header.EncryptionSeedSelect,
            RegionCode = image.Header.RegionCode,
            AutoStart = image.Header.AutoStart,
            NormalCardControl = image.Header.NormalCardControl,
            SecureCardControl = image.Header.SecureCardControl,
            SecureTransferTimeout = image.Header.SecureTransferTimeout,
            Arm9AutoLoad = image.Header.Arm9AutoLoad,
            Arm7AutoLoad = image.Header.Arm7AutoLoad,
            SecureDisable = image.Header.SecureDisable,
            Arm9 = arm9Definition,
            Arm7 = new(
                NdsProcessor.Arm7,
                arm7,
                image.Header.Arm7.LoadAddress,
                image.Header.Arm7.EntryAddress),
            Arm9i = arm9iDefinition,
            Arm7i = arm7iDefinition,
            DsiMetadata = dsiMetadata,
            Banner = image.Banner,
        };
        builder.SetNintendoLogo(image.Header.RawData.Span.Slice(0xC0, 156));
 
        foreach (NdsDirectory directory in image.FileSystem.Directories)
        {
            if (directory.Parent is not null)
            {
                builder.FileSystem.CreateDirectory(directory.FullPath);
            }
        }
 
        foreach (NdsFile file in image.FileSystem.Files)
        {
            builder.FileSystem.AddFile(
                file.FullPath,
                await file.ReadAllBytesAsync(cancellationToken).ConfigureAwait(false));
        }
 
        var importedPrivateFileIds = new HashSet<uint>();
        foreach (NdsOverlay overlay in image.Arm9Overlays.Concat(image.Arm7Overlays))
        {
            builder.AddOverlay(await ImportOverlayAsync(
                image,
                overlay,
                builder.FileSystem,
                importedPrivateFileIds,
                cancellationToken).ConfigureAwait(false));
        }
 
        return builder;
    }

    private static async ValueTask<NdsProgramDefinition?> ImportDsiProgramAsync(
        NdsImage image,
        NdsProgram? program,
        CancellationToken cancellationToken)
    {
        if (program is null)
        {
            return null;
        }
 
        return new(
            program.Processor,
            await ReadRegionAsync(image, program.Data, cancellationToken).ConfigureAwait(false),
            program.LoadAddress,
            program.LoadAddress);
    }

    private static async ValueTask<NdsOverlayDefinition> ImportOverlayAsync(
        NdsImage image,
        NdsOverlay overlay,
        NdsFileSystemBuilder fileSystem,
        HashSet<uint> importedPrivateFileIds,
        CancellationToken cancellationToken)
    {
        if (overlay.File is not null)
        {
            return NdsOverlayDefinition.LinkToFile(
                overlay.Processor,
                overlay.Id,
                fileSystem.GetFile(overlay.File.FullPath),
                overlay.LoadAddress,
                overlay.RamSize,
                overlay.BssSize,
                overlay.StaticInitializerStart,
                overlay.StaticInitializerEnd,
                overlay.CompressedSize,
                overlay.Flags);
        }
 
        if (overlay.Data is null)
        {
            throw new InvalidDataException($"Overlay {overlay.Id} references missing File ID {overlay.FileId}.");
        }
 
        if (!importedPrivateFileIds.Add(overlay.FileId))
        {
            throw new NotSupportedException("Multiple Overlays sharing one unnamed Allocation require an explicit shared-allocation recipe.");
        }
 
        return new(
            overlay.Processor,
            overlay.Id,
            await ReadRegionAsync(image, overlay.Data.Value, cancellationToken).ConfigureAwait(false),
            overlay.LoadAddress,
            overlay.RamSize,
            overlay.BssSize,
            overlay.StaticInitializerStart,
            overlay.StaticInitializerEnd,
            overlay.CompressedSize,
            overlay.Flags);
    }

    private static async ValueTask<byte[]> ReadRegionAsync(
        NdsImage image,
        NdsRegion region,
        CancellationToken cancellationToken)
    {
        if (region.Length > Array.MaxLength)
        {
            throw new IOException("A build component is too large to materialize in a detached recipe.");
        }
 
        using Stream stream = image.OpenRead(region);
        byte[] data = new byte[region.Length];
        await stream.ReadExactlyAsync(data, cancellationToken).ConfigureAwait(false);
        return data;
    }
}