using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.IO;

using System.Data;

using System.Reflection;

using System.Threading.Tasks;

​

using System.Text.Json;

using System.Text.Json.Serialization;

using System.Text.Json.Serialization.Metadata;

using System.Text.Json.Nodes;

​

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

​

//https://stackoverflow.com/questions/76438672/how-can-we-deserialize-to-protobuf-from-huge-json-using-jsonserializer-deseriali

​

using OASISLevel2TrackingPacket;

​

#nullable enable

​

namespace OASISLevel2TrackingPacket

{

    [global::ProtoBuf.ProtoContract]

    public partial class EntityTracking

    {

        [global::ProtoBuf.ProtoMember(2, Name = @"TrackingData")]

        public global::System.Collections.Generic.List<EntityTrackingActivity> TrackingDatas { get; } = new global::System.Collections.Generic.List<EntityTrackingActivity>();      

    }

​

    [global::ProtoBuf.ProtoContract]

    public partial class Person : EntityTracking

    {

        [global::ProtoBuf.ProtoMember(1, Name = @"Name")]

        public string? Name { get; set; }

    }

​

    [global::ProtoBuf.ProtoContract]

    public partial class EntityTrackingActivity

    {

        [global::ProtoBuf.ProtoMember(1, Name = @"Id")]

        public int Id { get; set; }

    }

}

​

    public static partial class JsonExtensions

    {

        public static Action<JsonTypeInfo> InitializeProtoMemberNames(Type type) => typeInfo => 

        {

            if (typeInfo.Kind != JsonTypeInfoKind.Object)

                return;

            if (!type.IsAssignableFrom(typeInfo.Type))

                return;

            // Fix property name(s).

            foreach (var property in typeInfo.Properties)

            {

                // Set the JSON property name to be the same as ProtoMemberAttribute.Name

                var name = property.AttributeProvider?.GetCustomAttributes(typeof(global::ProtoBuf.ProtoMemberAttribute), true)

                    .OfType<global::ProtoBuf.ProtoMemberAttribute>()

                    .FirstOrDefault()

                    ?.Name;

                if (name != null)

                    property.Name = name;

            }

        };

​

        public static Action<JsonTypeInfo> InitializeGetOnlyListSetters(Type type) => typeInfo => 

        {

            if (typeInfo.Kind != JsonTypeInfoKind.Object)

                return;

            if (!type.IsAssignableFrom(typeInfo.Type))

                return;

            // Add synthetic list setters.

            foreach (var property in typeInfo.Properties)

            {

                if (property.Get != null && property.Set == null && property.PropertyType.GetListItemType() is {} itemType)

                {

                    var method = typeof(JsonExtensions).GetMethod(nameof(JsonExtensions.CreateGetOnlyListPropertySetter),

                                                                  BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static)!;

                    var genericMethod = method.MakeGenericMethod(new[] { itemType });

                    var setter = genericMethod.Invoke(null, new object[] { property }) as Action<object, object?>;

                    property.Set = setter;

                }

            }

        };

        static Action<Object,Object?>? CreateGetOnlyListPropertySetter<TItem>(JsonPropertyInfo property)

        {

            if (property.Get == null)

                return null;

            (var getter, var name) = (property.Get, property.Name);

            return (obj, value) =>

            {

                var oldValue = (List<TItem>?)getter(obj);

                var newValue = value as List<TItem>;

                if (newValue == oldValue)

                    return;

                else if (oldValue == null)

                    throw new JsonException("Cannot populate list ${name} in ${obj}.");

                oldValue.Clear();

                if (newValue != null)

                    oldValue.AddRange(newValue);

            };

        }

​

        static MemberInfo? GetMemberInfo(this JsonPropertyInfo property) => (property.AttributeProvider as MemberInfo);

        static Type? GetListItemType(this Type type) =>

            type.IsGenericType && type.GetGenericTypeDefinition() == typeof(List<>) ? type.GetGenericArguments()[0] : null;

    }

​

    public class TestClass

    {

        public static async Task Test()

        {

            var filename = "hugefile.json";

            var json = 

                """

                [{"Name":"My name is 0","TrackingData":[{"Id":0},{"Id":1}]},{"Name":"My name is 1","TrackingData":[{"Id":2},{"Id":3}]},{"Name":"My name is 2","TrackingData":[{"Id":4},{"Id":5}]},{"Name":"My name is 3","TrackingData":[{"Id":6},{"Id":7}]}]

                """;

            Console.WriteLine(json);

            await File.WriteAllTextAsync(filename, json);

            var options = new JsonSerializerOptions

            {

                TypeInfoResolver = new DefaultJsonTypeInfoResolver

                {

                    Modifiers = { 

                        JsonExtensions.InitializeProtoMemberNames(typeof(Person)), 

                        JsonExtensions.InitializeGetOnlyListSetters(typeof(Person)) 

                    },

                },

            };

            await using (FileStream fileStream = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize: 4096, useAsync: true))

            {

                IAsyncEnumerable<Person?> people = JsonSerializer.DeserializeAsyncEnumerable<Person?>(fileStream, options);

                await foreach (Person? person in people)

                {

                    Console.WriteLine($"Hello, my name is \"{person?.Name}\", my tracking data is {JsonSerializer.Serialize(person?.TrackingDatas.Select(t => t.Id))}!");

                    Assert.That(person?.TrackingDatas.Count > 0);

                }           

            }

        }

    }

​

    public class Program

    {

        public static async Task Main(string[] args)

        {

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

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

            Console.WriteLine();

​

            try

            {

                await TestClass.Test();

            }

            catch (Exception ex)

            {

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

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​

#if false

        public static void InitializePersonTypeInfo(JsonTypeInfo typeInfo)

        {

            foreach (var property in typeInfo.Properties)

            {

                // Set the JSON property name to be the same as ProtoMemberAttribute.Name

                var name = property.AttributeProvider?.GetCustomAttributes(typeof(global::ProtoBuf.ProtoMemberAttribute), true)

                    .OfType<global::ProtoBuf.ProtoMemberAttribute>()

                    .FirstOrDefault()

                    ?.Name;

                if (name != null)

                    property.Name = name;

                // 

                if (property.GetMemberInfo()?.Name == nameof(Person.TrackingDatas) && property.Set == null && property.Get != null)

                {

                    property.Set = (obj, value) =>

                    {

                        var newValue = value as List<EntityTrackingActivity>;

                        var oldValue = ((Person)obj).TrackingDatas;

                        if (newValue == oldValue)

                            return;

                        if (oldValue == null)

                            throw new JsonException("Cannot set ${nameof(Person.TrackingDatas)}");

                        oldValue.Clear();

                        if (newValue != null)

                            oldValue.AddRange(newValue);

                    };

                }

            }

​

#endif

​

​