using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using LethalLib.Modules;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("MemeSoundboard")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("MemeSoundboard")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("2a19c5a9-6341-4a09-b1eb-a1a2ae48ec34")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
internal class <Module>
{
	static <Module>()
	{
	}
}
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 MemeSoundboard
{
	[BepInPlugin("florianbutz.memesoundboard", "Meme Soundboard", "1.1.2.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class MemeSoundboardBase : BaseUnityPlugin
	{
		private const string modGUID = "florianbutz.memesoundboard";

		private const string modName = "Meme Soundboard";

		private const string modVersion = "1.1.2.0";

		private static string bundlePath = "";

		private readonly Harmony harmony = new Harmony("florianbutz.memesoundboard");

		public static MemeSoundboardBase instance;

		internal ManualLogSource logSource;

		public static GameObject soundboardItemPrefab;

		private void Awake()
		{
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Expected O, but got Unknown
			if (Object.op_Implicit((Object)(object)(instance = null)))
			{
				instance = this;
			}
			logSource = Logger.CreateLogSource("Meme Soundboard");
			Configuration.Init();
			bundlePath = Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), "soundboarditemmodel");
			Assets.LoadAssetBundle(bundlePath);
			AssetBundle bundle = Assets.GetBundle();
			Item val = bundle.LoadAsset<Item>("soundboarditem");
			Soundboard soundboard = val.spawnPrefab.AddComponent<Soundboard>();
			((GrabbableObject)soundboard).itemProperties = val;
			AudioSource component = val.spawnPrefab.GetComponent<AudioSource>();
			component.volume = Mathf.Clamp(Configuration.SoundboardVolume, 0f, 1f);
			component.dopplerLevel = Mathf.Clamp(Configuration.DopplerLevel, 0f, 2f);
			Soundboard.soundboardClips = new List<AudioClip>();
			Soundboard.soundboardClipNames = new List<string>();
			AddNewSound("Vine Boom", bundle.LoadAsset<AudioClip>("vineboom"));
			AddNewSound("Tacco Bell", bundle.LoadAsset<AudioClip>("bell"));
			AddNewSound("Siren", bundle.LoadAsset<AudioClip>("siren"));
			AddNewSound("Violin Screech", bundle.LoadAsset<AudioClip>("violinscreech"));
			AddNewSound("Wilhelm Scream", bundle.LoadAsset<AudioClip>("wilhelmscream"));
			AddNewSound("Augh", bundle.LoadAsset<AudioClip>("augh"));
			AddNewSound("Reverb Fart", bundle.LoadAsset<AudioClip>("reverbfart"));
			AddNewSound("Horn", bundle.LoadAsset<AudioClip>("horn"));
			AddNewSound("Bowomp", bundle.LoadAsset<AudioClip>("bowomp"));
			AddNewSound("Ghost", bundle.LoadAsset<AudioClip>("ghost"));
			AddNewSound("Inception", bundle.LoadAsset<AudioClip>("inception"));
			AddNewSound("Fnaf Jumpscare", bundle.LoadAsset<AudioClip>("fnafjumpscare"));
			AddNewSound("Metal Pipe", bundle.LoadAsset<AudioClip>("metalpipe"));
			AddNewSound("What the hell bruh", bundle.LoadAsset<AudioClip>("browthbruh"));
			AddNewSound("Yippee", bundle.LoadAsset<AudioClip>("yippee"));
			soundboard.switchSoundClip = bundle.LoadAsset<AudioClip>("switchsound");
			TerminalNode val2 = (TerminalNode)ScriptableObject.CreateInstance("TerminalNode");
			Items.RegisterShopItem(val, (TerminalNode)null, (TerminalNode)null, val2, 15);
			soundboardItemPrefab = val.spawnPrefab;
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			for (int i = 0; i < types.Length; i++)
			{
				MethodInfo[] methods = types[i].GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
				foreach (MethodInfo methodInfo in methods)
				{
					if (methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false).Length != 0)
					{
						methodInfo.Invoke(null, null);
					}
				}
			}
			logSource.LogInfo((object)"Meme Soundboard has started successfully!");
			harmony.PatchAll();
		}

		public static void AddNewSound(string soundName, AudioClip soundClip)
		{
			Soundboard.soundboardClips.Add(soundClip);
			Soundboard.soundboardClipNames.Add(soundName);
		}
	}
	public class Soundboard : GrabbableObject
	{
		private AudioSource soundboardSource;

		private Text selectedSoundText;

		public AudioClip switchSoundClip;

		public static List<AudioClip> soundboardClips;

		public static List<string> soundboardClipNames;

		private Animator antennaLightAnim;

		public NetworkVariable<int> selectedSound = new NetworkVariable<int>(0, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		private bool isItemInMainHand;

		public void Awake()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			base.customGrabTooltip = "Grab - Play Meme Sounds!";
			base.grabbable = true;
			base.grabbableToEnemies = true;
			base.mainObjectRenderer = ((Component)this).GetComponent<MeshRenderer>();
			base.useCooldown = 2f;
			base.insertedBattery = new Battery(false, 5f);
			soundboardSource = ((Component)this).GetComponent<AudioSource>();
			antennaLightAnim = ((Component)this).GetComponentInChildren<Animator>();
			Text[] componentsInChildren = ((Component)this).GetComponentsInChildren<Text>();
			foreach (Text val in componentsInChildren)
			{
				if (((Object)((Component)val).gameObject).name == "SelectedSound")
				{
					selectedSoundText = val;
				}
			}
			selectedSoundText.text = soundboardClipNames[selectedSound.Value];
			foreach (string soundboardClipName in soundboardClipNames)
			{
				Debug.Log((object)soundboardClipName);
			}
			NetworkVariable<int> obj = selectedSound;
			obj.OnValueChanged = (OnValueChangedDelegate<int>)(object)Delegate.Combine((Delegate?)(object)obj.OnValueChanged, (Delegate?)(object)new OnValueChangedDelegate<int>(OnValueChanged));
		}

		[ServerRpc(RequireOwnership = false)]
		public void ChangeSelectedSoundServerRpc(int index)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(4043019660u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, index);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 4043019660u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					selectedSound.Value = index;
					soundboardSource.Stop();
				}
			}
		}

		private void OnValueChanged(int previous, int current)
		{
			Debug.Log((object)$"Detected NetworkVariable Change: Previous: {previous} | Current: {current}");
			selectedSoundText.text = soundboardClipNames[selectedSound.Value];
		}

		public override void ItemActivate(bool used, bool buttonDown = true)
		{
			((GrabbableObject)this).ItemActivate(used, buttonDown);
			soundboardSource.PlayOneShot(GetSoundboardSound(), Configuration.SoundboardVolume);
			antennaLightAnim.Play("AntennaLightFlicker_Animation");
		}

		public override void Update()
		{
			((GrabbableObject)this).Update();
			if (((ButtonControl)Keyboard.current[(Key)32]).wasPressedThisFrame && base.isHeld && ((NetworkBehaviour)this).IsOwner && isItemInMainHand)
			{
				Debug.Log((object)"Key was pressed! Switching Sound...");
				ChangeSelectedSoundServerRpc(NextIndex());
				selectedSoundText.text = soundboardClipNames[selectedSound.Value];
				Debug.Log((object)("Next Sound: " + (object)soundboardClips[selectedSound.Value]));
				soundboardSource.PlayOneShot(switchSoundClip, 0.35f);
			}
			if (((ButtonControl)Keyboard.current[(Key)31]).wasPressedThisFrame && base.isHeld && ((NetworkBehaviour)this).IsOwner && isItemInMainHand)
			{
				Debug.Log((object)"Key was pressed! Switching Sound...");
				ChangeSelectedSoundServerRpc(LastIndex());
				selectedSoundText.text = soundboardClipNames[selectedSound.Value];
				Debug.Log((object)("Next Sound: " + (object)soundboardClips[selectedSound.Value]));
				soundboardSource.PlayOneShot(switchSoundClip, 0.35f);
			}
			if (((ButtonControl)Keyboard.current[(Key)2]).wasPressedThisFrame && base.isHeld && ((NetworkBehaviour)this).IsOwner)
			{
				_ = isItemInMainHand;
			}
		}

		public override void PocketItem()
		{
			((GrabbableObject)this).PocketItem();
			((Component)((Component)selectedSoundText).transform.parent).gameObject.SetActive(false);
			selectedSoundText.text = soundboardClipNames[selectedSound.Value];
			isItemInMainHand = false;
			soundboardSource.Stop();
		}

		public override void EquipItem()
		{
			((GrabbableObject)this).EquipItem();
			((Component)((Component)selectedSoundText).transform.parent).gameObject.SetActive(true);
			isItemInMainHand = true;
			selectedSoundText.text = soundboardClipNames[selectedSound.Value];
		}

		public AudioClip GetSoundboardSound()
		{
			return soundboardClips[selectedSound.Value];
		}

		public int NextIndex()
		{
			Debug.Log((object)"Getting next soundindex...");
			if (soundboardClips.Count > selectedSound.Value + 1)
			{
				Debug.Log((object)"Aquired next sound index");
				return selectedSound.Value + 1;
			}
			return 0;
		}

		public int LastIndex()
		{
			Debug.Log((object)"Getting next soundindex...");
			if (0 <= selectedSound.Value - 1)
			{
				Debug.Log((object)"Aquired last sound index");
				return selectedSound.Value - 1;
			}
			return soundboardClips.Count - 1;
		}

		protected override void __initializeVariables()
		{
			if (selectedSound == null)
			{
				throw new Exception("Soundboard.selectedSound cannot be null. All NetworkVariableBase instances must be initialized.");
			}
			((NetworkVariableBase)selectedSound).Initialize((NetworkBehaviour)(object)this);
			((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)selectedSound, "selectedSound");
			((NetworkBehaviour)this).NetworkVariableFields.Add((NetworkVariableBase)(object)selectedSound);
			((GrabbableObject)this).__initializeVariables();
		}

		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeRPCS_Soundboard()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			NetworkManager.__rpc_func_table.Add(4043019660u, new RpcReceiveHandler(__rpc_handler_4043019660));
		}

		private static void __rpc_handler_4043019660(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int index = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref index);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Soundboard)(object)target).ChangeSelectedSoundServerRpc(index);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "Soundboard";
		}
	}
	[HarmonyPatch]
	public class NetworkObjectManager
	{
		private static GameObject networkPrefab;

		[HarmonyPostfix]
		[HarmonyPatch(typeof(GameNetworkManager), "Start")]
		public static void Init()
		{
			if (!((Object)(object)networkPrefab != (Object)null))
			{
				networkPrefab = MemeSoundboardBase.soundboardItemPrefab;
				NetworkManager.Singleton.AddNetworkPrefab(networkPrefab);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(StartOfRound), "Awake")]
		private static void SpawnNetworkHandler()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
			{
				Object.Instantiate<GameObject>(networkPrefab, Vector3.zero, Quaternion.identity).GetComponent<NetworkObject>().Spawn(false);
			}
		}
	}
	internal class Assets
	{
		internal static AssetBundle mainAssetBundle;

		private static string[] assetNames = new string[0];

		internal static void LoadAssetBundle(string assetbundlePath)
		{
			if ((Object)(object)mainAssetBundle == (Object)null)
			{
				mainAssetBundle = AssetBundle.LoadFromFile(assetbundlePath);
			}
			assetNames = mainAssetBundle.GetAllAssetNames();
		}

		internal static AssetBundle GetBundle()
		{
			if (!Object.op_Implicit((Object)(object)mainAssetBundle))
			{
				Debug.LogError((object)"There is no AssetBundle to load assets from.");
				return null;
			}
			return mainAssetBundle;
		}
	}
	internal static class Configuration
	{
		private const string CONFIG_FILE_NAME = "Soundboard.cfg";

		private static ConfigFile config;

		private static ConfigEntry<float> soundboardVolume;

		private static ConfigEntry<float> dopplerLevel;

		public static float SoundboardVolume => soundboardVolume.Value;

		public static float DopplerLevel => dopplerLevel.Value;

		public static void Init()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			config = new ConfigFile(Path.Combine(Paths.ConfigPath, "Soundboard.cfg"), true);
			soundboardVolume = config.Bind<float>("Config", "Soundboard master volume", 1f, "Changes the volume of the soundboard sounds. Value can be between 0 and 1.");
			dopplerLevel = config.Bind<float>("Config", "Soundboard doppler level", 0.5f, "Changes the doppler level of the soundboard sounds. Value can be between 0 and 2.");
		}
	}
}