NdsImageManifest.cs

using System.Text.Json;
using System.Text.Json.Serialization;
 
namespace NdsForge;

public sealed class NdsImageManifest
{
    public const int CurrentSchemaVersion = 1;
    private static readonly JsonSerializerOptions JsonOptions = CreateJsonOptions(indented: false);

    public int SchemaVersion { get; init; } = CurrentSchemaVersion;
    public long PhysicalLength { get; init; }
    public string ImageSha256 { get; init; } = string.Empty;
    public NdsManifestHeader Header { get; init; } = new();
    public NdsManifestDsi? Dsi { get; init; }
    public IReadOnlyList<NdsManifestProgram> Programs { get; init; } = [];
    public IReadOnlyList<string> Directories { get; init; } = [];
    public IReadOnlyList<NdsManifestFile> Files { get; init; } = [];
    public IReadOnlyList<NdsManifestAllocation> Allocations { get; init; } = [];
    public IReadOnlyList<NdsManifestOverlay> Overlays { get; init; } = [];
    public NdsManifestBanner? Banner { get; init; }

    public static ValueTask<NdsImageManifest> CaptureAsync(
        NdsImage image,
        CancellationToken cancellationToken = default) =>
        NdsImageManifestCapture.CaptureAsync(image, cancellationToken);

    public string ToJson(bool indented = true)
    {
        Validate();
        return JsonSerializer.Serialize(this, CreateJsonOptions(indented));
    }

    public static NdsImageManifest ParseJson(string json)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(json);
        NdsImageManifest manifest = JsonSerializer.Deserialize<NdsImageManifest>(json, JsonOptions) ??
            throw new InvalidDataException("The JSON document did not contain an NDS image manifest.");
        manifest.Validate();
        return manifest;
    }

    public async ValueTask WriteJsonAsync(
        Stream destination,
        bool indented = true,
        CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(destination);
        if (!destination.CanWrite)
        {
            throw new ArgumentException("The manifest destination must be writable.", nameof(destination));
        }
 
        Validate();
        await JsonSerializer.SerializeAsync(
            destination,
            this,
            CreateJsonOptions(indented),
            cancellationToken).ConfigureAwait(false);
    }

    public static async ValueTask<NdsImageManifest> ReadJsonAsync(
        Stream source,
        CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(source);
        if (!source.CanRead)
        {
            throw new ArgumentException("The manifest source must be readable.", nameof(source));
        }
 
        NdsImageManifest manifest = await JsonSerializer.DeserializeAsync<NdsImageManifest>(
            source,
            JsonOptions,
            cancellationToken).ConfigureAwait(false) ??
            throw new InvalidDataException("The JSON document did not contain an NDS image manifest.");
        manifest.Validate();
        return manifest;
    }

    internal void Validate()
    {
        if (SchemaVersion != CurrentSchemaVersion || PhysicalLength < 0 || Header is null ||
            Programs is null || Directories is null || Files is null || Allocations is null || Overlays is null)
        {
            throw new InvalidDataException("The NDS image manifest schema or required fields are invalid.");
        }
 
        ValidateHash(ImageSha256, nameof(ImageSha256));
        ValidateHash(Header.Sha256, "Header.Sha256");
        if (Header.Title is null || Header.GameCode is null || Header.MakerCode is null ||
            !Enum.IsDefined(Header.Kind) ||
            Programs.Any(static value => value is null) ||
            Directories.Any(static value => value is null) ||
            Files.Any(static value => value is null) ||
            Allocations.Any(static value => value is null) ||
            Overlays.Any(static value => value is null))
        {
            throw new InvalidDataException("The manifest contains an invalid image kind or null collection entry.");
        }
 
        if (Programs.Select(static value => value.Processor).Distinct().Count() != Programs.Count ||
            Programs.Any(static value => !Enum.IsDefined(value.Processor) || value.Offset < 0 || value.Length < 0))
        {
            throw new InvalidDataException("Manifest Programs must have unique processors and non-negative regions.");
        }
 
        foreach (NdsManifestProgram program in Programs)
        {
            ValidateHash(program.Sha256, $"Programs[{program.Processor}].Sha256");
        }
 
        if (Directories.Distinct(StringComparer.Ordinal).Count() != Directories.Count ||
            Directories.Any(static value => string.IsNullOrEmpty(value) || !value.StartsWith('/')))
        {
            throw new InvalidDataException("Manifest directories must be unique canonical absolute paths.");
        }
 
        if (Files.Select(static value => value.Path).Distinct(StringComparer.Ordinal).Count() != Files.Count ||
            Files.Any(static value => string.IsNullOrWhiteSpace(value.Path) || value.FileId < 0 || value.Offset < 0 || value.Length < 0))
        {
            throw new InvalidDataException("Manifest files must have unique paths, valid File IDs, and non-negative regions.");
        }
 
        foreach (NdsManifestFile file in Files)
        {
            ValidateHash(file.Sha256, $"Files[{file.Path}].Sha256");
        }
 
        if (Allocations.Select(static value => value.FileId).Distinct().Count() != Allocations.Count ||
            Allocations.Any(static value => value.FileId < 0 || value.Offset < 0 || value.Length < 0))
        {
            throw new InvalidDataException("Manifest allocations must have unique File IDs and non-negative regions.");
        }
 
        foreach (NdsManifestAllocation allocation in Allocations)
        {
            ValidateHash(allocation.Sha256, $"Allocations[{allocation.FileId}].Sha256");
        }
 
        if (Overlays.Select(static value => $"{value.Processor}:{value.OverlayId}").Distinct(StringComparer.Ordinal).Count() != Overlays.Count ||
            Overlays.Any(static value =>
                value.Processor is not NdsProcessor.Arm9 and not NdsProcessor.Arm7 ||
                value.Offset.HasValue != value.Length.HasValue || value.Offset < 0 || value.Length < 0 ||
                value.Offset.HasValue != (value.Sha256 is not null)))
        {
            throw new InvalidDataException("Manifest Overlays must have unique DS processor identities and coherent payload regions.");
        }
 
        foreach (NdsManifestOverlay overlay in Overlays.Where(static value => value.Sha256 is not null))
        {
            ValidateHash(overlay.Sha256!, $"Overlays[{overlay.Processor}:{overlay.OverlayId}].Sha256");
        }
 
        if (Banner is not null)
        {
            if (Banner.Offset < 0 || Banner.Length < 0 || Banner.Titles is null)
            {
                throw new InvalidDataException("The manifest Banner contains an invalid region or title map.");
            }
 
            ValidateHash(Banner.Sha256, "Banner.Sha256");
        }
 
        if (Dsi is not null &&
            (Dsi.ModcryptArea1 is null || Dsi.ModcryptArea2 is null ||
             Dsi.ModcryptArea1.Offset < 0 || Dsi.ModcryptArea1.Length < 0 ||
             Dsi.ModcryptArea2.Offset < 0 || Dsi.ModcryptArea2.Length < 0))
        {
            throw new InvalidDataException("The manifest DSi modcrypt regions are incomplete or negative.");
        }
    }

    private static void ValidateHash(string? value, string name)
    {
        if (value is null || value.Length != 64 ||
            value.Any(static character => !char.IsAsciiHexDigit(character) || char.IsUpper(character)))
        {
            throw new InvalidDataException($"Manifest field {name} is not a canonical lowercase SHA-256 digest.");
        }
    }

    private static JsonSerializerOptions CreateJsonOptions(bool indented)
    {
        var options = new JsonSerializerOptions
        {
            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
            WriteIndented = indented,
            UnmappedMemberHandling = JsonUnmappedMemberHandling.Disallow,
        };
        options.Converters.Add(new JsonStringEnumConverter());
        return options;
    }
}