NdsFileSystem.cs

using System.Diagnostics.CodeAnalysis;
 
namespace NdsForge;

public sealed class NdsFileSystem
{
    private readonly Dictionary<string, NdsFile> _filesByPath;
    private readonly Dictionary<int, NdsFile> _filesById;
    private readonly Dictionary<string, NdsDirectory> _directoriesByPath;

    internal NdsFileSystem(
        NdsDirectory root,
        IReadOnlyList<NdsDirectory> directories,
        IReadOnlyList<NdsFile> files,
        IReadOnlyList<NdsFileAllocation> allocations)
    {
        Root = root;
        Directories = directories;
        Files = files;
        Allocations = allocations;
        _filesByPath = files.ToDictionary(static file => file.FullPath, StringComparer.Ordinal);
        _filesById = files.ToDictionary(static file => file.Id);
        _directoriesByPath = directories.ToDictionary(static directory => directory.FullPath, StringComparer.Ordinal);
    }

    public NdsDirectory Root { get; }

    public IReadOnlyList<NdsDirectory> Directories { get; }

    public IReadOnlyList<NdsFile> Files { get; }

    public IReadOnlyList<NdsFileAllocation> Allocations { get; }

    public NdsFile GetFile(string path)
    {
        string normalized = NormalizePath(path);
        return _filesByPath.TryGetValue(normalized, out NdsFile? file)
            ? file
            : throw new FileNotFoundException($"NitroFS file '{normalized}' was not found.", normalized);
    }

    public bool TryGetFile(string path, [NotNullWhen(true)] out NdsFile? file) =>
        _filesByPath.TryGetValue(NormalizePath(path), out file);

    public NdsDirectory GetDirectory(string path)
    {
        string normalized = NormalizeDirectoryPath(path);
        return _directoriesByPath.TryGetValue(normalized, out NdsDirectory? directory)
            ? directory
            : throw new DirectoryNotFoundException($"NitroFS directory '{normalized}' was not found.");
    }

    public bool TryGetDirectory(string path, [NotNullWhen(true)] out NdsDirectory? directory) =>
        _directoriesByPath.TryGetValue(NormalizeDirectoryPath(path), out directory);

    public NdsFile GetFile(int fileId) => _filesById.TryGetValue(fileId, out NdsFile? file)
        ? file
        : throw new KeyNotFoundException($"No named NitroFS file has ID {fileId}.");

    internal bool TryGetFile(int fileId, [NotNullWhen(true)] out NdsFile? file) =>
        _filesById.TryGetValue(fileId, out file);

    private static string NormalizePath(string path)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(path);
        string normalized = path.Replace('\\', '/');
        if (!normalized.StartsWith('/'))
        {
            normalized = "/" + normalized;
        }
 
        if (normalized.EndsWith('/') ||
            normalized.Contains("//", StringComparison.Ordinal))
        {
            throw new ArgumentException("NitroFS paths must identify a file and contain no empty segments.", nameof(path));
        }
 
        foreach (string segment in normalized.Split('/', StringSplitOptions.RemoveEmptyEntries))
        {
            if (segment is "." or "..")
            {
                throw new ArgumentException("NitroFS paths cannot contain traversal segments.", nameof(path));
            }
        }
 
        return normalized;
    }

    private static string NormalizeDirectoryPath(string path)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(path);
        string normalized = path.Replace('\\', '/');
        if (!normalized.StartsWith('/'))
        {
            normalized = "/" + normalized;
        }
 
        if (normalized.Length > 1 && normalized.EndsWith('/'))
        {
            normalized = normalized.TrimEnd('/');
        }
 
        if (normalized.Contains("//", StringComparison.Ordinal) ||
            normalized.Split('/', StringSplitOptions.RemoveEmptyEntries).Any(static segment => segment is "." or ".."))
        {
            throw new ArgumentException("NitroFS directory paths cannot contain empty or traversal segments.", nameof(path));
        }
 
        return normalized;
    }
}