NdsImageComparer.cs

using System.Globalization;
 
namespace NdsForge;

public static class NdsImageComparer
{
    public static async ValueTask<NdsImageDiff> CompareAsync(
        NdsImage left,
        NdsImage right,
        CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(left);
        ArgumentNullException.ThrowIfNull(right);
        NdsImageManifest leftManifest = await NdsImageManifest.CaptureAsync(left, cancellationToken).ConfigureAwait(false);
        NdsImageManifest rightManifest = await NdsImageManifest.CaptureAsync(right, cancellationToken).ConfigureAwait(false);
        return Compare(leftManifest, rightManifest);
    }

    public static NdsImageDiff Compare(NdsImageManifest left, NdsImageManifest right)
    {
        ArgumentNullException.ThrowIfNull(left);
        ArgumentNullException.ThrowIfNull(right);
        left.Validate();
        right.Validate();
        var differences = new List<NdsSemanticDifference>();
        CompareHeader(left.Header, right.Header, differences);
        CompareDsi(left.Dsi, right.Dsi, differences);
        ComparePrograms(left.Programs, right.Programs, differences);
        CompareDirectories(left.Directories, right.Directories, differences);
        CompareFiles(left.Files, right.Files, differences);
        CompareAllocations(left.Allocations, right.Allocations, differences);
        CompareOverlays(left.Overlays, right.Overlays, differences);
        CompareBanner(left.Banner, right.Banner, differences);
        AddValue(differences, "Image.PhysicalLength", left.PhysicalLength, right.PhysicalLength, NdsDifferenceKind.Relocated);
        AddValue(differences, "Image.Sha256", left.ImageSha256, right.ImageSha256);
        return new(left.ImageSha256, right.ImageSha256, differences);
    }

    private static void CompareDirectories(
        IEnumerable<string> left,
        IEnumerable<string> right,
        List<NdsSemanticDifference> output)
    {
        var leftSet = left.ToHashSet(StringComparer.Ordinal);
        var rightSet = right.ToHashSet(StringComparer.Ordinal);
        output.AddRange(leftSet.Except(rightSet, StringComparer.Ordinal).Select(path =>
            new NdsSemanticDifference("Directories[" + path + "]", NdsDifferenceKind.Removed, "present", null)));
        output.AddRange(rightSet.Except(leftSet, StringComparer.Ordinal).Select(path =>
            new NdsSemanticDifference("Directories[" + path + "]", NdsDifferenceKind.Added, null, "present")));
    }

    private static void CompareHeader(NdsManifestHeader left, NdsManifestHeader right, List<NdsSemanticDifference> output)
    {
        AddValue(output, "Header.Title", left.Title, right.Title);
        AddValue(output, "Header.GameCode", left.GameCode, right.GameCode);
        AddValue(output, "Header.MakerCode", left.MakerCode, right.MakerCode);
        AddValue(output, "Header.Kind", left.Kind, right.Kind);
        AddValue(output, "Header.Version", left.Version, right.Version);
        AddValue(output, "Header.RegionCode", left.RegionCode, right.RegionCode);
        AddValue(output, "Header.AutoStart", left.AutoStart, right.AutoStart);
        AddValue(output, "Header.UsedImageSize", left.UsedImageSize, right.UsedImageSize, NdsDifferenceKind.Relocated);
        AddValue(output, "Header.DeviceCapacityBytes", left.DeviceCapacityBytes, right.DeviceCapacityBytes, NdsDifferenceKind.Relocated);
        AddValue(output, "Header.NormalCardControl", left.NormalCardControl, right.NormalCardControl);
        AddValue(output, "Header.SecureCardControl", left.SecureCardControl, right.SecureCardControl);
        AddValue(output, "Header.Sha256", left.Sha256, right.Sha256);
    }

    private static void CompareDsi(NdsManifestDsi? left, NdsManifestDsi? right, List<NdsSemanticDifference> output)
    {
        if (left is null || right is null)
        {
            AddPresence(output, "Dsi", left, right);
            return;
        }
 
        AddValue(output, "Dsi.TitleId", left.TitleId, right.TitleId);
        AddValue(output, "Dsi.TotalImageSize", left.TotalImageSize, right.TotalImageSize, NdsDifferenceKind.Relocated);
        AddValue(output, "Dsi.RegionFlags", left.RegionFlags, right.RegionFlags);
        AddValue(output, "Dsi.AccessControl", left.AccessControl, right.AccessControl);
        AddValue(output, "Dsi.HasModcryptAreas", left.HasModcryptAreas, right.HasModcryptAreas);
        AddValue(output, "Dsi.UsesInsecureModcryptKey", left.UsesInsecureModcryptKey, right.UsesInsecureModcryptKey);
        CompareRegion("Dsi.ModcryptArea1", left.ModcryptArea1, right.ModcryptArea1, output);
        CompareRegion("Dsi.ModcryptArea2", left.ModcryptArea2, right.ModcryptArea2, output);
    }

    private static void ComparePrograms(
        IEnumerable<NdsManifestProgram> left,
        IEnumerable<NdsManifestProgram> right,
        List<NdsSemanticDifference> output)
    {
        Dictionary<NdsProcessor, NdsManifestProgram> leftMap = left.ToDictionary(static value => value.Processor);
        Dictionary<NdsProcessor, NdsManifestProgram> rightMap = right.ToDictionary(static value => value.Processor);
        foreach (NdsProcessor processor in leftMap.Keys.Union(rightMap.Keys).Order())
        {
            string path = $"Programs[{processor}]";
            bool hasBefore = leftMap.TryGetValue(processor, out NdsManifestProgram? before);
            bool hasAfter = rightMap.TryGetValue(processor, out NdsManifestProgram? after);
            if (!hasBefore || !hasAfter)
            {
                AddPresence(output, path, before, after);
                continue;
            }
 
            NdsManifestProgram leftProgram = before!;
            NdsManifestProgram rightProgram = after!;
            AddValue(output, path + ".Sha256", leftProgram.Sha256, rightProgram.Sha256);
            AddValue(output, path + ".Offset", leftProgram.Offset, rightProgram.Offset, NdsDifferenceKind.Relocated);
            AddValue(output, path + ".Length", leftProgram.Length, rightProgram.Length);
            AddValue(output, path + ".LoadAddress", leftProgram.LoadAddress, rightProgram.LoadAddress);
            AddValue(output, path + ".EntryAddress", leftProgram.EntryAddress, rightProgram.EntryAddress);
        }
    }

    private static void CompareFiles(
        IEnumerable<NdsManifestFile> left,
        IEnumerable<NdsManifestFile> right,
        List<NdsSemanticDifference> output)
    {
        Dictionary<string, NdsManifestFile> leftMap = left.ToDictionary(static value => value.Path, StringComparer.Ordinal);
        Dictionary<string, NdsManifestFile> rightMap = right.ToDictionary(static value => value.Path, StringComparer.Ordinal);
        foreach (string path in leftMap.Keys.Intersect(rightMap.Keys, StringComparer.Ordinal).Order(StringComparer.Ordinal))
        {
            CompareFile("Files[" + path + "]", leftMap[path], rightMap[path], output);
        }
 
        List<NdsManifestFile> removed = leftMap.Values.Where(file => !rightMap.ContainsKey(file.Path)).ToList();
        List<NdsManifestFile> added = rightMap.Values.Where(file => !leftMap.ContainsKey(file.Path)).ToList();
        foreach (NdsManifestFile before in removed.ToArray())
        {
            NdsManifestFile[] matches = added
                .Where(after => after.Sha256 == before.Sha256 && after.Length == before.Length)
                .ToArray();
            if (matches.Length != 1 || removed.Count(candidate => candidate.Sha256 == before.Sha256 && candidate.Length == before.Length) != 1)
            {
                continue;
            }
 
            NdsManifestFile after = matches[0];
            output.Add(new("Files.Path", NdsDifferenceKind.Moved, before.Path, after.Path));
            CompareFile("Files[" + after.Path + "]", before, after, output);
            removed.Remove(before);
            added.Remove(after);
        }
 
        output.AddRange(removed.Select(file => new NdsSemanticDifference(
            "Files[" + file.Path + "]", NdsDifferenceKind.Removed, file.Sha256, null)));
        output.AddRange(added.Select(file => new NdsSemanticDifference(
            "Files[" + file.Path + "]", NdsDifferenceKind.Added, null, file.Sha256)));
    }

    private static void CompareFile(
        string path,
        NdsManifestFile left,
        NdsManifestFile right,
        List<NdsSemanticDifference> output)
    {
        AddValue(output, path + ".Sha256", left.Sha256, right.Sha256);
        AddValue(output, path + ".FileId", left.FileId, right.FileId, NdsDifferenceKind.Renumbered);
        AddValue(output, path + ".Offset", left.Offset, right.Offset, NdsDifferenceKind.Relocated);
        AddValue(output, path + ".Length", left.Length, right.Length);
    }

    private static void CompareAllocations(
        IEnumerable<NdsManifestAllocation> left,
        IEnumerable<NdsManifestAllocation> right,
        List<NdsSemanticDifference> output)
    {
        Dictionary<int, NdsManifestAllocation> leftMap = left.ToDictionary(static value => value.FileId);
        Dictionary<int, NdsManifestAllocation> rightMap = right.ToDictionary(static value => value.FileId);
        foreach (int fileId in leftMap.Keys.Union(rightMap.Keys).Order())
        {
            string path = $"Allocations[{fileId}]";
            bool hasBefore = leftMap.TryGetValue(fileId, out NdsManifestAllocation? before);
            bool hasAfter = rightMap.TryGetValue(fileId, out NdsManifestAllocation? after);
            if (!hasBefore || !hasAfter)
            {
                AddPresence(output, path, before, after);
                continue;
            }
 
            NdsManifestAllocation leftAllocation = before!;
            NdsManifestAllocation rightAllocation = after!;
            AddValue(output, path + ".Sha256", leftAllocation.Sha256, rightAllocation.Sha256);
            AddValue(output, path + ".Offset", leftAllocation.Offset, rightAllocation.Offset, NdsDifferenceKind.Relocated);
            AddValue(output, path + ".Length", leftAllocation.Length, rightAllocation.Length);
        }
    }

    private static void CompareOverlays(
        IEnumerable<NdsManifestOverlay> left,
        IEnumerable<NdsManifestOverlay> right,
        List<NdsSemanticDifference> output)
    {
        Dictionary<string, NdsManifestOverlay> leftMap = left.ToDictionary(OverlayKey, StringComparer.Ordinal);
        Dictionary<string, NdsManifestOverlay> rightMap = right.ToDictionary(OverlayKey, StringComparer.Ordinal);
        foreach (string key in leftMap.Keys.Union(rightMap.Keys, StringComparer.Ordinal).Order(StringComparer.Ordinal))
        {
            string path = "Overlays[" + key + "]";
            bool hasBefore = leftMap.TryGetValue(key, out NdsManifestOverlay? before);
            bool hasAfter = rightMap.TryGetValue(key, out NdsManifestOverlay? after);
            if (!hasBefore || !hasAfter)
            {
                AddPresence(output, path, before, after);
                continue;
            }
 
            NdsManifestOverlay leftOverlay = before!;
            NdsManifestOverlay rightOverlay = after!;
            AddValue(output, path + ".Sha256", leftOverlay.Sha256, rightOverlay.Sha256);
            AddValue(output, path + ".FileId", leftOverlay.FileId, rightOverlay.FileId, NdsDifferenceKind.Renumbered);
            AddValue(output, path + ".FilePath", leftOverlay.FilePath, rightOverlay.FilePath, NdsDifferenceKind.Moved);
            AddValue(output, path + ".Offset", leftOverlay.Offset, rightOverlay.Offset, NdsDifferenceKind.Relocated);
            AddValue(output, path + ".Length", leftOverlay.Length, rightOverlay.Length);
            AddValue(output, path + ".LoadAddress", leftOverlay.LoadAddress, rightOverlay.LoadAddress);
            AddValue(output, path + ".RamSize", leftOverlay.RamSize, rightOverlay.RamSize);
            AddValue(output, path + ".BssSize", leftOverlay.BssSize, rightOverlay.BssSize);
            AddValue(output, path + ".StaticInitializerStart", leftOverlay.StaticInitializerStart, rightOverlay.StaticInitializerStart);
            AddValue(output, path + ".StaticInitializerEnd", leftOverlay.StaticInitializerEnd, rightOverlay.StaticInitializerEnd);
            AddValue(output, path + ".CompressedSize", leftOverlay.CompressedSize, rightOverlay.CompressedSize);
            AddValue(output, path + ".Flags", leftOverlay.Flags, rightOverlay.Flags);
        }
    }

    private static void CompareBanner(NdsManifestBanner? left, NdsManifestBanner? right, List<NdsSemanticDifference> output)
    {
        if (left is null || right is null)
        {
            AddPresence(output, "Banner", left, right);
            return;
        }
 
        AddValue(output, "Banner.Sha256", left.Sha256, right.Sha256);
        AddValue(output, "Banner.Offset", left.Offset, right.Offset, NdsDifferenceKind.Relocated);
        AddValue(output, "Banner.Length", left.Length, right.Length);
        AddValue(output, "Banner.Version", left.Version, right.Version);
        AddValue(output, "Banner.IsAnimated", left.IsAnimated, right.IsAnimated);
        foreach (string language in left.Titles.Keys.Union(right.Titles.Keys, StringComparer.Ordinal).Order(StringComparer.Ordinal))
        {
            left.Titles.TryGetValue(language, out string? before);
            right.Titles.TryGetValue(language, out string? after);
            AddValue(output, $"Banner.Titles[{language}]", before, after);
        }
    }

    private static void CompareRegion(
        string path,
        NdsManifestRegion left,
        NdsManifestRegion right,
        List<NdsSemanticDifference> output)
    {
        AddValue(output, path + ".Offset", left.Offset, right.Offset, NdsDifferenceKind.Relocated);
        AddValue(output, path + ".Length", left.Length, right.Length, NdsDifferenceKind.Relocated);
    }

    private static void AddPresence(List<NdsSemanticDifference> output, string path, object? left, object? right)
    {
        if (left is null && right is not null)
        {
            output.Add(new(path, NdsDifferenceKind.Added, null, "present"));
        }
        else if (left is not null && right is null)
        {
            output.Add(new(path, NdsDifferenceKind.Removed, "present", null));
        }
    }

    private static void AddValue<T>(
        List<NdsSemanticDifference> output,
        string path,
        T left,
        T right,
        NdsDifferenceKind kind = NdsDifferenceKind.Modified)
    {
        if (EqualityComparer<T>.Default.Equals(left, right))
        {
            return;
        }
 
        output.Add(new(path, kind, Format(left), Format(right)));
    }

    private static string? Format<T>(T value) => value switch
    {
        null => null,
        IFormattable formattable => formattable.ToString(null, CultureInfo.InvariantCulture),
        _ => value.ToString(),
    };

    private static string OverlayKey(NdsManifestOverlay overlay) => $"{overlay.Processor}:{overlay.OverlayId}";
}