PorygonSharp/PorygonSharp/UserData/UserDataHandler.cs

using System;
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 Dictionary<Type, uint> UserDataLookup = new Dictionary<Type, uint>();

        private delegate IntPtr GetterDelegate(IntPtr ptr);
        private delegate void SetterDelegate(IntPtr ptr, IntPtr val);
        private delegate IntPtr CallerDelegate(IntPtr parent, IntPtr scriptOption,
            [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)]IntPtr[] parameters, int size);

        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();
            RegisterUserDataType(hash);
            if (UserDataLookup.ContainsKey(type))
                return;
            UserDataLookup.Add(type, hash);

            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();
            RegisterUserDataType(hash);
            if (UserDataLookup.ContainsKey(type))
                return;
            UserDataLookup.Add(type, hash);
            var values = Enum.GetValues(type);
            foreach (var value in values)
            {
                var getter = new GetterDelegate(ptr => EvalValueCreator.CreateIntegerEvalValue(Convert.ToInt64(value)));
                var valueName = Enum.GetName(type, value);
                var fieldName = valueName.ScriptHash();
                var t = ScriptType.ScriptType.CreateNumericScriptType(true, false);
                RegisterUserDataField(hash, fieldName,
                    CreateUserDataField(t, Marshal.GetFunctionPointerForDelegate(getter), IntPtr.Zero));
            }

        }

        private static void RegisterField(FieldInfo field, uint typeHash)
        {
            var getter = new GetterDelegate(ptr =>
            {
                var obj   = GCHandle.FromIntPtr(ptr).Target;
                var value = field.GetValue(obj);
                return EvalValueCreator.CreateValue(value).GetPointer();
            });

            var setterPtr = IntPtr.Zero;
            if (!field.IsInitOnly)
            {
                var setter = new SetterDelegate((ptr, val) =>
                {
                    var obj       = GCHandle.FromIntPtr(ptr).Target;
                    var evalValue = Convert.ChangeType(new EvalValue(val).GetObjectValue(), field.FieldType);
                    field.SetValue(obj, evalValue);
                });
                setterPtr = Marshal.GetFunctionPointerForDelegate(setter);
            }
            var scriptType = ScriptType.ScriptType.GetScriptType(field.FieldType);
            var userDataField = CreateUserDataField(scriptType, Marshal.GetFunctionPointerForDelegate(getter),
                setterPtr);

            var fieldName = field.Name.ScriptHash();
            RegisterUserDataField(typeHash, fieldName, userDataField);
        }

        private static void RegisterProperty(PropertyInfo property, uint typeHash)
        {
            var getterPtr = IntPtr.Zero;
            if (property.GetGetMethod(false) != null)
            {
                var getter = new GetterDelegate(ptr =>
                {
                    var obj   = GCHandle.FromIntPtr(ptr).Target;
                    var value = property.GetValue(obj);
                    return EvalValueCreator.CreateValue(value).GetPointer();
                });
                getterPtr = Marshal.GetFunctionPointerForDelegate(getter);
            }
            var setterPtr = IntPtr.Zero;
            if (property.GetSetMethod(false) != null)
            {
                var setter = new SetterDelegate((ptr, val) =>
                {
                    var obj       = GCHandle.FromIntPtr(ptr).Target;
                    var evalValue = Convert.ChangeType(new EvalValue(val).GetObjectValue(), property.PropertyType);
                    property.SetValue(obj, evalValue);
                });
                setterPtr = Marshal.GetFunctionPointerForDelegate(setter);
            }
            var scriptType = ScriptType.ScriptType.GetScriptType(property.PropertyType);
            var userDataField = CreateUserDataField(scriptType, getterPtr, setterPtr);

            var fieldName = property.Name.ScriptHash();
            RegisterUserDataField(typeHash, fieldName, userDataField);
        }

        private static void RegisterFunction(MethodInfo method, uint typeHash)
        {
            var parameterTypes = method.GetParameters().Select(x => x.ParameterType).ToArray();

            var getter = new GetterDelegate(ptr =>
            {
                var func = new CallerDelegate((parent, scriptOptions, parameters, size) =>
                {

                    var evaluatedParameters = new object[size];
                    for (var i = 0; i < size; i++)
                    {
                        var eval = new EvalValue(parameters[i]);
                        var val = eval.GetObjectValue();
                        var convertedType = Convert.ChangeType(val, parameterTypes[i]);
                        evaluatedParameters[i] = convertedType;
                    }

                    var parentObj = GCHandle.FromIntPtr(parent).Target;
                    var result = method.Invoke(parentObj, evaluatedParameters);
                    return EvalValueCreator.CreateValue(result).GetPointer();
                });
                var funcPtr = Marshal.GetFunctionPointerForDelegate(func);
                return EvalValueCreator.FunctionEvalValue(funcPtr, ptr).GetPointer();
            });
            var getterPtr = Marshal.GetFunctionPointerForDelegate(getter);
            var type = ScriptType.ScriptType.GetFunctionScriptType(method);
            if (type == IntPtr.Zero)
                return;
            var userDataField = CreateUserDataField(type, getterPtr, IntPtr.Zero);

            var fieldName = method.Name.ScriptHash();
            RegisterUserDataField(typeHash, fieldName, userDataField);
        }

        public static uint GetTypeId(Type t)
        {
            return UserDataLookup[t];
        }

        public static bool IsTypeRegistered(Type t)
        {
            return UserDataLookup.ContainsKey(t);
        }

        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("libPorygonLang", EntryPoint = "RegisterUserDataType", CallingConvention = CallingConvention.Cdecl)]
        private static extern void RegisterUserDataType(uint hashId);

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

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

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

    }
}