NdsFileNameTableWriter.cs

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

internal static class NdsFileNameTableWriter
{
    private const ushort RootDirectoryId = 0xF000;

    public static NdsFileSystemBuildSnapshot Write(
        IReadOnlyList<string> directories,
        IReadOnlyCollection<NdsBuildFile> files,
        int firstFileId)
    {
        var directoryIds = directories
            .Select((path, index) => (path, id: checked((ushort)(RootDirectoryId + index))))
            .ToDictionary(static value => value.path, static value => value.id, StringComparer.Ordinal);
        var filesByDirectory = files
            .GroupBy(static file => GetParent(file.Path), StringComparer.Ordinal)
            .ToDictionary(
                static group => group.Key,
                static group => group.OrderBy(static file => file.Path, StringComparer.Ordinal).ToArray(),
                StringComparer.Ordinal);
        var childrenByDirectory = directories
            .Where(static path => path != "/")
            .GroupBy(static path => GetParent(path), StringComparer.Ordinal)
            .ToDictionary(
                static group => group.Key,
                static group => group.Order(StringComparer.Ordinal).ToArray(),
                StringComparer.Ordinal);
        var orderedFiles = new List<NdsBuildFile>();
        var subtables = new byte[directories.Count][];
        var firstFileIds = new ushort[directories.Count];
        for (int index = 0; index < directories.Count; index++)
        {
            string directory = directories[index];
            firstFileIds[index] = checked((ushort)(firstFileId + orderedFiles.Count));
            NdsBuildFile[] directoryFiles = filesByDirectory.GetValueOrDefault(directory) ?? [];
            string[] childDirectories = childrenByDirectory.GetValueOrDefault(directory) ?? [];
            orderedFiles.AddRange(directoryFiles);
            subtables[index] = WriteSubtable(directoryFiles, childDirectories, directoryIds);
        }
 
        int mainTableLength = checked(directories.Count * 8);
        int totalLength = checked(mainTableLength + subtables.Sum(static data => data.Length));
        byte[] fnt = new byte[totalLength];
        int subtableOffset = mainTableLength;
        for (int index = 0; index < directories.Count; index++)
        {
            string directory = directories[index];
            int recordOffset = index * 8;
            BinaryPrimitives.WriteUInt32LittleEndian(fnt.AsSpan(recordOffset), checked((uint)subtableOffset));
            BinaryPrimitives.WriteUInt16LittleEndian(fnt.AsSpan(recordOffset + 4), firstFileIds[index]);
            ushort parent = directory == "/"
                ? checked((ushort)directories.Count)
                : directoryIds[GetParent(directory)];
            BinaryPrimitives.WriteUInt16LittleEndian(fnt.AsSpan(recordOffset + 6), parent);
            subtables[index].CopyTo(fnt, subtableOffset);
            subtableOffset += subtables[index].Length;
        }
 
        return new(fnt, orderedFiles, directoryIds, firstFileId);
    }

    private static byte[] WriteSubtable(
        IReadOnlyList<NdsBuildFile> files,
        IReadOnlyList<string> childDirectories,
        Dictionary<string, ushort> directoryIds)
    {
        using var stream = new MemoryStream();
        foreach (NdsBuildFile file in files)
        {
            WriteName(stream, GetName(file.Path), isDirectory: false);
        }
 
        foreach (string directory in childDirectories)
        {
            WriteName(stream, GetName(directory), isDirectory: true);
            ushort id = directoryIds[directory];
            stream.WriteByte((byte)id);
            stream.WriteByte((byte)(id >> 8));
        }
 
        stream.WriteByte(0);
        return stream.ToArray();
    }

    private static void WriteName(Stream stream, string name, bool isDirectory)
    {
        byte[] bytes = Encoding.Latin1.GetBytes(name);
        stream.WriteByte((byte)(bytes.Length | (isDirectory ? 0x80 : 0)));
        stream.Write(bytes);
    }

    private static string GetParent(string path)
    {
        int separator = path.LastIndexOf('/');
        return separator == 0 ? "/" : path[..separator];
    }

    private static string GetName(string path) => path[(path.LastIndexOf('/') + 1)..];
}