using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

​

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Converters;

using Newtonsoft.Json.Serialization;    

​

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

​

//https://stackoverflow.com/questions/78167383/map-json-string-array-of-headers-and-nested-array-of-results-to-c-sharp-generic

​

#nullable enable

​

    public class ObjectWithResultArrayConverter<TModel> : JsonConverter<TModel> where TModel : class, new()

    {

        protected virtual string HeadersName => "header";

        protected virtual string ResultsName => "results";

        public override TModel? ReadJson(JsonReader reader, Type objectType, TModel? existingValue, bool hasExistingValue, JsonSerializer serializer)

        {

            if (!(serializer.ContractResolver.ResolveContract(objectType) is JsonObjectContract contract))

                throw new NotImplementedException("Contract is not a JsonObjectContract");

            var resultsProperty = contract.Properties.GetClosestMatchProperty(ResultsName);

            if (resultsProperty == null)

                throw new NotImplementedException($"No results property {ResultsName} found.");

            if (reader.MoveToContentAndAssert().TokenType == JsonToken.Null)

                return null;

            var jObj = JObject.Load(reader);

            var headers = jObj.GetValue(HeadersName, StringComparison.OrdinalIgnoreCase).RemoveFromLowestPossibleParent() as JArray;

            var results = jObj.GetValue(ResultsName, StringComparison.OrdinalIgnoreCase).RemoveFromLowestPossibleParent() as JArray;

​

            var value = existingValue ?? (TModel?)contract.DefaultCreator?.Invoke() ?? new TModel();

            // Populate TModel properties other than the results

            serializer.Populate(jObj.CreateReader(), value);

            // Populate TModel results.

            if (headers != null && results != null)

            {

                var resultsJArray = new JArray(results.Children<JArray>().Select(innerArray => new JObject(headers.Zip(innerArray, (h, i) => new JProperty((string)h!, i)))));

                var resultsValue = serializer.Deserialize(resultsJArray.CreateReader(), resultsProperty.PropertyType);

                resultsProperty.ValueProvider!.SetValue(value, resultsValue);

            }

            return value;

        }

        public override bool CanWrite => false;

        public override void WriteJson(JsonWriter writer, TModel? value, JsonSerializer serializer) => throw new NotImplementedException();

    }

​

    public static partial class JsonExtensions

    {

        public static JsonReader MoveToContentAndAssert(this JsonReader reader)

        {

            ArgumentNullException.ThrowIfNull(reader);

            if (reader.TokenType == JsonToken.None)       // Skip past beginning of stream.

                reader.ReadAndAssert();

            while (reader.TokenType == JsonToken.Comment) // Skip past comments.

                reader.ReadAndAssert();

            return reader;

        }

​

        public static JsonReader ReadAndAssert(this JsonReader reader)

        {

            ArgumentNullException.ThrowIfNull(reader);

            if (!reader.Read())

                throw new JsonReaderException("Unexpected end of JSON stream.");

            return reader;

        }

​

        public static TJToken? RemoveFromLowestPossibleParent<TJToken>(this TJToken? node) where TJToken : JToken

        {

            if (node == null)

                return null;

            JToken toRemove;

            var property = node.Parent as JProperty;

            if (property != null)

            {

                // Also detach the node from its immediate containing property -- Remove() does not do this even though it seems like it should

                toRemove = property;

                property.Value = null!;

            }

            else

            {

                toRemove = node;

            }

            if (toRemove.Parent != null)

                toRemove.Remove();

            return node;

        }

    }

​

    public class Model

    {

        public string? RootEntity { get; set; }

        public int Count { get; set; }

        public List<Item> Results { get; set; } = new();

    }

​

    public record Item(string Name, string Email, string Function);

​

    class TestClass

    {

        public static void Test()

        {

            var jsonString = GetJson();

​

            var settings = new JsonSerializerSettings

            {

                Converters = { new ObjectWithResultArrayConverter<Model>() },

                // Add other settings as required, e.g.

                ContractResolver = new CamelCasePropertyNamesContractResolver(),

            };

            var model = JsonConvert.DeserializeObject<Model>(jsonString, settings);

            var json2 = JsonConvert.SerializeObject(model, Formatting.Indented, settings);

​

            Console.WriteLine("Deserialized and re-serialized {0}:", model);

            Console.WriteLine(json2);

            Assert.AreEqual(JToken.Parse(jsonString).SelectToken("results")?.Count(), JToken.Parse(json2).SelectToken("results")?.Count());

        }   

        static string GetJson() =>

            """

            { /* Some comment */ 

                "rootEntity": "function",

                "count": 2,

                "header": /* Some comment */  [ /* Some comment */ 

                    "name",

                    "email",/* Some comment */ 

                    "function"

                ],

                "results": /* Some comment */ [

                    [

                        "12 HOURS",

                        "test@test.com",

                        "testing"

                    ],

                    [

                        "Example",/* Some comment */ 

                        "example@test.com",

                        "second"

                    ]

                ]/* Some comment */ 

            }           

            """;

    }

​

​

    public class Program

    {

        public static void Main()

        {

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

            Console.WriteLine("{0} version: {1}", typeof(JsonSerializer).Namespace, typeof(JsonSerializer).Assembly.FullName);

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

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

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​