NdsImage.cs

namespace NdsForge;

public sealed class NdsImage : IDisposable, IAsyncDisposable
{
    private readonly IImageDataSource _source;
    private bool _disposed;

    internal NdsImage(
        IImageDataSource source,
        NdsHeader header,
        NdsFileSystem fileSystem,
        IReadOnlyList<NdsOverlay> arm9Overlays,
        IReadOnlyList<NdsOverlay> arm7Overlays,
        NdsBanner? banner)
    {
        _source = source;
        Header = header;
        FileSystem = fileSystem;
        Arm9Overlays = arm9Overlays;
        Arm7Overlays = arm7Overlays;
        Banner = banner;
    }

    public NdsHeader Header { get; }

    public NdsFileSystem FileSystem { get; }

    public IReadOnlyList<NdsOverlay> Arm9Overlays { get; }

    public IReadOnlyList<NdsOverlay> Arm7Overlays { get; }

    public NdsBanner? Banner { get; }

    public long Length => _source.Length;

    public static async ValueTask<NdsImage> OpenAsync(
        string path,
        NdsReadOptions? options = null,
        CancellationToken cancellationToken = default)
        => await NdsImageLoader.OpenPathAsync(path, options, cancellationToken).ConfigureAwait(false);

    public static NdsImage Open(
        Stream stream,
        bool leaveOpen = false,
        NdsReadOptions? options = null)
        => NdsImageLoader.OpenStream(stream, leaveOpen, options);

    public static async ValueTask<NdsImage> OpenAsync(
        Stream stream,
        bool leaveOpen = false,
        NdsReadOptions? options = null,
        CancellationToken cancellationToken = default)
        => await NdsImageLoader.OpenStreamAsync(stream, leaveOpen, options, cancellationToken).ConfigureAwait(false);

    public static NdsImage Load(ReadOnlyMemory<byte> data, NdsReadOptions? options = null)
        => NdsImageLoader.LoadMemory(data, options);

    public Stream OpenRead(NdsRegion region)
    {
        ObjectDisposedException.ThrowIf(_disposed, this);
        ValidateRegion(region, Length);
        return new ImageSliceStream(_source, region);
    }

    public async ValueTask CopyToAsync(
        NdsRegion region,
        Stream destination,
        CancellationToken cancellationToken = default)
    {
        ObjectDisposedException.ThrowIf(_disposed, this);
        ArgumentNullException.ThrowIfNull(destination);
        if (!destination.CanWrite)
        {
            throw new ArgumentException("The image-region destination must be writable.", nameof(destination));
        }
 
        using Stream source = OpenRead(region);
        await source.CopyToAsync(destination, cancellationToken).ConfigureAwait(false);
    }

    public async ValueTask TransformModcryptAreaAsync(
        NdsModcryptArea area,
        Stream destination,
        NdsModcryptContext context,
        CancellationToken cancellationToken = default)
    {
        ObjectDisposedException.ThrowIf(_disposed, this);
        ArgumentNullException.ThrowIfNull(destination);
        ArgumentNullException.ThrowIfNull(context);
        NdsDsiHeader dsi = Header.Dsi ??
            throw new InvalidOperationException("A DS-only image does not declare modcrypt areas.");
        NdsRegion region = dsi.GetModcryptArea(area);
 
        using Stream source = OpenRead(region);
        await NdsModcrypt.TransformAsync(
            source,
            destination,
            region.Length,
            context,
            area,
            cancellationToken: cancellationToken).ConfigureAwait(false);
    }

    public ValueTask<NdsExtractionResult> ExtractAsync(
        string destination,
        NdsExtractionOptions? options = null,
        CancellationToken cancellationToken = default)
    {
        ObjectDisposedException.ThrowIf(_disposed, this);
        ArgumentException.ThrowIfNullOrWhiteSpace(destination);
        return new NdsImageExtractor(this, destination, options ?? NdsExtractionOptions.Default)
            .ExtractAsync(cancellationToken);
    }

    public NdsImageEditor Edit()
    {
        ObjectDisposedException.ThrowIf(_disposed, this);
        return new(this);
    }

    public NdsValidationResult Validate(NdsValidationOptions? options = null)
    {
        ObjectDisposedException.ThrowIf(_disposed, this);
        options ??= NdsValidationOptions.Default;
        options.Validate();
        return NdsImageValidator.Validate(this, options);
    }

    public ValueTask<NdsImageManifest> CreateManifestAsync(CancellationToken cancellationToken = default)
    {
        ObjectDisposedException.ThrowIf(_disposed, this);
        return NdsImageManifest.CaptureAsync(this, cancellationToken);
    }

    public ValueTask<NdsImageDiff> CompareAsync(
        NdsImage other,
        CancellationToken cancellationToken = default)
    {
        ObjectDisposedException.ThrowIf(_disposed, this);
        ArgumentNullException.ThrowIfNull(other);
        return NdsImageComparer.CompareAsync(this, other, cancellationToken);
    }

    public void Dispose()
    {
        if (_disposed)
        {
            return;
        }
 
        _source.Dispose();
        _disposed = true;
    }

    public async ValueTask DisposeAsync()
    {
        if (_disposed)
        {
            return;
        }
 
        await _source.DisposeAsync().ConfigureAwait(false);
        _disposed = true;
    }

    private static void ValidateRegion(NdsRegion region, long imageLength)
    {
        if (region.Offset < 0 || region.Length < 0 || region.Offset > imageLength - region.Length)
        {
            throw new ArgumentOutOfRangeException(nameof(region), "The region is outside the image.");
        }
    }
 
}