using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Runtime.Remoting;
using System.Security.Permissions;
using AspClassic.Scripting.Runtime;
using AspClassic.Scripting.Utils;

namespace AspClassic.Scripting.Hosting;

public sealed class ObjectOperations : MarshalByRefObject
{
	private readonly DynamicOperations _ops;

	private readonly ScriptEngine _engine;

	public ScriptEngine Engine => _engine;

	internal ObjectOperations(DynamicOperations ops, ScriptEngine engine)
	{
		_ops = ops;
		_engine = engine;
	}

	public bool IsCallable(object obj)
	{
		return _ops.IsCallable(obj);
	}

	public dynamic Invoke(object obj, params object[] parameters)
	{
		return _ops.Invoke(obj, parameters);
	}

	public dynamic InvokeMember(object obj, string memberName, params object[] parameters)
	{
		return _ops.InvokeMember(obj, memberName, parameters);
	}

	public dynamic CreateInstance(object obj, params object[] parameters)
	{
		return _ops.CreateInstance(obj, parameters);
	}

	public dynamic GetMember(object obj, string name)
	{
		return _ops.GetMember(obj, name);
	}

	public T GetMember<T>(object obj, string name)
	{
		return _ops.GetMember<T>(obj, name);
	}

	public bool TryGetMember(object obj, string name, out object value)
	{
		return _ops.TryGetMember(obj, name, out value);
	}

	public bool ContainsMember(object obj, string name)
	{
		return _ops.ContainsMember(obj, name);
	}

	public void RemoveMember(object obj, string name)
	{
		_ops.RemoveMember(obj, name);
	}

	public void SetMember(object obj, string name, object value)
	{
		_ops.SetMember(obj, name, value);
	}

	public void SetMember<T>(object obj, string name, T value)
	{
		_ops.SetMember(obj, name, value);
	}

	public dynamic GetMember(object obj, string name, bool ignoreCase)
	{
		return _ops.GetMember(obj, name, ignoreCase);
	}

	public T GetMember<T>(object obj, string name, bool ignoreCase)
	{
		return _ops.GetMember<T>(obj, name, ignoreCase);
	}

	public bool TryGetMember(object obj, string name, bool ignoreCase, out object value)
	{
		return _ops.TryGetMember(obj, name, ignoreCase, out value);
	}

	public bool ContainsMember(object obj, string name, bool ignoreCase)
	{
		return _ops.ContainsMember(obj, name, ignoreCase);
	}

	public void RemoveMember(object obj, string name, bool ignoreCase)
	{
		_ops.RemoveMember(obj, name, ignoreCase);
	}

	public void SetMember(object obj, string name, object value, bool ignoreCase)
	{
		_ops.SetMember(obj, name, value, ignoreCase);
	}

	public void SetMember<T>(object obj, string name, T value, bool ignoreCase)
	{
		_ops.SetMember(obj, name, value, ignoreCase);
	}

	public T ConvertTo<T>(object obj)
	{
		return _ops.ConvertTo<T>(obj);
	}

	public object ConvertTo(object obj, Type type)
	{
		ContractUtils.RequiresNotNull(type, "type");
		return _ops.ConvertTo(obj, type);
	}

	public bool TryConvertTo<T>(object obj, out T result)
	{
		return _ops.TryConvertTo<T>(obj, out result);
	}

	public bool TryConvertTo(object obj, Type type, out object result)
	{
		return _ops.TryConvertTo(obj, type, out result);
	}

	public T ExplicitConvertTo<T>(object obj)
	{
		return _ops.ExplicitConvertTo<T>(obj);
	}

	public object ExplicitConvertTo(object obj, Type type)
	{
		ContractUtils.RequiresNotNull(type, "type");
		return _ops.ExplicitConvertTo(obj, type);
	}

	public bool TryExplicitConvertTo<T>(object obj, out T result)
	{
		return _ops.TryExplicitConvertTo<T>(obj, out result);
	}

	public bool TryExplicitConvertTo(object obj, Type type, out object result)
	{
		return _ops.TryExplicitConvertTo(obj, type, out result);
	}

	public T ImplicitConvertTo<T>(object obj)
	{
		return _ops.ImplicitConvertTo<T>(obj);
	}

	public object ImplicitConvertTo(object obj, Type type)
	{
		ContractUtils.RequiresNotNull(type, "type");
		return _ops.ImplicitConvertTo(obj, type);
	}

	public bool TryImplicitConvertTo<T>(object obj, out T result)
	{
		return _ops.TryImplicitConvertTo<T>(obj, out result);
	}

	public bool TryImplicitConvertTo(object obj, Type type, out object result)
	{
		return _ops.TryImplicitConvertTo(obj, type, out result);
	}

	public dynamic DoOperation(ExpressionType operation, object target)
	{
		return _ops.DoOperation<object, object>(operation, target);
	}

	public TResult DoOperation<TTarget, TResult>(ExpressionType operation, TTarget target)
	{
		return _ops.DoOperation<TTarget, TResult>(operation, target);
	}

	public dynamic DoOperation(ExpressionType operation, object target, object other)
	{
		return _ops.DoOperation<object, object, object>(operation, target, other);
	}

	public TResult DoOperation<TTarget, TOther, TResult>(ExpressionType operation, TTarget target, TOther other)
	{
		return _ops.DoOperation<TTarget, TOther, TResult>(operation, target, other);
	}

	public dynamic Add(object self, object other)
	{
		return DoOperation(ExpressionType.Add, self, other);
	}

	public dynamic Subtract(object self, object other)
	{
		return DoOperation(ExpressionType.Subtract, self, other);
	}

	public dynamic Power(object self, object other)
	{
		return DoOperation(ExpressionType.Power, self, other);
	}

	public dynamic Multiply(object self, object other)
	{
		return DoOperation(ExpressionType.Multiply, self, other);
	}

	public dynamic Divide(object self, object other)
	{
		return DoOperation(ExpressionType.Divide, self, other);
	}

	public dynamic Modulo(object self, object other)
	{
		return DoOperation(ExpressionType.Modulo, self, other);
	}

	public dynamic LeftShift(object self, object other)
	{
		return DoOperation(ExpressionType.LeftShift, self, other);
	}

	public dynamic RightShift(object self, object other)
	{
		return DoOperation(ExpressionType.RightShift, self, other);
	}

	public dynamic BitwiseAnd(object self, object other)
	{
		return DoOperation(ExpressionType.And, self, other);
	}

	public dynamic BitwiseOr(object self, object other)
	{
		return DoOperation(ExpressionType.Or, self, other);
	}

	public dynamic ExclusiveOr(object self, object other)
	{
		return DoOperation(ExpressionType.ExclusiveOr, self, other);
	}

	public bool LessThan(object self, object other)
	{
		return ConvertTo<bool>(_ops.DoOperation<object, object, object>(ExpressionType.LessThan, self, other));
	}

	public bool GreaterThan(object self, object other)
	{
		return ConvertTo<bool>(_ops.DoOperation<object, object, object>(ExpressionType.GreaterThan, self, other));
	}

	public bool LessThanOrEqual(object self, object other)
	{
		return ConvertTo<bool>(_ops.DoOperation<object, object, object>(ExpressionType.LessThanOrEqual, self, other));
	}

	public bool GreaterThanOrEqual(object self, object other)
	{
		return ConvertTo<bool>(_ops.DoOperation<object, object, object>(ExpressionType.GreaterThanOrEqual, self, other));
	}

	public bool Equal(object self, object other)
	{
		return ConvertTo<bool>(_ops.DoOperation<object, object, object>(ExpressionType.Equal, self, other));
	}

	public bool NotEqual(object self, object other)
	{
		return ConvertTo<bool>(_ops.DoOperation<object, object, object>(ExpressionType.NotEqual, self, other));
	}

	[Obsolete("Use Format method instead.")]
	public string GetCodeRepresentation(object obj)
	{
		return obj.ToString();
	}

	public string Format(object obj)
	{
		return _ops.Format(obj);
	}

	public IList<string> GetMemberNames(object obj)
	{
		return _ops.GetMemberNames(obj);
	}

	public string GetDocumentation(object obj)
	{
		return _ops.GetDocumentation(obj);
	}

	public IList<string> GetCallSignatures(object obj)
	{
		return _ops.GetCallSignatures(obj);
	}

	[Obsolete("Use Invoke instead")]
	public object Call(object obj, params object[] parameters)
	{
		return _ops.Invoke(obj, parameters);
	}

	[Obsolete("Use the ExpressionType overload instead")]
	public object DoOperation(Operators op, object target)
	{
		ExpressionType linqOp = GetLinqOp(op);
		return _ops.DoOperation<object, object>(linqOp, target);
	}

	[Obsolete("Use ExpressionType overload instead")]
	public TResult DoOperation<TTarget, TResult>(Operators op, TTarget target)
	{
		return _ops.DoOperation<TTarget, TResult>(GetLinqOp(op), target);
	}

	[Obsolete]
	private static ExpressionType GetLinqOp(Operators op)
	{
		ExpressionType? expressionType = null;
		return (op switch
		{
			Operators.Positive => ExpressionType.UnaryPlus, 
			Operators.Negate => ExpressionType.Negate, 
			Operators.OnesComplement => ExpressionType.OnesComplement, 
			Operators.IsFalse => ExpressionType.IsFalse, 
			Operators.Decrement => ExpressionType.Decrement, 
			Operators.Increment => ExpressionType.Increment, 
			_ => throw new InvalidOperationException($"Unrecognized shared operation: {op}"), 
		});
	}

	[Obsolete("Use Modulo instead")]
	public object Modulus(object self, object other)
	{
		return Modulo(self, other);
	}

	[Obsolete("Use ExpressionType overload instead")]
	public object DoOperation(Operators op, object target, object other)
	{
		return _ops.DoOperation<object, object, object>(GetLinqBinaryOp(op), target, other);
	}

	[Obsolete]
	private static ExpressionType GetLinqBinaryOp(Operators op)
	{
		ExpressionType? expressionType = null;
		return (op switch
		{
			Operators.Add => ExpressionType.Add, 
			Operators.BitwiseAnd => ExpressionType.And, 
			Operators.Divide => ExpressionType.Divide, 
			Operators.ExclusiveOr => ExpressionType.ExclusiveOr, 
			Operators.Mod => ExpressionType.Modulo, 
			Operators.Multiply => ExpressionType.Multiply, 
			Operators.BitwiseOr => ExpressionType.Or, 
			Operators.Power => ExpressionType.Power, 
			Operators.RightShift => ExpressionType.RightShift, 
			Operators.LeftShift => ExpressionType.LeftShift, 
			Operators.Subtract => ExpressionType.Subtract, 
			Operators.Equals => ExpressionType.Equal, 
			Operators.GreaterThan => ExpressionType.GreaterThan, 
			Operators.GreaterThanOrEqual => ExpressionType.GreaterThanOrEqual, 
			Operators.LessThan => ExpressionType.LessThan, 
			Operators.LessThanOrEqual => ExpressionType.LessThanOrEqual, 
			Operators.NotEquals => ExpressionType.NotEqual, 
			_ => throw new InvalidOperationException($"Unrecognized shared operation: {op}"), 
		});
	}

	[Obsolete("Use the ExpressionType overload instead")]
	public TResult DoOperation<TTarget, TOther, TResult>(Operators op, TTarget target, TOther other)
	{
		return _ops.DoOperation<TTarget, TOther, TResult>(GetLinqBinaryOp(op), target, other);
	}

	[Obsolete("Use Invoke instead")]
	public ObjectHandle Call(ObjectHandle obj, params ObjectHandle[] parameters)
	{
		return Invoke(obj, parameters);
	}

	[Obsolete("Use Invoke instead")]
	public ObjectHandle Call(ObjectHandle obj, params object[] parameters)
	{
		return Invoke(obj, parameters);
	}

	[Obsolete("Use the ExpressionType overload instead")]
	public object DoOperation(Operators op, ObjectHandle target)
	{
		return DoOperation(op, GetLocalObject(target));
	}

	[Obsolete("Use the ExpressionType enum instead")]
	public ObjectHandle DoOperation(Operators op, ObjectHandle target, ObjectHandle other)
	{
		return new ObjectHandle(DoOperation(op, GetLocalObject(target), GetLocalObject(other)));
	}

	[Obsolete("Use Modulo instead")]
	public ObjectHandle Modulus(ObjectHandle self, ObjectHandle other)
	{
		return Modulo(self, other);
	}

	public bool IsCallable([NotNull] ObjectHandle obj)
	{
		return IsCallable(GetLocalObject(obj));
	}

	public ObjectHandle Invoke([NotNull] ObjectHandle obj, params ObjectHandle[] parameters)
	{
		ContractUtils.RequiresNotNull(parameters, "parameters");
		return new ObjectHandle((object)Invoke(GetLocalObject(obj), GetLocalObjects(parameters)));
	}

	public ObjectHandle Invoke([NotNull] ObjectHandle obj, params object[] parameters)
	{
		return new ObjectHandle((object)Invoke(GetLocalObject(obj), parameters));
	}

	public ObjectHandle Create([NotNull] ObjectHandle obj, [NotNull] params ObjectHandle[] parameters)
	{
		return new ObjectHandle((object)CreateInstance(GetLocalObject(obj), GetLocalObjects(parameters)));
	}

	public ObjectHandle Create([NotNull] ObjectHandle obj, params object[] parameters)
	{
		return new ObjectHandle((object)CreateInstance(GetLocalObject(obj), parameters));
	}

	public void SetMember([NotNull] ObjectHandle obj, string name, [NotNull] ObjectHandle value)
	{
		SetMember(GetLocalObject(obj), name, GetLocalObject(value));
	}

	public void SetMember<T>([NotNull] ObjectHandle obj, string name, T value)
	{
		SetMember(GetLocalObject(obj), name, value);
	}

	public ObjectHandle GetMember([NotNull] ObjectHandle obj, string name)
	{
		return new ObjectHandle((object)GetMember(GetLocalObject(obj), name));
	}

	public T GetMember<T>([NotNull] ObjectHandle obj, string name)
	{
		return GetMember<T>(GetLocalObject(obj), name);
	}

	public bool TryGetMember([NotNull] ObjectHandle obj, string name, out ObjectHandle value)
	{
		if (TryGetMember(GetLocalObject(obj), name, out var value2))
		{
			value = new ObjectHandle(value2);
			return true;
		}
		value = null;
		return false;
	}

	public bool ContainsMember([NotNull] ObjectHandle obj, string name)
	{
		return ContainsMember(GetLocalObject(obj), name);
	}

	public void RemoveMember([NotNull] ObjectHandle obj, string name)
	{
		RemoveMember(GetLocalObject(obj), name);
	}

	public ObjectHandle ConvertTo<T>([NotNull] ObjectHandle obj)
	{
		return new ObjectHandle(ConvertTo<T>(GetLocalObject(obj)));
	}

	public ObjectHandle ConvertTo([NotNull] ObjectHandle obj, Type type)
	{
		return new ObjectHandle(ConvertTo(GetLocalObject(obj), type));
	}

	public bool TryConvertTo<T>([NotNull] ObjectHandle obj, out ObjectHandle result)
	{
		if (TryConvertTo<T>(GetLocalObject(obj), out var result2))
		{
			result = new ObjectHandle(result2);
			return true;
		}
		result = null;
		return false;
	}

	public bool TryConvertTo([NotNull] ObjectHandle obj, Type type, out ObjectHandle result)
	{
		if (TryConvertTo(GetLocalObject(obj), type, out var result2))
		{
			result = new ObjectHandle(result2);
			return true;
		}
		result = null;
		return false;
	}

	public ObjectHandle ExplicitConvertTo<T>([NotNull] ObjectHandle obj)
	{
		return new ObjectHandle(_ops.ExplicitConvertTo<T>(GetLocalObject(obj)));
	}

	public ObjectHandle ExplicitConvertTo([NotNull] ObjectHandle obj, Type type)
	{
		ContractUtils.RequiresNotNull(type, "type");
		return new ObjectHandle(_ops.ExplicitConvertTo(GetLocalObject(obj), type));
	}

	public bool TryExplicitConvertTo<T>([NotNull] ObjectHandle obj, out ObjectHandle result)
	{
		T result2;
		bool flag = _ops.TryExplicitConvertTo<T>(GetLocalObject(obj), out result2);
		if (flag)
		{
			result = new ObjectHandle(obj);
		}
		else
		{
			result = null;
		}
		return flag;
	}

	public bool TryExplicitConvertTo([NotNull] ObjectHandle obj, Type type, out ObjectHandle result)
	{
		object result2;
		bool flag = _ops.TryExplicitConvertTo(GetLocalObject(obj), type, out result2);
		if (flag)
		{
			result = new ObjectHandle(obj);
		}
		else
		{
			result = null;
		}
		return flag;
	}

	public ObjectHandle ImplicitConvertTo<T>([NotNull] ObjectHandle obj)
	{
		return new ObjectHandle(_ops.ImplicitConvertTo<T>(GetLocalObject(obj)));
	}

	public ObjectHandle ImplicitConvertTo([NotNull] ObjectHandle obj, Type type)
	{
		ContractUtils.RequiresNotNull(type, "type");
		return new ObjectHandle(_ops.ImplicitConvertTo(GetLocalObject(obj), type));
	}

	public bool TryImplicitConvertTo<T>([NotNull] ObjectHandle obj, out ObjectHandle result)
	{
		T result2;
		bool flag = _ops.TryImplicitConvertTo<T>(GetLocalObject(obj), out result2);
		if (flag)
		{
			result = new ObjectHandle(obj);
		}
		else
		{
			result = null;
		}
		return flag;
	}

	public bool TryImplicitConvertTo([NotNull] ObjectHandle obj, Type type, out ObjectHandle result)
	{
		object result2;
		bool flag = _ops.TryImplicitConvertTo(GetLocalObject(obj), type, out result2);
		if (flag)
		{
			result = new ObjectHandle(obj);
		}
		else
		{
			result = null;
		}
		return flag;
	}

	public T Unwrap<T>([NotNull] ObjectHandle obj)
	{
		return ConvertTo<T>(GetLocalObject(obj));
	}

	public ObjectHandle DoOperation(ExpressionType op, [NotNull] ObjectHandle target)
	{
		return new ObjectHandle((object)DoOperation(op, GetLocalObject(target)));
	}

	public ObjectHandle DoOperation(ExpressionType op, ObjectHandle target, ObjectHandle other)
	{
		return new ObjectHandle((object)DoOperation(op, GetLocalObject(target), GetLocalObject(other)));
	}

	public ObjectHandle Add([NotNull] ObjectHandle self, [NotNull] ObjectHandle other)
	{
		return new ObjectHandle((object)Add(GetLocalObject(self), GetLocalObject(other)));
	}

	public ObjectHandle Subtract([NotNull] ObjectHandle self, [NotNull] ObjectHandle other)
	{
		return new ObjectHandle((object)Subtract(GetLocalObject(self), GetLocalObject(other)));
	}

	public ObjectHandle Power([NotNull] ObjectHandle self, [NotNull] ObjectHandle other)
	{
		return new ObjectHandle((object)Power(GetLocalObject(self), GetLocalObject(other)));
	}

	public ObjectHandle Multiply([NotNull] ObjectHandle self, [NotNull] ObjectHandle other)
	{
		return new ObjectHandle((object)Multiply(GetLocalObject(self), GetLocalObject(other)));
	}

	public ObjectHandle Divide([NotNull] ObjectHandle self, [NotNull] ObjectHandle other)
	{
		return new ObjectHandle((object)Divide(GetLocalObject(self), GetLocalObject(other)));
	}

	public ObjectHandle Modulo([NotNull] ObjectHandle self, [NotNull] ObjectHandle other)
	{
		return new ObjectHandle((object)Modulo(GetLocalObject(self), GetLocalObject(other)));
	}

	public ObjectHandle LeftShift([NotNull] ObjectHandle self, [NotNull] ObjectHandle other)
	{
		return new ObjectHandle((object)LeftShift(GetLocalObject(self), GetLocalObject(other)));
	}

	public ObjectHandle RightShift([NotNull] ObjectHandle self, [NotNull] ObjectHandle other)
	{
		return new ObjectHandle((object)RightShift(GetLocalObject(self), GetLocalObject(other)));
	}

	public ObjectHandle BitwiseAnd([NotNull] ObjectHandle self, [NotNull] ObjectHandle other)
	{
		return new ObjectHandle((object)BitwiseAnd(GetLocalObject(self), GetLocalObject(other)));
	}

	public ObjectHandle BitwiseOr([NotNull] ObjectHandle self, [NotNull] ObjectHandle other)
	{
		return new ObjectHandle((object)BitwiseOr(GetLocalObject(self), GetLocalObject(other)));
	}

	public ObjectHandle ExclusiveOr([NotNull] ObjectHandle self, [NotNull] ObjectHandle other)
	{
		return new ObjectHandle((object)ExclusiveOr(GetLocalObject(self), GetLocalObject(other)));
	}

	public bool LessThan([NotNull] ObjectHandle self, [NotNull] ObjectHandle other)
	{
		return LessThan(GetLocalObject(self), GetLocalObject(other));
	}

	public bool GreaterThan([NotNull] ObjectHandle self, [NotNull] ObjectHandle other)
	{
		return GreaterThan(GetLocalObject(self), GetLocalObject(other));
	}

	public bool LessThanOrEqual([NotNull] ObjectHandle self, [NotNull] ObjectHandle other)
	{
		return LessThanOrEqual(GetLocalObject(self), GetLocalObject(other));
	}

	public bool GreaterThanOrEqual([NotNull] ObjectHandle self, [NotNull] ObjectHandle other)
	{
		return GreaterThanOrEqual(GetLocalObject(self), GetLocalObject(other));
	}

	public bool Equal([NotNull] ObjectHandle self, [NotNull] ObjectHandle other)
	{
		return Equal(GetLocalObject(self), GetLocalObject(other));
	}

	public bool NotEqual([NotNull] ObjectHandle self, [NotNull] ObjectHandle other)
	{
		return NotEqual(GetLocalObject(self), GetLocalObject(other));
	}

	public string Format([NotNull] ObjectHandle obj)
	{
		return Format(GetLocalObject(obj));
	}

	public IList<string> GetMemberNames([NotNull] ObjectHandle obj)
	{
		return GetMemberNames(GetLocalObject(obj));
	}

	public string GetDocumentation([NotNull] ObjectHandle obj)
	{
		return GetDocumentation(GetLocalObject(obj));
	}

	public IList<string> GetCallSignatures([NotNull] ObjectHandle obj)
	{
		return GetCallSignatures(GetLocalObject(obj));
	}

	private static object GetLocalObject([NotNull] ObjectHandle obj)
	{
		ContractUtils.RequiresNotNull(obj, "obj");
		return obj.Unwrap();
	}

	private static object[] GetLocalObjects(ObjectHandle[] ohs)
	{
		object[] array = new object[ohs.Length];
		for (int i = 0; i < array.Length; i++)
		{
			array[i] = GetLocalObject(ohs[i]);
		}
		return array;
	}

	[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure)]
	public override object InitializeLifetimeService()
	{
		return null;
	}
}