NdsDsiBuildMetadata.cs

namespace NdsForge;

public sealed class NdsDsiBuildMetadata
{
    private byte[] _extensionTemplate = new byte[0xE80];
    private byte[] _memoryBankSettings = CreateDefaultMemoryBankSettings();
    private byte[] _ageRatings = Enumerable.Repeat((byte)0x80, 0x10).ToArray();
    private NdsProcessor? _modcryptArea1Anchor;
    private NdsProcessor? _modcryptArea2Anchor;
    private long _modcryptArea1RelativeOffset;
    private long _modcryptArea2RelativeOffset;
    private NdsRegion _modcryptArea1;
    private NdsRegion _modcryptArea2;

    public byte DsiFlags { get; set; } = 0x01;

    public uint RegionFlags { get; set; } = uint.MaxValue;

    public uint AccessControl { get; set; }

    public uint ScfgExtMask { get; set; }

    public byte ApplicationFlags { get; set; }

    public uint Arm7DeviceListAddress { get; set; }

    public ulong TitleId { get; set; }

    public uint PublicSaveSize { get; set; }

    public uint PrivateSaveSize { get; set; }

    public NdsRegion ModcryptArea1
    {
        get => _modcryptArea1;
        set
        {
            _modcryptArea1 = value;
            _modcryptArea1Anchor = null;
            _modcryptArea1RelativeOffset = 0;
        }
    }

    public NdsRegion ModcryptArea2
    {
        get => _modcryptArea2;
        set
        {
            _modcryptArea2 = value;
            _modcryptArea2Anchor = null;
            _modcryptArea2RelativeOffset = 0;
        }
    }

    public NdsDsiIntegrityOptions Integrity { get; set; } = NdsDsiIntegrityOptions.Unauthenticated;

    public NdsDsiDigestOptions? Digests { get; set; }

    public static NdsDsiBuildMetadata FromHeader(NdsDsiHeader header)
    {
        ArgumentNullException.ThrowIfNull(header);
        var metadata = new NdsDsiBuildMetadata
        {
            _extensionTemplate = header.RawData.ToArray(),
            _memoryBankSettings = header.MemoryBankSettings.ToArray(),
            _ageRatings = header.AgeRatings.ToArray(),
            RegionFlags = header.RegionFlags,
            AccessControl = header.AccessControl,
            ScfgExtMask = header.ScfgExtMask,
            ApplicationFlags = header.ApplicationFlags,
            Arm7DeviceListAddress = header.Arm7DeviceListAddress,
            TitleId = header.TitleId,
            PublicSaveSize = header.PublicSaveSize,
            PrivateSaveSize = header.PrivateSaveSize,
            ModcryptArea1 = header.ModcryptArea1,
            ModcryptArea2 = header.ModcryptArea2,
        };
        return metadata;
    }

    public NdsDsiBuildMetadata SetMemoryBankSettings(ReadOnlySpan<byte> settings)
    {
        if (settings.Length != 0x30)
        {
            throw new ArgumentException("DSi memory-bank settings must contain exactly 48 bytes.", nameof(settings));
        }
 
        _memoryBankSettings = settings.ToArray();
        return this;
    }

    public NdsDsiBuildMetadata SetAgeRatings(ReadOnlySpan<byte> ratings)
    {
        if (ratings.Length != 0x10)
        {
            throw new ArgumentException("DSi age ratings must contain exactly sixteen bytes.", nameof(ratings));
        }
 
        _ageRatings = ratings.ToArray();
        return this;
    }

    internal ReadOnlyMemory<byte> ExtensionTemplate => _extensionTemplate;

    internal ReadOnlyMemory<byte> MemoryBankSettings => _memoryBankSettings;

    internal ReadOnlyMemory<byte> AgeRatings => _ageRatings;

    internal void AnchorModcryptAreas(IEnumerable<NdsProgram> programs)
    {
        NdsProgram[] candidates = programs.ToArray();
        (_modcryptArea1Anchor, _modcryptArea1RelativeOffset) = FindAnchor(ModcryptArea1, candidates);
        (_modcryptArea2Anchor, _modcryptArea2RelativeOffset) = FindAnchor(ModcryptArea2, candidates);
    }

    internal NdsRegion ResolveModcryptArea(NdsRegion area, bool first, NdsImageBuildLayout layout)
    {
        NdsProcessor? anchor = first ? _modcryptArea1Anchor : _modcryptArea2Anchor;
        long relativeOffset = first ? _modcryptArea1RelativeOffset : _modcryptArea2RelativeOffset;
        if (anchor is null)
        {
            return area;
        }
 
        NdsRegion program = anchor switch
        {
            NdsProcessor.Arm9 => layout.Arm9,
            NdsProcessor.Arm7 => layout.Arm7,
            NdsProcessor.Arm9i => layout.Arm9i!.Value,
            NdsProcessor.Arm7i => layout.Arm7i!.Value,
            _ => throw new InvalidDataException($"Unsupported modcrypt Program anchor {anchor}."),
        };
        return new(checked(program.Offset + relativeOffset), area.Length);
    }

    private static (NdsProcessor? Anchor, long RelativeOffset) FindAnchor(
        NdsRegion area,
        IReadOnlyList<NdsProgram> programs)
    {
        if (area.IsEmpty)
        {
            return (null, 0);
        }
 
        NdsProgram? program = programs.FirstOrDefault(candidate =>
            area.Offset >= candidate.Data.Offset && area.Offset < candidate.Data.End);
        return program is null
            ? (null, 0)
            : (program.Processor, area.Offset - program.Data.Offset);
    }

    private static byte[] CreateDefaultMemoryBankSettings() =>
    [
        0x81, 0x85, 0x89, 0x8D, 0x80, 0x84, 0x88, 0x8C, 0x90, 0x94, 0x98, 0x9C,
        0x80, 0x84, 0x88, 0x8C, 0x90, 0x94, 0x98, 0x9C,
        0x00, 0x00, 0x00, 0x00, 0x40, 0x37, 0xC0, 0x07, 0x00, 0x37, 0x40, 0x07,
        0x00, 0x30, 0x40, 0x00, 0x40, 0x37, 0xC0, 0x07, 0x00, 0x37, 0x40, 0x07,
        0x0F, 0x00, 0x00, 0x03,
    ];
}