using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using Nekusoul.ShopsOnly;
using Nekusoul.ShopsOnly.Properties;
using On.RoR2;
using RoR2;
using RoR2.ContentManagement;
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: AssemblyCompany("ShopsOnly")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+f9c8d1148948b477534976c0c29f48dc742e1aff")]
[assembly: AssemblyProduct("ShopsOnly")]
[assembly: AssemblyTitle("ShopsOnly")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace NekuSoul.ShopsOnly
{
	[BepInPlugin("de.NekuSoul.ShopsOnly", "ShopsOnly", "3.0.3")]
	public class ShopsOnly : BaseUnityPlugin
	{
		private static readonly string[] ReplacedChoices = new string[8] { "Chest1", "Chest2", "CategoryChestDamage", "CategoryChestHealing", "CategoryChestUtility", "CategoryChest2Damage Variant", "CategoryChest2Healing Variant", "CategoryChest2Utility Variant" };

		private readonly ContentPackProvider _content = new ContentPackProvider();

		private Type _multiShopController;

		private FieldInfo _terminalGameObjectsField;

		private PropertyInfo _networkCostProperty;

		public void Awake()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			_multiShopController = typeof(MultiShopController);
			_terminalGameObjectsField = _multiShopController.GetField("terminalGameObjects", BindingFlags.Instance | BindingFlags.NonPublic);
			_networkCostProperty = _multiShopController.GetProperty("Networkcost", BindingFlags.Instance | BindingFlags.NonPublic);
			MultiShopController.CreateTerminals += new hook_CreateTerminals(MultiShopController_CreateTerminals);
			SceneDirector.GenerateInteractableCardSelection += new hook_GenerateInteractableCardSelection(SceneDirector_GenerateInteractableCardSelection);
			ContentManager.collectContentPackProviders += new CollectContentPackProvidersDelegate(ContentManager_collectContentPackProviders);
		}

		private void ContentManager_collectContentPackProviders(AddContentPackProviderDelegate addContentPackProvider)
		{
			addContentPackProvider.Invoke((IContentPackProvider)(object)_content);
		}

		private void MultiShopController_CreateTerminals(orig_CreateTerminals orig, MultiShopController self)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			if (!RunArtifactManager.instance.IsArtifactEnabled(_content.Artifact))
			{
				orig.Invoke(self);
				return;
			}
			if (self.doEquipmentInstead)
			{
				orig.Invoke(self);
				return;
			}
			Xoroshiro128Plus val = (Xoroshiro128Plus)(_multiShopController.GetField("rng", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(self));
			if (val == null)
			{
				orig.Invoke(self);
				return;
			}
			float num = val.RangeFloat(0f, 1f);
			if (num > 0.975f)
			{
				self.itemTier = (ItemTier)2;
				self.baseCost = 400;
			}
			else if (num > 0.8f)
			{
				self.itemTier = (ItemTier)1;
				self.baseCost = 50;
			}
			else
			{
				self.itemTier = (ItemTier)0;
				self.baseCost = 25;
			}
			int difficultyScaledCost = Run.instance.GetDifficultyScaledCost(self.baseCost);
			_networkCostProperty.SetValue(self, difficultyScaledCost);
			orig.Invoke(self);
			GameObject[] array = (GameObject[])_terminalGameObjectsField.GetValue(self);
			GameObject[] array2 = array;
			foreach (GameObject val2 in array2)
			{
				ShopTerminalBehavior component = val2.GetComponent<ShopTerminalBehavior>();
				component.itemTier = self.itemTier;
				component.dropTable = null;
				PurchaseInteraction component2 = val2.GetComponent<PurchaseInteraction>();
				component2.Networkcost = difficultyScaledCost;
			}
		}

		private WeightedSelection<DirectorCard> SceneDirector_GenerateInteractableCardSelection(orig_GenerateInteractableCardSelection orig, SceneDirector self)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			if (!RunArtifactManager.instance.IsArtifactEnabled(_content.Artifact))
			{
				return orig.Invoke(self);
			}
			WeightedSelection<DirectorCard> val = orig.Invoke(self);
			float num = 0f;
			for (int i = 0; i < val.Count; i++)
			{
				ChoiceInfo<DirectorCard> choice = val.GetChoice(i);
				string name = ((Object)choice.value.spawnCard.prefab).name;
				if (ReplacedChoices.Contains(name))
				{
					num += choice.weight;
					choice.weight = 0f;
					val.ModifyChoiceWeight(i, 0f);
				}
			}
			for (int j = 0; j < val.Count; j++)
			{
				ChoiceInfo<DirectorCard> choice2 = val.GetChoice(j);
				string name2 = ((Object)choice2.value.spawnCard.prefab).name;
				if (!(name2 != "TripleShop"))
				{
					num += choice2.weight;
					choice2.weight += num;
					val.ModifyChoiceWeight(j, choice2.weight);
				}
			}
			return val;
		}
	}
}
namespace Nekusoul.ShopsOnly
{
	internal class ContentPackProvider : IContentPackProvider
	{
		[CompilerGenerated]
		private sealed class <FinalizeAsync>d__16 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public FinalizeAsyncArgs args;

			public ContentPackProvider <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <FinalizeAsync>d__16(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				args.ReportProgress(1f);
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <GenerateContentPackAsync>d__15 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public GetContentPackAsyncArgs args;

			public ContentPackProvider <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GenerateContentPackAsync>d__15(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				<>4__this.Artifact = ScriptableObject.CreateInstance<ArtifactDef>();
				<>4__this.Artifact.nameToken = "Artifact of Options";
				<>4__this.Artifact.descriptionToken = "Regular chests are replaced with Multishop Terminals.";
				<>4__this.Artifact.smallIconDeselectedSprite = <>4__this.DisabledTexture;
				<>4__this.Artifact.smallIconSelectedSprite = <>4__this.EnabledTexture;
				args.output.artifactDefs.Add((ArtifactDef[])(object)new ArtifactDef[1] { <>4__this.Artifact });
				args.ReportProgress(1f);
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <LoadStaticContentAsync>d__14 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LoadStaticContentAsyncArgs args;

			public ContentPackProvider <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <LoadStaticContentAsync>d__14(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.EnabledTexture = LoadSprite(Resources.enabled);
					args.ReportProgress(0.5f);
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>4__this.DisabledTexture = LoadSprite(Resources.disabled);
					args.ReportProgress(1f);
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public string identifier => "de.NekuSoul.ShopsOnly";

		public ArtifactDef Artifact { get; private set; }

		public Sprite EnabledTexture { get; private set; }

		public Sprite DisabledTexture { get; private set; }

		[IteratorStateMachine(typeof(<LoadStaticContentAsync>d__14))]
		public IEnumerator LoadStaticContentAsync(LoadStaticContentAsyncArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadStaticContentAsync>d__14(0)
			{
				<>4__this = this,
				args = args
			};
		}

		[IteratorStateMachine(typeof(<GenerateContentPackAsync>d__15))]
		public IEnumerator GenerateContentPackAsync(GetContentPackAsyncArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GenerateContentPackAsync>d__15(0)
			{
				<>4__this = this,
				args = args
			};
		}

		[IteratorStateMachine(typeof(<FinalizeAsync>d__16))]
		public IEnumerator FinalizeAsync(FinalizeAsyncArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FinalizeAsync>d__16(0)
			{
				<>4__this = this,
				args = args
			};
		}

		private static Sprite LoadSprite(byte[] resourceBytes)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			if (resourceBytes == null)
			{
				throw new ArgumentNullException("resourceBytes");
			}
			Texture2D val = new Texture2D(128, 128, (TextureFormat)4, false);
			ImageConversion.LoadImage(val, resourceBytes, false);
			return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
		}
	}
}
namespace Nekusoul.ShopsOnly.Properties
{
	[GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")]
	[DebuggerNonUserCode]
	[CompilerGenerated]
	internal class Resources
	{
		private static ResourceManager resourceMan;

		private static CultureInfo resourceCulture;

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static ResourceManager ResourceManager
		{
			get
			{
				if (resourceMan == null)
				{
					ResourceManager resourceManager = new ResourceManager("Nekusoul.ShopsOnly.Properties.Resources", typeof(Resources).Assembly);
					resourceMan = resourceManager;
				}
				return resourceMan;
			}
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static CultureInfo Culture
		{
			get
			{
				return resourceCulture;
			}
			set
			{
				resourceCulture = value;
			}
		}

		internal static byte[] disabled
		{
			get
			{
				object @object = ResourceManager.GetObject("disabled", resourceCulture);
				return (byte[])@object;
			}
		}

		internal static byte[] enabled
		{
			get
			{
				object @object = ResourceManager.GetObject("enabled", resourceCulture);
				return (byte[])@object;
			}
		}

		internal Resources()
		{
		}
	}
}