public static LuaValue Wrap(LuaValue[] args)
 {
     LuaFunction f = args[0] as LuaFunction;
     LuaCoroutine c = new LuaCoroutine(f);
     LuaFunction f2 = new LuaFunction(new LuaFunc(delegate(LuaValue[] args2) { return LuaBoolean.From(c.Resume(args2)); }));
     return f2;
 }

 public static LuaValue IsClass(LuaValue[] args)
 {
     if ((args[0] as LuaClass) != null)
         return LuaBoolean.True;
     else
         return LuaBoolean.False;
 }

        public static LuaValue open(LuaValue[] values)
        {
            //[PixelCrushers]LuaString file = values[0] as LuaString;
            LuaString modeStr = values.Length > 1 ? values[1] as LuaString : null;
            string mode = modeStr == null ? "r" : modeStr.Text;

            switch (mode)
            {
                case "r":
                case "r+":
                //[PixelCrushers]StreamReader reader = File.OpenText(file.Text);
                //[PixelCrushers]return new LuaUserdata(reader, FileLib.CreateMetaTable());
                return null;
                case "w":
                case "w+":
                //[PixelCrushers]StreamWriter writer = File.CreateText(file.Text);
                //[PixelCrushers]return new LuaUserdata(writer, FileLib.CreateMetaTable());
                return null;
                case "a":
                case "a+":
                //[PixelCrushers]writer = File.AppendText(file.Text);
                //[PixelCrushers]return new LuaUserdata(writer, FileLib.CreateMetaTable());
                return null;
                default:
                    throw new ArgumentException("Invalid file open mode " + mode);
            }
        }

 public static LuaValue Yield(LuaValue[] args)
 {
     LuaCoroutine c = args[0] as LuaCoroutine;
     c.Pause();
     // TODO: set restart args
     return LuaNil.Nil;
 }

        public override LuaValue Evaluate(LuaValue baseValue, LuaTable enviroment)
        {
            LuaValue value = LuaValue.GetKeyValue(baseValue, new LuaString(this.Method));
            LuaFunction function = value as LuaFunction;

            if (function != null)
            {
                if (this.Args.Table != null)
                {
                    return function.Function.Invoke(new LuaValue[] { baseValue, this.Args.Table.Evaluate(enviroment) });
                }
                else if (this.Args.String != null)
                {
                    return function.Function.Invoke(new LuaValue[] { baseValue, this.Args.String.Evaluate(enviroment) });
                }
                else
                {
                    //[PixelCrushers]List<LuaValue> args = this.Args.ArgList.ConvertAll(arg => arg.Evaluate(enviroment));
                    List<LuaValue> args = LuaInterpreterExtensions.EvaluateAll(this.Args.ArgList, enviroment);
                    args.Insert(0, baseValue);
                    return function.Function.Invoke(args.ToArray());
                }
            }
            else
            {
                throw new Exception("Invoke method call on non function value.");
            }
        }

        public static LuaValue Lines(LuaValue[] values)
        {
            LuaUserdata data = values[0] as LuaUserdata;
            TextReader reader = data.Value as TextReader;

            LuaFunction func = new LuaFunction((LuaValue[] args) =>
                {
                    LuaUserdata _data = values[0] as LuaUserdata;
                    TextReader _reader = data.Value as TextReader;

                    string line = _reader.ReadLine();

                    if (line != null)
                    {
                        return new LuaString(line);
                    }
                    else
                    {
                        return LuaNil.Nil;
                    }
                }
            );

            return new LuaMultiValue(new LuaValue[] { func, data, LuaNil.Nil });
        }

 public static LuaValue Flush(LuaValue[] values)
 {
     LuaUserdata data = values[0] as LuaUserdata;
     TextWriter writer = data.Value as TextWriter;
     writer.Flush();
     return null;
 }

        public override LuaValue Evaluate(LuaValue baseValue, LuaTable enviroment)
        {
            LuaValue value = null;
		try {LuaValue.GetKeyValue(baseValue, new LuaString(this.Method)); } catch (Exception) { }
            LuaFunction function = value as LuaFunction;

            if (function != null)
            {
                if (this.Args.Table != null)
                {
                    return function.Function.Invoke(new LuaValue[] { baseValue, this.Args.Table.Evaluate(enviroment) });
                }
                else if (this.Args.String != null)
                {
                    return function.Function.Invoke(new LuaValue[] { baseValue, this.Args.String.Evaluate(enviroment) });
                }
                else
                {
                    List<LuaValue> args = this.Args.ArgList.ConvertAll(arg => arg.Evaluate(enviroment));
                    args.Insert(0, baseValue);
                    return function.Function.Invoke(args.ToArray());
                }
            } // method call on table would be like _G:script()
            else if ((baseValue as LuaTable) != null)
            {
                List<LuaValue> args = this.Args.ArgList.ConvertAll(arg => arg.Evaluate(enviroment));
                return ((baseValue as LuaTable).MetaTable.GetValue("__call") as LuaFunction).Invoke(args.ToArray());
            }
            else if ((baseValue as LuaClass) != null)
            {
                LuaClass c = baseValue as LuaClass;
                List<LuaValue> args = this.Args.ArgList.ConvertAll(arg => arg.Evaluate(enviroment));
                args.Insert(0, new LuaString(this.Method));
                if (c.Self.MetaTable == null)
                    c.GenerateMetaTable();
                return (c.Self.MetaTable.GetValue("__call") as LuaFunction).Invoke(args.ToArray());
            }
            else if ((baseValue as LuaUserdata) != null)
            {
                List<LuaValue> args = this.Args.ArgList.ConvertAll(arg => arg.Evaluate(enviroment));
                LuaUserdata obj = baseValue as LuaUserdata;
                object o = obj.Value;
                if (obj.MetaTable != null)
                {
                    if (obj.MetaTable.GetValue(this.Method) != null)
                    {
                        LuaValue o2 = obj.MetaTable.GetValue(this.Method);
                        if ((o2 as LuaFunction) != null)
                            return (o2 as LuaFunction).Invoke(args.ToArray());
                        else if ((o2 as LuaTable) != null)
                            throw new NotImplementedException(); // TODO
                    }
                }
                return ObjectToLua.ToLuaValue(o.GetType().GetMethod(this.Method, BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Invoke(o, BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, args.ToArray(), CultureInfo.CurrentCulture));
            }
            else
            {
                throw new Exception("Invoke method call on non function value.");
            }
        }

 public static LuaValue DiffTime(LuaValue[] args)
 {
     // FIXM
     DateTime t2 = DateTime.Parse(args[0].Value.ToString());
     DateTime t1 = DateTime.Parse(args[1].Value.ToString());
     return new LuaUserdata(t2 - t1);
 }

        public static LuaValue Copy(LuaValue[] args)
        {
            LuaTable _new = (LuaTable) args[0];
            LuaTable old = (LuaTable) args[1];
            if (_new == null)
                throw new ArgumentNullException("Table to copy to cannot be nil!");
            if (old == null)
                throw new ArgumentNullException("Table to copy from cannot be nil!");
            if (old.Count == 0)
                return _new; // nothing to copy
            Dictionary<LuaValue, LuaValue> oldFields = (Dictionary<LuaValue, LuaValue>)old.KeyValuePairs;
            List<LuaValue> keys = new List<LuaValue>();
            List<LuaValue> values = new List<LuaValue>();

            foreach (LuaValue key in oldFields.Keys)
                keys.Add(key);
            foreach (LuaValue val in oldFields.Values)
                values.Add(val);

            // add to new table
            for (int i = 0; i < keys.Count; i++)
            {
                try {
                    _new.SetKeyValue(keys[i], values[i]);
                } catch (Exception ex) {
                    throw new Exception("Error copying at index " + i + ": " + ex.Message);
                }
            }
            return _new;
        }

        private static LuaFunction GetMetaFunction(string name, LuaValue leftValue, LuaValue rightValue)
        {
            LuaTable left = leftValue as LuaTable;

            if (left != null)
            {
                LuaFunction func = left.GetValue(name) as LuaFunction;

                if (func != null)
                {
                    return func;
                }
            }
            LuaFunction f = leftValue.MetaTable.GetValue(name) as LuaFunction;
            if (f != null)
                return f;

            LuaTable right = rightValue as LuaTable;

            if (right != null)
            {
                return right.GetValue(name) as LuaFunction;
            }
            f = rightValue.MetaTable.GetValue(name) as LuaFunction;
            if (f != null)
                return f;

            return null;
        }

		public VariableUpdateEventArgs(VariableUpdateType type, LuaValue thread, VariableDetails[] vars, bool cacheFlush)
		{
			mType = type;
			mThread = thread;
			mVariables = vars;
			mCacheFlush = cacheFlush;
		}

 public static LuaValue CreateClass(LuaValue[] args)
 {
     LuaTable from = new LuaTable();
     if (args.Length > 0)
         if (args[0].GetTypeCode() == "table" && ((IsClass(new LuaValue[] {args[0]}) as LuaBoolean).BoolValue == false))
             from = args[0] as LuaTable;
     LuaClass nClass = new LuaClass("CLASS_" + classCount++, false, false);
     List<LuaClass> Parents = new List<LuaClass>();
     for (int i = 0; i < args.Length; i++)
     {
         LuaClass c = args[i] as LuaClass;
         if (c == null)
             continue;
         if (c.Final)
             throw new Exception("Cannot inherit from a final class");
         else
         {
             Parents.Add(c);
             c.ChildClasses.Add(nClass);
         }
     }
     nClass.ParentClasses = Parents;
     TableLib.Copy(new LuaValue[] {nClass.Self, from});
     return nClass;
 }

        public static LuaValue Date(LuaValue[] values)
        {
            LuaString format = null;
            if (values.Length > 0)
                format = values[0] as LuaString;
            if (format != null)
            {
                if (format.Text == "*t")
                {
                    LuaTable table = new LuaTable();
                    DateTime now = DateTime.Now;
                    table.SetNameValue("year", new LuaNumber (now.Year));
                    table.SetNameValue("month", new LuaNumber (now.Month ));
                    table.SetNameValue("day", new LuaNumber (now.Day));
                    table.SetNameValue("hour", new LuaNumber (now.Hour));
                    table.SetNameValue("min", new LuaNumber (now.Minute));
                    table.SetNameValue("sec", new LuaNumber (now.Second));
                    table.SetNameValue("wday", new LuaNumber ((int)now.DayOfWeek));
                    table.SetNameValue("yday", new LuaNumber (now.DayOfYear));
                    table.SetNameValue("isdst", LuaBoolean.From(now.IsDaylightSavingTime()));
                }
                else
                {
                    return new LuaString(DateTime.Now.ToString(format.Text));
                }
            }

            return new LuaString(DateTime.Now.ToShortDateString());
        }

        public static LuaValue Concat(LuaValue[] values)
        {
            LuaTable table = values[0] as LuaTable;
            LuaString separator = values.Length > 1 ? values[1] as LuaString : LuaString.Empty;
            LuaNumber startNumber = values.Length > 2 ? values[2] as LuaNumber : null;
            LuaNumber endNumber = values.Length > 3 ? values[3] as LuaNumber : null;

            int start = startNumber == null ? 1 : (int)startNumber.Number;
            int end = endNumber == null ? table.Count : (int)endNumber.Number;

            if (start > end)
            {
                return LuaString.Empty;
            }
            else
            {
                StringBuilder text = new StringBuilder();

                for (int index = start; index < end; index++)
                {
                    text.Append(table.GetValue(index).ToString());
                    text.Append(separator.Text);
                }
                text.Append(table.GetValue(end).ToString());

                return new LuaString(text.ToString());
            }
        }

        public static LuaValue[] UnWrapLuaValues(LuaValue[] values)
        {
            if (values == null || values.Length == 0 || ContainsMultiValue(values) == false)
                return values;

            if (values.Length == 1 && values[0] is LuaMultiValue)
                return (values[0] as LuaMultiValue).Values;

            List<LuaValue> neatValues = new List<LuaValue>(values.Length);

            for (int i = 0; i < values.Length - 1; i++)
            {
                LuaValue value = values[i];
                LuaMultiValue multiValue = value as LuaMultiValue;

                if (multiValue != null)
                    neatValues.Add(multiValue.Values[0]);
                else
                    neatValues.Add(value);
            }

            LuaValue lastValue = values[values.Length - 1];
            LuaMultiValue lastMultiValue = lastValue as LuaMultiValue;

            if (lastMultiValue != null)
                neatValues.AddRange(lastMultiValue.Values);
            else
                neatValues.Add(lastValue);

            return neatValues.ToArray();
        }

        public override LuaValue Evaluate(LuaValue baseValue, LuaTable enviroment)
        {
            LuaValue value = LuaValue.GetKeyValue(baseValue, new LuaString(this.Method));
            LuaFunction function = value as LuaFunction;

            if (function != null)
            {
                if (this.Args.Table != null)
                {
                    return function.Function.Invoke(new LuaValue[] { baseValue, this.Args.Table.Evaluate(enviroment) });
                }
                else if (this.Args.String != null)
                {
                    return function.Function.Invoke(new LuaValue[] { baseValue, this.Args.String.Evaluate(enviroment) });
                }
                else
                {
            //                    List<LuaValue> args = this.Args.ArgList.ConvertAll(arg => arg.Evaluate(enviroment));
                    List<LuaValue> args = new List<LuaValue>();
                    foreach (var arg in this.Args.ArgList)
                        args.Add(arg.Evaluate(enviroment));
                    args.Insert(0, baseValue);
                    return function.Function.Invoke(args.ToArray());
                }
            }
            else
            {
                throw new Exception("Invoke method call on non function value.");
            }
        }

        /// <summary>
        /// Sets the assignment
        /// </summary>
        /// <param name="baseValue"></param>
        /// <param name="key"></param>
        /// <param name="value"></param>
        private static void SetKeyValue(LuaValue baseValue, LuaValue key, LuaValue value)
        {
            LuaValue newIndex = LuaNil.Nil;
            LuaTable table = baseValue as LuaTable;
            if (table != null)
            {
                if (table.MetaTable != null)
                {
                    newIndex = table.MetaTable.GetValue("__newindex");
                    // to be finished at the end of this method
                }

                if (newIndex == LuaNil.Nil)
                {
                    table.SetKeyValue(key, value);
                    return;
                }
            }
            else if ((baseValue as LuaClass) != null)
            {
                LuaClass c = baseValue as LuaClass;
                // null checks (mainly for debugging)
                if (c.Self.MetaTable == null)
                    c.GenerateMetaTable();
                //throw new Exception("Class metatable is nil!");
                newIndex = c.Self.MetaTable.GetValue("__newindex");
                if (newIndex == LuaNil.Nil)
                    c.Self.SetKeyValue(key, value);
                else
                    (newIndex as LuaFunction).Invoke(new LuaValue[] { baseValue, key, value });
                return;
            }
            else
            {
                LuaUserdata userdata = baseValue as LuaUserdata;
                if (userdata != null)
                {
                    if (userdata.MetaTable != null)
                    {
                        newIndex = userdata.MetaTable.GetValue("__newindex");
                    }

                    if (newIndex == LuaNil.Nil)
                    {
                        throw new Exception("Assign field of userdata without __newindex defined.");
                    }
                }
            }

            LuaFunction func = newIndex as LuaFunction;
            if (func != null)
            {
                func.Invoke(new LuaValue[] { baseValue, key, value });
            }
            else
            {
                SetKeyValue(newIndex, key, value);
            }
        }

		public void WriteValue(LuaValue value)
		{
			Write((int)value.Type);
			if (value.Type == LuaValueType.NUMBER)
				WriteNumber(value.AsNumber());
			else
				WriteObjectID(value.Value);
		}

 public static LuaValue Create(LuaValue[] args)
 {
     LuaFunction func = args[0] as LuaFunction;
     if (func == null)
         throw new ArgumentException("Function expected, got '" + args[0].Value.GetType().Name + "'");
     LuaCoroutine c = new LuaCoroutine(func);
     return c;
 }