inabox/InABox.Core/DatabaseSchema/DatabaseSchema.cs

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;

namespace InABox.Core
{
    public static class DatabaseSchema
    {
        // {className: {propertyName: property}}
        private static ConcurrentDictionary<Type, ImmutableDictionary<string, IProperty>> _properties
            = new ConcurrentDictionary<Type, ImmutableDictionary<string, IProperty>>();

        private struct SubObject
        {
            public Type PropertyType { get; set; }

            public string Name { get; set; }

            public Action<object, object> Setter { get; set; }

            public Func<object, object> Getter { get; set; }

            public SubObject(Type objectType, Type propertyType, string name)
            {
                PropertyType = propertyType;
                Name = name;
                Setter = Expressions.Setter(objectType, name);
                Getter = Expressions.Getter(objectType, name);
            }
        }

        private static ConcurrentDictionary<Type, ImmutableList<SubObject>> _subObjects { get; } = new ConcurrentDictionary<Type, ImmutableList<SubObject>>();

        private static IReadOnlyCollection<SubObject>? GetSubObjectDefs(Type t)
        {
            CheckProperties(t);
            return _subObjects.GetValueOrDefault(t);
        }

        public static IEnumerable<BaseObject> GetSubObjects(BaseObject obj)
        {
            var objs = GetSubObjectDefs(obj.GetType());
            if(objs is null)
            {
                yield break;
            }
            foreach (var subObjectDef in objs)
            {
                var subObj = subObjectDef.Getter(obj);
                if(subObj is BaseObject bObj)
                {
                    yield return bObj;
                }
            }
        }

        public static void InitializeSubObjects(BaseObject obj)
        {
            var objs = GetSubObjectDefs(obj.GetType());
            if(objs is null)
            {
                return;
            }
            foreach (var subObjectDef in objs)
            {
                var subObj = (Activator.CreateInstance(subObjectDef.PropertyType) as ISubObject)!;
                subObjectDef.Setter(obj, subObj);
                subObj.SetLinkedParent(obj);
                subObj.SetLinkedPath(subObjectDef.Name);
            }
        }

        // For synchronisation purposes, we register sub objects in bulk, removing the need for nested concurrent dictionaries.
        private static void RegisterSubObjects(Type objectType, IEnumerable<Tuple<Type, string>> objects)
        {
            if (!_subObjects.TryGetValue(objectType, out var subObjects))
            {
                subObjects = ImmutableList<SubObject>.Empty;
            }

            // No synchronisation issues, since the original collection is not being modified, just the entry in the concurrent dictionary is updated.
            _subObjects[objectType] = subObjects.AddRange(
                objects.Where(x => !subObjects.Any(y => x.Item1 == y.PropertyType && x.Item2 == y.Name))
                    .Select(x => new SubObject(objectType, x.Item1, x.Item2)));
        }

        private static void RegisterProperties(Type master, Type type, string prefix, StandardProperty? parent)
        {
            try
            {
                var classname = master.EntityName();
                var properties = CoreUtils.PropertyList(
                    type,
                    x => !x.PropertyType.IsInterface &&
                        x.GetGetMethod()?.IsPublic == true &&
                        (x.DeclaringType.IsSubclassOf(typeof(BaseObject)) 
                        || x.DeclaringType.IsSubclassOf(typeof(BaseEditor)))
                );
                var classProps = _properties.GetValueOrDefault(master);

                var subObjects = new List<Tuple<Type, string>>();
                var newProperties = new List<IProperty>();

                foreach (var prop in properties)
                {
                    var name = prefix.IsNullOrWhiteSpace() ? prop.Name : $"{prefix}.{prop.Name}";
                    var p = classProps?.GetValueOrDefault(name);
                    if (p == null && !prop.GetAccessors(true)[0].IsStatic)
                    {
                        BaseEditor? editor;
                        if (parent != null && parent.HasEditor && parent.Editor is NullEditor)
                        {
                            editor = parent.Editor;
                        }
                        else
                        {
                            editor = prop.GetEditor();
                        }

                        var captionAttr = prop.GetCustomAttribute<Caption>();
                        var subCaption = captionAttr != null ? captionAttr.Text : prop.Name;
                        var path = captionAttr == null || captionAttr.IncludePath; // If no caption attribute, we should always include the path
                        var caption = parent?.Caption ?? ""; // We default to the parent caption if subCaption doesn't exist
                        if (!string.IsNullOrWhiteSpace(subCaption))
                        {
                            if (!string.IsNullOrWhiteSpace(caption) && path)
                            {
                                caption = $"{caption} {subCaption}";
                            }
                            else
                            {
                                caption = subCaption;
                            }
                        }

                        // Once the parent page has been found, this property is cemented to that page - it cannot change page to its parent
                        // The same goes for sequence
                        var page = parent?.Page;
                        var sequence = parent?.Sequence;
                        if (string.IsNullOrWhiteSpace(page))
                        {
                            var sequenceAttribute = prop.GetCustomAttribute<EditorSequence>();
                            if (sequenceAttribute != null)
                            {
                                page = sequenceAttribute.Page;
                                sequence = sequenceAttribute.Sequence;
                            }
                        }
                        editor = editor?.Clone() as BaseEditor;
                        if (editor != null)
                        {
                            editor.Page = page;
                            editor.Caption = caption;
                            editor.EditorSequence = (int)(sequence ?? 999);

                            editor.Security = prop.GetCustomAttributes<SecurityAttribute>().ToArray();
                        }

                        bool required = false;
                        if (parent == null || parent.Required)
                        {
                            required = prop.GetCustomAttribute<RequiredColumnAttribute>() != null;
                        }

                        LoggablePropertyAttribute? loggable = null;
                        if (parent == null || parent.Loggable != null)
                        {
                            loggable = prop.GetCustomAttribute<LoggablePropertyAttribute>();
                        }

                        var newProperty = new StandardProperty
                        {
                            _class = master,
                            //Class = classname,
                            Name = name,
                            PropertyType = prop.PropertyType,
                            Editor = editor ?? new NullEditor(),
                            HasEditor = editor != null,
                            Caption = caption,
                            Sequence = sequence ?? 999,
                            Page = page ?? "",
                            Required = required,
                            Loggable = loggable,
                            Parent = parent,
                            Property = prop
                        };

                        var parentWithEditable = newProperty.GetOuterParent(x =>
                            x is StandardProperty st
                            && st.Property.GetCustomAttribute<EditableAttribute>() != null);
                        if(parentWithEditable != null)
                        {
                            var attr = (parentWithEditable as StandardProperty)!.Property.GetCustomAttribute<EditableAttribute>()!;
                            newProperty.Editor.Editable = newProperty.Editor.Editable.Combine(attr.Editable);
                        }
                        else if(prop.GetCustomAttribute<EditableAttribute>() is EditableAttribute attr)
                        {
                            newProperty.Editor.Editable = newProperty.Editor.Editable.Combine(attr.Editable);
                        }

                        var isLink = typeof(IEntityLink).IsAssignableFrom(prop.PropertyType);
                        var isEnclosedEntity = typeof(IEnclosedEntity).IsAssignableFrom(prop.PropertyType);
                        var isBaseEditor = prop.PropertyType.Equals(typeof(BaseEditor)) ||
                            prop.PropertyType.IsSubclassOf(typeof(BaseEditor));
                        if ((isLink || isEnclosedEntity) && !isBaseEditor)
                        {
                            subObjects.Add(new Tuple<Type, string>(prop.PropertyType, prop.Name));
                        }

                        if (isLink || isEnclosedEntity || isBaseEditor)
                        {
                            RegisterProperties(master, prop.PropertyType, name, newProperty);
                        }
                        else
                        {
                            newProperties.Add(newProperty);
                        }
                    }
                }

                RegisterProperties(master, newProperties);
                RegisterSubObjects(type, subObjects);

                if (type.IsSubclassOf(typeof(BaseObject)))
                    RegisterProperties(master, type.BaseType, prefix, parent);
            }
            catch (Exception e)
            {
                Logger.Send(LogType.Error, "", string.Format("*** Unknown Error: {0}\n{1}", e.Message, e.StackTrace));
            }
        }

        private static void RegisterProperties(Type type)
        {
            RegisterProperties(type, type, "", null);
        }

        public static object? DefaultValue(Type type)
        {
            if (type.IsValueType)
                return Activator.CreateInstance(type);
            if (type.Equals(typeof(string)))
                return "";
            return null;
        }
        
        private static readonly object _updatelock =  new object();

        private static void RegisterProperties(Type master, IEnumerable<IProperty> toAdd)
        {
            if (!_properties.TryGetValue(master, out var properties))
            {
                properties = ImmutableDictionary<string, IProperty>.Empty;
            }
            var newDict = properties.ToDictionary(x => x.Key, x => x.Value);
            foreach(var prop in toAdd)
            {
                newDict[prop.Name] = prop;
            }

            _properties[master] = newDict.ToImmutableDictionary();
        }
        
        public static void RegisterProperty(IProperty entry)
        {
            var type = entry.ClassType;
            if (type is null) return;

            if (!_properties.TryGetValue(type, out var properties))
            {
                properties = ImmutableDictionary<string, IProperty>.Empty;
            }
            _properties[type] = properties.Add(entry.Name, entry);
        }

        public static void Load(CustomProperty[] customproperties)
        {
            var perType = customproperties.GroupBy(x => x.ClassType);
            foreach(var group in perType)
            {
                if (group.Key is null) continue;

                RegisterProperties(group.Key, group);
            }
        }

        private static ImmutableDictionary<string, IProperty>? CheckProperties(Type type)
        {
            try
            {
                var props = _properties.GetValueOrDefault(type);
                var hasprops = props?.Any(x => x.Value is StandardProperty) == true;
                if (!hasprops && type.IsSubclassOf(typeof(BaseObject)))
                {
                    RegisterProperties(type);
                    return _properties.GetValueOrDefault(type);
                }
                else
                {
                    return props;
                }
            }
            catch (Exception e)
            {
                // This seems to be an intermittent error "Collection has been modified" when checking if the Dictionary has been populated already
                // I've added a .ToArray() to concretise the list, but who knows?
                Logger.Send(LogType.Error,"",$"Error Checking Properties for Type: {type.EntityName()}\n{e.Message}\n{e.StackTrace}");
                return null;
            }

        }

        public static IEnumerable<IProperty> Properties(Type type)
        {
            return CheckProperties(type)?.Select(x => x.Value) ?? Enumerable.Empty<IProperty>();
        }
        
        public static IProperty? Property(Type type, string name)
        {
            var prop = CheckProperties(type)?.GetValueOrDefault(name);

            // Walk up the inheritance tree, see if an ancestor has this property
            if (prop == null && type.BaseType != null)
                prop = Property(type.BaseType, name);
            return prop;
        }
        public static IProperty? Property<T>(Expression<Func<T, object?>> expression) => Property(typeof(T), CoreUtils.GetFullPropertyName(expression, "."));

        public static void InitializeObject<TObject>(TObject entity) where TObject : BaseObject
        {
            entity.UserProperties.Load(Properties(entity.GetType())
                .Where(x => x is CustomProperty)
                .Select(x => new KeyValuePair<string, object?>(x.Name, x.PropertyType)));
        }
    }
}