source: branches/2924_DotNetCoreMigration/HeuristicLab.DefinitionLanguage/PropertyDescription.cs @ 16985

using System;
using System.Linq;
using System.Reflection;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Serialization;

namespace HeuristicLab.DefinitionLanguage {
  internal enum PropertyType : long {
    Primitive,
    Reference
  }

  [JsonConverter(typeof(BaseConverter))]
  internal abstract class Property {
    public string Key { get; set; }
    public string PropertyType { get; set; }

    public abstract void Set(object instance);

    protected PropertyInfo GetInfo(object instance) {
      var type = instance.GetType();
      var all = type.GetProperties().Where(x => x.Name == Key);
      return all.FirstOrDefault(x => x.DeclaringType == type) ?? all.First();
    }
  }

  internal class PrimitiveProperty : Property {
    public string Value { get; set; }
    public PrimitiveProperty() {
      PropertyType = "Primitive";
    }
    public override void Set(object instance) {
      var info = GetInfo(instance);
      info.SetValue(instance, Parser.ParseString(Value, info.PropertyType));
    }
  }

  internal class ReferenceProperty : Property {
    public string Value { get; set; }

    public ReferenceProperty() {
      PropertyType = "Reference";
    }
    public override void Set(object instance) {
      var info = GetInfo(instance);
      info.SetValue(instance, Parser.GetInstance(Value));
    }
  }

  internal class ReferenceListProperty : Property {
    public string[] ReferenceList { get; set; }

    public override void Set(object instance) {
      throw new NotImplementedException();
    }
  }

  //https://stackoverflow.com/questions/20995865/deserializing-json-to-abstract-class
  public class BaseSpecifiedConcreteClassConverter : DefaultContractResolver {
    protected override JsonConverter ResolveContractConverter(Type objectType) {
      if (typeof(Property).IsAssignableFrom(objectType) && !objectType.IsAbstract)
        return null; // pretend TableSortRuleConvert is not specified (thus avoiding a stack overflow)
      return base.ResolveContractConverter(objectType);
    }
  }

  public class BaseConverter : JsonConverter {
    static JsonSerializerSettings SpecifiedSubclassConversion = new JsonSerializerSettings() { ContractResolver = new BaseSpecifiedConcreteClassConverter() };

    public override bool CanConvert(Type objectType) => objectType == typeof(Property);

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) {
      JObject jo = JObject.Load(reader);
      switch (jo["PropertyType"].Value<string>()) {
        case "Primitive":
          return JsonConvert.DeserializeObject<PrimitiveProperty>(jo.ToString(), SpecifiedSubclassConversion);
        case "Reference":
          return JsonConvert.DeserializeObject<ReferenceProperty>(jo.ToString(), SpecifiedSubclassConversion);
        default:
          throw new Exception();
      }
      throw new NotImplementedException();
    }

    public override bool CanWrite => false;

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) {
      throw new NotImplementedException(); // won't be called because CanWrite returns false
    }
  }
}