using System;
using System.Collections;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HG.Reflection;
using IL.RoR2;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using On.RoR2;
using R2API.Utils;
using R2HyperMultitudes.MathParser;
using RoR2;
using UnityEngine;
using UnityEngine.Networking;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: OptIn]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("R2HyperMultitudes")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("R2HyperMultitudes")]
[assembly: AssemblyTitle("R2HyperMultitudes")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace R2HyperMultitudes
{
	internal static class Log
	{
		private static ManualLogSource _logSource;

		internal static void Init(ManualLogSource logSource)
		{
			_logSource = logSource;
		}

		internal static void Debug(object data)
		{
			_logSource.LogDebug(data);
		}

		internal static void Error(object data)
		{
			_logSource.LogError(data);
		}

		internal static void Fatal(object data)
		{
			_logSource.LogFatal(data);
		}

		internal static void Info(object data)
		{
			_logSource.LogInfo(data);
		}

		internal static void Message(object data)
		{
			_logSource.LogMessage(data);
		}

		internal static void Warning(object data)
		{
			_logSource.LogWarning(data);
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("Raoul1808.R2HyperMultitudes", "R2HyperMultitudes", "1.0.0")]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		private delegate int RunInstanceReturnInt(Run self);

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static hook_AdvanceStage <>9__16_0;

			public static Action<Run> <>9__16_1;

			public static Func<Instruction, bool> <>9__16_5;

			public static Func<int, int> <>9__16_6;

			public static Manipulator <>9__16_2;

			public static Func<Instruction, bool> <>9__16_7;

			public static Func<int, int> <>9__16_8;

			public static Manipulator <>9__16_3;

			internal void <Awake>b__16_0(orig_AdvanceStage orig, Run self, SceneDef nextScene)
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Invalid comparison between Unknown and I4
				orig.Invoke(self, nextScene);
				if (_hypermultitudesEnabled.Value && (int)nextScene.sceneType == 1)
				{
					StageIndex++;
				}
			}

			internal void <Awake>b__16_1(Run run)
			{
				Log.Info("Resetting HyperMultitudes Multiplier");
				StageIndex = 1;
			}

			internal void <Awake>b__16_2(ILContext il)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Expected O, but got Unknown
				ILCursor val = new ILCursor(il);
				if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
				{
					(Instruction i) => ILPatternMatchingExt.MatchCallOrCallvirt<Run>(i, "get_livingPlayerCount")
				}))
				{
					val.EmitDelegate<Func<int, int>>((Func<int, int>)((int livingPlayerCount) => _origLivingPlayerCountValue));
				}
			}

			internal bool <Awake>b__16_5(Instruction i)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<Run>(i, "get_livingPlayerCount");
			}

			internal int <Awake>b__16_6(int livingPlayerCount)
			{
				return _origLivingPlayerCountValue;
			}

			internal void <Awake>b__16_3(ILContext il)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Expected O, but got Unknown
				ILCursor val = new ILCursor(il);
				if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
				{
					(Instruction i) => ILPatternMatchingExt.MatchCallOrCallvirt<Run>(i, "get_livingPlayerCount")
				}))
				{
					val.EmitDelegate<Func<int, int>>((Func<int, int>)((int livingPlayerCount) => _origLivingPlayerCountValue));
				}
			}

			internal bool <Awake>b__16_7(Instruction i)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt<Run>(i, "get_livingPlayerCount");
			}

			internal int <Awake>b__16_8(int livingPlayerCount)
			{
				return _origLivingPlayerCountValue;
			}
		}

		public const string Guid = "Raoul1808.R2HyperMultitudes";

		public const string Author = "Raoul1808";

		public const string Name = "R2HyperMultitudes";

		public const string Version = "1.0.0";

		private static ConfigEntry<string> _scalingExpression;

		private static ConfigEntry<bool> _hypermultitudesEnabled;

		public static Node MultitudesExpression;

		public static readonly ModStageContext StageContext = new ModStageContext();

		private static int _stageIndex;

		private static RunInstanceReturnInt _origLivingPlayerCount;

		private static RunInstanceReturnInt _origParticipatingPlayerCount;

		private static int _origLivingPlayerCountValue;

		private static int _origParticipatingPlayerCountValue;

		public static double MultitudesMultiplier { get; private set; }

		public static int StageIndex
		{
			get
			{
				return _stageIndex;
			}
			set
			{
				_stageIndex = value;
				StageContext.Stage = _stageIndex;
				MultitudesMultiplier = Math.Max(MultitudesExpression.Eval(StageContext), 1.0);
				string text = "HyperMultitudes Multiplier = " + MultitudesMultiplier;
				Debug.Log((object)text);
				Log.Info(text);
			}
		}

		private void Awake()
		{
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Expected O, but got Unknown
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Expected O, but got Unknown
			Log.Init(((BaseUnityPlugin)this).Logger);
			_hypermultitudesEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("HyperMultitudes", "Enabled", true, "Whether HyperMultitudes should be enabled or not");
			_scalingExpression = ((BaseUnityPlugin)this).Config.Bind<string>("HyperMultitudes", "MultiplierExpression", "2 * stage", "A mathematical expression which is calculated on every stage to determine the new multitudes multiplier to apply. Supports additions (+), subtractions (-), multiplications (*), divisions (/), parentheses and exponents (^)");
			Log.Info("Loading expression: " + _scalingExpression.Value);
			MultitudesExpression = new ExpressionParser(_scalingExpression.Value).Parse();
			MultitudesExpression.Eval(StageContext);
			Log.Info("Testing expression");
			for (int j = 1; j < 10; j++)
			{
				StageIndex = j;
			}
			Log.Info("Test ended");
			StageIndex = 1;
			object obj = <>c.<>9__16_0;
			if (obj == null)
			{
				hook_AdvanceStage val = delegate(orig_AdvanceStage orig, Run self, SceneDef nextScene)
				{
					//IL_0015: Unknown result type (might be due to invalid IL or missing references)
					//IL_001b: Invalid comparison between Unknown and I4
					orig.Invoke(self, nextScene);
					if (_hypermultitudesEnabled.Value && (int)nextScene.sceneType == 1)
					{
						StageIndex++;
					}
				};
				<>c.<>9__16_0 = val;
				obj = (object)val;
			}
			Run.AdvanceStage += (hook_AdvanceStage)obj;
			Run.onRunStartGlobal += delegate
			{
				Log.Info("Resetting HyperMultitudes Multiplier");
				StageIndex = 1;
			};
			_origLivingPlayerCount = new Hook((MethodBase)Reflection.GetMethodCached(typeof(Run), "get_livingPlayerCount"), Reflection.GetMethodCached(typeof(Plugin), "GetLivingPlayerCountHook")).GenerateTrampoline<RunInstanceReturnInt>();
			_origParticipatingPlayerCount = new Hook((MethodBase)Reflection.GetMethodCached(typeof(Run), "get_participatingPlayerCount"), Reflection.GetMethodCached(typeof(Plugin), "GetParticipatingPlayerCountHook")).GenerateTrampoline<RunInstanceReturnInt>();
			object obj2 = <>c.<>9__16_2;
			if (obj2 == null)
			{
				Manipulator val2 = delegate(ILContext il)
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					//IL_0007: Expected O, but got Unknown
					ILCursor val5 = new ILCursor(il);
					if (val5.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
					{
						(Instruction i) => ILPatternMatchingExt.MatchCallOrCallvirt<Run>(i, "get_livingPlayerCount")
					}))
					{
						val5.EmitDelegate<Func<int, int>>((Func<int, int>)((int livingPlayerCount) => _origLivingPlayerCountValue));
					}
				};
				<>c.<>9__16_2 = val2;
				obj2 = (object)val2;
			}
			AllPlayersTrigger.FixedUpdate += (Manipulator)obj2;
			object obj3 = <>c.<>9__16_3;
			if (obj3 == null)
			{
				Manipulator val3 = delegate(ILContext il)
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					//IL_0007: Expected O, but got Unknown
					ILCursor val4 = new ILCursor(il);
					if (val4.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
					{
						(Instruction i) => ILPatternMatchingExt.MatchCallOrCallvirt<Run>(i, "get_livingPlayerCount")
					}))
					{
						val4.EmitDelegate<Func<int, int>>((Func<int, int>)((int livingPlayerCount) => _origLivingPlayerCountValue));
					}
				};
				<>c.<>9__16_3 = val3;
				obj3 = (object)val3;
			}
			MultiBodyTrigger.FixedUpdate += (Manipulator)obj3;
			Stage.onStageStartGlobal += delegate
			{
				if (_hypermultitudesEnabled.Value)
				{
					((MonoBehaviour)this).StartCoroutine(SendChatScalingDelayed());
				}
			};
		}

		private IEnumerator SendChatScalingDelayed()
		{
			yield return (object)new WaitForSeconds(2f);
			SendChatScaling();
		}

		private static void SendChatScaling()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			if (NetworkServer.active)
			{
				SimpleChatMessage val = new SimpleChatMessage();
				val.baseToken = "HyperMultitudes Multiplier now at: {0}";
				val.paramTokens = new string[1] { MultitudesMultiplier.ToString(CultureInfo.InvariantCulture) };
				Chat.SendBroadcastChat((ChatMessageBase)(object)val);
			}
		}

		private static void SendChatExpression()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			if (NetworkServer.active)
			{
				SimpleChatMessage val = new SimpleChatMessage();
				val.baseToken = "HyperMultitudes Expression set to: {0}";
				val.paramTokens = new string[1] { _scalingExpression.Value };
				Chat.SendBroadcastChat((ChatMessageBase)(object)val);
			}
		}

		private static int GetLivingPlayerCountHook(Run self)
		{
			_origLivingPlayerCountValue = _origLivingPlayerCount(self);
			return (int)((double)_origLivingPlayerCountValue * MultitudesMultiplier);
		}

		private static int GetParticipatingPlayerCountHook(Run self)
		{
			_origParticipatingPlayerCountValue = _origParticipatingPlayerCount(self);
			return (int)((double)_origParticipatingPlayerCountValue * MultitudesMultiplier);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCEnable(ConCommandArgs args)
		{
			if (((ConCommandArgs)(ref args)).Count != 0)
			{
				Debug.LogError((object)"Invalid arguments. Did you mean mod_hm_set_expression or mod_hm_test_expression?");
				return;
			}
			if (_hypermultitudesEnabled.Value)
			{
				Debug.LogWarning((object)"HyperMultitudes is already enabled.");
				return;
			}
			_hypermultitudesEnabled.Value = true;
			Debug.Log((object)"HyperMultitudes enabled. Good luck");
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCDisable(ConCommandArgs args)
		{
			if (((ConCommandArgs)(ref args)).Count != 0)
			{
				Debug.LogError((object)"Invalid arguments. Did you mean mod_hm_set_expression or mod_hm_test_expression?");
				return;
			}
			if (!_hypermultitudesEnabled.Value)
			{
				Debug.LogWarning((object)"HyperMultitudes is already disabled.");
				return;
			}
			_hypermultitudesEnabled.Value = false;
			Debug.Log((object)"HyperMultitudes disabled.");
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCSetExpression(ConCommandArgs args)
		{
			((ConCommandArgs)(ref args)).CheckArgumentCount(1);
			try
			{
				string text = ((ConCommandArgs)(ref args))[0];
				Node node = new ExpressionParser(text).Parse();
				ModStageContext modStageContext = new ModStageContext
				{
					Stage = 1.0
				};
				node.Eval(new ModStageContext
				{
					Stage = 1.0
				});
				MultitudesExpression = node;
				_scalingExpression.Value = text;
				Debug.Log((object)("New HyperMultitudes expression set to: " + text));
				Debug.Log((object)"Testing new expression...");
				for (int i = 1; i <= 10; i++)
				{
					modStageContext.Stage = i;
					double num = node.Eval(modStageContext);
					Debug.Log((object)$"Stage = {i}, Result = {num}");
				}
				Debug.Log((object)"Testing done. If these results don't look right to you, double-check your expression and make sure it is properly wrapped between quotation marks (e.g: \"2 * stage\")");
				SendChatExpression();
			}
			catch (Exception arg)
			{
				Debug.LogError((object)"Invalid expression given. Make sure the expression is put in quotes! (e.g: \"2 * stage\")");
				Debug.LogError((object)"Check the logs for (potentially) more details");
				Log.Error($"Caught exception when setting new expression: {arg}");
			}
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCGetExpression(ConCommandArgs args)
		{
			Debug.LogWarning((object)((((ConCommandArgs)(ref args)).Count == 0) ? ("Current Expression: " + _scalingExpression.Value) : "Invalid arguments. Did you mean mod_hm_set_expression or mod_hm_test_expression?"));
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCTestExpression(ConCommandArgs args)
		{
			((ConCommandArgs)(ref args)).CheckArgumentCount(1);
			if (double.TryParse(((ConCommandArgs)(ref args))[0], out var result))
			{
				try
				{
					double num = new ExpressionParser(_scalingExpression.Value).Parse().Eval(new ModStageContext
					{
						Stage = result
					});
					Debug.Log((object)$"Result = {num}");
					return;
				}
				catch (Exception arg)
				{
					Log.Error($"Caught exception when testing existing expression: {arg}");
					return;
				}
			}
			Debug.LogError((object)"Invalid Argument. Correct usage is `mod_hm_test_expression <number>`");
		}
	}
	public class ModStageContext : IContext
	{
		public double Stage { get; set; }

		public double ResolveVariable(string name)
		{
			if (name.ToLower() == "stage" || name.ToLower() == "x")
			{
				return Stage;
			}
			throw new InvalidDataException("Unknown variable: " + name);
		}
	}
}
namespace R2HyperMultitudes.MathParser
{
	public class ExpressionParser
	{
		private Tokenizer _tokenizer;

		public ExpressionParser(string expression)
		{
			_tokenizer = new Tokenizer(new StringReader(expression));
		}

		public Node Parse()
		{
			Node result = ParseAddSubtract();
			if (_tokenizer.Token != 0)
			{
				throw new InvalidDataException("Unexpected characters at end of expression");
			}
			return result;
		}

		private Node ParseAddSubtract()
		{
			Node node = ParseMultiplyDivide();
			while (true)
			{
				Func<double, double, double> func = null;
				switch (_tokenizer.Token)
				{
				case Token.Add:
					func = (double a, double b) => a + b;
					break;
				case Token.Subtract:
					func = (double a, double b) => a - b;
					break;
				}
				if (func == null)
				{
					break;
				}
				_tokenizer.NextToken();
				Node rhs = ParseMultiplyDivide();
				node = new NodeBinary(node, rhs, func);
			}
			return node;
		}

		private Node ParseMultiplyDivide()
		{
			Node node = ParseUnary();
			while (true)
			{
				Func<double, double, double> func = null;
				switch (_tokenizer.Token)
				{
				case Token.Multiply:
					func = (double a, double b) => a * b;
					break;
				case Token.Divide:
					func = (double a, double b) => a / b;
					break;
				}
				if (func == null)
				{
					break;
				}
				_tokenizer.NextToken();
				Node rhs = ParseUnary();
				node = new NodeBinary(node, rhs, func);
			}
			return node;
		}

		private Node ParseUnary()
		{
			if (_tokenizer.Token == Token.Add)
			{
				_tokenizer.NextToken();
				return ParseUnary();
			}
			if (_tokenizer.Token == Token.Subtract)
			{
				_tokenizer.NextToken();
				return new NodeUnary(ParseUnary(), (double a) => 0.0 - a);
			}
			return ParsePow();
		}

		private Node ParsePow()
		{
			Node node = ParseLeaf();
			if (_tokenizer.Token == Token.Pow)
			{
				_tokenizer.NextToken();
				Node rhs = ParseLeaf();
				node = new NodeBinary(node, rhs, Math.Pow);
			}
			return node;
		}

		private Node ParseLeaf()
		{
			if (_tokenizer.Token == Token.Variable)
			{
				NodeVariable result = new NodeVariable(_tokenizer.Variable);
				_tokenizer.NextToken();
				return result;
			}
			if (_tokenizer.Token == Token.Number)
			{
				NodeNumber result2 = new NodeNumber(_tokenizer.Number);
				_tokenizer.NextToken();
				return result2;
			}
			if (_tokenizer.Token == Token.OpenParens)
			{
				_tokenizer.NextToken();
				Node result3 = ParseAddSubtract();
				if (_tokenizer.Token != Token.CloseParens)
				{
					throw new InvalidDataException("Missing close parenthesis");
				}
				_tokenizer.NextToken();
				return result3;
			}
			throw new InvalidDataException($"Unexpected token: {_tokenizer.Token}");
		}
	}
	public interface IContext
	{
		double ResolveVariable(string name);
	}
	public abstract class Node
	{
		public abstract double Eval(IContext ctx);
	}
	public class NodeNumber : Node
	{
		private double _number;

		public NodeNumber(double number)
		{
			_number = number;
		}

		public override double Eval(IContext ctx)
		{
			return _number;
		}
	}
	public class NodeBinary : Node
	{
		private Node _lhs;

		private Node _rhs;

		private Func<double, double, double> _op;

		public NodeBinary(Node lhs, Node rhs, Func<double, double, double> op)
		{
			_lhs = lhs;
			_rhs = rhs;
			_op = op;
		}

		public override double Eval(IContext ctx)
		{
			return _op(_lhs.Eval(ctx), _rhs.Eval(ctx));
		}
	}
	public class NodeUnary : Node
	{
		private Node _rhs;

		private Func<double, double> _op;

		public NodeUnary(Node rhs, Func<double, double> op)
		{
			_rhs = rhs;
			_op = op;
		}

		public override double Eval(IContext ctx)
		{
			return _op(_rhs.Eval(ctx));
		}
	}
	public class NodeVariable : Node
	{
		private string _variableName;

		public NodeVariable(string variable)
		{
			_variableName = variable;
		}

		public override double Eval(IContext ctx)
		{
			return ctx.ResolveVariable(_variableName);
		}
	}
	public enum Token
	{
		None,
		Number,
		Add,
		Subtract,
		Multiply,
		Divide,
		Pow,
		OpenParens,
		CloseParens,
		Variable
	}
	public class Tokenizer
	{
		private StringReader _reader;

		private char _currentChar;

		public double Number { get; private set; }

		public string Variable { get; private set; }

		public Token Token { get; private set; }

		public Tokenizer(StringReader reader)
		{
			_reader = reader;
			NextChar();
			NextToken();
		}

		private void NextChar()
		{
			int num = _reader.Read();
			_currentChar = ((num >= 0) ? ((char)num) : '\0');
		}

		public void NextToken()
		{
			while (char.IsWhiteSpace(_currentChar))
			{
				NextChar();
			}
			switch (_currentChar)
			{
			case '\0':
				Token = Token.None;
				return;
			case '+':
				NextChar();
				Token = Token.Add;
				return;
			case '-':
				NextChar();
				Token = Token.Subtract;
				return;
			case '*':
				NextChar();
				Token = Token.Multiply;
				return;
			case '/':
				NextChar();
				Token = Token.Divide;
				return;
			case '(':
				NextChar();
				Token = Token.OpenParens;
				return;
			case ')':
				NextChar();
				Token = Token.CloseParens;
				return;
			case '^':
				NextChar();
				Token = Token.Pow;
				return;
			}
			if (char.IsLetter(_currentChar) || _currentChar == '_')
			{
				StringBuilder stringBuilder = new StringBuilder();
				while (char.IsLetterOrDigit(_currentChar) || _currentChar == '_')
				{
					stringBuilder.Append(_currentChar);
					NextChar();
				}
				Variable = stringBuilder.ToString();
				Token = Token.Variable;
				return;
			}
			if (char.IsDigit(_currentChar) || _currentChar == '.')
			{
				StringBuilder stringBuilder2 = new StringBuilder();
				bool flag = false;
				while (char.IsDigit(_currentChar) || (!flag && _currentChar == '.'))
				{
					stringBuilder2.Append(_currentChar);
					flag = flag || _currentChar == '.';
					NextChar();
				}
				Number = double.Parse(stringBuilder2.ToString(), CultureInfo.InvariantCulture);
				Token = Token.Number;
				return;
			}
			throw new InvalidDataException($"Unexpected character: {_currentChar}");
		}
	}
}