using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using ComputerysModdingUtilities;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: StraftatMod(true)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("SpawnViewer")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("suvilba.straftat.spawnviewer")]
[assembly: AssemblyFileVersion("2.1.0.0")]
[assembly: AssemblyInformationalVersion("2.1.0+efc8b8e4df3f52e0040d34943932a5c82cd2ea6c")]
[assembly: AssemblyProduct("SpawnViewer")]
[assembly: AssemblyTitle("SpawnViewer")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.1.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace StraftatSpawnViewer
{
	public enum GameMode
	{
		_2v2,
		_1v1
	}
	public static class Configs
	{
		private const float BeamLengthMin = 1f;

		private const float BeamLengthMax = 400f;

		public static ConfigEntry<bool> Enabled { get; private set; }

		public static ConfigEntry<KeyboardShortcut> ToggleKey { get; private set; }

		public static ConfigEntry<KeyboardShortcut> RefreshKey { get; private set; }

		public static ConfigEntry<GameMode> Mode { get; private set; }

		public static ConfigEntry<float> BeamLength { get; private set; }

		public static ConfigEntry<Color> TeamAColor { get; private set; }

		public static ConfigEntry<Color> TeamBColor { get; private set; }

		public static event Action EnabledChanged;

		public static event Action ModeChanged;

		public static event Action BeamLengthChanged;

		public static event Action ColorsChanged;

		internal static void Init(ConfigFile config)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			Enabled = config.Bind<bool>("General", "Show Spawns", false, "Toggle spawn point visibility.");
			ToggleKey = config.Bind<KeyboardShortcut>("General", "Toggle Key", new KeyboardShortcut((KeyCode)286, Array.Empty<KeyCode>()), "Keybind to toggle spawn point visibility.");
			RefreshKey = config.Bind<KeyboardShortcut>("General", "Refresh Key", new KeyboardShortcut((KeyCode)287, Array.Empty<KeyCode>()), "Keybind to refresh spawn points mid map.");
			Mode = config.Bind<GameMode>("General", "Game Mode", GameMode._2v2, "Which spawn set to display.");
			BeamLength = config.Bind<float>("Markers", "Beam Length", 5f, new ConfigDescription("Height of the spawn point beams.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 400f), Array.Empty<object>()));
			TeamAColor = config.Bind<Color>("Markers", "Team A Color", new Color(0.25f, 0.75f, 1f), "Color of Team A spawnpoints.");
			TeamBColor = config.Bind<Color>("Markers", "Team B Color", new Color(1f, 0.35f, 0.55f), "Color of Team B spawnpoints.");
			Enabled.SettingChanged += delegate
			{
				Configs.EnabledChanged?.Invoke();
			};
			Mode.SettingChanged += delegate
			{
				Configs.ModeChanged?.Invoke();
			};
			BeamLength.SettingChanged += delegate
			{
				Configs.BeamLengthChanged?.Invoke();
			};
			TeamAColor.SettingChanged += delegate
			{
				Configs.ColorsChanged?.Invoke();
			};
			TeamBColor.SettingChanged += delegate
			{
				Configs.ColorsChanged?.Invoke();
			};
		}
	}
	[BepInPlugin("suvilba.straftat.spawnviewer", "SpawnViewer", "2.1.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public sealed class SpawnViewer : BaseUnityPlugin
	{
		private const string RootName = "StraftatSpawnViewer_ROOT";

		internal static ManualLogSource Logger;

		private GameObject _root;

		private SpawnpointDisplay _display;

		private Harmony _harmony;

		private bool _spawnsLocked;

		private bool _rescan;

		private int SpawnCount => (Configs.Mode.Value == GameMode._1v1) ? 2 : 4;

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			Configs.Init(((BaseUnityPlugin)this).Config);
			SubscribeToConfig();
			EnsureDisplay();
			SceneManager.sceneLoaded += OnSceneLoaded;
			_rescan = true;
			TryHarmonyPatch();
		}

		private void Update()
		{
			HandleInput();
			if (Configs.Enabled.Value && _rescan)
			{
				_rescan = false;
				RefreshSpawns();
			}
		}

		private void OnDestroy()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
			try
			{
				Harmony harmony = _harmony;
				if (harmony != null)
				{
					harmony.UnpatchSelf();
				}
			}
			catch
			{
			}
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			_spawnsLocked = false;
			_rescan = true;
		}

		private void HandleInput()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			KeyboardShortcut value = Configs.ToggleKey.Value;
			if (((KeyboardShortcut)(ref value)).IsDown())
			{
				Configs.Enabled.Value = !Configs.Enabled.Value;
			}
			value = Configs.RefreshKey.Value;
			if (((KeyboardShortcut)(ref value)).IsDown())
			{
				_spawnsLocked = false;
				_rescan = true;
			}
		}

		private void SubscribeToConfig()
		{
			Configs.EnabledChanged += delegate
			{
				if (Configs.Enabled.Value)
				{
					_spawnsLocked = false;
					_rescan = true;
				}
				else
				{
					_display.Hide();
				}
			};
			Configs.ModeChanged += delegate
			{
				_spawnsLocked = false;
				_display.Hide();
				_rescan = true;
			};
			Configs.BeamLengthChanged += delegate
			{
				_display.SetBeamLength(Configs.BeamLength.Value);
			};
			Configs.ColorsChanged += delegate
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				_display.SetColors(Configs.TeamAColor.Value, Configs.TeamBColor.Value);
			};
		}

		private void RefreshSpawns()
		{
			EnsureDisplay();
			if (!_spawnsLocked)
			{
				List<Transform> list = SpawnFinder.Find(Configs.Mode.Value);
				int spawnCount = SpawnCount;
				if (list.Count < spawnCount)
				{
					string arg = ((Configs.Mode.Value == GameMode._1v1) ? "1v1" : "2v2");
					Logger.LogWarning((object)$"SpawnViewer: Found {list.Count}/{spawnCount} {arg} spawnpoints.");
					_display.Hide();
				}
				else
				{
					_display.Show(list, spawnCount);
					_spawnsLocked = true;
				}
			}
		}

		private void EnsureDisplay()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			if ((Object)(object)_root == (Object)null)
			{
				_root = GameObject.Find("StraftatSpawnViewer_ROOT");
				if ((Object)(object)_root == (Object)null)
				{
					_root = new GameObject("StraftatSpawnViewer_ROOT");
					Object.DontDestroyOnLoad((Object)(object)_root);
				}
			}
			if ((Object)(object)_display == (Object)null)
			{
				_display = _root.GetComponent<SpawnpointDisplay>() ?? _root.AddComponent<SpawnpointDisplay>();
			}
		}

		private void TryHarmonyPatch()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			try
			{
				_harmony = new Harmony("suvilba.straftat.spawnviewer");
				Type type = AccessTools.TypeByName("PlayerManager");
				if (!(type == null))
				{
					PatchPostfixIfExists(type, "PopulateSpawnPoints");
					PatchPostfixIfExists(type, "SetActiveSpawnPoints");
					PatchPostfixIfExists(type, "RoundSpawn");
					PatchPostfixIfExists(type, "NewSceneSpawn");
				}
			}
			catch (Exception arg)
			{
				Logger.LogWarning((object)$"SpawnViewer Harmony patching failed: {arg}");
			}
		}

		private void PatchPostfixIfExists(Type type, string methodName)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(type, methodName, (Type[])null, (Type[])null);
			if (!(methodInfo == null))
			{
				_harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(typeof(SpawnViewer), "RefreshPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		public static void RefreshPostfix()
		{
			try
			{
				SpawnViewer[] array = Resources.FindObjectsOfTypeAll<SpawnViewer>();
				if (array != null && array.Length != 0)
				{
					array[0]._spawnsLocked = false;
					array[0]._rescan = true;
				}
			}
			catch (Exception arg)
			{
				Debug.LogWarning((object)$"SpawnViewer RefreshPostfix failed: {arg}");
			}
		}
	}
	internal static class PluginInfo
	{
		public const string PLUGIN_GUID = "suvilba.straftat.spawnviewer";

		public const string PLUGIN_NAME = "SpawnViewer";

		public const string PLUGIN_VERSION = "2.1.0";
	}
	internal static class SpawnFinder
	{
		private const string Tag1v1 = "Spawnpoints";

		private const string Tag2v2 = "Spawnpoints4Player";

		internal static List<Transform> Find(GameMode mode)
		{
			string tag = ((mode == GameMode._1v1) ? "Spawnpoints" : "Spawnpoints4Player");
			return (from s in (from s in Object.FindObjectsByType<SpawnPoint>((FindObjectsSortMode)0)
					where (Object)(object)((Component)s).transform.parent != (Object)null && ((Component)((Component)s).transform.parent).CompareTag(tag)
					select s).OrderBy<SpawnPoint, string>((SpawnPoint s) => ((Object)s).name, StringComparer.OrdinalIgnoreCase)
				select ((Component)s).transform).ToList();
		}
	}
	public sealed class SpawnpointDisplay : MonoBehaviour
	{
		private const float BallSize = 0.35f;

		private readonly GameObject[] _spheres = (GameObject[])(object)new GameObject[4];

		private readonly LineRenderer[] _beams = (LineRenderer[])(object)new LineRenderer[4];

		private Material _matA;

		private Material _matB;

		private void Awake()
		{
			BuildPool();
		}

		private void OnDestroy()
		{
			DestroyPool();
			if ((Object)(object)_matA != (Object)null)
			{
				Object.Destroy((Object)(object)_matA);
			}
			if ((Object)(object)_matB != (Object)null)
			{
				Object.Destroy((Object)(object)_matB);
			}
		}

		public void Show(IReadOnlyList<Transform> spawns, int count)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			EnsurePool();
			for (int i = 0; i < count && i < spawns.Count; i++)
			{
				PlaceSphere(i, spawns[i].position, spawns[i].eulerAngles.y);
			}
			for (int j = 0; j < 4; j++)
			{
				bool flag = j < count;
				if ((Object)(object)_spheres[j] != (Object)null)
				{
					_spheres[j].SetActive(flag);
				}
				if ((Object)(object)_beams[j] != (Object)null)
				{
					((Renderer)_beams[j]).enabled = flag;
				}
			}
		}

		public void Hide()
		{
			for (int i = 0; i < 4; i++)
			{
				if ((Object)(object)_spheres[i] != (Object)null)
				{
					_spheres[i].SetActive(false);
				}
				if ((Object)(object)_beams[i] != (Object)null)
				{
					((Renderer)_beams[i]).enabled = false;
				}
			}
		}

		public void SetBeamLength(float length)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < 4; i++)
			{
				if ((Object)(object)_beams[i] != (Object)null)
				{
					_beams[i].SetPosition(1, Vector3.up * length);
				}
			}
		}

		public void SetColors(Color teamA, Color teamB)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_matA != (Object)null)
			{
				Object.Destroy((Object)(object)_matA);
			}
			if ((Object)(object)_matB != (Object)null)
			{
				Object.Destroy((Object)(object)_matB);
			}
			_matA = MakeMaterial(teamA);
			_matB = MakeMaterial(teamB);
			for (int i = 0; i < 4; i++)
			{
				if (!((Object)(object)_spheres[i] == (Object)null))
				{
					Material val = ((i == 0 || i == 2) ? _matA : _matB);
					Renderer component = _spheres[i].GetComponent<Renderer>();
					if ((Object)(object)component != (Object)null)
					{
						component.sharedMaterial = val;
					}
					if ((Object)(object)_beams[i] != (Object)null)
					{
						((Renderer)_beams[i]).material = val;
					}
				}
			}
		}

		private void EnsurePool()
		{
			for (int i = 0; i < 4; i++)
			{
				if ((Object)(object)_spheres[i] == (Object)null || (Object)(object)_beams[i] == (Object)null)
				{
					BuildPool();
					break;
				}
			}
		}

		private void BuildPool()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			DestroyPool();
			if (_matA == null)
			{
				_matA = MakeMaterial(Configs.TeamAColor.Value);
			}
			if (_matB == null)
			{
				_matB = MakeMaterial(Configs.TeamBColor.Value);
			}
			CreateSphere(0, "Spawnpoint_A1", _matA);
			CreateSphere(1, "Spawnpoint_B1", _matB);
			CreateSphere(2, "Spawnpoint_A2", _matA);
			CreateSphere(3, "Spawnpoint_B2", _matB);
		}

		private void DestroyPool()
		{
			for (int i = 0; i < 4; i++)
			{
				if ((Object)(object)_spheres[i] != (Object)null)
				{
					Object.Destroy((Object)(object)_spheres[i]);
				}
				_spheres[i] = null;
				_beams[i] = null;
			}
		}

		private void CreateSphere(int slot, string objectName, Material mat)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObject.CreatePrimitive((PrimitiveType)0);
			((Object)val).name = objectName;
			((Object)val).hideFlags = (HideFlags)52;
			val.transform.SetParent(((Component)this).transform, true);
			val.transform.localScale = new Vector3(0.35f, 0.35f, 0.35f);
			Object.Destroy((Object)(object)val.GetComponent<Collider>());
			Renderer component = val.GetComponent<Renderer>();
			if ((Object)(object)component != (Object)null)
			{
				component.sharedMaterial = mat;
			}
			GameObject val2 = new GameObject(objectName + "_Beam")
			{
				hideFlags = (HideFlags)52
			};
			val2.transform.SetParent(val.transform, false);
			LineRenderer val3 = val2.AddComponent<LineRenderer>();
			val3.useWorldSpace = false;
			val3.positionCount = 2;
			val3.SetPosition(0, Vector3.zero);
			val3.SetPosition(1, Vector3.up * Configs.BeamLength.Value);
			val3.startWidth = 0.15f;
			val3.endWidth = 0.15f;
			((Renderer)val3).material = mat;
			val.SetActive(false);
			_spheres[slot] = val;
			_beams[slot] = val3;
		}

		private void PlaceSphere(int slot, Vector3 pos, float yaw)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = _spheres[slot];
			if (!((Object)(object)val == (Object)null))
			{
				val.transform.position = pos + new Vector3(0f, 0.225f, 0f);
				val.transform.rotation = Quaternion.Euler(0f, yaw, 0f);
			}
		}

		private static Material MakeMaterial(Color color)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			return new Material(Shader.Find("Unlit/Color"))
			{
				color = color
			};
		}
	}
}