using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
using System.Reflection;

namespace MotorMaster.Sdk
{
    public class RMAxis
    {
        private static class Win32
        {
            [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
            public static extern IntPtr LoadLibrary(string path);

            [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
            public static extern bool FreeLibrary(IntPtr handle);

            [DllImport("kernel32.dll", CharSet = CharSet.Ansi)]
            public static extern IntPtr GetProcAddress(IntPtr handle, string method_name);
        }

        public static class Native
        {
            [StructLayout(LayoutKind.Sequential, Pack = 4)]
            public struct EXCEPTION_POINTERS
            {
                public IntPtr pExceptionRecord;
                public IntPtr pContext;
            }
            [StructLayout(LayoutKind.Sequential, Pack = 4)]
            public struct EXCEPTION_RECORD
            {
                public UInt32 ExceptionCode;
                public UInt32 ExceptionFlags;
                public IntPtr pExceptionRecord;
                public IntPtr ExceptionAddress;
                public UInt32 NumberParameters;
                [MarshalAs(UnmanagedType.ByValArray, SizeConst = 15)]
                public UInt32[] ExceptionInformation;
            }

            [StructLayout(LayoutKind.Sequential, Pack = 4, CharSet = CharSet.Ansi)]
            public struct RawException
            {
                [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 0xFF)]
                public string message;

                [MarshalAs(UnmanagedType.I4)]
                public int line_number;

                [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 0xFF)]
                public string src_file;
            }

            public static Exception ToManagedException(SEHException ex)
            {
                Exception result = new Exception("Unknown Error", ex);

                int iExceptionCode = Marshal.GetExceptionCode();
                IntPtr pExceptionPointers = Marshal.GetExceptionPointers();

                EXCEPTION_POINTERS exception_pointers = (EXCEPTION_POINTERS)Marshal.PtrToStructure(pExceptionPointers, typeof(EXCEPTION_POINTERS));

                EXCEPTION_RECORD exception_record = (EXCEPTION_RECORD)Marshal.PtrToStructure(exception_pointers.pExceptionRecord, typeof(EXCEPTION_RECORD));

                if (((UInt32)iExceptionCode == 100) && (exception_record.NumberParameters > 0))
                {
                    RawException native = (RawException)Marshal.PtrToStructure((IntPtr)(exception_record.ExceptionInformation[0]), typeof(RawException));

                    result = new Exception(native.message, ex);
                    result.Data["line_number"] = native.line_number;
                    result.Data["src_file"] = native.src_file;

                    Marshal.DestroyStructure((IntPtr)(exception_record.ExceptionInformation[0]), typeof(RawException));
                    Marshal.FreeCoTaskMem((IntPtr)(exception_record.ExceptionInformation[0]));
                }

                return result;
            }

            public enum PARAM_TYPE : uint
            {
                BOOLEAN = 0,
                INT32 = 1,
                FLOAT = 2,
                ENUM = 3
            }

            public enum PARAM_EDIT : uint
            {
                NORMAL = 0,
                FACTORY = 1,
                FUNCTION = 2,
                READYONLY = 3
            }

            public const int MAX_STRING_SIZE = 0xFF;
            public const int MAX_ARRAY_SIZE = 0x03EB;

            [StructLayout(LayoutKind.Sequential, Pack = 4, CharSet = CharSet.Ansi)]
            public struct parameter_info_t
            {
                [MarshalAs(UnmanagedType.U4)]
                public PARAM_TYPE type;
                [MarshalAs(UnmanagedType.U4)]
                public PARAM_EDIT editability;
                [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_STRING_SIZE)]
                public string description;
                [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_STRING_SIZE)]
                public string enum_type;
            }

            public enum MOTION_COMMAND : uint
            {
                NONE = 0,
                GO_HOME = 1,
                DELAY = 2,
                MOVE_ABSOLUTE = 3,
                PUSH = 4,
                MOVE_RELATIVE = 5,
                CLOSE_LOOP_PUSH = 6
            };

            [StructLayout(LayoutKind.Sequential, Pack = 4)]
            public struct motion_command_t
            {
                public MOTION_COMMAND type;
                public float position;
                public float velocity;
                public float acceleration;
                public float deacceleration;
                public float band;
                public float push_force;
                public float push_distance;
                public int delay;
                public int next_command_index;
            }

            [StructLayout(LayoutKind.Sequential, Pack = 4)]
            public struct version_t
            {
                public int major;
                public int minor;
                public int build;
                public int type;
            }

            public static List<string> ToStringArray(IntPtr array_ptr, int count)
            {
                var result = new List<string>(count);

                for (int i = 0; i < count; i++)
                {
                    var temp = Marshal.PtrToStringAnsi(array_ptr + Native.MAX_STRING_SIZE * i, Native.MAX_STRING_SIZE);
                    result.Add(temp.Substring(0, temp.IndexOf('\0')));
                }
                    

                return result;
            }

            // Exception Settings
            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate void rm_set_exception_throw_delegate([MarshalAs(UnmanagedType.U1)] bool enable);
            public static rm_set_exception_throw_delegate rm_set_exception_throw;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate IntPtr rm_get_exception_delegate();
            public static rm_get_exception_delegate rm_get_exception;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate void rm_set_config_path_delegate([MarshalAs(UnmanagedType.LPStr)]string path);
            public static rm_set_config_path_delegate rm_set_config_path;

            // Factroy Create
            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate IntPtr rm_create_modbus_rtu_delegate([MarshalAs(UnmanagedType.LPStr)]string device, int baudrate, byte slave_id);
            public static rm_create_modbus_rtu_delegate rm_create_modbus_rtu;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate IntPtr rm_create_modbus_tcp_delegate([MarshalAs(UnmanagedType.LPStr)]string address, int port);
            public static rm_create_modbus_tcp_delegate rm_create_modbus_tcp;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate IntPtr rm_create_modbus_rtu_tcp_delegate([MarshalAs(UnmanagedType.LPStr)]string device, int baudrate, byte slave_id, int port);
            public static rm_create_modbus_rtu_tcp_delegate rm_create_modbus_rtu_tcp;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate IntPtr rm_create_canopen_delegate([MarshalAs(UnmanagedType.LPStr)]string device, int bitrate, byte node_id);
            public static rm_create_canopen_delegate rm_create_canopen;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate IntPtr rm_create_mock_delegate(version_t version);
            public static rm_create_mock_delegate rm_create_mock;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate void rm_destroy_delegate(IntPtr handle);
            public static rm_destroy_delegate rm_destroy;


            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate version_t rm_get_version_delegate(IntPtr handle);
            public static rm_get_version_delegate rm_get_version;

            // io

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate int rm_get_input_count_delegate(IntPtr handle);
            public static rm_get_input_count_delegate rm_get_input_count;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate int rm_get_output_count_delegate(IntPtr handle);
            public static rm_get_output_count_delegate rm_get_output_count;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate int rm_list_input_signal_delegate(IntPtr handle, IntPtr signal_out);
            public static rm_list_input_signal_delegate rm_list_input_signal;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate int rm_list_output_signal_delegate(IntPtr handle, IntPtr signal_out);
            public static rm_list_input_signal_delegate rm_list_output_signal;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
            public delegate void rm_set_input_signal_delegate(IntPtr handle, [MarshalAs(UnmanagedType.LPStr)]string signal, [MarshalAs(UnmanagedType.U1)]bool level);
            public static rm_set_input_signal_delegate rm_set_input_signal;
            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
            [return: MarshalAs(UnmanagedType.U1)]
            public delegate bool rm_get_input_signal_delegate(IntPtr handle, [MarshalAs(UnmanagedType.LPStr)]string signal);
            public static rm_get_input_signal_delegate rm_get_input_signal;
            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
            [return: MarshalAs(UnmanagedType.U1)]
            public delegate bool rm_get_output_signal_delegate(IntPtr handle, [MarshalAs(UnmanagedType.LPStr)]string signal);
            public static rm_get_output_signal_delegate rm_get_output_signal;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate IntPtr rm_get_map_input_delegate(IntPtr handle, int port);
            public static rm_get_map_input_delegate rm_get_map_input;
            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate IntPtr rm_get_map_output_delegate(IntPtr handle, int port);
            public static rm_get_map_output_delegate rm_get_map_output;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
            public delegate void rm_set_map_input_delegate(IntPtr handle, [MarshalAs(UnmanagedType.LPStr)]string signal, int port);
            public static rm_set_map_input_delegate rm_set_map_input;
            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
            public delegate void rm_set_map_output_delegate(IntPtr handle, [MarshalAs(UnmanagedType.LPStr)]string signal, int port);
            public static rm_set_map_output_delegate rm_set_map_output;

            // motion
            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate void rm_config_motion_delegate(IntPtr handle, float velocity, float acceleration, float deacceleration);
            public static rm_config_motion_delegate rm_config_motion;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate void rm_move_to_delegate(IntPtr handle, float position);
            public static rm_move_to_delegate rm_move_to;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate void rm_go_home_delegate(IntPtr handle);
            public static rm_go_home_delegate rm_go_home;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate void rm_move_absolute_delegate(IntPtr handle, float position, float velocity, float acceleration, float deacceleration, float band);
            public static rm_move_absolute_delegate rm_move_absolute;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate void rm_push_delegate(IntPtr handle, float force, float distance, float velocity);
            public static rm_push_delegate rm_push;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate void rm_precise_push_delegate(IntPtr handle, float force, float distance, float velocity, float force_band, uint force_check_time);
            public static rm_precise_push_delegate rm_precise_push;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            [return: MarshalAs(UnmanagedType.U1)]
            public delegate bool rm_wait_complete_delegate(IntPtr handle, uint timeout_ms);
            public static rm_wait_complete_delegate rm_wait_complete;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            [return: MarshalAs(UnmanagedType.U1)]
            public delegate bool rm_is_moving_delegate(IntPtr handle);
            public static rm_is_moving_delegate rm_is_moving;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            [return: MarshalAs(UnmanagedType.U1)]
            public delegate bool rm_is_reached_delegate(IntPtr handle);
            public static rm_is_reached_delegate rm_is_reached;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            [return: MarshalAs(UnmanagedType.U1)]
            public delegate bool rm_is_push_empty_delegate(IntPtr handle);
            public static rm_is_push_empty_delegate rm_is_push_empty;

            // command
            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate void rm_set_command_delegate(IntPtr handle, int index, motion_command_t command);
            public static rm_set_command_delegate rm_set_command;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate motion_command_t rm_get_command_delegate(IntPtr handle, int index);
            public static rm_get_command_delegate rm_get_command;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate void rm_execute_command_delegate(IntPtr handle, motion_command_t command);
            public static rm_execute_command_delegate rm_execute_command;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate void rm_trig_command_delegate(IntPtr handle, int index);
            public static rm_trig_command_delegate rm_trig_command;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate void rm_load_commands_delegate(IntPtr handle);
            public static rm_load_commands_delegate rm_load_commands;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate void rm_save_commands_delegate(IntPtr handle);
            public static rm_save_commands_delegate rm_save_commands;

            // property
            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate float rm_position_delegate(IntPtr handle);
            public static rm_position_delegate rm_position;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate float rm_velocity_delegate(IntPtr handle);
            public static rm_velocity_delegate rm_velocity;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate float rm_torque_delegate(IntPtr handle);
            public static rm_torque_delegate rm_torque;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate float rm_force_sensor_delegate(IntPtr handle);
            public static rm_force_sensor_delegate rm_force_sensor;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate UInt32 rm_error_code_delegate(IntPtr handle);
            public static rm_error_code_delegate rm_error_code;

            // parameters
            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate int rm_list_parameters_delegate(IntPtr handle, IntPtr param_name_out, IntPtr param_out);
            public static rm_list_parameters_delegate rm_list_parameters;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate int rm_list_enum_types_delegate(IntPtr handle, IntPtr types_out);
            public static rm_list_enum_types_delegate rm_list_enum_types;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
            public delegate int rm_list_enum_def_delegate(IntPtr handle, [MarshalAs(UnmanagedType.LPStr)]string enum_type, IntPtr keys_out, IntPtr values_out);
            public static rm_list_enum_def_delegate rm_list_enum_def;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
            public delegate IntPtr rm_get_enum_type_string_delegate(IntPtr handle, [MarshalAs(UnmanagedType.LPStr)]string enum_type, int enum_value);
            public static rm_get_enum_type_string_delegate rm_get_enum_type_string;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
            public delegate int rm_get_enum_type_value_delegate(IntPtr handle, [MarshalAs(UnmanagedType.LPStr)]string enum_type, [MarshalAs(UnmanagedType.LPStr)]string enum_type_string);
            public static rm_get_enum_type_value_delegate rm_get_enum_type_value;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
            public delegate void rm_get_parameter_delegate(IntPtr handle, [MarshalAs(UnmanagedType.LPStr)]string name, IntPtr data);
            public static rm_get_parameter_delegate rm_get_parameter;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
            public delegate void rm_set_parameter_delegate(IntPtr handle, [MarshalAs(UnmanagedType.LPStr)]string name, IntPtr data);
            public static rm_set_parameter_delegate rm_set_parameter;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate void rm_load_parameters_delegate(IntPtr handle);
            public static rm_load_parameters_delegate rm_load_parameters;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate void rm_save_parameters_delegate(IntPtr handle);
            public static rm_save_parameters_delegate rm_save_parameters;

            // misc
            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate void rm_reset_error_delegate(IntPtr handle);
            public static rm_reset_error_delegate rm_reset_error;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate void rm_set_servo_on_off_delegate(IntPtr handle, [MarshalAs(UnmanagedType.U1)]bool enable);
            public static rm_set_servo_on_off_delegate rm_set_servo_on_off;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            [return: MarshalAs(UnmanagedType.U1)]
            public delegate bool rm_get_servo_on_off_delegate(IntPtr handle);
            public static rm_get_servo_on_off_delegate rm_get_servo_on_off;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate void rm_stop_delegate(IntPtr handle);
            public static rm_stop_delegate rm_stop;

            [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public delegate void rm_debug_delegate(IntPtr handle, IntPtr info);
            public static rm_debug_delegate rm_debug;

        }

        private static IntPtr handle = IntPtr.Zero;

        public static void Initialize(string sdk_path)
        {
            handle = Win32.LoadLibrary(sdk_path);
            if (handle != IntPtr.Zero)
            {
                FieldInfo[] fields = typeof(Native).GetFields(BindingFlags.Static | BindingFlags.Public);
                foreach (FieldInfo field in fields)
                    if (field.FieldType != typeof(int))
                        field.SetValue(null, Marshal.GetDelegateForFunctionPointer(Win32.GetProcAddress(handle, field.Name), field.FieldType));

                //Native.rm_set_exception_throw(true);
                return;
            }
            throw new Exception($"{sdk_path} 无法加载");
        }

        private IntPtr instance = IntPtr.Zero;
        public RMAxis(IntPtr instance)
        {
            this.instance = instance;
        }

        private T RunWithManaged<T>(Func<T> function)
        {
            if (disposed)
                return default(T);
            return StaticRunWithManaged(function);
        }

        private void RunWithManaged(Action function)
        {
            if (disposed)
                return;
            StaticRunWithManaged(function);
        }

        private static T StaticRunWithManaged<T>(Func<T> function)
        {
            var result = function();
            var exception_ptr = Native.rm_get_exception();
            if (exception_ptr == IntPtr.Zero)
                return result;
            else
            {
                Native.RawException native = (Native.RawException)Marshal.PtrToStructure(exception_ptr, typeof(Native.RawException));

                var ex = new Exception(native.message);
                ex.Data["line_number"] = native.line_number;
                ex.Data["src_file"] = native.src_file;
                throw ex;
            }
        }

        private static void StaticRunWithManaged(Action function)
        {
            function();
            var exception_ptr = Native.rm_get_exception();
            if (exception_ptr == IntPtr.Zero)
                return;
            else
            {
                Native.RawException native = (Native.RawException)Marshal.PtrToStructure(exception_ptr, typeof(Native.RawException));

                var ex = new Exception(native.message);
                ex.Data["line_number"] = native.line_number;
                ex.Data["src_file"] = native.src_file;
                throw ex;
            }
        }

        public static void SetConfigPath(string path)
        {
            StaticRunWithManaged(() => Native.rm_set_config_path(path));
        }

        public static RMAxis CreateModbus(string device, int baudrate, ushort slave_id)
        {
            return new RMAxis(StaticRunWithManaged(() => Native.rm_create_modbus_rtu(device, baudrate, (byte)slave_id)));
        }

        public static RMAxis CreateModbus(string device, int baudrate, ushort slave_id, int port)
        {
            return new RMAxis(StaticRunWithManaged(() => Native.rm_create_modbus_rtu_tcp(device, baudrate, (byte)slave_id, port)));
        }

        public static RMAxis CreateModbus(string address, int port)
        {
            return new RMAxis(StaticRunWithManaged(() => Native.rm_create_modbus_tcp(address, port)));
        }

        public static RMAxis CreateCanOpen(string device, int bitrate, ushort node_id)
        {
            return new RMAxis(StaticRunWithManaged(() => Native.rm_create_canopen(device, bitrate, (byte)node_id)));
        }

        public static RMAxis CreateMock(Native.version_t version)
        {
            return new RMAxis(StaticRunWithManaged(() => Native.rm_create_mock(version)));
        }

        public static void Destroy(RMAxis axis)
        {
            axis.disposed = true;
            StaticRunWithManaged(() => Native.rm_destroy(axis.instance));
        }

        private bool disposed = false;

        public Native.version_t Version
        {
            get
            {
                return RunWithManaged(() => Native.rm_get_version(this.instance));
            }
        }

        public int InputCount
        {
            get
            {
                return RunWithManaged(() => Native.rm_get_input_count(this.instance));
            }
        }

        public int OutputCount
        {
            get
            {
                return RunWithManaged(() => Native.rm_get_output_count(this.instance));
            }
        }

        public List<string> InputSignal
        {
            get
            {
                return RunWithManaged(() =>
                {
                    IntPtr data_out = Marshal.AllocHGlobal(Native.MAX_ARRAY_SIZE * Native.MAX_STRING_SIZE + 0x100);
                    var count = Native.rm_list_input_signal(this.instance, data_out);

                    var result = Native.ToStringArray(data_out, count);

                    Marshal.FreeHGlobal(data_out);
                    return result;
                });
            }
        }

        public List<string> OutputSignal
        {
            get
            {
                return RunWithManaged(() =>
                {
                    IntPtr data_out = Marshal.AllocHGlobal(Native.MAX_ARRAY_SIZE * Native.MAX_STRING_SIZE + 0x100);
                    var count = Native.rm_list_output_signal(this.instance, data_out);

                    var result = Native.ToStringArray(data_out, count);

                    Marshal.FreeHGlobal(data_out);
                    return result;
                });
            }
        }

        public void SetInputSignal(string signal, bool level)
        {
            RunWithManaged(() => Native.rm_set_input_signal(this.instance, signal, level));
        }

        public bool GetInputSignal(string signal)
        {
            return RunWithManaged(() => Native.rm_get_input_signal(this.instance, signal));
        }

        public bool GetOutputSignal(string signal)
        {
            return RunWithManaged(() => Native.rm_get_output_signal(this.instance, signal));
        }

        public string GetInputMap(int port)
        {
            return RunWithManaged(() =>
            {
                var str_ptr = Native.rm_get_map_input(this.instance, port);
                var temp = Marshal.PtrToStringAnsi(str_ptr, Native.MAX_STRING_SIZE);
                temp = temp.Substring(0, temp.IndexOf('\0'));
                return temp;
            });
        }

        public string GetOutputMap(int port)
        {
            return RunWithManaged(() =>
            {
                var str_ptr = Native.rm_get_map_output(this.instance, port);
                var temp = Marshal.PtrToStringAnsi(str_ptr, Native.MAX_STRING_SIZE);
                temp = temp.Substring(0, temp.IndexOf('\0'));
                return temp;
            });
        }

        public void SetInputMap(string signal, int port)
        {
            RunWithManaged(() => Native.rm_set_map_input(this.instance, signal, port));
        }

        public void SetOutputMap(string signal, int port)
        {
            RunWithManaged(() => Native.rm_set_map_output(this.instance, signal, port));
        }

        public void ConfigMotion(float velocity, float acceleration, float deacceleration)
        {
            RunWithManaged(() => Native.rm_config_motion(this.instance, velocity, acceleration, deacceleration));
        }

        public void MoveTo(float position)
        {
            RunWithManaged(() => Native.rm_move_to(this.instance, position));
        }

        public void GoHome()
        {
            RunWithManaged(() => Native.rm_go_home(this.instance));
        }

        public void MoveAbsolute(
            float position, float velocity,
            float acceleration, float deacceleration, float band
            )
        {
            RunWithManaged(() => Native.rm_move_absolute(this.instance, position, velocity, acceleration, deacceleration, band));
        }

        public void Push(
            float force,
            float distance, float velocity
            )
        {
            RunWithManaged(() => Native.rm_push(this.instance, force, distance, velocity));
        }

        public void PrecisePush(
            float force,
            float distance, float velocity,
            float force_band, uint force_check_time
            )
        {
            RunWithManaged(() => Native.rm_precise_push(this.instance, force, distance, velocity, force_band, force_check_time));
        }

        public bool WaitComplete(uint timeout_ms)
        {
            return RunWithManaged(() => Native.rm_wait_complete(this.instance, timeout_ms));
        }

        public bool IsMoving()
        {
            return RunWithManaged(() => Native.rm_is_moving(this.instance));
        }

        public bool IsReached()
        {
            return RunWithManaged(() => Native.rm_is_reached(this.instance));
        }

        public bool IsPushEmpty()
        {
            return RunWithManaged(() => Native.rm_is_push_empty(this.instance));
        }

        public void SetCommand(int index, Native.motion_command_t command)
        {
            RunWithManaged(() => Native.rm_set_command(this.instance, index, command));
        }

        public Native.motion_command_t GetCommand(int index)
        {
            return RunWithManaged(() => Native.rm_get_command(this.instance, index));
        }

        public void ExecuteCommand(Native.motion_command_t command)
        {
            RunWithManaged(() => Native.rm_execute_command(this.instance, command));
        }

        public void TrigCommand(int index)
        {
            RunWithManaged(() => Native.rm_trig_command(this.instance, index));
        }

        public void LoadCommands()
        {
            RunWithManaged(() => Native.rm_load_commands(this.instance));
        }

        public void SaveCommands()
        {
            RunWithManaged(() => Native.rm_save_commands(this.instance));
        }

        public float Position
        {
            get
            {
                return RunWithManaged(() => Native.rm_position(this.instance));
            }
        }

        public float Velocity
        {
            get
            {
                return RunWithManaged(() => Native.rm_velocity(this.instance));
            }
        }

        public float Torque
        {
            get
            {
                return RunWithManaged(() => Native.rm_torque(this.instance));
            }
        }

        public float ForceSensor
        {
            get
            {
                return RunWithManaged(() => Native.rm_force_sensor(this.instance));
            }
        }

        public uint ErrorCode
        {
            get
            {
                return RunWithManaged(() => Native.rm_error_code(this.instance));
            }
        }

        public Dictionary<string, Native.parameter_info_t> Parameters
        {
            get
            {
                return RunWithManaged(() =>
                {
                    var result = new Dictionary<string, Native.parameter_info_t>();

                    int param_struct_size = Marshal.SizeOf(typeof(Native.parameter_info_t));
                    IntPtr param_name_out = Marshal.AllocHGlobal(Native.MAX_ARRAY_SIZE * Native.MAX_STRING_SIZE + 0x100);
                    IntPtr param_info_out = Marshal.AllocHGlobal(Native.MAX_ARRAY_SIZE * param_struct_size + 0x100);

                    var count = Native.rm_list_parameters(this.instance, param_name_out, param_info_out);

                    var names = Native.ToStringArray(param_name_out, count);

                    for (int i = 0; i < count; i++)
                        result[names[i]] =
                            (Native.parameter_info_t)Marshal.PtrToStructure(
                                param_info_out + param_struct_size * i,
                                typeof(Native.parameter_info_t));

                    Marshal.FreeHGlobal(param_name_out);
                    Marshal.FreeHGlobal(param_info_out);

                    return result;
                });
            }
        }

        public List<string> EnumTypes
        {
            get
            {
                return RunWithManaged(() =>
                {
                    IntPtr types_out = Marshal.AllocHGlobal(Native.MAX_ARRAY_SIZE * Native.MAX_STRING_SIZE + 0x100);

                    var count = Native.rm_list_enum_types(this.instance, types_out);

                    var result = Native.ToStringArray(types_out, count);

                    Marshal.FreeHGlobal(types_out);

                    return result;
                });
            }
        }

        public Dictionary<string, Dictionary<string, int>> EnumDefs
        {
            get
            {
                return RunWithManaged(() =>
                {
                    var result = new Dictionary<string, Dictionary<string, int>>();

                    var enum_types = this.EnumTypes;
                    foreach (var enum_type in enum_types)
                    {
                        IntPtr keys_out = Marshal.AllocHGlobal(Native.MAX_ARRAY_SIZE * Native.MAX_STRING_SIZE + 0x100);
                        IntPtr values_out = Marshal.AllocHGlobal(Native.MAX_ARRAY_SIZE * 4 + 0x100);

                        var count = Native.rm_list_enum_def(this.instance, enum_type, keys_out, values_out);

                        var keys = Native.ToStringArray(keys_out, count);

                        var typedef = new Dictionary<string, int>();

                        for (int i = 0; i < count; i++)
                            typedef[keys[i]] = Marshal.ReadInt32(values_out + 4 * i);

                        Marshal.FreeHGlobal(keys_out);
                        Marshal.FreeHGlobal(values_out);

                        result[enum_type] = typedef;
                    }

                    return result;
                });
            }
        }

        public T GetParameter<T>(string name)
        {
            return RunWithManaged(() =>
            {
                var data_ptr = Marshal.AllocHGlobal(4);
                Native.rm_get_parameter(this.instance, name, data_ptr);
                var result = new byte[4];
                Marshal.Copy(data_ptr, result, 0, 4);
                Marshal.FreeHGlobal(data_ptr);

                if (typeof(T) == typeof(int))
                    return (T)(object)BitConverter.ToInt32(result, 0);
                else if (typeof(T) == typeof(bool))
                    return (T)(object)BitConverter.ToBoolean(result, 0);
                else if (typeof(T) == typeof(float))
                    return (T)(object)BitConverter.ToSingle(result, 0);
                else
                    return (T)(object)BitConverter.ToInt16(result, 0);
            });
        }

        public void SetParameter<T>(string name, T value)
        {
            RunWithManaged(() =>
            {
                var data_ptr = Marshal.AllocHGlobal(4);
                var data = new byte[4];
                if (typeof(T) == typeof(int))
                    data = BitConverter.GetBytes((int)(object)value);
                else if (typeof(T) == typeof(bool))
                    data = BitConverter.GetBytes((bool)(object)value);
                else if (typeof(T) == typeof(float))
                    data = BitConverter.GetBytes((float)(object)value);
                else
                    data = BitConverter.GetBytes((ushort)(object)value);
                Marshal.Copy(data, 0, data_ptr, data.Length);
                Native.rm_set_parameter(this.instance, name, data_ptr);
                Marshal.FreeHGlobal(data_ptr);
            });
        }

        public void LoadParameters()
        {
            RunWithManaged(() => Native.rm_load_parameters(this.instance));
        }

        public void SaveParameters()
        {
            RunWithManaged(() => Native.rm_save_parameters(this.instance));
        }

        public void ResetError()
        {
            RunWithManaged(() => Native.rm_reset_error(this.instance));
        }

        public bool ServoOnOff
        {
            get
            {
                return RunWithManaged(() => Native.rm_get_servo_on_off(this.instance));
            }
            set
            {
                RunWithManaged(() => Native.rm_set_servo_on_off(this.instance, value));
            }
        }

        public void Stop()
        {
            RunWithManaged(() => Native.rm_stop(this.instance));
        }

        public void Debug(IntPtr info)
        {
            RunWithManaged(() => Native.rm_debug(this.instance, info));
        }
    }

}