NdsBannerBuilder.cs

using System.Buffers.Binary;
using System.Text;
 
namespace NdsForge;

public sealed class NdsBannerBuilder
{
    private readonly Dictionary<NdsBannerLanguage, string> _titles = [];
    private byte[] _paletteIndices = new byte[32 * 32];
    private ushort[] _palette = new ushort[16];
    private readonly byte[][] _animatedPaletteIndices = Enumerable.Range(0, 8)
        .Select(static _ => new byte[32 * 32])
        .ToArray();
    private readonly ushort[][] _animatedPalettes = Enumerable.Range(0, 8)
        .Select(static _ => new ushort[16])
        .ToArray();
    private NdsBannerAnimationStep[] _animationSteps = [];

    public NdsBannerBuilder(ushort version = 1)
    {
        if (version is not (1 or 2 or 3 or 0x0103))
        {
            throw new ArgumentOutOfRangeException(nameof(version), "Banner version must be 1, 2, 3, or 0x0103.");
        }
 
        Version = version;
    }

    public ushort Version { get; }

    public NdsBannerBuilder SetTitle(NdsBannerLanguage language, string title)
    {
        ArgumentNullException.ThrowIfNull(title);
        if ((int)language >= GetLanguageCount() ||
            title.Length > 127 ||
            title.Contains('\0', StringComparison.Ordinal))
        {
            throw new ArgumentException("The title language or length is not supported by this banner version.", nameof(title));
        }
 
        _titles[language] = title;
        return this;
    }

    public NdsBannerBuilder SetIndexedIcon(
        ReadOnlySpan<byte> paletteIndices,
        ReadOnlySpan<ushort> bgr555Palette)
    {
        ValidateIcon(paletteIndices, bgr555Palette);
        _paletteIndices = paletteIndices.ToArray();
        _palette = bgr555Palette.ToArray();
        return this;
    }

    public NdsBannerBuilder SetAnimatedFrame(
        int frame,
        ReadOnlySpan<byte> paletteIndices,
        ReadOnlySpan<ushort> bgr555Palette)
    {
        EnsureAnimated();
        ArgumentOutOfRangeException.ThrowIfNegative(frame);
        ArgumentOutOfRangeException.ThrowIfGreaterThan(frame, 7);
        ValidateIcon(paletteIndices, bgr555Palette);
        _animatedPaletteIndices[frame] = paletteIndices.ToArray();
        _animatedPalettes[frame] = bgr555Palette.ToArray();
        return this;
    }

    public NdsBannerBuilder SetAnimationSequence(IEnumerable<NdsBannerAnimationStep> steps)
    {
        EnsureAnimated();
        ArgumentNullException.ThrowIfNull(steps);
        NdsBannerAnimationStep[] materialized = steps.ToArray();
        if (materialized.Length > 63)
        {
            throw new ArgumentException("A DSi animation accepts at most 63 poses plus its required terminator.", nameof(steps));
        }
 
        foreach (NdsBannerAnimationStep step in materialized)
        {
            step.Validate();
        }
 
        _animationSteps = materialized;
        return this;
    }

    public NdsBanner Build()
    {
        byte[] data = new byte[NdsBanner.GetSize(Version)];
        NdsBinary.WriteUInt16(data, 0, Version);
        WriteIcon(data);
        foreach ((NdsBannerLanguage language, string title) in _titles)
        {
            int offset = 0x240 + ((int)language * 0x100);
            Encoding.Unicode.GetBytes(title, data.AsSpan(offset, 0xFE));
        }
 
        if (Version == 0x0103)
        {
            WriteAnimation(data);
        }
 
        int crcCount = Version == 0x0103 ? 4 : Version;
        for (int slot = 0; slot < crcCount; slot++)
        {
            (int offset, int length) = NdsBanner.GetCrcRegion(slot);
            BinaryPrimitives.WriteUInt16LittleEndian(
                data.AsSpan(2 + (slot * 2)),
                NdsChecksums.ComputeCrc16(data.AsSpan(offset, length)));
        }
 
        return NdsBanner.Parse(data);
    }

    private void WriteIcon(Span<byte> data)
    {
        WriteTiles(data.Slice(0x20, 0x200), _paletteIndices);
        WritePalette(data.Slice(0x220, 0x20), _palette);
    }

    private void WriteAnimation(Span<byte> data)
    {
        for (int frame = 0; frame < 8; frame++)
        {
            WriteTiles(data.Slice(0x1240 + (frame * 0x200), 0x200), _animatedPaletteIndices[frame]);
            WritePalette(data.Slice(0x2240 + (frame * 0x20), 0x20), _animatedPalettes[frame]);
        }
 
        for (int index = 0; index < _animationSteps.Length; index++)
        {
            BinaryPrimitives.WriteUInt16LittleEndian(data[(0x2340 + (index * 2))..], _animationSteps[index].Pack());
        }
    }

    private static void WriteTiles(Span<byte> tiles, ReadOnlySpan<byte> paletteIndices)
    {
        for (int y = 0; y < 32; y++)
        {
            for (int x = 0; x < 32; x += 2)
            {
                int tileOffset = ((((y / 8) * 4) + (x / 8)) * 32) + ((y % 8) * 4) + ((x % 8) / 2);
                byte low = paletteIndices[(y * 32) + x];
                byte high = paletteIndices[(y * 32) + x + 1];
                tiles[tileOffset] = (byte)(low | (high << 4));
            }
        }
    }

    private static void WritePalette(Span<byte> destination, ReadOnlySpan<ushort> palette)
    {
        for (int index = 0; index < palette.Length; index++)
        {
            BinaryPrimitives.WriteUInt16LittleEndian(destination[(index * 2)..], palette[index]);
        }
    }

    private static void ValidateIcon(ReadOnlySpan<byte> paletteIndices, ReadOnlySpan<ushort> bgr555Palette)
    {
        if (paletteIndices.Length != 32 * 32 || bgr555Palette.Length != 16)
        {
            throw new ArgumentException("A banner icon requires 1024 indices and 16 palette colors.");
        }
 
        if (paletteIndices.ContainsAnyExceptInRange((byte)0, (byte)15))
        {
            throw new ArgumentException("Banner palette indices must be between zero and 15.", nameof(paletteIndices));
        }
    }

    private void EnsureAnimated()
    {
        if (Version != 0x0103)
        {
            throw new InvalidOperationException("Animated frames require DSi banner version 0x0103.");
        }
    }

    private int GetLanguageCount() => Version switch
    {
        1 => 6,
        2 => 7,
        3 or 0x0103 => 8,
        _ => 0,
    };
}