using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Data;

using System.Globalization;

​

using System.Text.Json;

​

using MongoDB.Bson.IO;

using MongoDB.Bson;

using MongoDB.Bson.Serialization.Serializers;

using MongoDB.Bson.Serialization;

​

using Newtonsoft.Json.Linq;

​

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

​

#nullable enable

​

//https://stackoverflow.com/questions/62080252/convert-newtosoft-jobject-directly-to-bsondocument

​

    public static class BsonExtensions

    {

        // Rewritten from this answer https://stackoverflow.com/a/71175724 by https://stackoverflow.com/users/7818969/peebo

        // To https://stackoverflow.com/questions/62080252/convert-newtosoft-jobject-directly-to-bsondocument

        public static BsonDocument ToBsonDocument(this JsonElement e, bool writeRootArrayAsDocument = false, bool tryParseDateTimes = false) =>

            e.ValueKind switch

            {

                JsonValueKind.Object => 

                    new(e.EnumerateObject().Select(p => new BsonElement(p.Name, p.Value.ToBsonValue(tryParseDateTimes)))),

                // Newtonsoft converts arrays to documents by using the index as a key, so optionally do the same thing.

                JsonValueKind.Array when writeRootArrayAsDocument => 

                    new(e.EnumerateArray().Select((v, i)  => new BsonElement(i.ToString(NumberFormatInfo.InvariantInfo), v.ToBsonValue(tryParseDateTimes)))),

                _ => throw new NotSupportedException($"ToBsonDocument: {e}"),

            };

​

        public static BsonValue ToBsonValue(this JsonElement e, bool tryParseDateTimes = false) =>

            e.ValueKind switch

            {

                // TODO: determine whether you want strings that look like dates & times to be serialized as DateTime, DateTimeOffset, or just strings.

                JsonValueKind.String when tryParseDateTimes && e.TryGetDateTime(out var v) => BsonValue.Create(v),

                JsonValueKind.String => BsonValue.Create(e.GetString()),

                // TODO: decide whether to convert to Int64 unconditionally, or only when the value is larger than Int32

                JsonValueKind.Number when e.TryGetInt32(out var v) => BsonValue.Create(v),

                JsonValueKind.Number when e.TryGetInt64(out var v) => BsonValue.Create(v),

                // TODO: decide whether to convert floating values to decimal by default.  Decimal has more precision but a smaller range.

                //JsonValueKind.Number when e.TryGetDecimal(out var v) => BsonValue.Create(v),

                JsonValueKind.Number when e.TryGetDouble(out var v) => BsonValue.Create(v),

                JsonValueKind.Null => BsonValue.Create(null),

                JsonValueKind.True => BsonValue.Create(true),

                JsonValueKind.False => BsonValue.Create(false),

                JsonValueKind.Array => new BsonArray(e.EnumerateArray().Select(v => v.ToBsonValue(tryParseDateTimes))),

                JsonValueKind.Object => e.ToBsonDocument(false, tryParseDateTimes),

                _ => throw new NotSupportedException($"ToBsonValue: {e}"),

        };

    }

​

    class TestClass

    {

        public static void Test()

        {

            foreach (var json in GetJson())

            {

                Console.WriteLine();

                Test(json);

            }

        }

​

        public static void Test(string json)

        {

            using var jsonDoc = JsonDocument.Parse(json); // JsonDocument is disposable, and must be disposed to free up pooled memory.

            var bsonDoc = jsonDoc.RootElement.ToBsonDocument(true);

            // Verify that the BsonDocument is semantically identical to the original JSON.

            // Write it to JSON using the MongoDB driver

            // http://mongodb.github.io/mongo-csharp-driver/2.19/apidocs/html/T_MongoDB_Bson_IO_JsonOutputMode.htm

            var jsonWriterSettings = new JsonWriterSettings { OutputMode = JsonOutputMode.RelaxedExtendedJson };

            var newJson = bsonDoc.ToJson(jsonWriterSettings);

​

            //var newJson = bsonDoc.ToJson();

​

            Console.WriteLine(newJson); 

            // And assert that the old and new JSON are semantically identical

            if (jsonDoc.RootElement.ValueKind == JsonValueKind.Array)

                Assert.IsTrue(JToken.DeepEquals(JToken.Parse(json), new JArray(JObject.Parse(newJson).Properties().Select(p => p.Value)))); // Passes

            else

                Assert.IsTrue(JToken.DeepEquals(JToken.Parse(json), JToken.Parse(newJson))); // Passes

        }   

        static IEnumerable<string> GetJson() =>

            new []

            {

                "{\"name\":\"value\"}",

                """

                {

                    "glossary": {

                        "title": "example glossary",

                        "GlossDiv": {

                            "title": "S",

                            "GlossList": {

                                "GlossEntry": {

                                    "ID": "SGML",

                                    "SortAs": "SGML",

                                    "GlossTerm": "Standard Generalized Markup Language",

                                    "Acronym": "SGML",

                                    "Abbrev": "ISO 8879:1986",

                                    "GlossDef": {

                                        "para": "A meta-markup language, used to create markup languages such as DocBook.",

                                        "GlossSeeAlso": ["GML", "XML"]

                                    },

                                    "GlossSee": "markup"

                                }

                            }

                        }

                    }

                }

                """,

                """

                [1, 2, 3, null, "hello", [[0]], {"foo" : "bar"}, 15226303390001100]

                """,

                """

                { "datetime" : { "$date" : 152263033900000 } } 

                """,

            };

​

        public static void TestArray()

        {

            var json = 

                """

                [1, 2, 3, null, "hello", [[0]], {"foo" : "bar"}]

                """;

            // Turns out this will throw an exception.

            var bsonData = BsonDocument.Parse(json);

​

            var newJson = bsonData.ToJson();

            Console.WriteLine(newJson);

        }

    }

​

//https://www.mongodb.com/docs/v5.0/reference/mongodb-extended-json-v1/

//https://github.com/mongodb/specifications/blob/master/source/extended-json.rst#conversion-table

//https://www.mongodb.com/docs/drivers/csharp/current/fundamentals/data-formats/bson

//https://www.mongodb.com/docs/drivers/csharp/current/fundamentals/data-formats/bson/#std-label-csharp-bson-api

//https://mongodb.github.io/mongo-csharp-driver/2.19/apidocs/html/M_MongoDB_Bson_BsonDocument_Parse.htm

//https://mongodb.github.io/mongo-csharp-driver/2.19/apidocs/html/T_MongoDB_Bson_BsonValue.htm

//https://mongodb.github.io/mongo-csharp-driver/2.19/apidocs/html/T_MongoDB_Bson_BsonDocument.htm

//https://mongodb.github.io/mongo-csharp-driver/2.19/apidocs/html/M_MongoDB_Bson_BsonDocument_Parse.htm

//https://www.mongodb.com/docs/drivers/csharp/current/fundamentals/data-formats/bson/

//https://www.mongodb.com/docs/v6.0/reference/mongodb-extended-json-v1/

//https://mongodb.github.io/mongo-csharp-driver/2.19/apidocs/html/T_MongoDB_Bson_Serialization_BsonSerializationArgs.htm

​

​

    public class Program

    {

        public static void Main()

        {

            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("{0} version: {1}", typeof(BsonDocument).Assembly.GetName().Name,  typeof(BsonDocument).Assembly.FullName);

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

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

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​