using System;

using System.Collections.Generic;

using System.Text;

using System.Linq;

using System.Xml.Serialization;

using System.Xml;

using System.Xml.Linq;

using System.IO;

using System.Data;

using System.Runtime.Serialization;

using System.Runtime.Serialization.Formatters.Binary;

using System.IO.Compression;

using System.Reflection;

​

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

​

using Polenter.Serialization;

using Polenter.Serialization.Advanced;

using Polenter.Serialization.Core;

using Polenter.Serialization.Advanced.Deserializing;

using Polenter.Serialization.Advanced.Serializing;

​

//https://stackoverflow.com/questions/69840398/sharpserializer-ignore-attributes-properties-from-deserialization

​

    public class Root

    {

        public List<Model> Models { get; set; } = new ();

    }

​

    public class Model

    {

        public string Value { get; set; }

        [SharpSerializerIgnoreForDeserialize]

        public string IgnoreMe { get; set; }

    }

​

    [System.AttributeUsage(System.AttributeTargets.Property, AllowMultiple = false, Inherited = true)]

    public class SharpSerializerIgnoreForDeserializeAttribute : System.Attribute { }

​

    public class PropertyDeserializerDecorator : IPropertyDeserializer

    {

        readonly IPropertyDeserializer deserializer;

        public PropertyDeserializerDecorator(IPropertyDeserializer deserializer) => this.deserializer = deserializer ?? throw new ArgumentNullException();

        public virtual void Open(Stream stream) => deserializer.Open(stream);

        public virtual Property Deserialize() => deserializer.Deserialize();

        public virtual void Close() => deserializer.Close();

    }

​

    public class CustomPropertyDeserializer : PropertyDeserializerDecorator

    {

        Action<Property> deserializePropertyAction;

        public CustomPropertyDeserializer(IPropertyDeserializer deserializer, Action<Property> deserializePropertyAction = default) : base(deserializer) => this.deserializePropertyAction = deserializePropertyAction;

        public override Property Deserialize()

        {

            var property = base.Deserialize();

​

            if (deserializePropertyAction != null)

                property.WalkProperties(p => deserializePropertyAction(p));

            return property;

        }

    }

​

    public static partial class SharpSerializerExtensions

    {

        public static SharpSerializer Create(SharpSerializerXmlSettings settings, Action<Property> deserializePropertyAction = default)

        {

            // Adapted from https://github.com/polenter/SharpSerializer/blob/42f9a20b3934a7f2cece356cc8116a861cec0b91/SharpSerializer/SharpSerializer.cs#L139

            // By https://github.com/polenter

            var typeNameConverter = settings.AdvancedSettings.TypeNameConverter ??

                                                   new TypeNameConverter(

                                                       settings.IncludeAssemblyVersionInTypeName,

                                                       settings.IncludeCultureInTypeName,

                                                       settings.IncludePublicKeyTokenInTypeName);

            // SimpleValueConverter

            var simpleValueConverter = settings.AdvancedSettings.SimpleValueConverter ?? new SimpleValueConverter(settings.Culture, typeNameConverter);

            // XmlWriterSettings

            var xmlWriterSettings = new XmlWriterSettings

            {

                Encoding = settings.Encoding,

                Indent = true,

                OmitXmlDeclaration = true,

            };

            // XmlReaderSettings

            var xmlReaderSettings = new XmlReaderSettings

            {

                IgnoreComments = true,

                IgnoreWhitespace = true,

            };

            // Create Serializer and Deserializer

            var reader = new DefaultXmlReader(typeNameConverter, simpleValueConverter, xmlReaderSettings);

            var writer = new DefaultXmlWriter(typeNameConverter, simpleValueConverter, xmlWriterSettings);

​

            var _serializer = new XmlPropertySerializer(writer);

            var _deserializer = new CustomPropertyDeserializer(new XmlPropertyDeserializer(reader), deserializePropertyAction);

            var serializer = new SharpSerializer(_serializer, _deserializer)

            {

                //InstanceCreator = settings.InstanceCreator ?? new DefaultInstanceCreator(), -- InstanceCreator not present in SharpSerializer 3.0.1 

                RootName = settings.AdvancedSettings.RootName,

            };

            serializer.PropertyProvider.PropertiesToIgnore = settings.AdvancedSettings.PropertiesToIgnore;

            serializer.PropertyProvider.AttributesToIgnore = settings.AdvancedSettings.AttributesToIgnore;

            return serializer;

        }

        public static void WalkProperties(this Property property, Action<Property> action)

        {

            if (action == null || property == null)

                throw new ArgumentNullException();

            action(property);

​

            switch (property.Art)

            {

                case PropertyArt.Collection:

                    {

                        foreach (var item in ((CollectionProperty)property).Items)

                            item.WalkProperties(action);

                    }

                    break;

                case PropertyArt.Complex:

                    {

                        foreach (var item in ((ComplexProperty)property).Properties)

                            item.WalkProperties(action);

                    }

                    break;

                case PropertyArt.Dictionary:

                    {

                        foreach (var item in ((DictionaryProperty)property).Items)

                        {

                            item.Key.WalkProperties(action);

                            item.Value.WalkProperties(action);

                        }

                    }

                    break;

                case PropertyArt.MultiDimensionalArray:

                    {

                        foreach (var item in ((MultiDimensionalArrayProperty )property).Items)

                            item.Value.WalkProperties(action);

                    }

                    break;

                case PropertyArt.Null:

                case PropertyArt.Simple:

                case PropertyArt.Reference:

                    break;

                case PropertyArt.SingleDimensionalArray:

                    {

                        foreach (var item in ((SingleDimensionalArrayProperty)property).Items)

                            item.WalkProperties(action);

                    }

                    break;

                default:

                    throw new NotImplementedException(property.Art.ToString());

            }

        }

        public static void RemoveIgnoredChildProperties(Property p)

        {

            if (p.Art == PropertyArt.Complex)

            {

                var items = ((ComplexProperty)p).Properties;

                for (int i = items.Count - 1; i >= 0; i--)

                {

                    if (p.Type.GetProperty(items[i].Name)?.IsDefined(typeof(SharpSerializerIgnoreForDeserializeAttribute), true) == true)

                    {

                        items.RemoveAt(i);

                    }

                }

            }

        }

    }

​

    public class TestClass

    {

        public static void Test()

        {

            var test = new Root

            {

                Models = { new Model { Value = "value", IgnoreMe = "Ignore Me" } },

            };

            using var stream = new MemoryStream();

​

            var serializer = new SharpSerializer();

            serializer.Serialize(test, stream);

            stream.Position = 0;

            string xml;

            using (var reader = new StreamReader(stream, leaveOpen : true))

            {

                xml = reader.ReadToEnd();

            }

​

            Assert.IsTrue(xml.Contains("Ignore Me"));

            Console.WriteLine(xml);

​

            stream.Position = 0;

            var settings = new SharpSerializerXmlSettings();

            var customSerialzier = SharpSerializerExtensions.Create(settings, SharpSerializerExtensions.RemoveIgnoredChildProperties);

            var deserialized = (Root)customSerialzier.Deserialize(stream);

            deserialized.Dump();

            Assert.IsTrue(deserialized.Models.All(m => m.IgnoreMe == null));

        }

    }

​

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("Environment version: {0} ({1})", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , GetNetCoreVersion());

            Console.WriteLine("{0} version: {1}", typeof(SharpSerializer).Assembly.GetName().Name,  typeof(SharpSerializer).Assembly.FullName);

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

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

                Console.WriteLine(ex);

                throw;

            }

        }

        public static string GetNetCoreVersion()

        {

            //https://techblog.dorogin.com/how-to-detect-net-core-version-in-runtime-ecd65ad695be

            //

            var assembly = typeof(System.Runtime.GCSettings).GetTypeInfo().Assembly;

            var assemblyPath = assembly.Location.Split(new[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries);

            int netCoreAppIndex = Array.IndexOf(assemblyPath, "Microsoft.NETCore.App");

            if (netCoreAppIndex > 0 && netCoreAppIndex < assemblyPath.Length - 2)

                return assemblyPath[netCoreAppIndex + 1];

            return null;

        }

    }

​

#if false

    public class DebugPropertyDeserializerDecorator : PropertyDeserializerDecorator

    {

        public DebugPropertyDeserializerDecorator(IPropertyDeserializer deserializer) : base(deserializer) { }

        public override Property Deserialize()

        {

            var property = base.Deserialize();

​

            property.WalkProperties((p, s) =>

                {

                    Console.WriteLine("{0}{1} of type {2}, parent of type {3}", new string(' ', 2*s.Count), p.Name, p.Type, p.Parent?.Type);

                });

​

            return property;

        }

    }

​

    public class CustomPropertyProvider : PropertyProvider 

    {

        protected override PropertyInfo[] GetAllProperties(Type type)

        {

            var properties = base.GetAllProperties(type);

            if (type == typeof(Model))

            {

                properties = properties.Where(p => p.Name != nameof(Model.IgnoreMe)).ToArray();

            }

            Console.WriteLine(string.Join(",", properties.Select(p => p.ToString())));

            return properties;

        }

    }

#endif

​