NdsImageBuilder.cs

namespace NdsForge;

public sealed class NdsImageBuilder
{
    private byte[]? _nintendoLogo;

    private readonly List<NdsOverlayDefinition> _arm9Overlays = [];

    private readonly List<NdsOverlayDefinition> _arm7Overlays = [];

    public NdsImageBuilder()
    {
        FileSystem = new NdsFileSystemBuilder();
    }

    public NdsImageKind Kind { get; set; } = NdsImageKind.NintendoDs;

    public string Title { get; set; } = string.Empty;

    public string GameCode { get; set; } = "####";

    public string MakerCode { get; set; } = "00";

    public byte Version { get; set; }

    public byte EncryptionSeedSelect { get; set; }

    public byte RegionCode { get; set; }

    public byte AutoStart { get; set; }

    public uint NormalCardControl { get; set; }

    public uint SecureCardControl { get; set; }

    public ushort SecureTransferTimeout { get; set; }

    public uint Arm9AutoLoad { get; set; }

    public uint Arm7AutoLoad { get; set; }

    public ulong SecureDisable { get; set; }

    public NdsProgramDefinition? Arm9 { get; set; }

    public NdsProgramDefinition? Arm7 { get; set; }

    public NdsProgramDefinition? Arm9i { get; set; }

    public NdsProgramDefinition? Arm7i { get; set; }

    public NdsDsiBuildMetadata? DsiMetadata { get; set; }

    public NdsFileSystemBuilder FileSystem { get; }

    public NdsBanner? Banner { get; set; }

    public IReadOnlyList<NdsOverlayDefinition> Arm9Overlays => _arm9Overlays;

    public IReadOnlyList<NdsOverlayDefinition> Arm7Overlays => _arm7Overlays;

    public NdsImageBuilder AddOverlay(NdsOverlayDefinition overlay)
    {
        ArgumentNullException.ThrowIfNull(overlay);
        (overlay.Processor == NdsProcessor.Arm9 ? _arm9Overlays : _arm7Overlays).Add(overlay);
        return this;
    }

    public static ValueTask<NdsImageBuilder> FromImageAsync(
        NdsImage image,
        CancellationToken cancellationToken = default) =>
        NdsImageBuildImporter.ImportAsync(image, cancellationToken);

    public NdsImageBuilder SetNintendoLogo(ReadOnlySpan<byte> data)
    {
        if (data.Length != 156)
        {
            throw new ArgumentException("The encoded Nintendo DS logo must contain exactly 156 bytes.", nameof(data));
        }
 
        _nintendoLogo = data.ToArray();
        return this;
    }

    public ValueTask<NdsImageBuildResult> WriteAsync(
        Stream destination,
        NdsImageBuildOptions? options = null,
        CancellationToken cancellationToken = default) =>
        NdsImageBuildWriter.WriteAsync(this, destination, options ?? NdsImageBuildOptions.Default, cancellationToken);

    public async ValueTask<NdsImageBuildResult> WriteAsync(
        string path,
        NdsImageBuildOptions? options = null,
        CancellationToken cancellationToken = default)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(path);
        options ??= NdsImageBuildOptions.Default;
        options.Validate();
        string output = Path.GetFullPath(path);
        string? directory = Path.GetDirectoryName(output);
        if (!string.IsNullOrEmpty(directory))
        {
            Directory.CreateDirectory(directory);
        }
 
        if (File.Exists(output) && !options.OverwriteDestination)
        {
            throw new IOException($"Destination already exists: {output}");
        }
 
        string temporary = output + ".ndsforge-" + Guid.NewGuid().ToString("N");
        try
        {
            NdsImageBuildResult result;
            var stream = new FileStream(
                temporary,
                FileMode.CreateNew,
                FileAccess.ReadWrite,
                FileShare.None,
                64 * 1024,
                FileOptions.Asynchronous | FileOptions.SequentialScan);
            await using (stream.ConfigureAwait(false))
            {
                result = await WriteAsync(stream, options, cancellationToken).ConfigureAwait(false);
            }
 
            File.Move(temporary, output, options.OverwriteDestination);
            return result;
        }
        finally
        {
            File.Delete(temporary);
        }
    }

    public async ValueTask<byte[]> BuildAsync(
        NdsImageBuildOptions? options = null,
        CancellationToken cancellationToken = default)
    {
        using var stream = new MemoryStream();
        await WriteAsync(stream, options, cancellationToken).ConfigureAwait(false);
        return stream.ToArray();
    }

    internal ReadOnlyMemory<byte> NintendoLogo => _nintendoLogo;
}