NdsFileSystemBuilder.cs

using System.Collections.ObjectModel;
namespace NdsForge;

public sealed class NdsFileSystemBuilder
{
    private readonly SortedSet<string> _directories = new(StringComparer.Ordinal) { "/" };

    private readonly Dictionary<string, NdsBuildFile> _files = new(StringComparer.Ordinal);

    public IReadOnlyCollection<string> Directories => new ReadOnlyCollection<string>(_directories.ToArray());

    public IReadOnlyCollection<NdsBuildFile> Files => new ReadOnlyCollection<NdsBuildFile>(
        _files.Values.OrderBy(static file => file.Path, StringComparer.Ordinal).ToArray());

    public async ValueTask<NdsDirectoryImportResult> ImportDirectoryAsync(
        string sourceDirectory,
        string destinationDirectory = "/",
        NdsDirectoryImportOptions? options = null,
        CancellationToken cancellationToken = default)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(sourceDirectory);
        string destination = NormalizePath(destinationDirectory, allowRoot: true);
        options ??= NdsDirectoryImportOptions.Default;
        options.Validate();
        NdsHostDirectorySnapshot snapshot = await NdsHostDirectoryImporter.StageAsync(
            sourceDirectory,
            destination,
            options,
            cancellationToken).ConfigureAwait(false);
        return ApplyImport(snapshot, options.CollisionPolicy);
    }

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

    public NdsFileSystemBuilder CreateDirectory(string path)
    {
        string normalized = NormalizePath(path, allowRoot: true);
        EnsureParents(normalized);
        _directories.Add(normalized);
        return this;
    }

    public NdsFileSystemBuilder AddFile(string path, ReadOnlySpan<byte> contents)
    {
        string normalized = NormalizePath(path, allowRoot: false);
        if (_files.ContainsKey(normalized) || _directories.Contains(normalized))
        {
            throw new IOException($"NitroFS entry already exists: {normalized}");
        }
 
        string parent = GetParent(normalized);
        EnsureParents(parent);
        _directories.Add(parent);
        _files.Add(normalized, new(normalized, contents.ToArray()));
        return this;
    }

    public NdsFileSystemBuilder SetFile(string path, ReadOnlySpan<byte> contents)
    {
        string normalized = NormalizePath(path, allowRoot: false);
        if (_directories.Contains(normalized))
        {
            throw new IOException($"A directory already exists at {normalized}.");
        }
 
        string parent = GetParent(normalized);
        EnsureParents(parent);
        _directories.Add(parent);
        _files[normalized] = new(normalized, contents.ToArray());
        return this;
    }

    public NdsFileSystemBuilder RemoveFile(string path)
    {
        string normalized = NormalizePath(path, allowRoot: false);
        if (!_files.Remove(normalized))
        {
            throw new FileNotFoundException($"NitroFS file was not found: {normalized}", normalized);
        }
 
        return this;
    }

    public NdsFileSystemBuilder MoveFile(string sourcePath, string destinationPath)
    {
        string source = NormalizePath(sourcePath, allowRoot: false);
        string destination = NormalizePath(destinationPath, allowRoot: false);
        if (!_files.TryGetValue(source, out NdsBuildFile? file))
        {
            throw new FileNotFoundException($"NitroFS file was not found: {source}", source);
        }
 
        if (_files.ContainsKey(destination) || _directories.Contains(destination))
        {
            throw new IOException($"NitroFS entry already exists: {destination}");
        }
 
        string parent = GetParent(destination);
        EnsureParents(parent);
        _directories.Add(parent);
        _files.Remove(source);
        file.Path = destination;
        _files.Add(destination, file);
        return this;
    }

    public NdsFileSystemBuilder MoveDirectory(string sourcePath, string destinationPath)
    {
        string source = NormalizePath(sourcePath, allowRoot: false);
        string destination = NormalizePath(destinationPath, allowRoot: false);
        if (!_directories.Contains(source))
        {
            throw new DirectoryNotFoundException($"NitroFS directory was not found: {source}");
        }
 
        if (destination.StartsWith(source + "/", StringComparison.Ordinal))
        {
            throw new IOException("A directory cannot be moved into its own subtree.");
        }
 
        if (_directories.Contains(destination) || _files.ContainsKey(destination))
        {
            throw new IOException($"NitroFS entry already exists: {destination}");
        }
 
        EnsureParents(GetParent(destination));
        string[] affectedDirectories = _directories
            .Where(path => path == source || path.StartsWith(source + "/", StringComparison.Ordinal))
            .ToArray();
        NdsBuildFile[] affectedFiles = _files.Values
            .Where(file => file.Path.StartsWith(source + "/", StringComparison.Ordinal))
            .ToArray();
        foreach (string directory in affectedDirectories)
        {
            _directories.Remove(directory);
        }
 
        foreach (NdsBuildFile file in affectedFiles)
        {
            _files.Remove(file.Path);
        }
 
        foreach (string directory in affectedDirectories)
        {
            _directories.Add(destination + directory[source.Length..]);
        }
 
        foreach (NdsBuildFile file in affectedFiles)
        {
            file.Path = destination + file.Path[source.Length..];
            _files.Add(file.Path, file);
        }
 
        return this;
    }

    public NdsFileSystemBuilder RemoveDirectory(string path)
    {
        string normalized = NormalizePath(path, allowRoot: false);
        if (!_directories.Contains(normalized))
        {
            throw new DirectoryNotFoundException($"NitroFS directory was not found: {normalized}");
        }
 
        string prefix = normalized + "/";
        if (_directories.Any(value => value.StartsWith(prefix, StringComparison.Ordinal)) ||
            _files.Keys.Any(value => value.StartsWith(prefix, StringComparison.Ordinal)))
        {
            throw new IOException($"NitroFS directory is not empty: {normalized}");
        }
 
        _directories.Remove(normalized);
        return this;
    }

    internal NdsFileSystemBuildSnapshot BuildSnapshot(int firstFileId = 0)
    {
        string[] directories = _directories.Order(StringComparer.Ordinal).ToArray();
        if (directories.Length > 4096 || firstFileId < 0 || firstFileId + _files.Count > ushort.MaxValue + 1)
        {
            throw new InvalidDataException("NitroFS exceeds its 12-bit directory or 16-bit file-ID space.");
        }
 
        return NdsFileNameTableWriter.Write(directories, _files.Values.ToArray(), firstFileId);
    }

    private NdsDirectoryImportResult ApplyImport(
        NdsHostDirectorySnapshot snapshot,
        NdsFileCollisionPolicy collisionPolicy)
    {
        foreach (string directory in snapshot.Directories)
        {
            if (_files.ContainsKey(directory) ||
                _files.Keys.Any(file => directory.StartsWith(file + "/", StringComparison.Ordinal)))
            {
                throw new IOException($"A file blocks imported directory path {directory}.");
            }
        }
 
        foreach (NdsHostFileSnapshot file in snapshot.Files)
        {
            if (_directories.Contains(file.Path) ||
                _files.Keys.Any(existing => file.Path.StartsWith(existing + "/", StringComparison.Ordinal)))
            {
                throw new IOException($"A directory or parent file conflicts with imported payload {file.Path}.");
            }
 
            if (collisionPolicy == NdsFileCollisionPolicy.Fail && _files.ContainsKey(file.Path))
            {
                throw new IOException($"A NitroFS file already exists at imported path {file.Path}.");
            }
        }
 
        int directoryCount = snapshot.Directories.Count(directory => !_directories.Contains(directory));
        foreach (string directory in snapshot.Directories)
        {
            CreateDirectory(directory);
        }
 
        int fileCount = 0;
        int skipped = snapshot.SkippedLinks;
        long bytes = 0;
        foreach (NdsHostFileSnapshot file in snapshot.Files)
        {
            if (_files.ContainsKey(file.Path) && collisionPolicy == NdsFileCollisionPolicy.KeepExisting)
            {
                skipped++;
                continue;
            }
 
            SetFile(file.Path, file.Contents);
            fileCount++;
            bytes = checked(bytes + file.Contents.LongLength);
        }
 
        return new(fileCount, directoryCount, bytes, skipped);
    }

    private void EnsureParents(string path)
    {
        if (path == "/")
        {
            return;
        }
 
        if (_files.ContainsKey(path))
        {
            throw new IOException($"A file already occupies required directory path {path}.");
        }
 
        string parent = GetParent(path);
        EnsureParents(parent);
        _directories.Add(parent);
    }

    internal static string NormalizePath(string path, bool allowRoot)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(path);
        string normalized = path.Replace('\\', '/');
        if (!normalized.StartsWith('/'))
        {
            normalized = "/" + normalized;
        }
 
        if ((!allowRoot && normalized == "/") ||
            (normalized.Length > 1 && normalized.EndsWith('/')) ||
            normalized.Contains("//", StringComparison.Ordinal))
        {
            throw new ArgumentException("NitroFS path is empty or ambiguous.", nameof(path));
        }
 
        foreach (string segment in normalized.Split('/', StringSplitOptions.RemoveEmptyEntries))
        {
            if (segment is "." or ".." || segment.Length > 127 ||
                segment.Any(static value => value > 0xFF || value is '/' or '\\'))
            {
                throw new ArgumentException("NitroFS path contains a name that cannot be represented as one-byte FNT data.", nameof(path));
            }
        }
 
        return normalized;
    }

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