using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.IO;

​

using System.Text.Json;

using System.Text.Json.Serialization;

using System.Text.Json.Nodes;

​

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

​

//https://stackoverflow.com/questions/75555849/deserialize-false-as-null-with-system-text-json

​

#nullable enable

​

    public class BoolConverter : JsonConverter<bool>

    {

        public override void Write(Utf8JsonWriter writer, bool value, JsonSerializerOptions options) =>

            writer.WriteBooleanValue(value);

        public override bool Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) =>

            reader.TokenType switch

            {

                JsonTokenType.True => true,

                JsonTokenType.False => false,

                JsonTokenType.Null => false,

                _ => throw new JsonException(),

            };

    }

​

    public static partial class JsonExtensions

    {

        public static JsonNode? ReplaceFalseWithNullProperties(this JsonNode? root)

        {

            foreach (var item in root.DescendantItemsAndSelf(false).Where(i => i.name != null && i.node is JsonValue v && v.TryGetValue<bool>(out var b) && b == false).ToList())

                ((JsonObject)item.parent!)[item.name!] = null;

            return root;

        }

    }

    public static partial class JsonExtensions

    {

        //Taken from https://stackoverflow.com/questions/73887517/how-to-recursively-descend-a-system-text-json-jsonnode-hierarchy-equivalent-to

        /// Recursively enumerates all JsonNodes (including their index or name and parent) in the given JsonNode object in document order.

        public static IEnumerable<(JsonNode? node, int? index, string? name, JsonNode? parent)> DescendantItemsAndSelf(this JsonNode? root, bool includeSelf = true) => 

            RecursiveEnumerableExtensions.Traverse(

                (node: root, index: (int?)null, name: (string?)null, parent: (JsonNode?)null),

                (i) => i.node switch

                {

                    JsonObject o => o.AsDictionary().Select(p => (p.Value, (int?)null, p.Key.AsNullableReference(), i.node.AsNullableReference())),

                    JsonArray a => a.Select((item, index) => (item, index.AsNullableValue(), (string?)null, i.node.AsNullableReference())),

                    _ => i.ToEmptyEnumerable(),

                }, includeSelf);

​

        static IEnumerable<T> ToEmptyEnumerable<T>(this T item) => Enumerable.Empty<T>();

        static T? AsNullableReference<T>(this T item) where T : class => item;

        static Nullable<T> AsNullableValue<T>(this T item) where T : struct => item;

        static IDictionary<string, JsonNode?> AsDictionary(this JsonObject o) => o;

    }

​

    public static partial class RecursiveEnumerableExtensions

    {

        // Rewritten from the answer by Eric Lippert https://stackoverflow.com/users/88656/eric-lippert

        // to "Efficient graph traversal with LINQ - eliminating recursion" http://stackoverflow.com/questions/10253161/efficient-graph-traversal-with-linq-eliminating-recursion

        // to ensure items are returned in the order they are encountered.

        public static IEnumerable<T> Traverse<T>(

            T root,

            Func<T, IEnumerable<T>> children, bool includeSelf = true)

        {

            if (includeSelf)

                yield return root;

            var stack = new Stack<IEnumerator<T>>();

            try

            {

                stack.Push(children(root).GetEnumerator());

                while (stack.Count != 0)

                {

                    var enumerator = stack.Peek();

                    if (!enumerator.MoveNext())

                    {

                        stack.Pop();

                        enumerator.Dispose();

                    }

                    else

                    {

                        yield return enumerator.Current;

                        stack.Push(children(enumerator.Current).GetEnumerator());

                    }

                }

            }

            finally

            {

                foreach (var enumerator in stack)

                    enumerator.Dispose();

            }

        }

    }

​

    public class SomeType { } // NOT INCUDED IN QUESTION

​

    public sealed class JsonDefinition {

       public string? Property { get; set; }

       public int? Property2 { get; set; }

       public NestedJsonType? Property3 { get; set; }

       public bool BoolProperty { get; set; }

    }

​

    public sealed class NestedJsonType{

       public SomeType? Property { get; set; }

    }

    class TestClass

    {

        public static void Test()

        {

            var input = GetJson();

​

            Console.WriteLine("Input JSON:");

            Console.WriteLine(input);

            Console.WriteLine("Preprocessed JsonNode:");

            Console.WriteLine(JsonNode.Parse(input, documentOptions : new() { CommentHandling = JsonCommentHandling.Skip }).ReplaceFalseWithNullProperties()?.ToJsonString());

            var options = new JsonSerializerOptions

            {

                PropertyNamingPolicy = JsonNamingPolicy.CamelCase,

                ReadCommentHandling = JsonCommentHandling.Skip,

                Converters = { new BoolConverter() },

                // Add other options as required:

                WriteIndented = true,

            };

            var model = JsonNode.Parse(input, documentOptions : new() { CommentHandling = JsonCommentHandling.Skip })

                .ReplaceFalseWithNullProperties()

                .Deserialize<JsonDefinition>(options);

​

​

            Console.WriteLine("\nRe-serialized {0}:", model);

            Console.WriteLine(JsonSerializer.Serialize(model, options));

        }   

        static string GetJson() =>

@"

{

   ""property"": false, // expected type: string

   ""property2"": false, // expected type: int

   ""property3"": { // data might be nested

      ""property"": false // expected type SomeType

   },

   ""boolProperty"" : false // expected type bool

}

";          

    }

​

    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("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;

            }

        }

    }

​