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

        }

    }

​

[ProtoContract]

    public class Building : Component<BuildingMetadata>

    {

        [ProtoMember(1)]

        public string Id { get; set; }

​

        [ProtoMember(2)]

        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]

    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 == null ? null : JsonConvert.SerializeObject(Value); set => Value = (value == null ? null : JsonConvert.DeserializeObject<JToken>(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(1, typeof(Component<ComponentMetadata>))] This has to be removed, or serializing an instance of ComponentBase will crash.

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

    {

        [ProtoMember(1)]

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

​

        [ProtoMember(2)]

        public string Model => Metadata.Model;

​

        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]

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

    }

​

[ProtoContract]

    public class InnerComponent : Component<ComponentMetadata>

    {

        [ProtoMember(1)]

        [JsonIgnore]

        public string tag { get; set; }

    }

​

    class TestClass

    {

        public static void Test()

        {

            // TestPropertyMetadata();

            // TestComponentBase();

            TestBuilding();

        }

​

        static void TestBuilding()

        {

            PropertyMetadata propertyMetaData = new()

            {

                Value = JToken.Parse(GetJson()),

                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(GetJson()),

                },

            };

            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.That(JToken.DeepEquals(test1.Metadata.PropertyMetadata["propKey1"].Value, test1.Metadata.PropertyMetadata["propKey1"].Value));

            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(test1.Metadata.PropertyMetadata.Keys.SequenceEqual(test2.Metadata.PropertyMetadata.Keys)); -- Throws an error

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

        }

​

        static void TestPropertyMetadata()

        {

            PropertyMetadata test1 = new()

            {

                Value = JToken.Parse(GetJson()),

                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()

        {

            ComponentBase test1 = new()

            {

                Properties =

                {

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

                },

            };

​

            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 string GetJson() => @"{""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;

        }

    }

}