using System;
using System.Collections.Generic;
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 BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using OniroDev.Patches;
using Unity.Collections;
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("WeedKillerAdjuster")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("WeedKiller Adjuster - Ported to v81")]
[assembly: AssemblyFileVersion("2.0.0.0")]
[assembly: AssemblyInformationalVersion("2.0.0")]
[assembly: AssemblyProduct("WeedKillerAdjuster")]
[assembly: AssemblyTitle("WeedKillerAdjuster")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.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 OniroDev
{
	[BepInPlugin("OniroDev.WeedKillerAdjuster", "WeedKillerAdjuster", "2.0.0")]
	public class WeedKillerAdjusterBase : BaseUnityPlugin
	{
		private readonly Harmony _harmony = new Harmony("OniroDev.WeedKillerAdjuster");

		public static WeedKillerAdjusterBase Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
			WeedKillerAdjusterLogger.Initialize("OniroDev.WeedKillerAdjuster");
			WeedKillerAdjusterLogger.Log("WeedKillerAdjuster starting up (OniroDev.WeedKillerAdjuster)");
			new WeedKillerConfig(((BaseUnityPlugin)this).Config);
			WeedKillerAdjusterLogger.Log("Applying patches...");
			_harmony.PatchAll(typeof(WeedKillerPatch));
			_harmony.PatchAll(typeof(WeedKillerConfig));
			WeedKillerAdjusterLogger.Log("Patches applied successfully.");
		}
	}
	internal static class PluginInfo
	{
		internal const string PLUGIN_GUID = "OniroDev.WeedKillerAdjuster";

		internal const string PLUGIN_NAME = "WeedKillerAdjuster";

		internal const string PLUGIN_VERSION = "2.0.0";
	}
	public static class WeedKillerAdjusterLogger
	{
		private static ManualLogSource _logSource;

		public static void Initialize(string pluginGUID)
		{
			_logSource = Logger.CreateLogSource(pluginGUID);
		}

		public static void Log(object message)
		{
			ManualLogSource logSource = _logSource;
			if (logSource != null)
			{
				logSource.LogInfo(message);
			}
		}

		public static void LogWarning(object message)
		{
			ManualLogSource logSource = _logSource;
			if (logSource != null)
			{
				logSource.LogWarning(message);
			}
		}

		public static void LogError(object message)
		{
			ManualLogSource logSource = _logSource;
			if (logSource != null)
			{
				logSource.LogError(message);
			}
		}
	}
	public class WeedKillerConfig
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static HandleNamedMessageDelegate <0>__OnRequestSync;

			public static HandleNamedMessageDelegate <1>__OnReceiveSync;
		}

		public static ConfigEntry<float> weedKillRate;

		public static ConfigEntry<float> weedKillTank;

		public static ConfigEntry<bool> usesBattery;

		private static WeedKillerConfig _default;

		private static WeedKillerConfig _synced;

		private float _killRate;

		private float _killTank;

		private bool _battery;

		public static bool IsSynced { get; private set; }

		private static CustomMessagingManager MessageManager => NetworkManager.Singleton.CustomMessagingManager;

		private static bool IsHost => NetworkManager.Singleton.IsHost;

		private static bool IsClient => NetworkManager.Singleton.IsClient;

		public WeedKillerConfig(ConfigFile configFile)
		{
			configFile.SaveOnConfigSet = false;
			weedKillRate = configFile.Bind<float>("Weed Killer Settings", "Vain Shroud Kill Rate", 1f, "Multiplier for kill rate of Vain Shrouds. Set to 7 to kill them 7x faster than normal.");
			weedKillTank = configFile.Bind<float>("Weed Killer Settings", "Weed Killer Base Fuel Tank", 1f, "Multiplier for fuel tank capacity. Set to 7 for 7x more spray fuel.");
			usesBattery = configFile.Bind<bool>("Weed Killer Settings", "Use Battery Charges", false, "When true, the weed killer uses battery charges and can be recharged on the ship. When enabled, the Fuel Tank multiplier is ignored.");
			ClearOrphanedEntries(configFile);
			configFile.Save();
			configFile.SaveOnConfigSet = true;
			_default = this;
			_synced = this;
			SnapshotFromConfig();
			WeedKillerAdjusterLogger.Log($"Config loaded — killRate={weedKillRate.Value}, killTank={weedKillTank.Value}, battery={usesBattery.Value}");
		}

		private void SnapshotFromConfig()
		{
			_killRate = weedKillRate.Value;
			_killTank = weedKillTank.Value;
			_battery = usesBattery.Value;
		}

		private static byte[] Serialize(WeedKillerConfig cfg)
		{
			byte[] array = new byte[9];
			Buffer.BlockCopy(BitConverter.GetBytes(cfg._killRate), 0, array, 0, 4);
			Buffer.BlockCopy(BitConverter.GetBytes(cfg._killTank), 0, array, 4, 4);
			array[8] = (byte)(cfg._battery ? 1 : 0);
			return array;
		}

		private static WeedKillerConfig Deserialize(byte[] data)
		{
			return new WeedKillerConfig
			{
				_killRate = BitConverter.ToSingle(data, 0),
				_killTank = BitConverter.ToSingle(data, 4),
				_battery = (data[8] != 0)
			};
		}

		private WeedKillerConfig()
		{
		}

		private static void ApplySynced(WeedKillerConfig cfg)
		{
			weedKillRate.Value = cfg._killRate;
			weedKillTank.Value = cfg._killTank;
			usesBattery.Value = cfg._battery;
			_synced = cfg;
			IsSynced = true;
			WeedKillerAdjusterLogger.Log("Config synced from host.");
		}

		private static void RevertSync()
		{
			if (_default != null)
			{
				weedKillRate.Value = _default._killRate;
				weedKillTank.Value = _default._killTank;
				usesBattery.Value = _default._battery;
				_synced = _default;
				IsSynced = false;
				WeedKillerAdjusterLogger.Log("Config reverted to local defaults.");
			}
		}

		public static void RequestSync()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (!IsClient)
			{
				return;
			}
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(0, (Allocator)2, -1);
			try
			{
				MessageManager.SendNamedMessage("OniroDev.WeedKillerAdjuster_OnRequestConfigSync", 0uL, val, (NetworkDelivery)3);
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val)).Dispose();
			}
		}

		public static void OnRequestSync(ulong clientId, FastBufferReader _)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: 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)
			if (!IsHost)
			{
				return;
			}
			WeedKillerAdjusterLogger.Log($"Config sync request from client {clientId}");
			byte[] array = Serialize(_default);
			int num = array.Length;
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(num + 4, (Allocator)2, -1);
			try
			{
				((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref num, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteBytesSafe(array, -1, 0);
				MessageManager.SendNamedMessage("OniroDev.WeedKillerAdjuster_OnReceiveConfigSync", clientId, val, (NetworkDelivery)3);
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val)).Dispose();
			}
		}

		public static void OnReceiveSync(ulong _, FastBufferReader reader)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (!((FastBufferReader)(ref reader)).TryBeginRead(4))
			{
				WeedKillerAdjusterLogger.LogError("Config sync error: could not read length.");
				return;
			}
			int num = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
			if (!((FastBufferReader)(ref reader)).TryBeginRead(num))
			{
				WeedKillerAdjusterLogger.LogError("Config sync error: could not read payload.");
				return;
			}
			byte[] data = new byte[num];
			((FastBufferReader)(ref reader)).ReadBytesSafe(ref data, num, 0);
			try
			{
				ApplySynced(Deserialize(data));
			}
			catch (Exception arg)
			{
				WeedKillerAdjusterLogger.LogError($"Config sync deserialization failed: {arg}");
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
		public static void InitializeLocalPlayer()
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			if (IsHost)
			{
				CustomMessagingManager messageManager = MessageManager;
				object obj = <>O.<0>__OnRequestSync;
				if (obj == null)
				{
					HandleNamedMessageDelegate val = OnRequestSync;
					<>O.<0>__OnRequestSync = val;
					obj = (object)val;
				}
				messageManager.RegisterNamedMessageHandler("OniroDev.WeedKillerAdjuster_OnRequestConfigSync", (HandleNamedMessageDelegate)obj);
				IsSynced = true;
				return;
			}
			IsSynced = false;
			CustomMessagingManager messageManager2 = MessageManager;
			object obj2 = <>O.<1>__OnReceiveSync;
			if (obj2 == null)
			{
				HandleNamedMessageDelegate val2 = OnReceiveSync;
				<>O.<1>__OnReceiveSync = val2;
				obj2 = (object)val2;
			}
			messageManager2.RegisterNamedMessageHandler("OniroDev.WeedKillerAdjuster_OnReceiveConfigSync", (HandleNamedMessageDelegate)obj2);
			RequestSync();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(GameNetworkManager), "StartDisconnect")]
		public static void PlayerLeave()
		{
			RevertSync();
		}

		private static void ClearOrphanedEntries(ConfigFile configFile)
		{
			if (AccessTools.Property(typeof(ConfigFile), "OrphanedEntries")?.GetValue(configFile) is Dictionary<ConfigDefinition, string> dictionary)
			{
				dictionary.Clear();
			}
		}
	}
}
namespace OniroDev.Patches
{
	public class WeedKillerPatch
	{
		private static readonly FieldRef<SprayPaintItem, float> _sprayCanTankRef = AccessTools.FieldRefAccess<SprayPaintItem, float>("sprayCanTank");

		private static readonly FieldRef<SprayPaintItem, float> _killWeedSpeedRef = TryGetKillWeedSpeedRef();

		private static readonly FieldRef<SprayPaintItem, bool> _isSprayingRef = AccessTools.FieldRefAccess<SprayPaintItem, bool>("isSpraying");

		private static readonly Dictionary<SprayPaintItem, float> _tempCanTank = new Dictionary<SprayPaintItem, float>();

		private static FieldRef<SprayPaintItem, float> TryGetKillWeedSpeedRef()
		{
			FieldInfo fieldInfo = AccessTools.Field(typeof(SprayPaintItem), "killWeedSpeed");
			if (fieldInfo == null)
			{
				WeedKillerAdjusterLogger.LogWarning("SprayPaintItem.killWeedSpeed not found in this game version. weedKillRate multiplier will be applied to drain rate instead.");
				return null;
			}
			return AccessTools.FieldRefAccess<SprayPaintItem, float>(fieldInfo);
		}

		[HarmonyPatch(typeof(SprayPaintItem), "Start")]
		[HarmonyPostfix]
		public static void WeedKillerKillRatePatch(SprayPaintItem __instance)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			if (_killWeedSpeedRef != null)
			{
				float num = _killWeedSpeedRef.Invoke(__instance) * WeedKillerConfig.weedKillRate.Value;
				_killWeedSpeedRef.Invoke(__instance) = num;
				WeedKillerAdjusterLogger.Log($"killWeedSpeed scaled to {num} (x{WeedKillerConfig.weedKillRate.Value})");
			}
			if (__instance.isWeedKillerSprayBottle && WeedKillerConfig.usesBattery.Value)
			{
				((GrabbableObject)__instance).insertedBattery = new Battery(false, _sprayCanTankRef.Invoke(__instance));
				((GrabbableObject)__instance).itemProperties.requiresBattery = true;
				WeedKillerAdjusterLogger.Log("Weed killer battery mode enabled.");
			}
		}

		[HarmonyPatch(typeof(GrabbableObject), "ChargeBatteries")]
		[HarmonyPrefix]
		private static void WeedKillerChargeBatteries(GrabbableObject __instance)
		{
			SprayPaintItem val = (SprayPaintItem)(object)((__instance is SprayPaintItem) ? __instance : null);
			if (val != null && val.isWeedKillerSprayBottle && WeedKillerConfig.usesBattery.Value)
			{
				_sprayCanTankRef.Invoke(val) = ((GrabbableObject)val).insertedBattery.charge;
			}
		}

		[HarmonyPatch(typeof(SprayPaintItem), "LateUpdate")]
		[HarmonyPrefix]
		private static void PreWeedKillerLateUpdate(SprayPaintItem __instance)
		{
			_tempCanTank[__instance] = _sprayCanTankRef.Invoke(__instance);
		}

		[HarmonyPatch(typeof(SprayPaintItem), "LateUpdate")]
		[HarmonyPostfix]
		private static void PostWeedKillerLateUpdate(SprayPaintItem __instance)
		{
			if (!__instance.isWeedKillerSprayBottle)
			{
				return;
			}
			bool flag = _isSprayingRef.Invoke(__instance);
			if (((GrabbableObject)__instance).isHeld && flag)
			{
				if (_killWeedSpeedRef != null)
				{
					if (!_tempCanTank.TryGetValue(__instance, out var value))
					{
						return;
					}
					float num = Mathf.Max(value - Time.deltaTime / (15f * WeedKillerConfig.weedKillTank.Value), 0f);
					_sprayCanTankRef.Invoke(__instance) = num;
				}
				else
				{
					float num2 = _sprayCanTankRef.Invoke(__instance);
					float num3 = Time.deltaTime * (WeedKillerConfig.weedKillRate.Value - 1f) / (15f * WeedKillerConfig.weedKillTank.Value);
					_sprayCanTankRef.Invoke(__instance) = Mathf.Max(num2 - num3, 0f);
				}
			}
			if (WeedKillerConfig.usesBattery.Value)
			{
				((GrabbableObject)__instance).insertedBattery.charge = _sprayCanTankRef.Invoke(__instance);
			}
		}

		[HarmonyPatch(typeof(SprayPaintItem), "OnDestroy")]
		[HarmonyPostfix]
		private static void WeedKillerOnDestroy(SprayPaintItem __instance)
		{
			_tempCanTank.Remove(__instance);
		}
	}
}