using System;
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 HarmonyLib;
using Microsoft.CodeAnalysis;
using ModelReplacement;
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("DuroModelPack")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("DuroModelPack")]
[assembly: AssemblyTitle("DuroModelPack")]
[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 duromodelpack
{
	public class MRCHIBIROBOSCAVENGER_0VARIANT : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "ChibiRoboScavenger_0 Variant";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}
	}
	public class MRLKSMSCAVENGER_0VARIANT : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "LKSMScavenger_0 Variant";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}
	}
	public class MRGREENGOBLINSCAVENGER_0VARIANT : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "GreenGoblinScavenger_0 Variant";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}
	}
	public class MRCROCKERSCAVENGER_0VARIANT : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "CrockerScavenger_0 Variant";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}
	}
	public class MRCHRISBORESSCAVENGER_0VARIANT : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "ChrisBoresScavenger_0 Variant";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}
	}
	public class MRSKINNERSCAVENGER_0VARIANT : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "SkinnerScavenger_0 Variant";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}
	}
	public class MRSACKBOYSCAVENGER_0VARIANT : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "SackboyScavenger_0 Variant";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}
	}
	public class MRRYOSCAVENGER0VARIANT : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "RyoScavenger0 Variant";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}
	}
	public class MRTESTSCAVENGER_0VARIANT : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "TestScavenger_0 Variant";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}
	}
	public class MRREDBEARDSCAVENGER_0VARIANT : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "RedbeardScavenger_0 Variant";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}
	}
	public class MRCVCSCAVENGER_0VARIANT : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "CVCScavenger_0 Variant";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}
	}
	public class MRCARLSCAVENGER_0VARIANT : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "CarlScavenger_0 Variant";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}
	}
	public class MRPETERSCAVENGER_01VARIANT : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "PeterScavenger_0 1 Variant";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}
	}
	public class MRFLOUNDERSCAVENGER_0VARIANT : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "FlounderScavenger_0 Variant";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}
	}
	[BepInPlugin("com.duromkl.modelpack", "DuroModelPack", "0.1.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public static ConfigFile config;

		public static ConfigEntry<bool> enableModelForAllSuits { get; private set; }

		public static ConfigEntry<bool> enableModelAsDefault { get; private set; }

		public static ConfigEntry<string> suitNamesToEnableModel { get; private set; }

		private static void InitConfig()
		{
			enableModelForAllSuits = config.Bind<bool>("Suits to Replace Settings", "Enable Model for all Suits", false, "Enable to model replace every suit. Set to false to specify suits");
			enableModelAsDefault = config.Bind<bool>("Suits to Replace Settings", "Enable Model as default", false, "Enable to model replace every suit that hasn't been otherwise registered.");
			suitNamesToEnableModel = config.Bind<string>("Suits to Replace Settings", "Suits to enable Model for", "Chibi Robo, Green Goblin, Chris Bores, Crocker, Mr. M, Ryo Hazuki, Sackboy, Seymour Skinner, Red Beard, Count von Count, Carl, Spiderman, Atomic Flounder, Test Character", "Enter a comma separated list of suit names.(Additionally, [Green suit,Pajama suit,Hazard suit])");
		}

		private void Awake()
		{
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Expected O, but got Unknown
			config = ((BaseUnityPlugin)this).Config;
			InitConfig();
			Assets.PopulateAssets();
			if (enableModelForAllSuits.Value)
			{
				ModelReplacementAPI.RegisterModelReplacementOverride(typeof(MRCHIBIROBOSCAVENGER_0VARIANT));
			}
			if (enableModelAsDefault.Value)
			{
				ModelReplacementAPI.RegisterModelReplacementDefault(typeof(MRCHIBIROBOSCAVENGER_0VARIANT));
			}
			string[] array = suitNamesToEnableModel.Value.Split(',');
			string[] array2 = array;
			foreach (string text in array2)
			{
				ModelReplacementAPI.RegisterSuitModelReplacement("Chibi Robo", typeof(MRCHIBIROBOSCAVENGER_0VARIANT));
				ModelReplacementAPI.RegisterSuitModelReplacement("Green Goblin", typeof(MRGREENGOBLINSCAVENGER_0VARIANT));
				ModelReplacementAPI.RegisterSuitModelReplacement("Chris Bores", typeof(MRCHRISBORESSCAVENGER_0VARIANT));
				ModelReplacementAPI.RegisterSuitModelReplacement("Ryo Hazuki", typeof(MRRYOSCAVENGER0VARIANT));
				ModelReplacementAPI.RegisterSuitModelReplacement("Mr. M", typeof(MRLKSMSCAVENGER_0VARIANT));
				ModelReplacementAPI.RegisterSuitModelReplacement("Crocker", typeof(MRCROCKERSCAVENGER_0VARIANT));
				ModelReplacementAPI.RegisterSuitModelReplacement("Sackboy", typeof(MRSACKBOYSCAVENGER_0VARIANT));
				ModelReplacementAPI.RegisterSuitModelReplacement("Seymour Skinner", typeof(MRSKINNERSCAVENGER_0VARIANT));
				ModelReplacementAPI.RegisterSuitModelReplacement("Red Beard", typeof(MRREDBEARDSCAVENGER_0VARIANT));
				ModelReplacementAPI.RegisterSuitModelReplacement("Count von Count", typeof(MRCVCSCAVENGER_0VARIANT));
				ModelReplacementAPI.RegisterSuitModelReplacement("Carl", typeof(MRCARLSCAVENGER_0VARIANT));
				ModelReplacementAPI.RegisterSuitModelReplacement("Spiderman", typeof(MRPETERSCAVENGER_01VARIANT));
				ModelReplacementAPI.RegisterSuitModelReplacement("Atomic Flounder", typeof(MRFLOUNDERSCAVENGER_0VARIANT));
				ModelReplacementAPI.RegisterSuitModelReplacement("Test Character", typeof(MRTESTSCAVENGER_0VARIANT));
			}
			Harmony val = new Harmony("com.duromkl.modelpack");
			val.PatchAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin com.duromkl.modelpack is loaded!");
		}
	}
	public static class Assets
	{
		public static string mainAssetBundleName = "templatebundle";

		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)
		{
		}
	}
}