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 Microsoft.CodeAnalysis;
using MonoMod.RuntimeDetour.HookGen;
using On.RoR2;
using RoR2;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Rendering;

[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("LiTDrifterPlugin")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("LiTDrifterPlugin")]
[assembly: AssemblyTitle("LiTDrifterPlugin")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[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 TestMod
{
	internal static class Log
	{
		private static ManualLogSource _logSource;

		internal static void Init(ManualLogSource logSource)
		{
			_logSource = logSource;
		}

		internal static void Debug(object data)
		{
			_logSource.LogDebug(data);
		}

		internal static void Error(object data)
		{
			_logSource.LogError(data);
		}

		internal static void Fatal(object data)
		{
			_logSource.LogFatal(data);
		}

		internal static void Info(object data)
		{
			_logSource.LogInfo(data);
		}

		internal static void Message(object data)
		{
			_logSource.LogMessage(data);
		}

		internal static void Warning(object data)
		{
			_logSource.LogWarning(data);
		}
	}
}
namespace LiTDrifter
{
	[BepInPlugin("com.icebro.LiTDrifter", "LiTDrifter", "1.0.0")]
	public class LiTDrifterPlugin : BaseUnityPlugin
	{
		private class FieldException : Exception
		{
			public FieldException(string message, Exception innerException)
				: base(message, innerException)
			{
			}
		}

		private class ElementException : Exception
		{
			public int Index { get; }

			public ElementException(int index, string message)
				: base(message)
			{
				Index = index;
			}
		}

		private static AssetBundle assetBundle;

		private static readonly List<Material> materialsWithRoRShader = new List<Material>();

		private ConfigEntry<bool> replaceDrifter;

		private static SkinDef drifterSkin;

		internal static LiTDrifterPlugin Instance { get; private set; }

		internal static ManualLogSource InstanceLogger
		{
			get
			{
				LiTDrifterPlugin instance = Instance;
				return (instance != null) ? ((BaseUnityPlugin)instance).Logger : null;
			}
		}

		private void Start()
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			Instance = this;
			BeforeStart();
			assetBundle = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), "LiTDrifter.icebrolitdrifter"));
			((ResourceAvailability)(ref BodyCatalog.availability)).CallWhenAvailable((Action)BodyCatalogInit);
			SurvivorCatalog.SetSurvivorDefs += new hook_SetSurvivorDefs(SurvivorCatalogOnSetSurvivorDefs);
			HookEndpointManager.Add((MethodBase)typeof(Language).GetMethod("LoadStrings"), (Delegate)new Action<Action<Language>, Language>(LanguageLoadStrings));
			ReplaceShaders();
		}

		private void SurvivorCatalogOnSetSurvivorDefs(orig_SetSurvivorDefs orig, SurvivorDef[] newSurvivorDefs)
		{
			orig.Invoke(newSurvivorDefs);
			if (replaceDrifter.Value)
			{
				SurvivorDef val = SurvivorCatalog.FindSurvivorDefFromBody(BodyCatalog.FindBodyPrefab("DrifterBody"));
				ModelSkinController component = ((Component)val.displayPrefab.transform.Find("mdlDrifter")).GetComponent<ModelSkinController>();
				component.skins[0] = drifterSkin;
			}
		}

		private void BeforeStart()
		{
			replaceDrifter = ((BaseUnityPlugin)this).Config.Bind<bool>("Lost in Transit Drifter", "Replace drifter", false, "replaces default drifter skin and surivor icon !!");
		}

		private static void ReplaceShaders()
		{
			LoadMaterialsWithReplacedShader("RoR2/Base/Shaders/HGStandard.shader", "Assets/characterbodyexample/LiTDrifterShader.mat");
		}

		private static void LoadMaterialsWithReplacedShader(string shaderPath, params string[] materialPaths)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			Shader shader = Addressables.LoadAssetAsync<Shader>((object)shaderPath).WaitForCompletion();
			foreach (string text in materialPaths)
			{
				Material val = assetBundle.LoadAsset<Material>(text);
				val.shader = shader;
				materialsWithRoRShader.Add(val);
			}
		}

		private static void LanguageLoadStrings(Action<Language> orig, Language self)
		{
			orig(self);
			self.SetStringByToken("ICEBRO_SKIN_LITDRIFTER_NAME", "Lost in Transit");
			self.SetStringByToken("ICEBRO_SKIN_LITDRIFTER_DESC", "man ,,.,. looks like we're ,..,.,.,,. lost in transit or something ,..,.,.,,,.., ");
		}

		private void BodyCatalogInit()
		{
			if (replaceDrifter.Value)
			{
				GameObject val = BodyCatalog.FindBodyPrefab("DrifterBody");
				CharacterBody component = val.GetComponent<CharacterBody>();
				component.portraitIcon = (Texture)(object)assetBundle.LoadAsset<Sprite>("Assets/characterbodyexample/drifter_icon.png").texture;
			}
			AddDrifterBodyLiTDrifterSkin();
		}

		private void AddDrifterBodyLiTDrifterSkin()
		{
			string text = "DrifterBody";
			string text2 = "LiTDrifter";
			try
			{
				GameObject val = BodyCatalog.FindBodyPrefab(text);
				if (!Object.op_Implicit((Object)(object)val))
				{
					InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin because \"" + text + "\" doesn't exist"));
					return;
				}
				ModelLocator component = val.GetComponent<ModelLocator>();
				if (!Object.op_Implicit((Object)(object)component))
				{
					InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\" because it doesn't have \"ModelLocator\" component"));
					return;
				}
				GameObject gameObject = ((Component)component.modelTransform).gameObject;
				ModelSkinController skinController = (Object.op_Implicit((Object)(object)gameObject) ? gameObject.GetComponent<ModelSkinController>() : null);
				if (!Object.op_Implicit((Object)(object)skinController))
				{
					InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\" because it doesn't have \"ModelSkinController\" component"));
					return;
				}
				Renderer[] renderers = gameObject.GetComponentsInChildren<Renderer>(true);
				Light[] componentsInChildren = gameObject.GetComponentsInChildren<Light>(true);
				SkinDef skin = ScriptableObject.CreateInstance<SkinDef>();
				SkinDefParams skinParams = ScriptableObject.CreateInstance<SkinDefParams>();
				skin.skinDefParams = skinParams;
				TryCatchThrow("Icon", delegate
				{
					skin.icon = assetBundle.LoadAsset<Sprite>("Assets/characterbodyexample/Default_Drifter.png");
				});
				((Object)skin).name = text2;
				skin.nameToken = "ICEBRO_SKIN_LITDRIFTER_NAME";
				skin.rootObject = gameObject;
				TryCatchThrow("Base Skins", delegate
				{
					skin.baseSkins = (SkinDef[])(object)new SkinDef[1] { ThrowIfOutOfBounds(0, "Index 0 is out of bounds of skins array", skinController.skins, 0) };
				});
				TryCatchThrow("Renderer Infos", delegate
				{
					//IL_0011: Unknown result type (might be due to invalid IL or missing references)
					//IL_0030: Unknown result type (might be due to invalid IL or missing references)
					//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_0083: 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_00eb: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
					skinParams.rendererInfos = (RendererInfo[])(object)new RendererInfo[2]
					{
						new RendererInfo
						{
							defaultMaterial = assetBundle.LoadAsset<Material>("Assets/characterbodyexample/LiTDrifterShader.mat"),
							defaultShadowCastingMode = (ShadowCastingMode)1,
							ignoreOverlays = false,
							renderer = ThrowIfNull<Renderer>(0, "There is no renderer with the name \"meshDrifter\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "meshDrifter")))
						},
						new RendererInfo
						{
							defaultMaterial = assetBundle.LoadAsset<Material>("Assets/characterbodyexample/LiTDrifterShader.mat"),
							defaultShadowCastingMode = (ShadowCastingMode)1,
							ignoreOverlays = false,
							renderer = ThrowIfNull<Renderer>(1, "There is no renderer with the name \"meshBag\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "meshBag")))
						}
					};
				});
				TryCatchThrow("Mesh Replacements", delegate
				{
					//IL_0011: Unknown result type (might be due to invalid IL or missing references)
					//IL_0069: Unknown result type (might be due to invalid IL or missing references)
					//IL_006a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0073: Unknown result type (might be due to invalid IL or missing references)
					//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
					//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
					skinParams.meshReplacements = (MeshReplacement[])(object)new MeshReplacement[2]
					{
						new MeshReplacement
						{
							mesh = assetBundle.LoadAsset<Mesh>("Assets/SkinMods/LiTDrifter/Meshes/LITDrifterBody.mesh"),
							renderer = ThrowIfNull<Renderer>(0, "There is no renderer with the name \"meshDrifter\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "meshDrifter")))
						},
						new MeshReplacement
						{
							mesh = assetBundle.LoadAsset<Mesh>("Assets/SkinMods/LiTDrifter/Meshes/LITDrifterBag.mesh"),
							renderer = ThrowIfNull<Renderer>(1, "There is no renderer with the name \"meshBag\"", ((IEnumerable<Renderer>)renderers).FirstOrDefault((Func<Renderer, bool>)((Renderer r) => ((Object)r).name == "meshBag")))
						}
					};
				});
				if (replaceDrifter.Value)
				{
					skinController.skins[0] = skin;
					drifterSkin = skin;
				}
				else
				{
					Array.Resize(ref skinController.skins, skinController.skins.Length + 1);
					skinController.skins[^1] = skin;
				}
			}
			catch (FieldException ex)
			{
				if (ex.InnerException is ElementException ex2)
				{
					InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
					InstanceLogger.LogWarning((object)$"Field causing issue: {ex.Message}, element: {ex2.Index}");
					InstanceLogger.LogWarning((object)ex2.Message);
					InstanceLogger.LogError((object)ex.InnerException);
				}
				else
				{
					InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
					InstanceLogger.LogWarning((object)("Field causing issue: " + ex.Message));
					InstanceLogger.LogError((object)ex.InnerException);
				}
			}
			catch (Exception ex3)
			{
				InstanceLogger.LogWarning((object)("Failed to add \"" + text2 + "\" skin to \"" + text + "\""));
				InstanceLogger.LogError((object)ex3);
			}
		}

		private static T ThrowIfEquals<T>(int index, string message, T value, T expected) where T : Enum
		{
			if (value.Equals(expected))
			{
				throw new ElementException(index, message);
			}
			return value;
		}

		private static T ThrowIfOutOfBounds<T>(int index, string message, T[] array, int elementIndex) where T : class
		{
			if (array == null || array.Length <= elementIndex)
			{
				throw new ElementException(index, message);
			}
			return array[elementIndex];
		}

		private static T ThrowIfNull<T>(int index, string message, T value) where T : class
		{
			if (value == null)
			{
				throw new ElementException(index, message);
			}
			return value;
		}

		private static void TryCatchThrow(string message, Action action)
		{
			try
			{
				action?.Invoke();
			}
			catch (Exception innerException)
			{
				throw new FieldException(message, innerException);
			}
		}

		private static void TryAddComponent<T>(GameObject obj) where T : Component
		{
			if (Object.op_Implicit((Object)(object)obj) && !Object.op_Implicit((Object)(object)obj.GetComponent<T>()))
			{
				obj.AddComponent<T>();
			}
		}
	}
}