PorygonSharp/PorygonSharp/UserData/UserDataHandler.cs

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Runtime.InteropServices;
using PorygonSharp.Attributes;
using PorygonSharp.EvalValues;
using PorygonSharp.Utilities;

namespace PorygonSharp.UserData
{
    public static class UserDataHandler
    {
        private static readonly ConcurrentDictionary<Type, UserData> UserDataLookup = new ConcurrentDictionary<Type, UserData>();
        private static readonly ConcurrentDictionary<uint, UserData> ReverseLookup = new ConcurrentDictionary<uint, UserData>();


        public static void RegisterAssembly(Assembly assembly)
        {
            foreach (var type in assembly.GetTypes())
            {
                var attr = type.GetCustomAttribute<PorygonUserdataAttribute>();
                if (attr != null)
                {
                    RegisterType(attr.Identifier, type);
                }

                var enumAttr = type.GetCustomAttribute<PorygonEnumAttribute>();
                if (enumAttr != null)
                {
                    RegisterEnumType(enumAttr.Name, type);
                    StaticScope.RegisterStaticVariable(enumAttr.Name, Activator.CreateInstance(type));
                }
            }
        }

        public static void RegisterType(string name, Type type)
        {
            var hash = name.ScriptHash();
            lock (UserDataLookup)
            {
                if (UserDataLookup.ContainsKey(type))
                    return;
                RegisterUserDataType(hash);
                var ud = new UserData(hash);
                UserDataLookup.TryAdd(type, ud);
                ReverseLookup.TryAdd(hash, ud);
            }

            const BindingFlags bindingFlags = BindingFlags.Public           | BindingFlags.Instance |
                                              BindingFlags.FlattenHierarchy | BindingFlags.Static;
            var fields = type.GetFields(bindingFlags);
            foreach (var field in fields)
            {
                RegisterField(field, hash);
            }

            var properties = type.GetProperties(bindingFlags);
            foreach (var property in properties)
            {
                RegisterProperty(property, hash);
            }

            var methods = type.GetMethods(bindingFlags);
            foreach (var method in methods)
            {
                RegisterFunction(method, hash);
            }
        }

        public static void RegisterEnumType(string name, Type type)
        {
            var hash = name.ScriptHash();
            lock (UserDataLookup)
            {
                if (UserDataLookup.ContainsKey(type))
                    return;
                RegisterUserDataType(hash);
                var ud = new UserData(hash);
                UserDataLookup.TryAdd(type, ud);
                ReverseLookup.TryAdd(hash, ud);
            }
            var values = Enum.GetValues(type);
            foreach (var value in values)
            {
                var getter = new UserDataField.GetterDelegate(ptr => EvalValueCreator.CreateIntegerEvalValue(Convert.ToInt64(value)));
                var fieldData = new UserDataField(getter, null);
                var valueName = Enum.GetName(type, value);
                var fieldName = valueName.ScriptHash();
                var t = ScriptType.ScriptType.CreateNumericScriptType(true, false);
                RegisterUserDataField(hash, fieldName,
                    CreateUserDataField(t, fieldData.GetGetterPointer(), IntPtr.Zero));
                ReverseLookup[hash].Fields[fieldName] = fieldData;
            }

        }

        private static void RegisterField(FieldInfo field, uint typeHash)
        {
            var scriptType = ScriptType.ScriptType.GetScriptType(field.FieldType);
            if (!scriptType.HasValue)
                return;
            if (!ReverseLookup.TryGetValue(typeHash, out var userData))
                return;
            var fieldName = field.Name.ScriptHash();
            if (userData.Fields.ContainsKey(fieldName))
                return;
            var fieldData = new UserDataField(field);
            var userDataField = CreateUserDataField(scriptType.Value, fieldData.GetGetterPointer(),
                fieldData.GetSetterPointer());

            RegisterUserDataField(typeHash, fieldName, userDataField);
            userData.Fields.Add(fieldName, fieldData);
        }

        private static void RegisterProperty(PropertyInfo property, uint typeHash)
        {
            var scriptType = ScriptType.ScriptType.GetScriptType(property.PropertyType);
            if (!scriptType.HasValue)
                return;
            if (!ReverseLookup.TryGetValue(typeHash, out var userData))
                return;
            var fieldName = property.Name.ScriptHash();
            if (userData.Fields.ContainsKey(fieldName))
                return;
            var fieldData = new UserDataField(property);
            var userDataField = CreateUserDataField(scriptType.Value, fieldData.GetGetterPointer(),
                fieldData.GetSetterPointer());

            RegisterUserDataField(typeHash, fieldName, userDataField);
            userData.Fields.Add(fieldName, fieldData);
        }

        private static void RegisterFunction(MethodInfo method, uint typeHash)
        {

            var type = ScriptType.ScriptType.GetFunctionScriptType(method);
            if (type == IntPtr.Zero || !type.HasValue)
                return;
            if (!ReverseLookup.TryGetValue(typeHash, out var userData))
                return;
            var fieldName = method.Name.ScriptHash();
            if (userData.Fields.ContainsKey(fieldName))
                return;
            var fieldData = new UserDataField(method);
            var userDataField = CreateUserDataField(type.Value, fieldData.GetGetterPointer(), IntPtr.Zero);

            RegisterUserDataField(typeHash, fieldName, userDataField);
            userData.Fields.Add(fieldName, fieldData);
        }

        public static uint GetTypeId(Type t)
        {
            if (UserDataLookup.TryGetValue(t, out var i))
                return i.Id;
            var attr = t.GetCustomAttribute<PorygonUserdataAttribute>();
            if (attr == null)
                return 0;
            var id = attr.Identifier.ScriptHash();
            if (ReverseLookup.ContainsKey(id))
                return id;
            return 0;
        }

        public static bool IsTypeRegistered(Type t)
        {
            if (UserDataLookup.ContainsKey(t)) return true;
            var attr = t.GetCustomAttribute<PorygonUserdataAttribute>();
            if (attr == null)
                return false;
            var id = attr.Identifier.ScriptHash();
            return ReverseLookup.ContainsKey(id);
        }

        public static int GetUserDataFieldCount(Type t)
        {
            var hash = GetTypeId(t);
            return GetUserDataFieldCount(hash);
        }

        internal static IntPtr CreateUserDataType(Type t)
        {
            var hash = GetTypeId(t);
            return CreateUserDataType(hash);
        }

        [DllImport("PorygonLang", EntryPoint = "RegisterUserDataType", CallingConvention = CallingConvention.Cdecl)]
        private static extern void RegisterUserDataType(uint hashId);

        [DllImport("PorygonLang", EntryPoint = "RegisterUserDataField", CallingConvention = CallingConvention.Cdecl)]
        private static extern void RegisterUserDataField(uint hashId, uint fieldId, IntPtr field);

        [DllImport("PorygonLang", EntryPoint = "CreateUserDataField", CallingConvention = CallingConvention.Cdecl)]
        private static extern IntPtr CreateUserDataField(IntPtr type, IntPtr getter, IntPtr setter);

        [DllImport("PorygonLang", EntryPoint = "GetUserDataFieldCount", CallingConvention = CallingConvention.Cdecl)]
        private static extern int GetUserDataFieldCount(uint hashId);
        
        [DllImport("PorygonLang", EntryPoint = "CreateUserDataType", CallingConvention = CallingConvention.Cdecl)]
        private static extern IntPtr CreateUserDataType(uint hashId);

    }
}