using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.IO;

using System.Data;

using System.ComponentModel;

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Converters;

using Newtonsoft.Json.Serialization;

using NUnit.Framework;

using ProtoBuf.Meta;

using ProtoBuf;

using static System.Net.Mime.MediaTypeNames;

​

//https://stackoverflow.com/questions/73767478/specified-method-is-not-supported-error-on-calling-grpc-service-using-protobuf-n

​

    [ProtoContract]

    public class Building : Component<BuildingMetadata>

    {

        [ProtoMember(1)]

        public string Id { get; set; }

​

        [ProtoMember(2)]

        public string tag { get; set; }

    }

​

    [ProtoContract]

    public class InnerComponent : Component<ComponentMetadata>

    {

        [ProtoMember(1)]

        [JsonIgnore]

        public string tag { get; set; }

    }

​

    [ProtoContract]

    public class BuildingMetadata : ComponentMetadata

    {

        [ProtoMember(1)]

        public BuildingType Type { get; set; }

​

        [ProtoMember(2)]

        public bool IsAttached { get; set; }

​

        public override object Clone()

        {

            var baseClone = base.Clone() as ComponentMetadata;

            return new BuildingMetadata()

            {

                Model = baseClone.Model,

                PropertyMetadata = baseClone.PropertyMetadata,

            };

        }

    }

​

    [ProtoContract]

    public enum BuildingType

    {

    }

​

    [ProtoContract]

    [ProtoInclude(1001, typeof(BuildingMetadata))] 

    public class ComponentMetadata : ICloneable

    {

        [ProtoMember(1)]

        public string Model { get; set; }

​

        [ProtoMember(2)]

        public IDictionary<string, PropertyMetadata> PropertyMetadata { get; set; } = new Dictionary<string, PropertyMetadata>();

​

        public virtual object Clone()

        {

            return new ComponentMetadata()

            {

                Model = Model,

                PropertyMetadata = PropertyMetadata.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.Clone() as PropertyMetadata),

            };

        }

    }

​

    [ProtoContract]

    public class PropertyMetadata : ICloneable

    {

        [ProtoMember(1)]

        string SerializedValue { get => Value?.ToString(Formatting.None); set => Value = (value == null ? null : JToken.Parse(value)); } // FIXED

​

        [JsonProperty("Value")]

        public JToken Value { get; set; }

​

        [ProtoMember(2)]

        [JsonProperty("Version")]

        public int Version { get; set; }

​

        [ProtoMember(3)]

        [JsonProperty("backVersion")]

        public int BackVersion { get; set; }

​

        [ProtoMember(4)]

        [JsonProperty("backCode")]

        public int BackCode { get; set; }

​

        [ProtoMember(5)]

        [JsonProperty("Description")]

        public string Description { get; set; }

​

        [ProtoMember(6)]

        [JsonProperty("createTime")]

        public string CreateTime { get; set; }

​

        public object Clone()

        {

            return new PropertyMetadata()

            {

                CreateTime = CreateTime ?? DateTime.UtcNow.ToString("o"),

            };

        }

    }

​

    [ProtoContract]

    public interface IComponent

    {

        ComponentMetadata GetMetadata();

​

        IEnumerable<(string name, IComponent component)> ListComponents();

​

        IEnumerable<(string name, JToken property)> ListProperties();

​

        bool TryGetProperty(string name, out JToken property);

​

        bool TryGetComponent(string name, out IComponent component);

    }

​

    [ProtoContract]

    [ProtoInclude(1002, typeof(Building))] 

    [ProtoInclude(1001, typeof(InnerComponent))] 

    public class Component<TMetadataType> : ComponentBase, IComponent where TMetadataType : ComponentMetadata, new()

    {

        [ProtoMember(1)]

        public TMetadataType Metadata { get; set; } = new TMetadataType();

​

        [ProtoMember(2)]

        public string Model { get => Metadata.Model; private set { } } // Private set required for serialization

​

        public IEnumerable<(string, IComponent)> ListComponents() => Components.Select(x => (x.Key, x.Value as IComponent));

​

        public IEnumerable<(string, JToken)> ListProperties() => Properties.Select(x => (x.Key, x.Value));

​

        public ComponentMetadata GetMetadata() => Metadata;

​

        public bool TryGetComponent(string name, out IComponent component)

        {

            component = null;

            if (!Components.TryGetValue(name, out var innerComponent))

            {

                return false;

            }

​

            component = innerComponent as IComponent;

            return true;

        }

​

        public bool TryGetProperty(string name, out JToken property) => Properties.TryGetValue(name, out property);

    }

​

    [ProtoContract]

    [ProtoInclude(1002, typeof(Component<BuildingMetadata>))] 

    [ProtoInclude(1001, typeof(Component<ComponentMetadata>))] 

    public class ComponentBase

    {

        [ProtoMember(1)]

        string SerializedProperties { get => Properties == null ? null : JsonConvert.SerializeObject(Properties); set => Properties = (value == null ? null : JsonConvert.DeserializeObject<Dictionary<string, JToken>>(value)); }

​

        public IDictionary<string, JToken> Properties { get; set; } = new Dictionary<string, JToken>();

​

        [ProtoMember(2)]

        public IDictionary<string, InnerComponent> Components { get; set; } = new Dictionary<string, InnerComponent>();

    }

​

    class TestClass

    {

        public static void Test()

        {

            Console.WriteLine(JToken.Parse( JToken.FromObject(DateTime.Today.AddMinutes(102.4)).ToString(Formatting.None)).ToString(Formatting.Indented));

            Console.WriteLine(JToken.Parse( JToken.Parse(@"""atomic value""").ToString(Formatting.None)).ToString(Formatting.Indented));

            // TestPropertyMetadata();

            // TestComponentBase();

            foreach (var json in GetJson())

            {

                TestBuilding(json);

            }

        }

​

        static void TestBuilding(string json)

        {

            PropertyMetadata propertyMetaData = new()

            {

                Value = JToken.Parse(json),

                Version = 3,

                BackVersion = 2,

                BackCode = 10101,

                Description = "description",

                CreateTime = "9/19/2022",

            };

​

            Building test1 = new()

            {

                Id = "building1",

                tag = "tag1",

                Metadata = new BuildingMetadata()

                {

                    IsAttached = true,

                    Model = "model1",

                    PropertyMetadata = new Dictionary<string, PropertyMetadata>()

                    {

                        { "propKey1", propertyMetaData },

                    },

                },

                Properties = {

                    ["foo"] = JToken.Parse(json),

                },

                Components = 

                {

                    ["foo"] = new InnerComponent { tag = "inner component tag" },

                }

            };

            using var stream = new MemoryStream();

​

            Serializer.Serialize(stream, test1);

​

            stream.Position = 0;

​

            var test2 = Serializer.Deserialize<Building>(stream);

​

            Assert.That(test1.Id.Equals(test2.Id));

            Assert.That(test1.tag.Equals(test2.tag));

​

            Assert.AreEqual(test1.Properties.Count, test2.Properties.Count);

            Assert.That(test1.Properties.Keys.SequenceEqual(test2.Properties.Keys)); // Throws an error

            Assert.That(test1.Properties.Values.Zip(test2.Properties.Values).All(p => JToken.DeepEquals(p.Item1, p.Item2)));

            Assert.That(test1.Metadata.IsAttached == test2.Metadata.IsAttached); // Throws an error

            Assert.That(test1.Metadata.Model.Equals(test2.Metadata.Model)); // Throws an error

            Assert.That(JToken.DeepEquals(test1.Metadata.PropertyMetadata["propKey1"].Value, test2.Metadata.PropertyMetadata["propKey1"].Value));

            Assert.AreEqual(test1.Metadata.PropertyMetadata.Count, test2.Metadata.PropertyMetadata.Count);

            Assert.That(test1.Metadata.PropertyMetadata.Keys.SequenceEqual(test2.Metadata.PropertyMetadata.Keys)); // Throws an error

            Assert.That(test1.Metadata.PropertyMetadata.Values.Select(v => JsonConvert.SerializeObject(v)).SequenceEqual(test2.Metadata.PropertyMetadata.Values.Select(v => JsonConvert.SerializeObject(v))));

            Assert.AreEqual(test1.Components.Count, test2.Components.Count);

            Assert.That(test1.Components.Values.Select(c => c?.tag).SequenceEqual(test2.Components.Values.Select(c => c?.tag))); // Fails

            Assert.That(test1.Components.Keys.SequenceEqual(test2.Components.Keys)); // Fails

            Assert.AreEqual(JsonConvert.SerializeObject(test1), JsonConvert.SerializeObject(test2));

            Console.WriteLine("Succesfully round-tripped {0}:\n", test2);

            Console.WriteLine(JsonConvert.SerializeObject(test2, Formatting.Indented));

        }

​

        static void TestPropertyMetadata(string json)

        {

            PropertyMetadata test1 = new()

            {

                Value = JToken.Parse(json),

                Version = 3,

                BackVersion = 2,

                BackCode = 10101,

                Description = "description",

                CreateTime = "9/19/2022",

            };

​

            using var stream = new MemoryStream();

​

            Serializer.Serialize(stream, test1);

​

            stream.Position = 0;

​

            var test2 = Serializer.Deserialize<PropertyMetadata>(stream);

​

            Assert.AreEqual(JsonConvert.SerializeObject(test1), JsonConvert.SerializeObject(test2));

​

            Assert.That(JToken.DeepEquals(test1.Value, test2.Value));

        }

​

        static void TestComponentBase(string json)

        {

            ComponentBase test1 = new()

            {

                Properties =

                {

                    ["foo"] = JToken.Parse(json),

                },

            };

​

            using var stream = new MemoryStream();

​

            Serializer.Serialize(stream, test1);

​

            stream.Position = 0;

​

            var test2 = Serializer.Deserialize<ComponentBase>(stream);

​

            Assert.That(test1.Properties.Keys.SequenceEqual(test2.Properties.Keys));

            Assert.That(test1.Properties.Values.Zip(test2.Properties.Values).All(p => JToken.DeepEquals(p.Item1, p.Item2)));

​

            Assert.AreEqual(JsonConvert.SerializeObject(test1), JsonConvert.SerializeObject(test2));

​

        }

​

        public static IEnumerable<string> GetJson() => new [] { 

            @"null",

            @"[null]",

            @"10101",

            @"""atomic value""",

            @"{""ccc"":"""",""ccc_file_name"":"""",""consent_id"":""120266"",""council_code"":""DEMO"",""date_cccissued"":null,""date_granted"":null,""date_issued"":null,""date_lodged"":""2012-05-03T00:00:00"",""days_inactive"":null,""days_live"":null,""days_suspended"":null,""form6_received"":null,""inspections"":""In Progress"",""issued"":"""",""last_updated"":null,""lodged"":""Accepted"",""processing"":"""",""rfis"":""Pending""}"

        };

    }

​

​

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;

        }

    }

}

​

#if false

[ProtoContract]

    public class ProtoBufInput

    {

        [ProtoMember(1)]

        public string Id { get; set; }

​

        [ProtoMember(2)]

        public Building BuildingObj { get; set; }

​

        [ProtoMember(3)]

        public byte[] Payload { get; set; }

​

        public ProtoBufInput(string id, Building buildingObj, byte[] payload) // Fixed BuildingObj => Building

        {

            BuildingObj = buildingObj;

            Id = id;

            Payload = payload;

        }

    }

​

[ProtoContract]

    public class ProtoBufResult

    {

        [ProtoMember(1)]

        public int RandomNumber { get; set; }

​

        [ProtoMember(2)]

        public bool RandomBool { get; set; }

​

        [ProtoMember(3)]

        public IList<string> ErrorMessages { get; set; }

​

        [ProtoMember(5)]

        public Building BuildingObj { get; set; }

​

        [ProtoMember(6)]

        public string RandomString { get; set; }

​

        public ProtoBufResult()

        {

            RandomNumber = 0;

            RandomBool = false;

        }

    }

#endif