StatusCollection.cs

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text.Json;
using System.Text.Json.Serialization;

namespace JSONstat.IO;

/// <summary>
/// The legal forms of the <c>status</c> property: array (per cell), string
/// (uniform), object (per cell by linear key), or none.
/// See <c>../wiki/dataset-structure.md</c>.
/// </summary>
public enum StatusKind
{
    /// <summary>No status property present.</summary>
    None,

    /// <summary>An array with one status per value.</summary>
    Array,

    /// <summary>A single status string applied to all values.</summary>
    String,

    /// <summary>An object mapping linear indices to status codes.</summary>
    Object
}

/// <summary>
/// The dataset <c>status</c> property, normalized into one of the three legal
/// wire forms (array / string / object) plus an absent form.
/// </summary>
[JsonConverter(typeof(StatusCollectionConverter))]
public sealed class StatusCollection
{
    private readonly string?[]? _array;
    private readonly string? _single;
    private readonly Dictionary<string, string>? _object;

    private StatusCollection(StatusKind kind, string?[]? array, string? single, Dictionary<string, string>? obj)
    {
        Kind = kind;
        _array = array;
        _single = single;
        _object = obj;
    }

    /// <summary>The current wire form.</summary>
    public StatusKind Kind { get; }

    /// <summary>The per-cell array, when <see cref="Kind"/> is <see cref="StatusKind.Array"/>.</summary>
    internal string?[]? ArrayValues => _array;

    /// <summary>The uniform string, when <see cref="Kind"/> is <see cref="StatusKind.String"/>.</summary>
    internal string? StringValue => _single;

    /// <summary>The per-cell map, when <see cref="Kind"/> is <see cref="StatusKind.Object"/>.</summary>
    internal IReadOnlyDictionary<string, string>? ObjectValues => _object;

    /// <summary>An empty (absent) status.</summary>
    public static StatusCollection None() => new StatusCollection(StatusKind.None, null, null, null);

    /// <summary>Builds an array-form status.</summary>
    public static StatusCollection ArrayOf(string?[] values) => new StatusCollection(StatusKind.Array, values, null, null);

    /// <summary>Builds a uniform string-form status.</summary>
    public static StatusCollection StringOf(string value) => new StatusCollection(StatusKind.String, null, value, null);

    /// <summary>Builds an object-form status.</summary>
    public static StatusCollection ObjectOf(Dictionary<string, string> values) => new StatusCollection(StatusKind.Object, null, null, values);

    /// <summary>
    /// Resolves the status for the given linear index, applying the precedence
    /// object > array > string.
    /// </summary>
    public string? GetStatus(int linear)
    {
        switch (Kind)
        {
            case StatusKind.Object:
                return _object != null && _object.TryGetValue(linear.ToString(CultureInfo.InvariantCulture), out var s)
                    ? s
                    : null;
            case StatusKind.Array:
                return _array != null && linear >= 0 && linear < _array.Length ? _array[linear] : null;
            case StatusKind.String:
                return _single;
            default:
                return null;
        }
    }
}

/// <summary>Reads/writes <see cref="StatusCollection"/> (array, string, object, or absent).</summary>
internal sealed class StatusCollectionConverter : JsonConverter<StatusCollection>
{
    public override StatusCollection Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        switch (reader.TokenType)
        {
            case JsonTokenType.StartArray:
            {
                var list = new List<string>();
                while (reader.Read() && reader.TokenType != JsonTokenType.EndArray)
                {
                    list.Add(reader.TokenType == JsonTokenType.Null ? null! : reader.GetString()!);
                }
                return StatusCollection.ArrayOf(list.ToArray());
            }
            case JsonTokenType.String:
                return StatusCollection.StringOf(reader.GetString()!);
            case JsonTokenType.StartObject:
            {
                var dict = new Dictionary<string, string>();
                while (reader.Read())
                {
                    if (reader.TokenType == JsonTokenType.EndObject) break;
                    string key = reader.GetString()!;
                    if (!reader.Read()) throw new JsonException("Unexpected end of status object.");
                    dict[key] = reader.TokenType == JsonTokenType.Null ? null! : reader.GetString()!;
                }
                return StatusCollection.ObjectOf(dict);
            }
            default:
                throw new JsonException("JSON-stat 'status' must be an array, a string, or an object.");
        }
    }

    public override void Write(Utf8JsonWriter writer, StatusCollection value, JsonSerializerOptions options)
    {
        switch (value.Kind)
        {
            case StatusKind.String:
                writer.WriteStringValue(value.StringValue);
                return;
            case StatusKind.Array:
                writer.WriteStartArray();
                if (value.ArrayValues != null)
                {
                    foreach (var s in value.ArrayValues)
                    {
                        if (s is null) writer.WriteNullValue();
                        else writer.WriteStringValue(s);
                    }
                }
                writer.WriteEndArray();
                return;
            case StatusKind.Object:
                writer.WriteStartObject();
                if (value.ObjectValues != null)
                {
                    foreach (var kv in value.ObjectValues.OrderBy(p => ParseKey(p.Key)))
                    {
                        writer.WritePropertyName(kv.Key);
                        if (kv.Value is null) writer.WriteNullValue();
                        else writer.WriteStringValue(kv.Value);
                    }
                }
                writer.WriteEndObject();
                return;
            default:
                // Should not be written (WhenWritingNull + callers skip None).
                writer.WriteNullValue();
                return;
        }
    }

    private static int ParseKey(string key) =>
        int.TryParse(key, NumberStyles.Integer, CultureInfo.InvariantCulture, out var n) ? n : 0;
}