using System;
using System.Collections;
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 System.Text.RegularExpressions;
using BepInEx;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("CrazyFrenchFace")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Fak U Punch")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("CrazyFrenchFace")]
[assembly: AssemblyTitle("CrazyFrenchFace")]
[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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace CrazyFrenchFace
{
	[BepInPlugin("prideunique.ultrakill.customsisyphus", "Custom Sisyphus", "1.0.0")]
	public class CustomSisyphus : BaseUnityPlugin
	{
		public const string modGUID = "prideunique.ultrakill.customsisyphus";

		public const string modName = "Custom Sisyphus";

		public const string modVersion = "1.0.0";

		public static Dictionary<string, List<string>> AudioReplacements = new Dictionary<string, List<string>>();

		public static Material SisyphusHeadMaterial = null;

		public static string ReplacementsPath;

		public static Harmony HarmonyPatch = new Harmony("prideunique.ultrakill.customsisyphus");

		private void Awake()
		{
			ReplacementsPath = Path.Combine(Paths.PluginPath, "SisyphusAudios");
			if (!Directory.Exists(ReplacementsPath))
			{
				Directory.CreateDirectory(ReplacementsPath);
			}
			LoadReplacements();
			((MonoBehaviour)this).StartCoroutine(InitializeHeadMaterial());
			HarmonyPatch.PatchAll(typeof(FleshPrisonPatch));
			HarmonyPatch.PatchAll(typeof(SisyphusPrimeIntroPatch));
			HarmonyPatch.PatchAll(typeof(SisyphusPrimePatch));
		}

		public static IEnumerator InitializeHeadMaterial()
		{
			string text = Directory.GetFiles(ReplacementsPath, "*.png").FirstOrDefault();
			UnityWebRequest request = UnityWebRequestTexture.GetTexture(text);
			try
			{
				yield return request.SendWebRequest();
				SisyphusHeadMaterial = new Material(Shader.Find("Standard"));
				SisyphusHeadMaterial.mainTexture = (Texture)(object)DownloadHandlerTexture.GetContent(request);
			}
			finally
			{
				((IDisposable)request)?.Dispose();
			}
		}

		private void LoadReplacements()
		{
			string[] files = Directory.GetFiles(ReplacementsPath, "*.ogg", SearchOption.AllDirectories);
			foreach (string text in files)
			{
				string key = Regex.Replace(Path.GetFileName(text).Split(new char[1] { '.' })[0], "[\\d-]", string.Empty);
				if (!AudioReplacements.ContainsKey(key))
				{
					AudioReplacements[key] = new List<string>();
				}
				AudioReplacements[key].Add(text);
			}
		}
	}
	public static class FleshPrisonPatch
	{
		[HarmonyPatch(typeof(FleshPrison), "Start")]
		[HarmonyPostfix]
		private static void FleshPrisonStart(FleshPrison __instance)
		{
			ReplaceAudioClips(__instance);
		}

		private static void ReplaceAudioClips(FleshPrison __instance)
		{
			SubtitledAudioSource val = default(SubtitledAudioSource);
			foreach (AudioSource item in ObjectFinder.FindObjectsOfType<AudioSource>())
			{
				if (Object.op_Implicit((Object)(object)item.clip))
				{
					List<SubtitleDataLine> list = new List<SubtitleDataLine>();
					bool flag = false;
					if (((Object)item.clip).name == "sp_thisprison")
					{
						Debug.Log((object)"Replacing sisyphus intro (prison)");
						((MonoBehaviour)__instance).StartCoroutine(Utils.ReplaceAudioSourceClip(item, "sp_thisprison.ogg"));
						flag = true;
					}
					if (flag && ((Component)item).TryGetComponent<SubtitledAudioSource>(ref val))
					{
						object value = Traverse.Create((object)val).Field("subtitles").GetValue();
						((SubtitleData)((value is SubtitleData) ? value : null)).lines = list.ToArray();
					}
				}
			}
		}
	}
	public static class ObjectFinder
	{
		public static List<T> FindObjectsOfType<T>() where T : Component
		{
			//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)
			List<T> list = new List<T>();
			Scene activeScene = SceneManager.GetActiveScene();
			GameObject[] rootGameObjects = ((Scene)(ref activeScene)).GetRootGameObjects();
			for (int i = 0; i < rootGameObjects.Length; i++)
			{
				FindInChildren(rootGameObjects[i], list);
			}
			return list;
		}

		private static void FindInChildren<T>(GameObject gameObject, List<T> results) where T : Component
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			T item = default(T);
			if (gameObject.TryGetComponent<T>(ref item))
			{
				results.Add(item);
			}
			foreach (Transform item2 in gameObject.transform)
			{
				FindInChildren(((Component)item2).gameObject, results);
			}
		}
	}
	public static class SisyphusPrimeIntroPatch
	{
		[HarmonyPatch(typeof(SisyphusPrimeIntro), "Start")]
		[HarmonyPostfix]
		private static void SisyphusPrimeIntroStart(SisyphusPrimeIntro __instance)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			Transform val = ((Component)__instance).transform.Find("Sisyphus (1)").Find("Sisyphus_Head");
			Transform val2 = ((Component)__instance).transform.Find("Sisyphus (1)").Find("Sisyphus_Hair");
			Transform val3 = ((Component)__instance).transform.Find("Sisyphus (1)").Find("Sisyphus_Beard");
			ChangeMaterials component = ((Component)val).GetComponent<ChangeMaterials>();
			for (int i = 0; i < component.materials.Length; i++)
			{
				Material val4 = new Material(component.materials[i]);
				val4.mainTexture = CustomSisyphus.SisyphusHeadMaterial.mainTexture;
				component.materials[i] = val4;
			}
			Renderer component2 = ((Component)val).GetComponent<Renderer>();
			Material val5 = new Material(component2.material);
			val5.mainTexture = CustomSisyphus.SisyphusHeadMaterial.mainTexture;
			component2.sharedMaterial = val5;
			Object.Destroy((Object)(object)((Component)val3).gameObject);
			Object.Destroy((Object)(object)((Component)val2).gameObject);
			ReplaceAudioClips(__instance);
		}

		private static void ReplaceAudioClips(SisyphusPrimeIntro __instance)
		{
			SubtitledAudioSource val = default(SubtitledAudioSource);
			foreach (AudioSource item in ObjectFinder.FindObjectsOfType<AudioSource>())
			{
				if (Object.op_Implicit((Object)(object)item.clip))
				{
					List<SubtitleDataLine> list = new List<SubtitleDataLine>();
					bool flag = false;
					switch (((Object)item.clip).name)
					{
					case "sp_intro":
						Debug.Log((object)"Replacing sisyphus intro");
						((MonoBehaviour)__instance).StartCoroutine(Utils.ReplaceAudioSourceClip(item, "sp_intro.ogg"));
						flag = true;
						break;
					case "sp_outro":
						Debug.Log((object)"Replacing sisyphus outro");
						((MonoBehaviour)__instance).StartCoroutine(Utils.ReplaceAudioSourceClip(item, "sp_outro.ogg"));
						flag = true;
						break;
					case "sp_keepthemcoming":
						Debug.Log((object)"Replacing keep them coming");
						((MonoBehaviour)__instance).StartCoroutine(Utils.ReplaceAudioSourceClip(item, "sp_keepthemcoming.ogg"));
						flag = true;
						break;
					}
					if (flag && ((Component)item).TryGetComponent<SubtitledAudioSource>(ref val))
					{
						object value = Traverse.Create((object)val).Field("subtitles").GetValue();
						((SubtitleData)((value is SubtitleData) ? value : null)).lines = list.ToArray();
					}
				}
			}
		}
	}
	public static class SisyphusPrimePatch
	{
		[HarmonyPatch(typeof(SisyphusPrime), "Start")]
		[HarmonyPostfix]
		private static void SisyphusPrimeStart(SisyphusPrime __instance)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			Transform val = ((Component)__instance).transform.Find("Sisyphus (1)").Find("Sisyphus_Head");
			ChangeMaterials component = ((Component)val).GetComponent<ChangeMaterials>();
			for (int i = 0; i < component.materials.Length; i++)
			{
				Material val2 = new Material(component.materials[i]);
				val2.mainTexture = CustomSisyphus.SisyphusHeadMaterial.mainTexture;
				component.materials[i] = val2;
			}
			Renderer component2 = ((Component)val).GetComponent<Renderer>();
			Material val3 = new Material(component2.material);
			val3.mainTexture = CustomSisyphus.SisyphusHeadMaterial.mainTexture;
			component2.sharedMaterial = val3;
			((MonoBehaviour)__instance).StartCoroutine(LoadAndReplaceAudioClips(__instance, "destroy"));
			((MonoBehaviour)__instance).StartCoroutine(LoadAndReplaceAudioClips(__instance, "clap"));
			((MonoBehaviour)__instance).StartCoroutine(LoadAndReplaceAudioClips(__instance, "explode"));
			((MonoBehaviour)__instance).StartCoroutine(LoadAndReplaceAudioClips(__instance, "hurt"));
			((MonoBehaviour)__instance).StartCoroutine(LoadAndReplaceAudioClips(__instance, "taunt"));
			((MonoBehaviour)__instance).StartCoroutine(LoadAndReplaceAudioClips(__instance, "player_death"));
			((MonoBehaviour)__instance).StartCoroutine(ReplaceSisyphusPhaseAudioClip(__instance, "phase"));
		}

		private static IEnumerator LoadAndReplaceAudioClips(SisyphusPrime __instance, string audioSet)
		{
			if (!CustomSisyphus.AudioReplacements.ContainsKey(audioSet))
			{
				yield break;
			}
			List<AudioClip> loadedAudioClips = new List<AudioClip>();
			for (int i = 0; i < CustomSisyphus.AudioReplacements[audioSet].Count; i++)
			{
				string text = CustomSisyphus.AudioReplacements[audioSet][i];
				UnityWebRequest request = UnityWebRequestMultimedia.GetAudioClip(text, (AudioType)14);
				try
				{
					yield return request.SendWebRequest();
					loadedAudioClips.Add(DownloadHandlerAudioClip.GetContent(request));
				}
				finally
				{
					((IDisposable)request)?.Dispose();
				}
			}
			ReplaceAudioClips(__instance, loadedAudioClips, audioSet);
		}

		private static void ReplaceAudioClips(SisyphusPrime __instance, List<AudioClip> audioClips, string audioSet)
		{
			switch (audioSet)
			{
			case "destroy":
				__instance.uppercutComboVoice = audioClips.ToArray();
				break;
			case "clap":
				__instance.clapVoice = audioClips.ToArray();
				break;
			case "explode":
				__instance.explosionVoice = audioClips.ToArray();
				break;
			case "hurt":
				__instance.hurtVoice = audioClips.ToArray();
				break;
			case "taunt":
				__instance.tauntVoice = audioClips.ToArray();
				break;
			case "player_death":
				__instance.stompComboVoice = audioClips.ToArray();
				break;
			}
		}

		public static IEnumerator ReplaceSisyphusPhaseAudioClip(SisyphusPrime __instance, string audioSet)
		{
			if (CustomSisyphus.AudioReplacements.ContainsKey(audioSet))
			{
				string text = CustomSisyphus.AudioReplacements[audioSet][0];
				UnityWebRequest request = UnityWebRequestMultimedia.GetAudioClip(text, (AudioType)14);
				try
				{
					yield return request.SendWebRequest();
					Utils.ReplaceAudioClip(ref __instance.phaseChangeVoice, DownloadHandlerAudioClip.GetContent(request));
				}
				finally
				{
					((IDisposable)request)?.Dispose();
				}
			}
		}
	}
	public static class Utils
	{
		public static IEnumerator ReplaceAudioSourceClip(AudioSource audioSource, string fileName)
		{
			string text = Path.Combine(CustomSisyphus.ReplacementsPath, fileName);
			UnityWebRequest request = UnityWebRequestMultimedia.GetAudioClip(text, (AudioType)14);
			try
			{
				yield return request.SendWebRequest();
				ReplaceAudioSourceClip(ref audioSource, DownloadHandlerAudioClip.GetContent(request));
			}
			finally
			{
				((IDisposable)request)?.Dispose();
			}
		}

		public static void ReplaceAudioClip(ref AudioClip audioClip, AudioClip replaceAudioClip)
		{
			audioClip = replaceAudioClip;
		}

		public static void ReplaceAudioSourceClip(ref AudioSource audioSource, AudioClip replaceAudioClip)
		{
			audioSource.clip = replaceAudioClip;
		}

		public static SubtitleDataLine MakeLine(string subtitle, float time)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			return new SubtitleDataLine
			{
				subtitle = subtitle,
				time = time
			};
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "CrazyFrenchFace";

		public const string PLUGIN_NAME = "CrazyFrenchFace";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}