using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
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 Dissonance;
using GameNetcodeStuff;
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-CSharp")]
[assembly: AssemblyCompany("MeowSkullsVT0.2")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("MeowSkullsVT0.2")]
[assembly: AssemblyTitle("MeowSkullsVT0.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
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;
		}
	}
}
namespace ModelReplacement
{
	public class MRMEOWSKULLSMAR : BodyReplacementBase
	{
		public ManualLogSource MardentallAddModelScripts;

		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "meowskullsMar";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			MardentallAddModelScripts = new ManualLogSource("MardentaalLogSource2");
			Logger.Sources.Add((ILogSource)(object)MardentallAddModelScripts);
			MardentallAddModelScripts.LogInfo((object)"This is a test message for MardentaalLogSource2");
			try
			{
				GameObject gameObject = ((Component)base.replacementModel.transform.Find("F_MED_ChillCat.001")).gameObject;
				if ((Object)(object)gameObject != (Object)null)
				{
					MardentallAddModelScripts.LogInfo((object)$"mouth variable is found, apparently: {gameObject}");
					MouthSync mouthSync = gameObject.AddComponent(typeof(MouthSync)) as MouthSync;
					MardentallAddModelScripts.LogInfo((object)"mouth variable has been applied");
					MardentallAddModelScripts.LogInfo((object)$"mouthSync value: {mouthSync}");
					mouthSync.player = ((BodyReplacementBase)this).controller;
					MardentallAddModelScripts.LogInfo((object)$"mouthSync.player value: {mouthSync.player}");
					mouthSync.init();
				}
				else
				{
					MardentallAddModelScripts.LogInfo((object)"Model wasn't found");
				}
			}
			catch (Exception)
			{
				MardentallAddModelScripts.LogInfo((object)"Failure to function properly :3");
			}
			Logger.Sources.Remove((ILogSource)(object)MardentallAddModelScripts);
		}
	}
	public class MouthSync : MonoBehaviour
	{
		public PlayerControllerB player;

		public ManualLogSource MouthSyncLog;

		public ManualLogSource MouthSyncUpdateLog;

		protected VoicePlayerState voice;

		private Vector2 mouthOpen = new Vector2(0f, -0.5f);

		private Vector2 mouthClose = new Vector2(0f, 0f);

		private Vector2 mouthValue = new Vector2(0f, 0f);

		protected MeshFilter mouthMesh;

		private List<Vector2> uvMapping = new List<Vector2>
		{
			new Vector2(0f, 0f),
			new Vector2(0f, 0f)
		};

		protected SkinnedMeshRenderer skinnedMeshRenderer;

		private List<Material> modelMaterialList;

		protected int mouthMaterialCoord = 0;

		private void Start()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			MouthSyncLog = new ManualLogSource("MouthSyncLog");
			Logger.Sources.Add((ILogSource)(object)MouthSyncLog);
			skinnedMeshRenderer = ((Component)this).GetComponent<SkinnedMeshRenderer>();
			modelMaterialList = ((Renderer)skinnedMeshRenderer).materials.ToList();
			MouthSyncLog.LogInfo((object)$"size of ModelMaterials: {modelMaterialList.Count} :3");
			for (int i = 0; i < modelMaterialList.Count; i++)
			{
				if (((Object)modelMaterialList[i]).name == "T_F_MED_ChillCat_Mouth_D9 (Instance)")
				{
					MouthSyncLog.LogInfo((object)"Cat_Mouth was found!!! :3");
					mouthMaterialCoord = i;
				}
				else
				{
					MouthSyncLog.LogInfo((object)("wrong texture, was " + ((Object)modelMaterialList[i]).name + " :3"));
				}
			}
			Logger.Sources.Remove((ILogSource)(object)MouthSyncLog);
		}

		private void Update()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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)StartOfRound.Instance.voiceChatModule == (Object)null)
			{
				return;
			}
			if (voice == null)
			{
				init();
				return;
			}
			if (voice.IsSpeaking && (double)voice.Amplitude > 0.03 && !player.isPlayerDead)
			{
				mouthValue = mouthOpen;
			}
			else
			{
				mouthValue = mouthClose;
			}
			modelMaterialList[mouthMaterialCoord].mainTextureOffset = mouthValue;
			((Renderer)skinnedMeshRenderer).SetMaterials(modelMaterialList);
		}

		public void init()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			//IL_0044: Expected O, but got Unknown
			StartOfRound.Instance.RefreshPlayerVoicePlaybackObjects();
			voice = player.voicePlayerState;
			if (voice == null && (Object)player == (Object)StartOfRound.Instance.localPlayerController)
			{
				voice = StartOfRound.Instance.voiceChatModule.FindPlayer(StartOfRound.Instance.voiceChatModule.LocalPlayerName);
			}
		}
	}
	[BepInPlugin("com.mardentaa.MeowSkullsVT", "MeowSkullsVT", "0.1.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public ManualLogSource MardentaalLogSource3;

		public static ConfigFile config;

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

		private static void InitConfig()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			voiceSensitivity = config.Bind<float>("Voice Sensitivity For Meowskull mouth", "Sensitivity Value", 7f, "Number from 5 to 20");
			ManualLogSource val = new ManualLogSource("MardentaalLogSource3");
			Logger.Sources.Add((ILogSource)(object)val);
			val.LogInfo((object)"This is a test message for MardentaalLogSource3 in InitConfig within the plugin doc :3");
			Logger.Sources.Remove((ILogSource)(object)val);
		}

		private void Awake()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			config = ((BaseUnityPlugin)this).Config;
			InitConfig();
			Assets.PopulateAssets();
			ModelReplacementAPI.RegisterSuitModelReplacement("meowskullsMar", typeof(MRMEOWSKULLSMAR));
			Harmony val = new Harmony("com.mardentaa.MeowSkullsVT");
			val.PatchAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin com.mardentaa.MeowSkullsVT is loaded!");
		}
	}
	public static class Assets
	{
		public static string mainAssetBundleName = "meowskulls_mardentaal";

		public static AssetBundle MainAssetBundle = null;

		private static string GetAssemblyName()
		{
			return Assembly.GetExecutingAssembly().GetName().Name.Replace(" ", "_");
		}

		public static void PopulateAssets()
		{
			if ((Object)(object)MainAssetBundle == (Object)null)
			{
				Console.WriteLine(GetAssemblyName() + "." + mainAssetBundleName);
				using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(GetAssemblyName() + "." + mainAssetBundleName);
				MainAssetBundle = AssetBundle.LoadFromStream(stream);
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}