using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
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 HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("Halichu")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+48f0d5621abec3e2ceba44fad0cad9fd4f7b5c6d")]
[assembly: AssemblyProduct("DeathMinimap")]
[assembly: AssemblyTitle("DeathMinimap")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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 DeathMinimap
{
	public enum MinimapSize
	{
		Small,
		Medium,
		Large
	}
	[BepInPlugin("Halichu.DeathMinimap", "DeathMinimap", "1.0.0")]
	public class DeathMinimap : BaseUnityPlugin
	{
		private static float scaleSpeed = 5f;

		private static float scale = 0.5f;

		private static float targetScale = 1f;

		internal static DeathMinimap Instance { get; private set; } = null;


		internal static ManualLogSource Logger => Instance._logger;

		private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;

		internal Harmony? Harmony { get; set; }

		internal static ConfigEntry<MinimapSize> Size { get; private set; } = null;


		internal static RenderTexture? renderTexture { get; set; } = null;


		internal static Camera? camera { get; set; } = null;


		internal static bool spectating { get; set; } = false;


		internal static bool active { get; set; } = false;


		internal static bool activePrev { get; set; } = false;


		private void Awake()
		{
			Instance = this;
			((Component)this).gameObject.transform.parent = null;
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			Size = ((BaseUnityPlugin)this).Config.Bind<MinimapSize>("General", "Minimap Size", MinimapSize.Small, "Size of the minimap display");
			Patch();
			Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} has loaded!");
		}

		internal void Patch()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0026: Expected O, but got Unknown
			if (Harmony == null)
			{
				Harmony val = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
				Harmony val2 = val;
				Harmony = val;
			}
			Harmony.PatchAll();
		}

		internal void Unpatch()
		{
			Harmony? harmony = Harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		private void Update()
		{
			if (spectating)
			{
				active = (InputManager.instance.InputToggleGet((InputKey)8) && SemiFunc.InputDown((InputKey)8)) || SemiFunc.InputHold((InputKey)8);
			}
			targetScale = (active ? 1f : 0.5f);
			scale = Mathf.Lerp(scale, targetScale, Time.deltaTime * scaleSpeed);
			UpdateCameraTransform();
		}

		private void UpdateCameraTransform()
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (spectating && Object.op_Implicit((Object)(object)SpectateCamera.instance))
			{
				Transform transform = ((Component)SpectateCamera.instance).transform;
				if (!Object.op_Implicit((Object)(object)DirtFinderMapPlayer.Instance.PlayerTransform))
				{
					Logger.LogWarning((object)"DirtFinderMapPlayer transform null.");
					DirtFinderMapPlayer.Instance.PlayerTransform = new GameObject().transform;
				}
				DirtFinderMapPlayer.Instance.PlayerTransform.position = transform.position;
				Transform playerTransform = DirtFinderMapPlayer.Instance.PlayerTransform;
				Quaternion rotation = transform.rotation;
				float y = ((Quaternion)(ref rotation)).eulerAngles.y;
				rotation = transform.rotation;
				playerTransform.rotation = Quaternion.Euler(0f, y, ((Quaternion)(ref rotation)).eulerAngles.z);
				PlayerController.instance.playerAvatarScript.LastNavmeshPosition = SpectateCamera.instance.player.LastNavmeshPosition;
			}
		}

		private void OnGUI()
		{
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			if (!spectating)
			{
				return;
			}
			if (active != activePrev)
			{
				activePrev = active;
				Sound val = (activePrev ? PlayerAvatar.instance.mapToolController.SoundStart : PlayerAvatar.instance.mapToolController.SoundStop);
				if (Object.op_Implicit((Object)(object)SpectateCamera.instance))
				{
					val.Play(((Component)SpectateCamera.instance).transform.position, 1f, 1f, 1f, 1f);
				}
			}
			Map.Instance.Active = active;
			if (!active)
			{
				targetScale = 0.5f;
				return;
			}
			CameraTopFade.Instance.Set(0.5f, 0.1f);
			(float width, float height) minimapSize = GetMinimapSize();
			float item = minimapSize.width;
			float item2 = minimapSize.height;
			float num = ((float)Screen.width - item) / 2f;
			float num2 = ((float)Screen.height - item2) / 2f;
			Rect mapRect = default(Rect);
			((Rect)(ref mapRect))..ctor(num, num2, item, item2);
			DrawMapTexture(mapRect);
			DrawMapFrame(mapRect);
			DrawMapLabel(mapRect);
		}

		private static void DrawMapTexture(Rect mapRect)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			Color color = GUI.color;
			GUI.color = new Color(1f, 1f, 1f, scale * 0.9f + 0.1f);
			GUI.DrawTexture(mapRect, (Texture)(object)renderTexture, (ScaleMode)0, false);
			GUI.color = color;
		}

		private static void DrawMapFrame(Rect mapRect)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			Color color = GUI.color;
			GUI.color = new Color(0.8f, 0.8f, 0.8f, scale);
			float num = 2f;
			GUI.DrawTexture(new Rect(((Rect)(ref mapRect)).x, ((Rect)(ref mapRect)).y, ((Rect)(ref mapRect)).width, num), (Texture)(object)Texture2D.whiteTexture);
			GUI.DrawTexture(new Rect(((Rect)(ref mapRect)).x, ((Rect)(ref mapRect)).y + ((Rect)(ref mapRect)).height - num, ((Rect)(ref mapRect)).width, num), (Texture)(object)Texture2D.whiteTexture);
			GUI.DrawTexture(new Rect(((Rect)(ref mapRect)).x, ((Rect)(ref mapRect)).y, num, ((Rect)(ref mapRect)).height), (Texture)(object)Texture2D.whiteTexture);
			GUI.DrawTexture(new Rect(((Rect)(ref mapRect)).x + ((Rect)(ref mapRect)).width - num, ((Rect)(ref mapRect)).y, num, ((Rect)(ref mapRect)).height), (Texture)(object)Texture2D.whiteTexture);
			GUI.color = color;
		}

		private static void DrawMapLabel(Rect mapRect)
		{
			//IL_000b: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			GUIStyle val = new GUIStyle(GUI.skin.label)
			{
				alignment = (TextAnchor)4,
				fontSize = Mathf.RoundToInt(14f * scale)
			};
			val.normal.textColor = new Color(1f, 1f, 1f, scale);
			GUIStyle val2 = val;
			Rect val3 = default(Rect);
			((Rect)(ref val3))..ctor(((Rect)(ref mapRect)).x, ((Rect)(ref mapRect)).y - 25f, ((Rect)(ref mapRect)).width, 20f);
			GUI.Label(val3, "Death Minimap", val2);
		}

		internal static void SetSpectating(bool isSpectating)
		{
			spectating = isSpectating;
		}

		private static (float width, float height) GetMinimapSize()
		{
			MinimapSize value = Size.Value;
			if (1 == 0)
			{
			}
			(float, float) result = value switch
			{
				MinimapSize.Small => (RenderTextureMain.instance.textureWidthSmall, RenderTextureMain.instance.textureHeightSmall), 
				MinimapSize.Medium => (RenderTextureMain.instance.textureWidthMedium, RenderTextureMain.instance.textureHeightMedium), 
				MinimapSize.Large => (RenderTextureMain.instance.textureWidthLarge, RenderTextureMain.instance.textureHeightLarge), 
				_ => (RenderTextureMain.instance.textureWidthSmall, RenderTextureMain.instance.textureHeightSmall), 
			};
			if (1 == 0)
			{
			}
			return result;
		}
	}
	[HarmonyPatch(typeof(DirtFinderMapPlayer))]
	internal static class DirtFinderMapPlayerPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Awake")]
		private static void Awake_Postfix(DirtFinderMapPlayer __instance)
		{
			Camera componentInChildren = ((Component)__instance).GetComponentInChildren<Camera>();
			if (((Object)componentInChildren).name != "Dirt Finder Map Camera")
			{
				DeathMinimap.Logger.LogWarning((object)"Dirt Finder Map Camera not found.");
			}
			else if (!Object.op_Implicit((Object)(object)DeathMinimap.camera))
			{
				DeathMinimap.camera = componentInChildren;
			}
		}
	}
	[HarmonyPatch(typeof(GameDirector))]
	internal static class GameDirectorPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("Revive")]
		private static void Revive_Prefix()
		{
			DeathMinimap.SetSpectating(isSpectating: false);
		}

		[HarmonyPrefix]
		[HarmonyPatch("gameStateStart")]
		private static void GameStateStart_Prefix()
		{
			if (DeathMinimap.spectating)
			{
				DeathMinimap.SetSpectating(isSpectating: false);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerAvatar))]
	internal static class PlayerAvatarPatch
	{
		[CompilerGenerated]
		private sealed class <LoadRenderTexture>d__1 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Camera camera;

			private RenderTexture <renderTexture>5__1;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <LoadRenderTexture>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<renderTexture>5__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<renderTexture>5__1 = camera.activeTexture;
					break;
				case 1:
					<>1__state = -1;
					<renderTexture>5__1 = camera.activeTexture;
					break;
				}
				if (!Object.op_Implicit((Object)(object)<renderTexture>5__1))
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				DeathMinimap.renderTexture = <renderTexture>5__1;
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("SetSpectate")]
		private static void SetSpectate_Prefix()
		{
			Map.Instance.ActiveParent.SetActive(true);
			if (Object.op_Implicit((Object)(object)DeathMinimap.camera))
			{
				((MonoBehaviour)Map.Instance).StartCoroutine(LoadRenderTexture(DeathMinimap.camera));
			}
		}

		[IteratorStateMachine(typeof(<LoadRenderTexture>d__1))]
		private static IEnumerator LoadRenderTexture(Camera camera)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadRenderTexture>d__1(0)
			{
				camera = camera
			};
		}
	}
	[HarmonyPatch(typeof(SpectateCamera))]
	internal static class SpectateCameraPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("StateNormal")]
		private static void StateNormal_Prefix()
		{
			if ((SemiFunc.RunIsLevel() || SemiFunc.RunIsShop()) && !DeathMinimap.spectating && Object.op_Implicit((Object)(object)SpectateCamera.instance.player))
			{
				DeathMinimap.SetSpectating(isSpectating: true);
			}
		}
	}
}