using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using GameTweaks.Configs;
using GameTweaks.Patches;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using ScheduleOne.DevUtilities;
using ScheduleOne.Employees;
using ScheduleOne.Equipping;
using ScheduleOne.ItemFramework;
using ScheduleOne.NPCs.CharacterClasses;
using ScheduleOne.ObjectScripts;
using ScheduleOne.Trash;
using ScheduleOne.UI.Items;
using ScheduleOne.UI.MainMenu;
using ScheduleOne.Variables;
using TMPro;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("GameTweaks")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Let's you tweak various things about the game")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("GameTweaks")]
[assembly: AssemblyTitle("GameTweaks")]
[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 GameTweaks
{
	public class ConfigGroup
	{
		public void BindConfigs(string section_name)
		{
			PropertyInfo[] properties = GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public);
			PropertyInfo[] array = properties;
			foreach (PropertyInfo propertyInfo in array)
			{
				if (propertyInfo.GetValue(this) is ConfigSettings configSettings)
				{
					configSettings.BindConfig(section_name, propertyInfo.Name);
				}
			}
		}
	}
	public abstract class ConfigSettings
	{
		public string FieldName { get; protected set; }

		public string Description { get; protected set; }

		public abstract void BindConfig(string section, string field_name);
	}
	public class ConfigSettingsBool : ConfigSettings
	{
		public bool Default { get; }

		public ConfigEntry<bool> ConfigEntry { get; set; }

		public ConfigSettingsBool(string field_name, string description, bool defaultValue)
		{
			base.Description = description;
			Default = defaultValue;
			base.FieldName = field_name;
		}

		public override void BindConfig(string section, string field_name)
		{
			ConfigEntry = ((BaseUnityPlugin)Plugin.instance).Config.Bind<bool>(section, field_name, Default, base.Description);
		}
	}
	public class ConfigSettingsInt : ConfigSettings
	{
		public int Default { get; }

		public ConfigEntry<int> ConfigEntry { get; set; }

		public ConfigSettingsInt(string field_name, string description, int defaultValue)
		{
			base.Description = description;
			Default = defaultValue;
			base.FieldName = field_name;
		}

		public override void BindConfig(string section, string field_name)
		{
			ConfigEntry = ((BaseUnityPlugin)Plugin.instance).Config.Bind<int>(section, field_name, Default, base.Description);
		}
	}
	public class ConfigSettingsFloat : ConfigSettings
	{
		public float Default { get; }

		public ConfigEntry<float> ConfigEntry { get; set; }

		public ConfigSettingsFloat(string field_name, string description, float defaultValue)
		{
			base.Description = description;
			Default = defaultValue;
			base.FieldName = field_name;
		}

		public override void BindConfig(string section, string field_name)
		{
			ConfigEntry = ((BaseUnityPlugin)Plugin.instance).Config.Bind<float>(section, field_name, Default, base.Description);
		}
	}
	[BepInPlugin("GameTweaks", "GameTweaks", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		public static Plugin instance;

		public GeneralConfig GeneralConfig = new GeneralConfig();

		public TrashConfig TrashConfig = new TrashConfig();

		public MachineConfig MachineConfig = new MachineConfig();

		public BotanistConfig BotanistConfig = new BotanistConfig();

		public ChemistConfig ChemistConfig = new ChemistConfig();

		public CleanerConfig CleanerConfig = new CleanerConfig();

		public PackagerConfig PackagerConfig = new PackagerConfig();

		private void Awake()
		{
			instance = this;
			GeneralConfig.BindConfigs("General Configuration");
			TrashConfig.BindConfigs("Trash Configuration");
			MachineConfig.BindConfigs("Machine Configuration");
			BotanistConfig.BindConfigs("Botanist Configuration");
			ChemistConfig.BindConfigs("Chemist Configuration");
			CleanerConfig.BindConfigs("Cleaner Configuration");
			PackagerConfig.BindConfigs("Packager Configuration");
			Harmony.CreateAndPatchAll(typeof(GeneralTweaks), (string)null);
			Harmony.CreateAndPatchAll(typeof(MachineTweaks), (string)null);
			Harmony.CreateAndPatchAll(typeof(DealerTweaks), (string)null);
			Harmony.CreateAndPatchAll(typeof(NPCTweaks), (string)null);
			Harmony.CreateAndPatchAll(typeof(ItemTweaks), (string)null);
		}

		public void HandleFieldUpdate(object __instance, ConfigSettings setting)
		{
			FieldInfo field = __instance.GetType().GetField(setting.FieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field == null)
			{
				Debug.LogError((object)$"GameTweaks] FIELD NOT FOUND: {field}");
			}
			else if (setting is ConfigSettingsInt)
			{
				int value = (setting as ConfigSettingsInt).ConfigEntry.Value;
				field.SetValue(__instance, value);
			}
			else if (setting is ConfigSettingsFloat)
			{
				float value2 = (setting as ConfigSettingsFloat).ConfigEntry.Value;
				field.SetValue(__instance, value2);
			}
			else
			{
				Debug.LogError((object)"GameTweaks] VALUE NOT FOUND");
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "GameTweaks";

		public const string PLUGIN_NAME = "GameTweaks";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace GameTweaks.Patches
{
	internal class DealerTweaks
	{
	}
	internal class GeneralTweaks
	{
		[HarmonyPatch(typeof(Disclaimer), "Awake")]
		[HarmonyPrefix]
		public static void Pre_DisclaimerAwake(Disclaimer __instance)
		{
			if (Plugin.instance.GeneralConfig.SkipIntroDisclaimer.ConfigEntry.Value)
			{
				__instance.Duration = 0f;
			}
		}
	}
	internal class ItemTweaks
	{
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		public static void Post_ItemInstanceStackLimit(ItemInstance __instance, ref int __result)
		{
			if (Plugin.instance.GeneralConfig.EnableStackSizeOverride.ConfigEntry.Value)
			{
				__result = Plugin.instance.GeneralConfig.ItemStackSizeOverride.ConfigEntry.Value;
			}
		}

		[HarmonyPatch(typeof(TrashItem), "Interacted")]
		[HarmonyPrefix]
		public static bool Pre_TrashItemInteracted(TrashItem __instance)
		{
			if (Equippable_TrashGrabber.IsEquipped && __instance.CanGoInContainer)
			{
				if (Plugin.instance.TrashConfig.TrashGrabberVoidTrash.ConfigEntry.Value)
				{
					Equippable_TrashGrabber.Instance.GrabAnim.Play();
					__instance.DestroyTrash();
					return false;
				}
				if (Plugin.instance.TrashConfig.TrashGrabberAllowOverfill.ConfigEntry.Value)
				{
					Equippable_TrashGrabber.Instance.PickupTrash(__instance);
					return false;
				}
			}
			return true;
		}

		[HarmonyPatch(typeof(Equippable_TrashGrabber), "GetCapacity")]
		[HarmonyPostfix]
		public static void Post_TrashGrabberGetCapacity(Equippable_TrashGrabber __instance, ref int __result)
		{
			__result = Plugin.instance.TrashConfig.TrashGrabberCapacity.ConfigEntry.Value;
			if (!Plugin.instance.TrashConfig.TrashGrabberAllowOverfill.ConfigEntry.Value)
			{
				__result -= __instance.trashGrabberInstance.GetTotalSize();
			}
		}

		[HarmonyPatch(typeof(TrashGrabberItemUI), "UpdateUI")]
		[HarmonyPrefix]
		public static bool Pre_TrashGrabberUpdateUI(TrashGrabberItemUI __instance)
		{
			if (((ItemUI)__instance).Destroyed)
			{
				return false;
			}
			((TMP_Text)__instance.ValueLabel).text = Mathf.FloorToInt(Mathf.Clamp01((float)__instance.trashGrabberInstance.GetTotalSize() / (float)Plugin.instance.TrashConfig.TrashGrabberCapacity.ConfigEntry.Value) * 100f) + "%";
			((ItemUI)__instance).IconImg.sprite = ((ItemUI)__instance).itemInstance.Icon;
			((ItemUI)__instance).SetDisplayedQuantity(((ItemUI)__instance).itemInstance.Quantity);
			return false;
		}
	}
	internal class MachineTweaks
	{
		[HarmonyPatch(typeof(MixingStation), "Awake")]
		[HarmonyPrefix]
		public static void Pre_MixingStationAwake(MixingStation __instance)
		{
			if (Plugin.instance.GeneralConfig.EnableStackSizeOverride.ConfigEntry.Value)
			{
				__instance.MaxMixQuantity = Plugin.instance.GeneralConfig.ItemStackSizeOverride.ConfigEntry.Value;
			}
			__instance.MixTimePerItem = Plugin.instance.MachineConfig.MixingStationMixTimePerItem.ConfigEntry.Value;
		}

		[HarmonyPatch(typeof(DryingRack), "Awake")]
		[HarmonyPrefix]
		public static void Pre_DryingRackAwake(DryingRack __instance)
		{
			if (Plugin.instance.GeneralConfig.EnableStackSizeOverride.ConfigEntry.Value)
			{
				__instance.ItemCapacity = Plugin.instance.GeneralConfig.ItemStackSizeOverride.ConfigEntry.Value;
			}
		}
	}
	internal class NPCTweaks
	{
		[HarmonyPatch(typeof(Fixer), "GetAdditionalSigningFee")]
		[HarmonyPrefix]
		public static bool Pre_FixerGetAdditionalSigningFee(Fixer __instance, ref float __result)
		{
			int num = Mathf.RoundToInt(NetworkSingleton<VariableDatabase>.Instance.GetValue<float>("LifetimeEmployeesRecruited"));
			float num2 = ((num <= 5) ? ((float)num * 100f) : (500f + (float)(num - 5) * 250f));
			__result = Mathf.Min(num2, Plugin.instance.GeneralConfig.MaxFixerAdditionalSigningFee.ConfigEntry.Value);
			return false;
		}

		[HarmonyPatch(typeof(EmployeeManager), "Awake")]
		[HarmonyPrefix]
		public static void Pre_EmployeeManagerAwake(EmployeeManager __instance)
		{
			((Employee)__instance.BotanistPrefab).SigningFee = Plugin.instance.BotanistConfig.SigningFee.ConfigEntry.Value;
			((Employee)__instance.BotanistPrefab).DailyWage = Plugin.instance.BotanistConfig.DailyWage.ConfigEntry.Value;
			((Employee)__instance.ChemistPrefab).SigningFee = Plugin.instance.ChemistConfig.SigningFee.ConfigEntry.Value;
			((Employee)__instance.ChemistPrefab).DailyWage = Plugin.instance.ChemistConfig.DailyWage.ConfigEntry.Value;
			((Employee)__instance.CleanerPrefab).SigningFee = Plugin.instance.CleanerConfig.SigningFee.ConfigEntry.Value;
			((Employee)__instance.CleanerPrefab).DailyWage = Plugin.instance.CleanerConfig.DailyWage.ConfigEntry.Value;
			((Employee)__instance.PackagerPrefab).SigningFee = Plugin.instance.PackagerConfig.SigningFee.ConfigEntry.Value;
			((Employee)__instance.PackagerPrefab).DailyWage = Plugin.instance.PackagerConfig.DailyWage.ConfigEntry.Value;
		}

		[HarmonyPatch(typeof(Botanist), "AssignProperty")]
		[HarmonyPostfix]
		public static void Post_BotanistAssignProperty(Botanist __instance)
		{
			PropertyInfo[] properties = typeof(BotanistConfig).GetProperties(BindingFlags.Instance | BindingFlags.Public);
			PropertyInfo[] array = properties;
			foreach (PropertyInfo propertyInfo in array)
			{
				if (propertyInfo.GetValue(Plugin.instance.BotanistConfig) is ConfigSettings setting)
				{
					Plugin.instance.HandleFieldUpdate(__instance, setting);
				}
			}
		}

		[HarmonyPatch(typeof(Chemist), "AssignProperty")]
		[HarmonyPostfix]
		public static void Post_ChemistAssignProperty(Chemist __instance)
		{
			PropertyInfo[] properties = typeof(ChemistConfig).GetProperties(BindingFlags.Instance | BindingFlags.Public);
			PropertyInfo[] array = properties;
			foreach (PropertyInfo propertyInfo in array)
			{
				if (propertyInfo.GetValue(Plugin.instance.ChemistConfig) is ConfigSettings configSettings)
				{
					if (configSettings.FieldName == "MAX_ASSIGNED_STATIONS")
					{
						int value = (configSettings as ConfigSettingsInt).ConfigEntry.Value;
						Debug.LogError((object)$"Update Field {configSettings.FieldName} set to value {value}");
						__instance.configuration.Stations.MaxItems = value;
					}
					else
					{
						Plugin.instance.HandleFieldUpdate(__instance, configSettings);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Cleaner), "AssignProperty")]
		[HarmonyPostfix]
		public static void Post_CleanerAssignProperty(Cleaner __instance)
		{
			PropertyInfo[] properties = typeof(CleanerConfig).GetProperties(BindingFlags.Instance | BindingFlags.Public);
			PropertyInfo[] array = properties;
			foreach (PropertyInfo propertyInfo in array)
			{
				if (propertyInfo.GetValue(Plugin.instance.CleanerConfig) is ConfigSettings configSettings)
				{
					if (configSettings.FieldName == "MAX_ASSIGNED_BINS")
					{
						int value = (configSettings as ConfigSettingsInt).ConfigEntry.Value;
						__instance.configuration.Bins.MaxItems = value;
					}
					else
					{
						Plugin.instance.HandleFieldUpdate(__instance, configSettings);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Packager), "AssignProperty")]
		[HarmonyPostfix]
		public static void Post_PackagerAssignProperty(Packager __instance)
		{
			PropertyInfo[] properties = typeof(PackagerConfig).GetProperties(BindingFlags.Instance | BindingFlags.Public);
			PropertyInfo[] array = properties;
			foreach (PropertyInfo propertyInfo in array)
			{
				if (propertyInfo.GetValue(Plugin.instance.PackagerConfig) is ConfigSettings setting)
				{
					Plugin.instance.HandleFieldUpdate(__instance, setting);
				}
			}
		}
	}
}
namespace GameTweaks.Configs
{
	public class BotanistConfig : ConfigGroup
	{
		public ConfigSettingsFloat SigningFee { get; private set; } = new ConfigSettingsFloat("SigningFee", "How much it costs to hire a Botanist", 1000f);


		public ConfigSettingsFloat DailyWage { get; private set; } = new ConfigSettingsFloat("DailyWage", "The daily wage of a Botanist", 200f);


		public ConfigSettingsInt MaxAssignedPots { get; private set; } = new ConfigSettingsInt("MaxAssignedPots", "Max amount of pots that can be assigned to the Botanist", 8);


		public ConfigSettingsFloat HarvestTime { get; private set; } = new ConfigSettingsFloat("HARVEST_TIME", "Amount of time it takes the Botanist to harvest", 15f);


		public ConfigSettingsFloat SeedSowTime { get; private set; } = new ConfigSettingsFloat("SEED_SOW_TIME", "Amount of time it takes the Botanist to sow a seed", 15f);


		public ConfigSettingsFloat AdditivePourTime { get; private set; } = new ConfigSettingsFloat("ADDITIVE_POUR_TIME", "Amount of time it takes the Botanist to sow a seed", 10f);


		public ConfigSettingsFloat WaterPourTime { get; private set; } = new ConfigSettingsFloat("WATER_POUR_TIME", "Amount of time it takes the Botanist to pour water", 10f);


		public ConfigSettingsFloat SoilPourTime { get; private set; } = new ConfigSettingsFloat("SOIL_POUR_TIME", "Amount of time it takes the Botanist to pour soil", 10f);


		public ConfigSettingsFloat TargetWaterLevelMax { get; private set; } = new ConfigSettingsFloat("TARGET_WATER_LEVEL_MAX", "Max water level a Botanist can fill a pot to", 1f);


		public ConfigSettingsFloat TargetWaterLevelMin { get; private set; } = new ConfigSettingsFloat("TARGET_WATER_LEVEL_MIN", "Minimum water level a Botanist can fill a pot to", 0.75f);


		public ConfigSettingsFloat WateringThreshold { get; private set; } = new ConfigSettingsFloat("WATERING_THRESHOLD", "Pots with water below this amount will be watered bythe  Botanist", 0.3f);


		public ConfigSettingsFloat CriticalWateringThreshold { get; private set; } = new ConfigSettingsFloat("CRITICAL_WATERING_THRESHOLD", "Pots with water below this amount will be prioritized by the Botanist", 0.1f);

	}
	public class ChemistConfig : ConfigGroup
	{
		public ConfigSettingsFloat SigningFee { get; private set; } = new ConfigSettingsFloat("SigningFee", "How much it costs to hire a Chemist", 1500f);


		public ConfigSettingsFloat DailyWage { get; private set; } = new ConfigSettingsFloat("DailyWage", "The daily wage of a Chemist", 300f);


		public ConfigSettingsInt MaxAssignedStations { get; private set; } = new ConfigSettingsInt("MAX_ASSIGNED_STATIONS", "Max amount of stations the Chemist can be assigned to", 4);

	}
	public class CleanerConfig : ConfigGroup
	{
		public ConfigSettingsFloat SigningFee { get; private set; } = new ConfigSettingsFloat("SigningFee", "How much it costs to hire a Cleaner", 500f);


		public ConfigSettingsFloat DailyWage { get; private set; } = new ConfigSettingsFloat("DailyWage", "The daily wage of a Cleaner", 100f);


		public ConfigSettingsInt MaxAssignedBins { get; private set; } = new ConfigSettingsInt("MAX_ASSIGNED_BINS", "Max amount of bins the Cleaner can be assigned to", 3);

	}
	public class GeneralConfig : ConfigGroup
	{
		public ConfigSettingsBool SkipIntroDisclaimer { get; private set; } = new ConfigSettingsBool("SkipIntroDisclaimer", "Skip the intro when the game starts", defaultValue: false);


		public ConfigSettingsBool EnableStackSizeOverride { get; private set; } = new ConfigSettingsBool("EnableStackSizeOverride", "Allows you to enable the ItemStackSizeOverride config option", defaultValue: false);


		public ConfigSettingsInt ItemStackSizeOverride { get; private set; } = new ConfigSettingsInt("ItemStackSizeOverride", "Sets the stack size of all items to this value if EnableStackSizeOverride is true", 60);


		public ConfigSettingsFloat MaxFixerAdditionalSigningFee { get; private set; } = new ConfigSettingsFloat("MaxFixerAdditionalSigningFee", "Sets the max amount the Fixer will charge based on how many employees have been hired", 500f);

	}
	public class MachineConfig : ConfigGroup
	{
		public ConfigSettingsInt MixingStationMixTimePerItem { get; private set; } = new ConfigSettingsInt("ItemStackSizeOverride", "Time it takes to mix per item", 15);

	}
	public class PackagerConfig : ConfigGroup
	{
		public ConfigSettingsFloat SigningFee { get; private set; } = new ConfigSettingsFloat("SigningFee", "How much it costs to hire a Packager", 100f);


		public ConfigSettingsFloat DailyWage { get; private set; } = new ConfigSettingsFloat("DailyWage", "The daily wage of a Packager", 200f);


		public ConfigSettingsInt MaxAssignedStations { get; private set; } = new ConfigSettingsInt("MaxAssignedStations", "Max amount of stations that can be assigned to the Packager", 3);


		public ConfigSettingsFloat PackagingSpeedMultiplier { get; private set; } = new ConfigSettingsFloat("PackagingSpeedMultiplier", "How fast the packager packages product", 1f);

	}
	public class TrashConfig : ConfigGroup
	{
		public ConfigSettingsBool TrashGrabberVoidTrash { get; private set; } = new ConfigSettingsBool("TrashGrabberVoidTrash", "Instantly destroys trash added to trash grabber", defaultValue: false);


		public ConfigSettingsBool TrashGrabberAllowOverfill { get; private set; } = new ConfigSettingsBool("TrashGrabberAllowOverfill", "Allows the trash grabber to pick up trash even if it's full", defaultValue: false);


		public ConfigSettingsInt TrashGrabberCapacity { get; private set; } = new ConfigSettingsInt("TrashGrabberCapacity", "How much trash the trash grabber can hold.", 20);


		public ConfigSettingsBool TrashcanVoidTrash { get; private set; } = new ConfigSettingsBool("TrashcanVoidTrash", "Instantly destroys trash added to trash grabber", defaultValue: false);


		public ConfigSettingsBool TrashcanAllowOverfill { get; private set; } = new ConfigSettingsBool("TrashcanAllowOverfill", "Allows the trash grabber to pick up trash even if it's full", defaultValue: false);


		public ConfigSettingsInt TrashcanCapacity { get; private set; } = new ConfigSettingsInt("TrashcanCapacity", "How much trash the trash grabber can hold.", 10);


		public ConfigSettingsFloat TrashcanEffectiveRange { get; private set; } = new ConfigSettingsFloat("TrashcanEffectiveRange", "How much trash the trash grabber can hold.", 5f);

	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}