using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

​

using System.Text.Json;

using System.Text.Json.Serialization;

​

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

​

using NuGet.Versioning;

​

//https://stackoverflow.com/questions/75422403/how-do-i-deserialize-nuget-nugetversion-into-a-class-in-c

​

#nullable enable

​

    public class NuGetVersionConverter : System.Text.Json.Serialization.JsonConverter<NuGetVersion>

    {

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

            NuGetVersion.Parse(reader.GetString());

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

            writer.WriteStringValue(value.ToString());

    }

    public class VersionRangeConverter : System.Text.Json.Serialization.JsonConverter<VersionRange>

    {

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

            VersionRange.Parse(reader.GetString());

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

            // ToString()->Parse()->ToString() adapted from https://github.com/NuGet/NuGet.Client/blob/f24bad0668193ce21a1db8cabd1ce95ba509c7f0/src/NuGet.Core/NuGet.Protocol/Converters/VersionRangeConverter.cs#L41

            // Though in all honesty I'm not sure why the round-trip is necessary.

            writer.WriteStringValue((VersionRange.Parse(value.ToString())).ToString());

    }

    // TODO: 

    // VersionInfoConverter, https://github.com/NuGet/NuGet.Client/blob/3c5cea96aa281d0703d7334d16be14fe8a7e0918/src/NuGet.Core/NuGet.Protocol/Converters/VersionInfoConverter.cs

    // FingerprintsConverter, https://github.com/NuGet/NuGet.Client/blob/f24bad0668193ce21a1db8cabd1ce95ba509c7f0/src/NuGet.Core/NuGet.Protocol/Converters/FingerprintsConverter.cs

​

    public class Nuget

    {

        public string? Name { get; set; }

        public string? Id { get; set; }

        [System.Text.Json.Serialization.JsonConverter(typeof(NuGetVersionConverter))] 

        public NuGetVersion Version { get; set; }

        public string? PackageSource { get; set; }

        public System.DateTimeOffset BlobCreation { get; set; }

    }

​

    class TestClass

    {

        public static void Test()

        {

            var nuget1 = new Nuget

            {

                Name = "NuGet.Versioning",

                Id = "NuGet.Versioning",

                Version = NuGetVersion.Parse("6.0.3-rc.1"),

                BlobCreation = DateTimeOffset.Parse("2022-11-09T19:09:55.7275382+00:00"),

            };

            var options = new JsonSerializerOptions

            {

                Converters = { new NuGetVersionConverter(), new VersionRangeConverter(), new JsonStringEnumConverter(JsonNamingPolicy.CamelCase) },

                DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,

                // Other options as required

                WriteIndented = true,

            };

            var json = JsonSerializer.Serialize(nuget1, options);

            Console.WriteLine(json);

            var nuget2 = JsonSerializer.Deserialize<Nuget>(json, options);

            Assert.AreEqual(nuget1.Version, nuget2?.Version);

            var json2 = Newtonsoft.Json.JsonConvert.SerializeObject(nuget1, Newtonsoft.Json.Formatting.Indented, NuGet.Protocol.JsonExtensions.ObjectSerializationSettings);

            Console.WriteLine(json2);

​

            var nuget3 = JsonSerializer.Deserialize<Nuget>(json2, options);

            Assert.AreEqual(nuget1.Version, nuget3?.Version);

            TestTestNuGetProtocolJsonExtensionsSettings(nuget1, json);

​

            TestNuGetProtocolJsonExtensionsFromJson(nuget1);

        }   

        static void TestTestNuGetProtocolJsonExtensionsSettings(Nuget nuget1, string json)

        {

            var nuget = Newtonsoft.Json.JsonConvert.DeserializeObject<Nuget>(json, 

                NuGet.Protocol.JsonExtensions.ObjectSerializationSettings);

            Assert.AreEqual(nuget1.Version, nuget?.Version);

        }

        static void TestNuGetProtocolJsonExtensionsFromJson(Nuget nuget1)

        {

            var json = NuGet.Protocol.JsonExtensions.ToJson(nuget1);

            var nuget = NuGet.Protocol.JsonExtensions.FromJson<Nuget>(json);

            Assert.AreEqual(nuget1.Version, nuget?.Version);

        }

    }

​

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

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

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

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​