using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.IO;

​

using System.Text.Json.Serialization;

using System.Text.Json;

​

using NUnit.Framework; // Throws NUnit.Framework.AssertionException

​

//https://stackoverflow.com/questions/74813998/how-to-deserialize-json-array-with-changeable-number-of-subarrays-using-system-t

​

#nullable enable

​

    public class Jagged2DOr1DListConverter : JsonConverterFactory

    {

        public virtual bool CanWrite => true;

        public override bool CanConvert(Type typeToConvert) => Get2DListItemType(typeToConvert) != null;

​

        public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options)

        {

            var itemType = Get2DListItemType(typeToConvert)!;

            var converterType = typeof(Jagged2DOr1DListConverter<>).MakeGenericType(itemType);

            return (JsonConverter)Activator.CreateInstance(converterType, new object [] { CanWrite })!;

        }

        static Type? Get2DListItemType(Type type)

        {

            if (!type.IsGenericType || type.GetGenericTypeDefinition() != typeof(List<>))

                return null;

            var midType = type.GetGenericArguments()[0];

            if (!midType.IsGenericType || midType.GetGenericTypeDefinition() != typeof(List<>))

                return null;

            var itemType = midType.GetGenericArguments()[0];

            if (itemType == typeof(string) || itemType == typeof(byte []))

                return itemType;

            // values declared as object are serialized polymorphically, so we can't say whether they will appear as JSON arrays, objects or primitives.  

            // So don't convert List<List<object>> automatically.

            if (itemType == typeof(object))

                return null; 

            // The following check could be enhanced to detect and allow conversion of List<List<Dictionary<TKey, TValue>>> types, since these are serialized as JSON objects rather than arrays.

            if (typeof(IEnumerable).IsAssignableFrom(itemType))

                return null;

            return itemType;

        }

    }

​

    public class Jagged2DOr1DListReadOnlyConverter : Jagged2DOr1DListConverter

    {

        public override bool CanWrite => false;

    }

​

    public class Jagged2DOr1DListConverter<TItem> : JsonConverter<List<List<TItem>>>

    {

        public Jagged2DOr1DListConverter() : this(true) {}

        public Jagged2DOr1DListConverter(bool canWrite) => CanWrite = canWrite;

​

        public bool CanWrite { get; }

​

        public override List<List<TItem>>? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)

        {

            if (reader.TokenType == JsonTokenType.Null)

                return null;

            else if (reader.TokenType != JsonTokenType.StartArray)

                throw new JsonException();

            List<List<TItem>> outerList = new();

            List<TItem>? innerList = null;

​

            while (reader.Read() && reader.TokenType != JsonTokenType.EndArray)

            {

                if (reader.TokenType == JsonTokenType.StartArray)

                {

                    if (outerList.Count > 0 && innerList != null)

                        throw new JsonException();  // Mixtures of items and lists of items are not implemented

                    var itemList = JsonSerializer.Deserialize<List<TItem>>(ref reader, options); // You could throw an exception here if itemList is null, if you want

                    outerList.Add(itemList!); // You could throw an exception here if the 

                }

                else

                {

                    if (innerList == null)

                    {

                        if (outerList.Count > 0)

                            throw new JsonException();  // Mixtures of items and lists of items are not implemented

                        outerList.Add(innerList = new ());

                    }

                    innerList.Add(JsonSerializer.Deserialize<TItem>(ref reader, options)!);

                }

            }

            return outerList;

        }

​

        public override void Write(Utf8JsonWriter writer, List<List<TItem>> value, JsonSerializerOptions options)

        {

            if (CanWrite && value.Count == 1)

            {

                JsonSerializer.Serialize(writer, value.First(), options);

            }

            else

            {

                writer.WriteStartArray();

                foreach (var item in value)

                    JsonSerializer.Serialize(writer, item, options);

                writer.WriteEndArray();

            }

        }

    }

​

    public class Data

    {

        //[JsonConverter(typeof(Jagged2DOr1DListConverter))]

        public List<List<decimal>> chart { get; set; } = new (); // Use int, double, float or decimal here, as required.

    }

​

    public class Root

    {

        public Data data { get; set; } = new();

    }

​

    class TestClass

    {

        public static void Test()

        {

            TestCanConvert();

            foreach (var json in GetJson())

            {

                TestReadWrite(json);

                TestReadOnly(json);

                TestTruncatedJson(json);

            }

        }   

​

        static void TestCanConvert()

        {

            var converter = new Jagged2DOr1DListConverter();

            Assert.That(converter.CanConvert(typeof(List<List<string>>)));

            Assert.That(converter.CanConvert(typeof(List<List<byte []>>)));

            Assert.That(!converter.CanConvert(typeof(List<List<object>>)));

            Assert.That(converter.CanConvert(typeof(List<List<Root>>)));

            Assert.That(!converter.CanConvert(typeof(List<List<string []>>)));

            Assert.That(!converter.CanConvert(typeof(List<List<byte [][]>>)));

            Assert.That(!converter.CanConvert(typeof(List<List<object []>>)));

            Assert.That(!converter.CanConvert(typeof(List<List<List<string>>>)));

            Assert.That(!converter.CanConvert(typeof(List<List<List<byte>>>)));

            Assert.That(!converter.CanConvert(typeof(List<List<List<object>>>)));

        }

        static void TestReadWrite(string json)

        {

            var options = new JsonSerializerOptions

            {

                Converters = { new Jagged2DOr1DListConverter() },

                // Other    

                WriteIndented = true,

            };

            var root = JsonSerializer.Deserialize<Root>(json, options);

            var newJson = JsonSerializer.Serialize(root, options);

            Console.WriteLine("Re-serialized {0}:", root);

            Console.WriteLine(newJson);

            AssertEqualsJson(json, newJson);

            var root2 = JsonSerializer.Deserialize<Root>(newJson, options);

            Assert.AreEqual(root?.data?.chart?.Count, root2?.data?.chart?.Count);

            Assert.AreEqual(root?.data?.chart?.SelectMany(i => i)?.Count(), root2?.data?.chart?.SelectMany(i => i)?.Count());

        }

​

        static void TestReadOnly(string json)

        {

            var options = new JsonSerializerOptions

            {

                Converters = { new Jagged2DOr1DListReadOnlyConverter() },

                // Other    

                WriteIndented = true,

            };

            var root = JsonSerializer.Deserialize<Root>(json, options);

            var newJson = JsonSerializer.Serialize(root, options);

            Console.WriteLine("Re-serialized {0}:", root);

            Console.WriteLine(newJson);

            //AssertEqualsJson(json, newJson);  Here the JSON will not be equal.

            var root2 = JsonSerializer.Deserialize<Root>(newJson, options);

            Assert.AreEqual(root?.data?.chart?.Count, root2?.data?.chart?.Count);

            Assert.AreEqual(root?.data?.chart?.SelectMany(i => i)?.Count(), root2?.data?.chart?.SelectMany(i => i)?.Count());

        }

​

        static void TestTruncatedJson(string json)

        {

            var options = new JsonSerializerOptions

            {

                Converters = { new Jagged2DOr1DListConverter() },

                // Other    

                PropertyNamingPolicy = JsonNamingPolicy.CamelCase,

                WriteIndented = true,

                ReadCommentHandling = JsonCommentHandling.Skip,

            };

​

            for (int i = 2; i < json.Length-1; i++)

            {

                var badJson = json.Substring(0, json.Length - i);

                var ex = Assert.Throws<JsonException>(() => JsonSerializer .Deserialize<Root>(badJson, options));

                if (i == 2)

                    Console.WriteLine(ex.Message);

            }

        }   

        static void AssertEqualsJson(string json1, string json2)

        {

            Assert.IsTrue(Newtonsoft.Json.Linq.JToken.DeepEquals(

                Newtonsoft.Json.Linq.JToken.Parse(json1, new Newtonsoft.Json.Linq.JsonLoadSettings { CommentHandling = Newtonsoft.Json.Linq.CommentHandling.Ignore }),

                Newtonsoft.Json.Linq.JToken.Parse(json2, new Newtonsoft.Json.Linq.JsonLoadSettings { CommentHandling = Newtonsoft.Json.Linq.CommentHandling.Ignore })

            ));

        }

        static IEnumerable<string> GetJson() => new []

        {

            """

            {"data" : { "chart": [ 1, 1 ] } }

            """,

            """

            {"data": {"chart": [ [ 1, 1 ],  [ 2, 2 ], [ 3, 3 ], [ 4, 4 ]]}}

            """

        };

    }

​

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("Environment version: {0} ({1})", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , Environment.Version);

            Console.WriteLine("System.Text.Json version: " + typeof(JsonSerializer).Assembly.FullName);

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

                Console.WriteLine("Failed with unhandled exception: ");

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​