using System;
using System.Linq;
using System.Reflection;
using System.Collections.Generic;
using System.Runtime.InteropServices;

using NLua.Exceptions;
using NLua.Extensions;
using NLua.GenerateEventAssembly;
using NLua.Method;
using NLua.Native;

// ReSharper disable UnusedMember.Global

namespace NLua
{
	// ReSharper disable once ClassNeverInstantiated.Global
	public class Lua : IDisposable
	{
		// We need to keep this in a managed reference so the delegate doesn't get garbage collected
		private static readonly LuaNativeFunction _panicCallback = PanicCallback;

		private readonly LuaGlobals _globals = new();

		/// <summary>
		/// True while a script is being executed
		/// </summary>
		// ReSharper disable once UnusedAutoPropertyAccessor.Global
		public bool IsExecuting { get; private set; }

		internal LuaState State { get; private set; }

		internal ObjectTranslator Translator { get; private set; }

		// The commented code bellow is the initLua, the code assigned here is minified for size/performance reasons.
		private const string InitLuanet = @"local a={}local rawget=rawget;local b=luanet.import_type;local c=luanet.load_assembly;luanet.error,luanet.type=error,type;function a:__index(d)local e=rawget(self,'.fqn')e=(e and e..'.'or'')..d;local f=rawget(luanet,d)or b(e)if f==nil then pcall(c,e)f={['.fqn']=e}setmetatable(f,a)end;rawset(self,d,f)return f end;function a:__call(...)error('No such type: '..rawget(self,'.fqn'),2)end;luanet['.fqn']=false;setmetatable(luanet,a)luanet.load_assembly('mscorlib')";
		//@"local metatable = {}
		//       local rawget = rawget
		//       local import_type = luanet.import_type
		//       local load_assembly = luanet.load_assembly
		//       luanet.error, luanet.type = error, type
		//       -- Lookup a .NET identifier component.
		//       function metatable:__index(key) -- key is e.g. 'Form'
		//           -- Get the fully-qualified name, e.g. 'System.Windows.Forms.Form'
		//           local fqn = rawget(self,'.fqn')
		//           fqn = ((fqn and fqn .. '.') or '') .. key

		//           -- Try to find either a luanet function or a CLR type
		//           local obj = rawget(luanet,key) or import_type(fqn)

		//           -- If key is neither a luanet function or a CLR type, then it is simply
		//           -- an identifier component.
		//           if obj == nil then
		//               -- It might be an assembly, so we load it too.
		//               pcall(load_assembly,fqn)
		//               obj = { ['.fqn'] = fqn }
		//               setmetatable(obj, metatable)
		//           end

		//           -- Cache this lookup
		//           rawset(self, key, obj)
		//           return obj
		//       end

		//       -- A non-type has been called; e.g. foo = System.Foo()
		//       function metatable:__call(...)
		//           error('No such type: ' .. rawget(self,'.fqn'), 2)
		//       end

		//       -- This is the root of the .NET namespace
		//       luanet['.fqn'] = false
		//       setmetatable(luanet, metatable)

		//       -- Preload the mscorlib assembly
		//       luanet.load_assembly('mscorlib')";

		private const string ClrPackage = @"if not luanet then require'luanet'end;local a,b=luanet.import_type,luanet.load_assembly;local c={__index=function(d,e)local f=rawget(d,e)if f==nil then f=a(d.packageName.."".""..e)if f==nil then f=a(e)end;d[e]=f end;return f end}function luanet.namespace(g)if type(g)=='table'then local h={}for i=1,#g do h[i]=luanet.namespace(g[i])end;return unpack(h)end;local j={packageName=g}setmetatable(j,c)return j end;local k,l;local function m()l={}k={__index=function(n,e)for i,d in ipairs(l)do local f=d[e]if f then _G[e]=f;return f end end end}setmetatable(_G,k)end;function CLRPackage(o,p)p=p or o;local q=pcall(b,o)return luanet.namespace(p)end;function import(o,p)if not k then m()end;if not p then local i=o:find('%.dll$')if i then p=o:sub(1,i-1)else p=o end end;local j=CLRPackage(o,p)table.insert(l,j)return j end;function luanet.make_array(r,s)local t=r[#s]for i,u in ipairs(s)do t:SetValue(u,i-1)end;return t end;function luanet.each(v)local w=v:GetEnumerator()return function()if w:MoveNext()then return w.Current end end end";
		//@"---
		//--- This lua module provides auto importing of .net classes into a named package.
		//--- Makes for super easy use of LuaInterface glue
		//---
		//--- example:
		//---   Threading = CLRPackage(""System"", ""System.Threading"")
		//---   Threading.Thread.Sleep(100)
		//---
		//--- Extensions:
		//--- import() is a version of CLRPackage() which puts the package into a list which is used by a global __index lookup,
		//--- and thus works rather like C#'s using statement. It also recognizes the case where one is importing a local
		//--- assembly, which must end with an explicit .dll extension.

		//--- Alternatively, luanet.namespace can be used for convenience without polluting the global namespace:
		//---   local sys,sysi = luanet.namespace {'System','System.IO'}
		//--    sys.Console.WriteLine(""we are at {0}"",sysi.Directory.GetCurrentDirectory())


		//-- LuaInterface hosted with stock Lua interpreter will need to explicitly require this...
		//if not luanet then require 'luanet' end

		//local import_type, load_assembly = luanet.import_type, luanet.load_assembly

		//local mt = {
		//    --- Lookup a previously unfound class and add it to our table
		//    __index = function(package, classname)
		//        local class = rawget(package, classname)
		//        if class == nil then
		//            class = import_type(package.packageName .. ""."" .. classname)
		//            if class == nil then class = import_type(classname) end
		//            package[classname] = class		-- keep what we found around, so it will be shared
		//        end
		//        return class
		//    end
		//}

		//function luanet.namespace(ns)
		//    if type(ns) == 'table' then
		//        local res = {}
		//        for i = 1,#ns do
		//            res[i] = luanet.namespace(ns[i])
		//        end
		//        return unpack(res)
		//    end
		//    -- FIXME - table.packageName could instead be a private index (see Lua 13.4.4)
		//    local t = { packageName = ns }
		//    setmetatable(t,mt)
		//    return t
		//end

		//local globalMT, packages

		//local function set_global_mt()
		//    packages = {}
		//    globalMT = {
		//        __index = function(T,classname)
		//                for i,package in ipairs(packages) do
		//                    local class = package[classname]
		//                    if class then
		//                        _G[classname] = class
		//                        return class
		//                    end
		//                end
		//        end
		//    }
		//    setmetatable(_G, globalMT)
		//end

		//--- Create a new Package class
		//function CLRPackage(assemblyName, packageName)
		//  -- a sensible default...
		//  packageName = packageName or assemblyName
		//  local ok = pcall(load_assembly,assemblyName)			-- Make sure our assembly is loaded
		//  return luanet.namespace(packageName)
		//end

		//function import (assemblyName, packageName)
		//    if not globalMT then
		//        set_global_mt()
		//    end
		//    if not packageName then
		//        local i = assemblyName:find('%.dll$')
		//        if i then packageName = assemblyName:sub(1,i-1)
		//        else packageName = assemblyName end
		//    end
		//    local t = CLRPackage(assemblyName,packageName)
		//    table.insert(packages,t)
		//    return t
		//end


		//function luanet.make_array (tp,tbl)
		//    local arr = tp[#tbl]
		//    for i,v in ipairs(tbl) do
		//        arr:SetValue(v,i-1)
		//    end
		//    return arr
		//end

		//function luanet.each(o)
		//   local e = o:GetEnumerator()
		//   return function()
		//      if e:MoveNext() then
		//        return e.Current
		//     end
		//   end
		//end
		//";

		public bool UseTraceback { get; set; } = false;

		/// <summary>
		/// The maximum number of recursive steps to take when adding global reference variables.  Defaults to 2.
		/// </summary>
		public int MaximumRecursion
		{
			get => _globals.MaximumRecursion;
			set => _globals.MaximumRecursion = value;
		}

		/// <summary>
		/// An alphabetically sorted list of all globals (objects, methods, etc.) externally added to this Lua instance
		/// </summary>
		/// <remarks>Members of globals are also listed. The formatting is optimized for text input auto-completion.</remarks>
		public IEnumerable<string> Globals => _globals.Globals;

		/// <summary>
		/// Get the thread object of this state.
		/// </summary>
		public LuaThread Thread
		{
			get
			{
				var oldTop = State.GetTop();
				State.PushThread();
				var returnValue = Translator.GetObject(State, -1);

				State.SetTop(oldTop);
				return (LuaThread)returnValue;
			}
		}

		/// <summary>
		/// Get the main thread object
		/// </summary>
		public LuaThread MainThread
		{
			get
			{
				var mainThread = State.MainThread;
				var oldTop = mainThread.GetTop();
				mainThread.PushThread();
				var returnValue = Translator.GetObject(mainThread, -1);

				mainThread.SetTop(oldTop);
				return (LuaThread)returnValue;
			}
		}

		public Lua(bool openLibs = true)
		{
			State = new(openLibs);
			Init();
			State.AtPanic(_panicCallback);
		}

		internal void Init()
		{
			State.PushString("NLua_Loaded");
			State.PushBoolean(true);
			State.SetTable((int)LuaRegistry.Index);
			State.NewTable();
			State.SetGlobal("luanet");
			State.PushGlobalTable();
			State.GetGlobal("luanet");
			State.PushString("getmetatable");
			State.GetGlobal("getmetatable");
			State.SetTable(-3);
			State.PopGlobalTable();
			Translator = new(this, State);

			ObjectTranslatorPool.Instance.Add(State, Translator);

			State.PopGlobalTable();
			State.DoString(InitLuanet);
		}

		public void Close()
		{
			if (State == null)
			{
				return;
			}

			State.Close();
			ObjectTranslatorPool.Instance.Remove(State);
			State = null;
		}

		internal static int PanicCallback(IntPtr state)
		{
			var luaState = LuaState.FromIntPtr(state);
			var reason = $"Unprotected error in call to Lua API ({luaState.ToString(-1, false)})";
			throw new LuaException(reason);
		}

		/// <summary>
		/// Assuming we have a Lua error string sitting on the stack, throw a C# exception out to the user's app
		/// </summary>
		/// <exception cref = "LuaScriptException">Thrown if the script caused an exception</exception>
		private void ThrowExceptionFromError(int oldTop)
		{
			var err = Translator.GetObject(State, -1);
			State.SetTop(oldTop);

			// A pre-wrapped exception - just rethrow it (stack trace of InnerException will be preserved)
			if (err is LuaScriptException luaEx)
			{
				throw luaEx;
			}

			// A non-wrapped Lua error (best interpreted as a string) - wrap it and throw it
			err ??= "Unknown Lua Error";
			throw new LuaScriptException(err.ToString(), string.Empty);
		}

		/// <summary>
		/// Push a debug.traceback reference onto the stack, for a pcall function to use as error handler. (Remember to increment any top-of-stack markers!)
		/// </summary>
		private static int PushDebugTraceback(LuaState luaState, int argCount)
		{
			luaState.GetGlobal("debug");
			luaState.GetField(-1, "traceback");
			luaState.Remove(-2);
			var errIndex = -argCount - 2;
			luaState.Insert(errIndex);
			return errIndex;
		}

		/// <summary>
		/// <para>Return a debug.traceback() call result (a multi-line string, containing a full stack trace, including C calls.</para>
		/// <para>Note: it won't return anything unless the interpreter is in the middle of execution - that is, it only makes sense to call it from a method called from Lua, or during a coroutine yield.</para>
		/// </summary>
		internal string GetDebugTraceback()
		{
			var oldTop = State.GetTop();
			State.GetGlobal("debug"); // stack: debug
			State.GetField(-1, "traceback"); // stack: debug,traceback
			State.Remove(-2); // stack: traceback
			State.PCall(0, -1, 0);
			return Translator.PopValues(State, oldTop)[0] as string;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name = "chunk"></param>
		/// <param name = "name"></param>
		/// <returns></returns>
		public LuaFunction LoadString(string chunk, string name)
		{
			var oldTop = State.GetTop();
			IsExecuting = true;

			try
			{
				if (State.LoadString(chunk, name) != LuaStatus.OK)
				{
					ThrowExceptionFromError(oldTop);
				}
			}
			finally
			{
				IsExecuting = false;
			}

			var result = Translator.GetFunction(State, -1);
			Translator.PopValues(State, oldTop);
			return result;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name = "chunk"></param>
		/// <param name = "name"></param>
		/// <returns></returns>
		public LuaFunction LoadString(byte[] chunk, string name)
		{
			var oldTop = State.GetTop();
			IsExecuting = true;

			try
			{
				if (State.LoadBuffer(chunk, name) != LuaStatus.OK)
				{
					ThrowExceptionFromError(oldTop);
				}
			}
			finally
			{
				IsExecuting = false;
			}

			var result = Translator.GetFunction(State, -1);
			Translator.PopValues(State, oldTop);
			return result;
		}

		/// <summary>
		/// Load a File on, and return a LuaFunction to execute the file loaded (useful to see if the syntax of a file is ok)
		/// </summary>
		/// <param name = "fileName"></param>
		/// <returns></returns>
		public LuaFunction LoadFile(string fileName)
		{
			var oldTop = State.GetTop();

			if (State.LoadFile(fileName) != LuaStatus.OK)
			{
				ThrowExceptionFromError(oldTop);
			}

			var result = Translator.GetFunction(State, -1);
			Translator.PopValues(State, oldTop);
			return result;
		}

		/// <summary>
		/// Executes a Lua chunk and returns all the chunk's return values in an array.
		/// </summary>
		/// <param name = "chunk">Chunk to execute</param>
		/// <param name = "chunkName">Name to associate with the chunk. Defaults to "chunk".</param>
		/// <returns></returns>
		public object[] DoString(byte[] chunk, string chunkName = "chunk")
		{
			var oldTop = State.GetTop();
			IsExecuting = true;

			if (State.LoadBuffer(chunk, chunkName) != LuaStatus.OK)
			{
				ThrowExceptionFromError(oldTop);
			}

			var errorFunctionIndex = 0;

			if (UseTraceback)
			{
				errorFunctionIndex = PushDebugTraceback(State, 0);
				oldTop++;
			}

			try
			{
				if (State.PCall(0, -1, errorFunctionIndex) != LuaStatus.OK)
				{
					ThrowExceptionFromError(oldTop);
				}

				return Translator.PopValues(State, oldTop);
			}
			finally
			{
				IsExecuting = false;
			}
		}

		/// <summary>
		/// Executes a Lua chunk and returns all the chunk's return values in an array.
		/// </summary>
		/// <param name = "chunk">Chunk to execute</param>
		/// <param name = "chunkName">Name to associate with the chunk. Defaults to "chunk".</param>
		/// <returns></returns>
		public object[] DoString(string chunk, string chunkName = "chunk")
		{
			var oldTop = State.GetTop();
			IsExecuting = true;

			if (State.LoadString(chunk, chunkName) != LuaStatus.OK)
			{
				ThrowExceptionFromError(oldTop);
			}

			var errorFunctionIndex = 0;

			if (UseTraceback)
			{
				errorFunctionIndex = PushDebugTraceback(State, 0);
				oldTop++;
			}

			try
			{
				if (State.PCall(0, -1, errorFunctionIndex) != LuaStatus.OK)
				{
					ThrowExceptionFromError(oldTop);
				}

				return Translator.PopValues(State, oldTop);
			}
			finally
			{
				IsExecuting = false;
			}
		}

		/// <summary>
		/// Executes a Lua file and returns all the chunk's return
		/// values in an array
		/// </summary>
		public object[] DoFile(string fileName)
		{
			var oldTop = State.GetTop();

			if (State.LoadFile(fileName) != LuaStatus.OK)
			{
				ThrowExceptionFromError(oldTop);
			}

			IsExecuting = true;

			var errorFunctionIndex = 0;
			if (UseTraceback)
			{
				errorFunctionIndex = PushDebugTraceback(State, 0);
				oldTop++;
			}

			try
			{
				if (State.PCall(0, -1, errorFunctionIndex) != LuaStatus.OK)
				{
					ThrowExceptionFromError(oldTop);
				}

				return Translator.PopValues(State, oldTop);
			}
			finally
			{
				IsExecuting = false;
			}
		}

		public object GetObjectFromPath(string fullPath)
		{
			var oldTop = State.GetTop();
			var path = FullPathToArray(fullPath);
			State.GetGlobal(path[0]);
			var returnValue = Translator.GetObject(State, -1);

			if (path.Length > 1)
			{
				var luaBase = returnValue as LuaBase;
				var remainingPath = new string[path.Length - 1];
				Array.Copy(path, 1, remainingPath, 0, path.Length - 1);
				returnValue = GetObject(remainingPath);
				luaBase?.Dispose();
			}

			State.SetTop(oldTop);
			return returnValue;
		}

		public void SetObjectToPath(string fullPath, object value)
		{
			var oldTop = State.GetTop();
			var path = FullPathToArray(fullPath);

			if (path.Length == 1)
			{
				Translator.Push(State, value);
				State.SetGlobal(fullPath);
			}
			else
			{
				State.GetGlobal(path[0]);
				var remainingPath = new string[path.Length - 1];
				Array.Copy(path, 1, remainingPath, 0, path.Length - 1);
				SetObject(remainingPath, value);
			}

			State.SetTop(oldTop);

			// Globals auto-complete
			if (value == null)
			{
				// Remove now obsolete entries
				_globals.RemoveGlobal(fullPath);
			}
			else
			{
				// Add new entries
				if (!_globals.Contains(fullPath))
				{
					_globals.RegisterGlobal(fullPath, value.GetType(), 0);
				}
			}
		}

		/// <summary>
		/// Indexer for global variables from the LuaInterpreter
		/// Supports navigation of tables by using . operator
		/// </summary>
		/// <param name="fullPath"></param>
		/// <returns></returns>
		public object this[string fullPath]
		{
			get
			{
				// Silently convert Lua integer to double for backward compatibility with index[] operator
				var obj = GetObjectFromPath(fullPath);
				if (obj is long l)
				{
					return (double)l;
				}

				return obj;
			}
			set => SetObjectToPath(fullPath, value);
		}

		/// <summary>
		/// Navigates a table in the top of the stack, returning
		/// the value of the specified field
		/// </summary>
		/// <param name="remainingPath"></param>
		/// <returns></returns>
		internal object GetObject(string[] remainingPath)
		{
			object returnValue = null;

			foreach (var t in remainingPath)
			{
				State.PushString(t);
				State.GetTable(-2);
				returnValue = Translator.GetObject(State, -1);

				if (returnValue == null)
				{
					break;
				}
			}

			return returnValue;
		}

		/// <summary>
		/// Gets a numeric global variable
		/// </summary>
		public double GetNumber(string fullPath)
		{
			// Silently convert Lua integer to double for backward compatibility with GetNumber method
			var obj = GetObjectFromPath(fullPath);
			if (obj is long l)
			{
				return l;
			}

			return (double)obj;
		}

		public int GetInteger(string fullPath)
		{
			var result = GetObjectFromPath(fullPath);
			if (result == null)
			{
				return 0;
			}

			return (int)(long)result;
		}

		public long GetLong(string fullPath)
		{
			var result = GetObjectFromPath(fullPath);
			if (result == null)
			{
				return 0L;
			}

			return (long)result;
		}

		/// <summary>
		/// Gets a string global variable
		/// </summary>
		public string GetString(string fullPath)
		{
			var obj = GetObjectFromPath(fullPath);
			return obj?.ToString();
		}

		/// <summary>
		/// Gets a table global variable
		/// </summary>
		public LuaTable GetTable(string fullPath)
			=> (LuaTable)GetObjectFromPath(fullPath);

		/// <summary>
		/// Gets a table global variable as an object implementing
		/// the interfaceType interface
		/// </summary>
		public object GetTable(Type interfaceType, string fullPath)
			=> CodeGeneration.Instance.GetClassInstance(interfaceType, GetTable(fullPath));

		/// <summary>
		/// Gets a thread global variable
		/// </summary>
		public LuaThread GetThread(string fullPath)
			=> (LuaThread)GetObjectFromPath(fullPath);

		/// <summary>
		/// Gets a function global variable
		/// </summary>
		public LuaFunction GetFunction(string fullPath)
		{
			var obj = GetObjectFromPath(fullPath);
			if (obj is LuaFunction luaFunction)
			{
				return luaFunction;
			}

			luaFunction = new((LuaNativeFunction)obj, this);
			return luaFunction;
		}

		/// <summary>
		/// Register a delegate type to be used to convert Lua functions to C# delegates (useful for iOS where there is no dynamic code generation)
		/// type delegateType
		/// </summary>
		public void RegisterLuaDelegateType(Type delegateType, Type luaDelegateType)
			=> CodeGeneration.Instance.RegisterLuaDelegateType(delegateType, luaDelegateType);

		public void RegisterLuaClassType(Type klass, Type luaClass)
			=> CodeGeneration.Instance.RegisterLuaClassType(klass, luaClass);

		public void LoadCLRPackage()
			=> State.DoString(ClrPackage);

		/// <summary>
		/// Gets a function global variable as a delegate of
		/// type delegateType
		/// </summary>
		public Delegate GetFunction(Type delegateType, string fullPath)
			=> CodeGeneration.Instance.GetDelegate(delegateType, GetFunction(fullPath));

		/// <summary>
		/// Calls the object as a function with the provided arguments and
		/// casting returned values to the types in returnTypes before returning
		/// them in an array
		/// </summary>
		internal object[] CallFunction(object function, object[] args, Type[] returnTypes = null)
		{
			var nArgs = 0;
			var oldTop = State.GetTop();

			if (!State.CheckStack(args.Length + 6))
			{
				throw new LuaException("Lua stack overflow");
			}

			Translator.Push(State, function);

			if (args.Length > 0)
			{
				nArgs = args.Length;

				foreach (var t in args)
				{
					Translator.Push(State, t);
				}
			}

			IsExecuting = true;

			try
			{
				var errfunction = 0;
				if (UseTraceback)
				{
					errfunction = PushDebugTraceback(State, nArgs);
					oldTop++;
				}

				var error = State.PCall(nArgs, -1, errfunction);
				if (error != LuaStatus.OK)
				{
					ThrowExceptionFromError(oldTop);
				}
			}
			finally
			{
				IsExecuting = false;
			}

			return returnTypes != null
				? Translator.PopValues(State, oldTop, returnTypes)
				: Translator.PopValues(State, oldTop);
		}

		/// <summary>
		/// Navigates a table to set the value of one of its fields
		/// </summary>
		internal void SetObject(string[] remainingPath, object val)
		{
			for (var i = 0; i < remainingPath.Length - 1; i++)
			{
				State.PushString(remainingPath[i]);
				State.GetTable(-2);
			}

			State.PushString(remainingPath[remainingPath.Length - 1]);
			Translator.Push(State, val);
			State.SetTable(-3);
		}

		/// <summary>
		/// Creates a new empty table
		/// </summary>
		public LuaTable NewTable()
		{
			var oldTop = State.GetTop();
			State.NewTable();
			var ret = Translator.GetTable(State, -1);
			State.SetTop(oldTop);
			return ret;
		}

		internal static string[] FullPathToArray(string fullPath)
			=> fullPath.SplitWithEscape('.', '\\').ToArray();

		/// <summary>
		/// Creates a new table as a global variable or as a field
		/// inside an existing table
		/// </summary>
		/// <param name="fullPath"></param>
		public void NewTable(string fullPath)
		{
			var path = FullPathToArray(fullPath);
			var oldTop = State.GetTop();

			if (path.Length == 1)
			{
				State.NewTable();
				State.SetGlobal(fullPath);
			}
			else
			{
				State.GetGlobal(path[0]);

				for (var i = 1; i < path.Length - 1; i++)
				{
					State.PushString(path[i]);
					State.GetTable(-2);
				}

				State.PushString(path[path.Length - 1]);
				State.NewTable();
				State.SetTable(-3);
			}

			State.SetTop(oldTop);
		}

		public Dictionary<object, object> GetTableDict(LuaTable table)
		{
			if (table == null)
			{
				throw new ArgumentNullException(nameof(table));
			}

			var dict = new Dictionary<object, object>();
			var oldTop = State.GetTop();
			Translator.Push(State, table);
			State.PushNil();

			while (State.Next(-2))
			{
				dict[Translator.GetObject(State, -2)] = Translator.GetObject(State, -1);
				State.SetTop(-2);
			}

			State.SetTop(oldTop);
			return dict;
		}

		internal void DisposeInternal(int reference, bool finalized)
		{
			if (finalized && Translator != null)
			{
				Translator.AddFinalizedReference(reference);
				return;
			}

			if (State != null && !finalized)
			{
				State.Unref(reference);
			}
		}

		/// <summary>
		/// Gets a field of the table corresponding to the provided reference
		/// using rawget (do not use metatables)
		/// </summary>
		internal object RawGetObject(int reference, string field)
		{
			var oldTop = State.GetTop();
			State.GetRef(reference);
			State.PushString(field);
			State.RawGet(-2);
			var obj = Translator.GetObject(State, -1);
			State.SetTop(oldTop);
			return obj;
		}

		/// <summary>
		/// Gets a field of the table or userdata corresponding to the provided reference
		/// </summary>
		internal object GetObject(int reference, string field)
		{
			var oldTop = State.GetTop();
			State.GetRef(reference);
			var returnValue = GetObject(FullPathToArray(field));
			State.SetTop(oldTop);
			return returnValue;
		}

		/// <summary>
		/// Gets a numeric field of the table or userdata corresponding the the provided reference
		/// </summary>
		internal object GetObject(int reference, object field)
		{
			var oldTop = State.GetTop();
			State.GetRef(reference);
			Translator.Push(State, field);
			State.GetTable(-2);
			var returnValue = Translator.GetObject(State, -1);
			State.SetTop(oldTop);
			return returnValue;
		}

		/// <summary>
		/// Sets a field of the table or userdata corresponding the the provided reference
		/// to the provided value
		/// </summary>
		internal void SetObject(int reference, string field, object val)
		{
			var oldTop = State.GetTop();
			State.GetRef(reference);
			SetObject(FullPathToArray(field), val);
			State.SetTop(oldTop);
		}

		/// <summary>
		/// Sets a numeric field of the table or userdata corresponding the the provided reference
		/// to the provided value
		/// </summary>
		internal void SetObject(int reference, object field, object val)
		{
			var oldTop = State.GetTop();
			State.GetRef(reference);
			Translator.Push(State, field);
			Translator.Push(State, val);
			State.SetTable(-3);
			State.SetTop(oldTop);
		}

		/// <summary>
		/// Gets the luaState from the thread
		/// </summary>
		internal LuaState GetThreadState(int reference)
		{
			var oldTop = State.GetTop();
			State.GetRef(reference);
			var state = State.ToThread(-1);
			State.SetTop(oldTop);
			return state;
		}

		/// <summary>
		/// Creates a new empty thread
		/// </summary>
		public LuaThread NewThread()
		{
			var oldTop = State.GetTop();

			State.NewThread();
			var thread = (LuaThread)Translator.GetObject(State, -1);

			State.SetTop(oldTop);
			return thread;
		}

		/// <summary>
		/// Creates a new coroutine thread
		/// </summary>
		public LuaThread NewThread(LuaFunction function)
		{
			var oldTop = State.GetTop();

			var state = State.NewThread();
			var thread = (LuaThread)Translator.GetObject(State, -1);

			Translator.Push(State, function);
			State.XMove(state, 1);

			State.SetTop(oldTop);
			return thread;
		}

		public LuaFunction RegisterFunction(string path, MethodBase function)
			=> RegisterFunction(path, null, function);

		/// <summary>
		/// Registers an object's method as a Lua function (global or table field)
		/// The method may have any signature
		/// </summary>
		public LuaFunction RegisterFunction(string path, object target, MethodBase function)
		{
			// We leave nothing on the stack when we are done
			var oldTop = State.GetTop();
			var wrapper = new LuaMethodWrapper(Translator, target, new(function.DeclaringType), function);

			Translator.Push(State, new LuaNativeFunction(wrapper.InvokeFunction));

			var value = Translator.GetObject(State, -1);
			SetObjectToPath(path, value);

			var f = GetFunction(path);
			State.SetTop(oldTop);
			return f;
		}

		/// <summary>
		/// Compares the two values referenced by ref1 and ref2 for equality
		/// </summary>
		internal bool CompareRef(int ref1, int ref2)
		{
			var top = State.GetTop();
			State.GetRef(ref1);
			State.GetRef(ref2);
			var equal = State.AreEqual(-1, -2);
			State.SetTop(top);
			return equal;
		}

		internal void PushCSFunction(LuaNativeFunction function)
			=> Translator.PushFunction(State, function);

		~Lua()
		{
			Dispose();
		}

		public void Dispose()
		{
			if (Translator != null)
			{
				Translator.PendingEvents.Dispose();
				if (Translator.Tag != IntPtr.Zero)
				{
					Marshal.FreeHGlobal(Translator.Tag);
				}

				Translator = null;
			}

			Close();
			GC.SuppressFinalize(this);
		}
	}
}