using System;

using System.IO;

using System.Text;

using System.Text.Json;

using System.Reflection;

using System.Xml;

using System.Xml.Serialization;

using System.Collections.Generic;

using System.Linq;

public class Program

{

    [XmlType(Namespace ="http://www.cpandl.com")]

    public class XmlString

    {

        [XmlElement(Namespace = "http://www.prop1.com")]

        public string PROP1 { get; set; }

        [XmlElement(Namespace = "http://www.prop3.com")]

        public string PROP3 { get; set; }

        public XmlString() { }

    }

    public static void Main()

    {

        var obj = new XmlString

        {

            PROP1 = "TEST",

            PROP3 = "PROP3"

        };

        var myNamespaces = new XmlSerializerNamespaces();

        myNamespaces.Add("books", "http://www.prop1.com");

        myNamespaces.Add("money", "http://www.prop3.com");

        myNamespaces.Add("money2", "http://www.cpandl.com");

        var writer = new StringWriter();

        new XmlSerializer(typeof(XmlString)).Serialize(writer, obj, myNamespaces);

        Console.WriteLine(writer.ToString());

        var jsonStr = @"{

  ""DOCUMENTID"": {

    ""DOCUMENTCODE"": ""TST123456789"",

    ""ORGANIZATIONID"": {

      ""ORGANIZATIONCODE"": ""GSO""

    },

    ""DESCRIPTION"": ""TESTING STUFF""

  },

  ""FILE"": ""TESTING1234.pdf"",

  ""DOCUMENTTYPE"": {

    ""TYPECODE"": ""U""

  },

  ""CLASSID"": {

    ""CLASSCODE"": ""UTSUPLD"",

    ""ORGANIZATIONID"": {

      ""ORGANIZATIONCODE"": ""*""

    }

  },

  ""TEXTFIELD"": null,

  ""USERDEFINEDAREA"": {

    ""CUSTOMFIELD"": [

      {

        ""PROPERTYCODE"": ""UTSID"",

        ""CLASSID"": {

          ""CLASSCODE"": ""UTSUPLD""

        },

        ""TEXTFIELD"": ""1234567"",

        ""entity"": ""DOCU"",

        ""type"": ""CHAR""

      },

      {

        ""PROPERTYCODE"": ""UTSFORM"",

        ""CLASSID"": {

          ""CLASSCODE"": ""UTSUPLD""

        },

        ""TEXTFIELD"": ""TEST FORM"",

        ""entity"": ""DOCU"",

        ""type"": ""CHAR""

      },

      {

        ""PROPERTYCODE"": ""UTSWO"",

        ""CLASSID"": {

          ""CLASSCODE"": ""UTSUPLD""

        },

        ""TEXTFIELD"": ""123456"",

        ""entity"": ""DOCU"",

        ""type"": ""CHAR""

      }

    ]

  },

  ""autoid"": ""false""

}";

        var json = JsonDocument.Parse(jsonStr).RootElement;

        var documentCode = json.GetProperty("CLASSID").TryGetProperty("YEAR", out var str);

        Console.WriteLine(documentCode);

        var sign = "-";

        var num = "456789123";

        var decimals = 4;

        var numberString = $"{sign}{num[0..(num.Length - decimals)]}.{num[(num.Length - decimals + 1)..]}";

        var didParse = double.TryParse(numberString, out var dbl); 

        Console.WriteLine(dbl + 100000);

        var reader = new Utf8JsonReader(Encoding.UTF8.GetBytes(jsonStr));

        var doc = DeserializeInternal(typeof(EamDocument), ref reader);

        Console.WriteLine(JsonSerializer.Serialize(doc, new JsonSerializerOptions { WriteIndented = true} ));

    }

    //public static object Deserialize(Type type, ref Utf8JsonReader reader) {

    //    var reader = new Utf8JsonReader(buff);

    //    return Deserialize<T>(ref reader);

    //}

    public static object DeserializeInternal(Type type, ref Utf8JsonReader reader)

    {

        var obj = Activator.CreateInstance(type);

        var dict = GetDeserializationProperties(obj.GetType());

        while (reader.Read())

        {

            if (reader.TokenType == JsonTokenType.PropertyName)

            {

                var propertyName = reader.GetString();

                Console.WriteLine(propertyName);

                if (dict.TryGetValue(propertyName!, out var property))

                {

                    reader.Read();

                    if (reader.TokenType == JsonTokenType.String)

                    {

                        property.SetValue(obj, reader.GetString());

                    }

                    else if (reader.TokenType == JsonTokenType.StartArray)

                    {

                        reader.Read();

                        //while(reader.TokenType != JsonTokenType.EndArray) {

                            if (reader.TokenType == JsonTokenType.StartObject) {

                                reader.Read();

                                var subType = property.PropertyType;

                                var subObj = Activator.CreateInstance(subType);

                                //Console.WriteLine(subType);

                            }

                            //property.SetValue(obj, reader.GetString());

                        //}

                        //break;

                    }

                }

            }

        }

        return obj;

    }

    private static IDictionary<string, PropertyInfo> GetDeserializationProperties(Type type) {

        var properties = type.GetProperties()

            .Where(prop => prop.IsDefined(typeof(EamPropertyAttribute), false));

        var dict = new Dictionary<string, PropertyInfo>();

        foreach (var item in properties) {

            var attrs = item.GetCustomAttributes(false).Where(attr => attr is EamPropertyAttribute a && !a.DeserializeIgnore).FirstOrDefault();

            if (attrs == null) continue;

            dict.Add(((EamPropertyAttribute)attrs).Property, item);

        }

        return dict;

    }

}

​

public class EamDocument

{

    [EamProperty("DOCUMENTCODE", "DOCUMENTID")]

    public string DocumentCode { get; set; }

​

    [EamProperty("DESCRIPTION", "DOCUMENTID")]

    public string Description { get; set; }

​

    [EamProperty("CLASSCODE", "CLASSID")]

    public string Class { get; set; }

​

    [EamProperty("ORGANIZATIONCODE", "DOCUMENTID/ORGANIZATIONID")]

    public string Organization { get; set; }

​

    [EamProperty("FILE")]

    public string File { get; set; }

​

    [EamProperty("entity", DeserializeIgnore = true)]

    public string Entity { get; set; } = "DOCU";

​

    [EamProperty("TYPECODE", "DOCUMENTTYPE", DeserializeIgnore = true)]

    public string DocumentType { get; set; } = "U";

​

    [EamProperty("CUSTOMFIELD", "USERDEFINEDAREA", DictionaryKeyType = typeof(string), DictionaryValueType = typeof(CustomField))]

    public Dictionary<string, CustomField> CustomFields { get; set; }

​

    public EamDocument() { }

​

    public EamDocument(string documentCode, string description, string organization, string file, string documentClass, Dictionary<string, CustomField> customFields)

    {

        DocumentCode = documentCode;

        Description = description;

        File = file;

        Organization = organization;

        Class = documentClass;

        CustomFields = customFields ?? new Dictionary<string, CustomField>();

    }

​

    public EamDocument(string documentCode, string description, string organization, string file, string documentClass) : 

    this (documentCode, description, file, organization, documentClass, null) { }

}

​

public class CustomField

{

    [EamProperty("PROPERTYCODE")]

    public string Property { get; set; }

    [EamProperty("PROPERTYLABEL")]

    public string PropertyLabel { get; set; }

    [EamProperty("CLASSCODE")]

    public string Class { get; set; }

    [EamProperty("ORGANIZATIONCODE")]

    public string ClassOrganization { get; set; }

    //[EamProperty("PROPERTYCODE")]

    public object Value { get; set; }

    [EamProperty("MAXVALUE")]

    public string MaxValue { get; set; }

    [EamProperty("MINVALUE")]

    public string MinValue { get; set; }

    [EamProperty("UOM")]

    public string Uom { get; set; }

    [EamProperty("LOVTYPE")]

    public bool IsLovField { get; set; }

    [EamProperty("LOVVALIDATE")]

    public bool IsLovValidatable { get; set; }

    [EamProperty("GROUPLABEL")]

    public string GroupLabel { get; set; }

    [EamProperty("index")]

    public int Index { get; set; }

    [EamProperty("TYPE")]

    public string Type { get; set; }

​

    public CustomField () { }

​

    public CustomField (string property, string propertyClass, string classOrganization, object value, string type)

    {

        Property = property;

        Class = propertyClass;

        ClassOrganization = classOrganization;

        Value = value;

        Type = type; 

    }

}

​

class EamPropertyAttribute : Attribute

    {

        public string Property { get; set; }

        public string Path { get; set; }

        public bool DeserializeIgnore { get; set; }

        public Type DictionaryKeyType { get; set; }

        public Type DictionaryValueType { get; set; }

        public Type ListType { get; set; }

​

        public EamPropertyAttribute(string property, string path)

        {

            Property = property;

            Path = path;

        }

​

        public EamPropertyAttribute(string property) 

        {

            Property = property;

        }

    }