using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
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 Dissonance;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using RepoCore.Comps;
using RepoCore.Utils;
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: AssemblyCompany("zeeblo.RepoCore")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0+589e4a90255f7642790b9e6c65a7c18d6d3ad98c")]
[assembly: AssemblyProduct("RepoCore")]
[assembly: AssemblyTitle("zeeblo.RepoCore")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace RepoCore
{
	[BepInPlugin("RepoCore.zeeblo.dev", "RepoCore", "0.1.0")]
	public class Plugin : BaseUnityPlugin
	{
		public const string modGUID = "RepoCore.zeeblo.dev";

		public const string modName = "RepoCore";

		public const string modVersion = "0.1.0";

		private readonly Harmony _harmony = new Harmony("RepoCore.zeeblo.dev");

		internal static ManualLogSource mls = Logger.CreateLogSource("RepoCore.zeeblo.dev");

		public static string MainDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().CodeBase).Replace("file:\\", "");

		private void Awake()
		{
			LConfig.AllConfigs(((BaseUnityPlugin)this).Config);
			LMAssets.LoadAllAssets();
			PatchAllStuff();
		}

		private void PatchAllStuff()
		{
			_harmony.PatchAll(Assembly.GetExecutingAssembly());
		}

		public static void SendLog(string msg)
		{
			if (LConfig.viewLogs.Value)
			{
				mls.LogInfo((object)msg);
			}
		}

		public static string GetAssetPath(string file, string parent = "Assetbundles")
		{
			string text = MainDir + "\\Assets\\" + parent + "\\" + file;
			string result = MainDir + "/" + file;
			if (File.Exists(text))
			{
				return text;
			}
			return result;
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "zeeblo.RepoCore";

		public const string PLUGIN_NAME = "RepoCore";

		public const string PLUGIN_VERSION = "0.1.0";
	}
}
namespace RepoCore.Utils
{
	internal class LMAssets
	{
		public static GameObject ScavHead;

		public static void LoadAllAssets()
		{
			LoadStuff();
		}

		private static void LoadStuff()
		{
			string assetPath = Plugin.GetAssetPath("repo_core");
			AssetBundle val = AssetBundle.LoadFromFile(assetPath);
			ScavHead = val.LoadAsset<GameObject>("lc_head.prefab");
		}
	}
	public class LConfig
	{
		public static ConfigEntry<float> defaultAmpMulti;

		public static ConfigEntry<bool> viewLogs;

		public static void AllConfigs(ConfigFile cfg)
		{
			defaultAmpMulti = cfg.Bind<float>("General", "Head Bob Multiplier", 3.85f, "How much the heads will rotate back");
			viewLogs = cfg.Bind<bool>("General", "Show developer debug logs", true, "If you have a console open it'll show more details");
		}
	}
}
namespace RepoCore.Scripts
{
	internal class ChatTalk
	{
		private static void TextToSpeech(HUDManager __instance, ref string chatMessage, int playerWhoSent)
		{
			if (playerWhoSent >= 0)
			{
				Plugin.SendLog($"  Message Sent by {playerWhoSent}: {chatMessage}");
			}
		}
	}
	[HarmonyPatch]
	internal class Speaking
	{
		[CompilerGenerated]
		private sealed class <AddSpeakComp>d__8 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private Dictionary<ulong, int>.Enumerator <>s__1;

			private KeyValuePair<ulong, int> <plr>5__2;

			private PlayerControllerB <player>5__3;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>s__1 = default(Dictionary<ulong, int>.Enumerator);
				<player>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					RemoveVoiceForAll();
					<>2__current = (object)new WaitForSeconds(10f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					Plugin.SendLog(">>> Adding Events!");
					<>s__1 = StartOfRound.Instance.ClientPlayerList.GetEnumerator();
					try
					{
						while (<>s__1.MoveNext())
						{
							<plr>5__2 = <>s__1.Current;
							<player>5__3 = StartOfRound.Instance.allPlayerScripts[<plr>5__2.Value];
							if (StartOfRound.Instance.allPlayerScripts[<plr>5__2.Value].voicePlayerState == null)
							{
								Plugin.SendLog($"VoiceState is null: {StartOfRound.Instance.allPlayerScripts[<plr>5__2.Value].voicePlayerState}");
								continue;
							}
							if ((Object)(object)((Component)<player>5__3).gameObject.GetComponent<VoiceSpeak>() == (Object)null)
							{
								((Component)<player>5__3).gameObject.AddComponent<VoiceSpeak>().PlayerID = <plr>5__2.Value;
							}
							Plugin.SendLog($">>> Ulong: {<plr>5__2.Key} | int: {<plr>5__2.Value}");
							<player>5__3 = null;
						}
					}
					finally
					{
						((IDisposable)<>s__1).Dispose();
					}
					<>s__1 = default(Dictionary<ulong, int>.Enumerator);
					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();
			}
		}

		private static Coroutine speakComponent;

		[HarmonyPatch(typeof(StartOfRound), "OnPlayerConnectedClientRpc")]
		[HarmonyPostfix]
		private static void addVoiceOnJoin()
		{
			StartSpeakComp();
		}

		[HarmonyPatch(typeof(StartOfRound), "RefreshPlayerVoicePlaybackObjects")]
		[HarmonyPrefix]
		private static bool RefreshVoicesAgain()
		{
			Plugin.SendLog("Refreshing Voices for all players");
			StartSpeakComp();
			return true;
		}

		[HarmonyPatch(typeof(StartOfRound), "OnDisable")]
		[HarmonyPostfix]
		private static void OnDisable()
		{
			((MonoBehaviour)StartOfRound.Instance).StopCoroutine(speakComponent);
			speakComponent = null;
			Plugin.mls.LogInfo((object)"StartOfRound.OnDisable()");
		}

		[HarmonyPatch(typeof(StartOfRound), "OnClientDisconnect")]
		[HarmonyPrefix]
		private static bool OnClientDisconnectPatch()
		{
			Plugin.SendLog(">>> OnClientDisconnect() | Host maybe left?");
			RemoveVoiceForAll();
			return true;
		}

		[HarmonyPatch(typeof(StartOfRound), "OnPlayerDC")]
		[HarmonyPostfix]
		private static void CheckClientsConnected()
		{
			Plugin.SendLog(">>> Player Disconnected");
			StartSpeakComp();
		}

		[HarmonyPatch(typeof(HUDManager), "AddTextToChatOnServer")]
		[HarmonyPrefix]
		private static bool PlayerKickedPatch(string chatMessage, int playerId)
		{
			if (chatMessage.Contains("was kicked") && playerId == -1)
			{
				Plugin.SendLog(">>> Player Kicked");
				RemoveVoiceForAll();
			}
			return true;
		}

		private static void StartSpeakComp()
		{
			if (speakComponent != null)
			{
				((MonoBehaviour)StartOfRound.Instance).StopCoroutine(speakComponent);
			}
			speakComponent = ((MonoBehaviour)StartOfRound.Instance).StartCoroutine(AddSpeakComp());
		}

		[IteratorStateMachine(typeof(<AddSpeakComp>d__8))]
		private static IEnumerator AddSpeakComp()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AddSpeakComp>d__8(0);
		}

		private static void RemoveVoiceForAll()
		{
			foreach (KeyValuePair<ulong, int> clientPlayer in StartOfRound.Instance.ClientPlayerList)
			{
				PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[clientPlayer.Value];
				if ((Object)(object)((Component)val).gameObject.GetComponent<VoiceSpeak>() != (Object)null)
				{
					((Component)val).gameObject.GetComponent<VoiceSpeak>().RemoveThisClass();
					Plugin.SendLog("RemoveVoiceForAll() Executed");
				}
			}
		}
	}
}
namespace RepoCore.Comps
{
	public class VoiceSpeak : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <RotateDelay>d__22 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public float amp;

			public bool rotateUp;

			public VoiceSpeak <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>4__this.RotateHead(amp, rotateUp: false);
					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();
			}
		}

		public int PlayerID;

		public PlayerControllerB thisPlayer;

		public VoicePlayerState speakState;

		public GameObject head;

		public GameObject upperHead;

		public GameObject lowerHead;

		public MeshRenderer upperHeadMaterial;

		public MeshRenderer lowerHeadMaterial;

		public Transform ogHead;

		public Vector3 ogHeadScale;

		public Quaternion defaultRotation;

		public bool isTalking;

		private void Start()
		{
			speakState = StartOfRound.Instance.allPlayerScripts[PlayerID].voicePlayerState;
			Plugin.SendLog($">>> VoiceSpeak ID: {PlayerID}");
			Plugin.SendLog($">>> speakstate: {speakState}");
			PositionHead();
			speakState.OnStoppedSpeaking += PlayerNotTalking;
			isTalking = false;
		}

		private void PositionHead()
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			thisPlayer = StartOfRound.Instance.allPlayerScripts[PlayerID];
			ogHead = thisPlayer.thisPlayerBody.Find("ScavengerModel/metarig/spine/spine.001/spine.002/spine.003/spine.004");
			if ((Object)(object)ogHead != (Object)null)
			{
				GameObject val = Object.Instantiate<GameObject>(LMAssets.ScavHead, ogHead.position, ogHead.rotation);
				val.transform.SetParent(((Component)ogHead).transform);
				head = val;
				upperHead = ((Component)head.transform.Find("upper head")).gameObject;
				lowerHead = ((Component)head.transform.Find("lower head")).gameObject;
				head.transform.localScale = new Vector3(14f, 14f, 14f);
				head.transform.localPosition = new Vector3(0f, 10f, -14f);
				ogHeadScale = ((Component)ogHead).transform.localScale;
				defaultRotation = upperHead.transform.localRotation;
				upperHeadMaterial = upperHead.GetComponent<MeshRenderer>();
				lowerHeadMaterial = lowerHead.GetComponent<MeshRenderer>();
				((Renderer)upperHeadMaterial).material = ((Renderer)thisPlayer.thisPlayerModel).material;
				((Renderer)lowerHeadMaterial).material = ((Renderer)thisPlayer.thisPlayerModel).material;
				head.SetActive(false);
			}
		}

		public void RemoveThisClass()
		{
			Plugin.SendLog($"Destroyed VoiceSpeak.cs: {PlayerID}");
			if (speakState != null)
			{
				speakState.OnStoppedSpeaking -= PlayerNotTalking;
				speakState = null;
				Plugin.SendLog($"{PlayerID} VoiceSpeak: unsubbed from PlayerNotTalking");
			}
			if ((Object)(object)head != (Object)null)
			{
				Object.Destroy((Object)(object)head);
			}
			Object.Destroy((Object)(object)this);
		}

		private void OnDestroy()
		{
			RemoveThisClass();
			Plugin.SendLog("Executed OnDestroy() to prevent memory leak from OnStoppedSpeaking event");
		}

		private void Update()
		{
			if (StartOfRound.Instance.allPlayerScripts[PlayerID].isPlayerDead)
			{
				RemoveThisClass();
			}
			else if (speakState != null && speakState.IsSpeaking && speakState.Amplitude >= 0.005f)
			{
				PlayerIsTalking(speakState);
			}
		}

		private void LateUpdate()
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			if (!StartOfRound.Instance.allPlayerScripts[PlayerID].isPlayerDead)
			{
				if ((Object)(object)ogHead != (Object)null && isTalking)
				{
					head.SetActive(true);
					ogHead.localScale = new Vector3(0.01f, 0.01f, 0.01f);
				}
				else
				{
					head.SetActive(false);
					ogHead.localScale = ogHeadScale;
				}
			}
		}

		private void PlayerIsTalking(VoicePlayerState state)
		{
			if (!StartOfRound.Instance.allPlayerScripts[PlayerID].isPlayerDead)
			{
				((Renderer)upperHeadMaterial).material = ((Renderer)thisPlayer.thisPlayerModel).material;
				((Renderer)lowerHeadMaterial).material = ((Renderer)thisPlayer.thisPlayerModel).material;
				if (state.Amplitude < 0.0003f)
				{
					RotateHead(state.Amplitude, rotateUp: false);
					return;
				}
				RotateHead(state.Amplitude);
				((MonoBehaviour)StartOfRound.Instance).StartCoroutine(RotateDelay(state.Amplitude, rotateUp: false));
				isTalking = true;
			}
		}

		private void PlayerNotTalking(VoicePlayerState state)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (!StartOfRound.Instance.allPlayerScripts[PlayerID].isPlayerDead)
			{
				upperHead.transform.localRotation = defaultRotation;
				isTalking = false;
			}
		}

		private void RotateHead(float amp, bool rotateUp = true)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: 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)
			if (!((Object)(object)head == (Object)null))
			{
				upperHead = ((Component)head.transform.Find("upper head")).gameObject;
				float num = (rotateUp ? 120 : 320);
				float lookPos = (rotateUp ? (-22f) : (-90f));
				float num2 = CalculateXPos(amp, lookPos);
				num += Math.Abs(num2);
				Vector3 val = default(Vector3);
				((Vector3)(ref val))..ctor(num2, 0f, 0f);
				Quaternion val2 = Quaternion.Euler(val);
				upperHead.transform.localRotation = Quaternion.RotateTowards(upperHead.transform.localRotation, val2, num * Time.deltaTime);
			}
		}

		private static float CalculateXPos(float amp, float lookPos)
		{
			if (lookPos == -90f)
			{
				return lookPos;
			}
			int num = -165;
			int num2 = -90;
			float num3 = amp * lookPos;
			float num4 = lookPos * num3 * LConfig.defaultAmpMulti.Value;
			return Mathf.Clamp(num4, (float)num2, (float)num);
		}

		[IteratorStateMachine(typeof(<RotateDelay>d__22))]
		private IEnumerator RotateDelay(float amp, bool rotateUp)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RotateDelay>d__22(0)
			{
				<>4__this = this,
				amp = amp,
				rotateUp = rotateUp
			};
		}
	}
}