using System;
using System.Diagnostics;
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 HarmonyLib;
using LobbyCompatibility.Attributes;
using LobbyCompatibility.Enums;
using LobbyCompatibility.Features;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
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("KROOOL.ExtendDaysMod")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("ExtendDaysMod")]
[assembly: AssemblyTitle("KROOOL.ExtendDaysMod")]
[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.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;
		}
	}
	[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 ExtendDaysMod
{
	[BepInPlugin("KROOOL.ExtendDaysMod", "ExtendDaysMod", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[LobbyCompatibility(/*Could not decode attribute arguments.*/)]
	public class ExtendDaysMod : BaseUnityPlugin
	{
		private static ConfigEntry<int> _cfgQuotaPerDay;

		private static ConfigEntry<int> _cfgDayExtension;

		private static ConfigEntry<int> _cfgMaxExtraDays;

		internal static ManualLogSource Logger { get; private set; }

		internal static Harmony? Harmony { get; set; }

		internal static int QuotaPerDay => _cfgQuotaPerDay.Value;

		internal static int DayExtension => _cfgDayExtension.Value;

		internal static int MaxExtraDays => _cfgMaxExtraDays.Value;

		private void Awake()
		{
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Expected O, but got Unknown
			Logger = ((BaseUnityPlugin)this).Logger;
			_cfgQuotaPerDay = ((BaseUnityPlugin)this).Config.Bind<int>("ExtendDays", "QuotaPerDay", 200, "Profit required for +1 extra day");
			_cfgDayExtension = ((BaseUnityPlugin)this).Config.Bind<int>("ExtendDays", "DayExtension", 1, "Number of days added per block");
			_cfgMaxExtraDays = ((BaseUnityPlugin)this).Config.Bind<int>("ExtendDays", "MaxExtraDays", 5, "Maximum extra days allowed");
			RegisterWithLethalConfig();
			PluginHelper.RegisterPlugin("KROOOL.ExtendDaysMod", new Version("1.0.0"), (CompatibilityLevel)2, (VersionStrictness)2);
			Harmony = new Harmony("KROOOL.ExtendDaysMod");
			Harmony.PatchAll();
			Logger.LogInfo((object)"KROOOL.ExtendDaysMod v1.0.0 loaded!");
		}

		private void RegisterWithLethalConfig()
		{
			Assembly assembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly a) => a.GetName().Name.Equals("LethalConfig", StringComparison.OrdinalIgnoreCase));
			if (assembly == null)
			{
				return;
			}
			Type type = assembly.GetType("LethalConfig.LethalConfigManager");
			Type sliderType;
			Type sliderOpt;
			MethodInfo addItem;
			if (!(type == null))
			{
				type.GetMethod("RegisterSection", new Type[2]
				{
					typeof(string),
					typeof(string)
				})?.Invoke(null, new object[2] { "ExtendDays", "ExtendDaysMod Settings" });
				sliderType = assembly.GetType("LethalConfig.ConfigItems.IntSliderConfigItem") ?? assembly.GetType("LethalConfig.ConfigItems.FloatSliderConfigItem");
				sliderOpt = assembly.GetType("LethalConfig.ConfigItems.Options.IntSliderOptions") ?? assembly.GetType("LethalConfig.ConfigItems.Options.FloatSliderOptions");
				addItem = type.GetMethod("AddConfigItem", new Type[1] { typeof(object) });
				if (sliderType != null && sliderOpt != null && addItem != null)
				{
					MakeSlider(_cfgQuotaPerDay, 1, 10000, "Profit required for +1 extra day");
					MakeSlider(_cfgDayExtension, 1, 10, "Days added per block of profit");
					MakeSlider(_cfgMaxExtraDays, 0, 20, "Maximum extra days allowed");
				}
			}
			void MakeSlider(ConfigEntry<int> cfg, int min, int max, string desc)
			{
				ConstructorInfo constructor = sliderType.GetConstructor(new Type[2]
				{
					typeof(ConfigEntry<int>),
					sliderOpt
				});
				object obj = Activator.CreateInstance(sliderOpt);
				sliderOpt.GetProperty("Min").SetValue(obj, min);
				sliderOpt.GetProperty("Max").SetValue(obj, max);
				sliderOpt.GetProperty("Description")?.SetValue(obj, desc);
				object obj2 = constructor.Invoke(new object[2] { cfg, obj });
				addItem.Invoke(null, new object[1] { obj2 });
			}
		}

		internal static void Patch()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			if (Harmony == null)
			{
				Harmony = new Harmony("KROOOL.ExtendDaysMod");
			}
			Logger.LogDebug((object)"Patching...");
			Harmony.PatchAll();
			Logger.LogDebug((object)"Finished patching!");
		}

		internal static void Unpatch()
		{
			Logger.LogDebug((object)"Unpatching...");
			Harmony? harmony = Harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			Logger.LogDebug((object)"Finished unpatching!");
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "KROOOL.ExtendDaysMod";

		public const string PLUGIN_NAME = "ExtendDaysMod";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace ExtendDaysMod.Patches
{
	[HarmonyPatch(typeof(TimeOfDay), "SetNewProfitQuota")]
	public static class Patch_SetNewProfitQuota_Extend
	{
		private static void Postfix(TimeOfDay __instance)
		{
			if (((NetworkBehaviour)__instance).IsServer)
			{
				int num = __instance.profitQuota / ExtendDaysMod.QuotaPerDay;
				int num2 = num * ExtendDaysMod.DayExtension;
				num2 = Mathf.Min(num2, ExtendDaysMod.MaxExtraDays);
				float num3 = __instance.quotaVariables.deadlineDaysAmount;
				float num4 = __instance.totalTime / num3;
				float num5 = num4 * (float)num2;
				__instance.timeUntilDeadline += num5;
				__instance.daysUntilDeadline += num2;
				ExtendDaysMod.Logger.LogInfo((object)$"[ExtendDaysMod] (Server) +{num2} days → +{num5:F1}s");
			}
		}
	}
	[HarmonyPatch(typeof(TimeOfDay), "SyncNewProfitQuotaClientRpc")]
	public static class Patch_SyncNewProfit_Extend
	{
		private static void Postfix(TimeOfDay __instance, int newProfitQuota, int overtimeBonus, int fulfilledQuota)
		{
			if (((NetworkBehaviour)__instance).IsClient)
			{
				int num = __instance.profitQuota / ExtendDaysMod.QuotaPerDay;
				int num2 = num * ExtendDaysMod.DayExtension;
				num2 = Mathf.Min(num2, ExtendDaysMod.MaxExtraDays);
				float num3 = __instance.quotaVariables.deadlineDaysAmount;
				float num4 = __instance.totalTime / num3;
				float num5 = num4 * (float)num2;
				__instance.timeUntilDeadline += num5;
				__instance.daysUntilDeadline += num2;
				ExtendDaysMod.Logger.LogInfo((object)$"[ExtendDaysMod] (Client) +{num2} days → +{num5:F1}s");
			}
		}
	}
	[HarmonyPatch(typeof(TimeOfDay), "UpdateProfitQuotaCurrentTime")]
	public static class Patch_UpdateQuotaHUD
	{
		private static void Postfix(TimeOfDay __instance)
		{
			if (((NetworkBehaviour)__instance).IsClient)
			{
				int num = __instance.profitQuota / ExtendDaysMod.QuotaPerDay;
				int num2 = num * ExtendDaysMod.DayExtension;
				num2 = Mathf.Min(num2, ExtendDaysMod.MaxExtraDays);
				__instance.daysUntilDeadline += num2;
			}
		}
	}
}