using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("PlanetwideAmmoSupply")]
[assembly: AssemblyDescription("Dyson Sphere Program BepInEx mod.")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("PlanetwideAmmoSupply")]
[assembly: AssemblyCopyright("Copyright (c) 2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("00000000-0000-0000-0000-000000000000")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = "")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace PlanetwideAmmoSupply;

internal static class AmmoSourcing
{
	private struct StationDist
	{
		public int index;

		public float distSqr;
	}

	private static readonly List<StationDist> _scratch = new List<StationDist>(64);

	private static readonly Comparison<StationDist> _byDist = (StationDist a, StationDist b) => a.distSqr.CompareTo(b.distSqr);

	internal static int TryPullFromPlanet(PlanetFactory factory, int itemId, int want, Vector3 pos, float radius, out int incMoved)
	{
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01da: Unknown result type (might be due to invalid IL or missing references)
		//IL_01db: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
		incMoved = 0;
		if (factory == null || itemId <= 0 || want <= 0)
		{
			return 0;
		}
		PlanetTransport transport = factory.transport;
		if (transport == null || transport.stationPool == null)
		{
			return 0;
		}
		bool value = Plugin.RequireStationSupplyFlag.Value;
		bool value2 = Plugin.NearestStationFirst.Value;
		float num = ((radius > 0f) ? (radius * radius) : 0f);
		EntityData[] entityPool = factory.entityPool;
		int stationCursor = transport.stationCursor;
		int moved = 0;
		Vector3 val2;
		if (value2)
		{
			_scratch.Clear();
			for (int i = 1; i < stationCursor; i++)
			{
				StationComponent val = transport.stationPool[i];
				if (val == null || val.id != i || val.storage == null)
				{
					continue;
				}
				float num2 = 0f;
				if (entityPool != null)
				{
					int entityId = val.entityId;
					if (entityId > 0 && entityId < entityPool.Length)
					{
						val2 = entityPool[entityId].pos - pos;
						num2 = ((Vector3)(ref val2)).sqrMagnitude;
						if (num > 0f && num2 > num)
						{
							continue;
						}
					}
				}
				if (StationHasItem(val, itemId, value))
				{
					_scratch.Add(new StationDist
					{
						index = i,
						distSqr = num2
					});
				}
			}
			_scratch.Sort(_byDist);
			for (int j = 0; j < _scratch.Count; j++)
			{
				if (moved >= want)
				{
					break;
				}
				DrainStation(transport.stationPool[_scratch[j].index], itemId, want, value, ref moved, ref incMoved);
			}
		}
		else
		{
			for (int k = 1; k < stationCursor && moved < want; k++)
			{
				StationComponent val3 = transport.stationPool[k];
				if (val3 == null || val3.id != k || val3.storage == null)
				{
					continue;
				}
				if (num > 0f && entityPool != null)
				{
					int entityId2 = val3.entityId;
					if (entityId2 > 0 && entityId2 < entityPool.Length)
					{
						val2 = entityPool[entityId2].pos - pos;
						if (((Vector3)(ref val2)).sqrMagnitude > num)
						{
							continue;
						}
					}
				}
				DrainStation(val3, itemId, want, value, ref moved, ref incMoved);
			}
		}
		return moved;
	}

	private static bool StationHasItem(StationComponent station, int itemId, bool requireSupply)
	{
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Invalid comparison between Unknown and I4
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0048: Invalid comparison between Unknown and I4
		StationStore[] storage = station.storage;
		for (int i = 0; i < storage.Length; i++)
		{
			if (storage[i].itemId == itemId && storage[i].count > 0 && (!requireSupply || (int)storage[i].localLogic == 1 || (int)storage[i].remoteLogic == 1))
			{
				return true;
			}
		}
		return false;
	}

	private static void DrainStation(StationComponent station, int itemId, int want, bool requireSupply, ref int moved, ref int incMoved)
	{
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Invalid comparison between Unknown and I4
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Invalid comparison between Unknown and I4
		StationStore[] storage = station.storage;
		for (int i = 0; i < storage.Length; i++)
		{
			if (moved >= want)
			{
				break;
			}
			if (storage[i].itemId != itemId || storage[i].count <= 0 || (requireSupply && (int)storage[i].localLogic != 1 && (int)storage[i].remoteLogic != 1))
			{
				continue;
			}
			int num = want - moved;
			if (num > storage[i].count)
			{
				num = storage[i].count;
			}
			int num2 = 0;
			if (storage[i].inc > 0)
			{
				num2 = (int)((float)storage[i].inc * (float)num / (float)storage[i].count + 0.5f);
				if (num2 > storage[i].inc)
				{
					num2 = storage[i].inc;
				}
			}
			storage[i].count -= num;
			storage[i].inc -= num2;
			moved += num;
			incMoved += num2;
		}
	}

	internal static int FindAvailableAmmo(PlanetFactory factory, EAmmoType ammoType, Vector3 pos, float radius)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: Expected I4, but got Unknown
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		int num = (int)ammoType;
		if (num <= 0 || ItemProto.turretNeeds == null || num >= ItemProto.turretNeeds.Length)
		{
			return 0;
		}
		int[] array = ItemProto.turretNeeds[num];
		if (array == null)
		{
			return 0;
		}
		if (Plugin.PreferHighestAmmoTier.Value)
		{
			for (int num2 = array.Length - 1; num2 >= 0; num2--)
			{
				int num3 = array[num2];
				if (num3 > 0 && HasStock(factory, num3, pos, radius))
				{
					return num3;
				}
			}
		}
		else
		{
			foreach (int num4 in array)
			{
				if (num4 > 0 && HasStock(factory, num4, pos, radius))
				{
					return num4;
				}
			}
		}
		return 0;
	}

	internal static float NearestAmmoStationDistance(PlanetFactory factory, int itemId, EAmmoType ammoType, Vector3 pos)
	{
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Expected I4, but got Unknown
		//IL_010e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0113: Unknown result type (might be due to invalid IL or missing references)
		//IL_0114: Unknown result type (might be due to invalid IL or missing references)
		//IL_0119: Unknown result type (might be due to invalid IL or missing references)
		PlanetTransport val = factory?.transport;
		if (val == null || val.stationPool == null)
		{
			return -1f;
		}
		bool value = Plugin.RequireStationSupplyFlag.Value;
		EntityData[] entityPool = factory.entityPool;
		int stationCursor = val.stationCursor;
		int[] array = null;
		if (itemId <= 0)
		{
			int num = (int)ammoType;
			if (num > 0 && ItemProto.turretNeeds != null && num < ItemProto.turretNeeds.Length)
			{
				array = ItemProto.turretNeeds[num];
			}
		}
		float num2 = -1f;
		for (int i = 1; i < stationCursor; i++)
		{
			StationComponent val2 = val.stationPool[i];
			if (val2 == null || val2.id != i || val2.storage == null)
			{
				continue;
			}
			bool flag = false;
			if (itemId > 0)
			{
				flag = StationHasItem(val2, itemId, value);
			}
			else if (array != null)
			{
				for (int j = 0; j < array.Length; j++)
				{
					if (flag)
					{
						break;
					}
					if (array[j] > 0)
					{
						flag = StationHasItem(val2, array[j], value);
					}
				}
			}
			if (!flag)
			{
				continue;
			}
			float num3 = 0f;
			if (entityPool != null)
			{
				int entityId = val2.entityId;
				if (entityId > 0 && entityId < entityPool.Length)
				{
					Vector3 val3 = entityPool[entityId].pos - pos;
					num3 = ((Vector3)(ref val3)).sqrMagnitude;
				}
			}
			if (num2 < 0f || num3 < num2)
			{
				num2 = num3;
			}
		}
		if (!(num2 < 0f))
		{
			return Mathf.Sqrt(num2);
		}
		return -1f;
	}

	private static bool HasStock(PlanetFactory factory, int itemId, Vector3 pos, float radius)
	{
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_009c: Unknown result type (might be due to invalid IL or missing references)
		PlanetTransport transport = factory.transport;
		if (transport == null || transport.stationPool == null)
		{
			return false;
		}
		bool value = Plugin.RequireStationSupplyFlag.Value;
		float num = ((radius > 0f) ? (radius * radius) : 0f);
		EntityData[] entityPool = factory.entityPool;
		int stationCursor = transport.stationCursor;
		for (int i = 1; i < stationCursor; i++)
		{
			StationComponent val = transport.stationPool[i];
			if (val == null || val.id != i || val.storage == null)
			{
				continue;
			}
			if (num > 0f && entityPool != null)
			{
				int entityId = val.entityId;
				if (entityId > 0 && entityId < entityPool.Length)
				{
					Vector3 val2 = entityPool[entityId].pos - pos;
					if (((Vector3)(ref val2)).sqrMagnitude > num)
					{
						continue;
					}
				}
			}
			if (StationHasItem(val, itemId, value))
			{
				return true;
			}
		}
		return false;
	}
}
internal static class PlanetwideAmmoSupplyLog
{
	private const string Tag = "[PlanetwideAmmoSupply] ";

	private static ManualLogSource logger;

	private static ConfigEntry<bool> debugGate;

	public static void Init(ManualLogSource src, ConfigEntry<bool> debug)
	{
		logger = src;
		debugGate = debug;
	}

	public static bool IsDebugEnabled()
	{
		if (debugGate != null)
		{
			return debugGate.Value;
		}
		return false;
	}

	public static void Info(string msg)
	{
		if (logger != null && IsDebugEnabled())
		{
			logger.LogInfo((object)("[PlanetwideAmmoSupply] " + msg));
		}
	}

	public static void Warn(string msg)
	{
		if (logger != null)
		{
			logger.LogWarning((object)("[PlanetwideAmmoSupply] " + msg));
		}
	}

	public static void Error(string msg)
	{
		if (logger != null)
		{
			logger.LogError((object)("[PlanetwideAmmoSupply] " + msg));
		}
	}
}
[HarmonyPatch(typeof(DefenseSystem), "GameTick", new Type[]
{
	typeof(long),
	typeof(bool)
})]
internal static class DefenseSystemSupplyPatch
{
	private struct TurretScan
	{
		public int total;

		public int belowCap;

		public int refilled;

		public int movedItems;

		public int noStock;

		public float nearestSupply;
	}

	private struct BattleScan
	{
		public int bases;

		public int slotsRefilled;

		public int movedItems;
	}

	private const int TurretAmmoTarget = 5;

	private const long LogThrottleTicks = 300L;

	private static long _lastLogTick = long.MinValue;

	private static void Postfix(DefenseSystem __instance, long tick, bool isActive)
	{
		try
		{
			if (!Plugin.Enabled.Value || __instance == null)
			{
				return;
			}
			int num = Plugin.RefillIntervalTicks.Value;
			if (num < 1)
			{
				num = 1;
			}
			if (tick % num != 0L)
			{
				return;
			}
			PlanetFactory factory = __instance.factory;
			if (factory == null)
			{
				return;
			}
			float value = Plugin.SupplyRadius.Value;
			TurretScan turretScan = default(TurretScan);
			BattleScan battleScan = default(BattleScan);
			if (Plugin.SupplyTurrets.Value)
			{
				turretScan = RefillTurrets(__instance, factory, value);
			}
			if (Plugin.SupplyBattleBases.Value)
			{
				battleScan = RefillBattleBases(__instance, factory, value);
			}
			if (!isActive || !PlanetwideAmmoSupplyLog.IsDebugEnabled())
			{
				return;
			}
			bool value2 = Plugin.VerboseScan.Value;
			bool flag = turretScan.movedItems > 0 || battleScan.movedItems > 0 || turretScan.noStock > 0;
			if (!(value2 || flag) || tick - _lastLogTick < 300)
			{
				return;
			}
			_lastLogTick = tick;
			string text = "[supply] planet=" + factory.planetId + " turrets{" + (value2 ? ("total=" + turretScan.total + " belowCap=" + turretScan.belowCap + " ") : "") + "refilled=" + turretScan.refilled + " items=" + turretScan.movedItems + ((turretScan.noStock > 0) ? (" noStock=" + turretScan.noStock) : "") + "}";
			if (value2)
			{
				text = text + " radius=" + ((value <= 0f) ? "planetwide" : value.ToString("0"));
				if (turretScan.belowCap > 0)
				{
					text = text + " nearestStation=" + ((turretScan.nearestSupply < 0f) ? "none-on-planet" : turretScan.nearestSupply.ToString("0"));
				}
			}
			if (value2 || battleScan.movedItems > 0)
			{
				text = text + " battlebase{" + (value2 ? ("bases=" + battleScan.bases + " ") : "") + "items=" + battleScan.movedItems + "}";
			}
			PlanetwideAmmoSupplyLog.Info(text);
		}
		catch (Exception ex)
		{
			PlanetwideAmmoSupplyLog.Error("[patch] DefenseSystem.GameTick postfix threw: " + ex);
		}
	}

	private static TurretScan RefillTurrets(DefenseSystem def, PlanetFactory factory, float radius)
	{
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_015f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0125: Unknown result type (might be due to invalid IL or missing references)
		//IL_012a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
		TurretScan result = default(TurretScan);
		DataPool<TurretComponent> turrets = def.turrets;
		if (turrets == null || turrets.buffer == null)
		{
			return result;
		}
		TurretComponent[] buffer = turrets.buffer;
		int cursor = turrets.cursor;
		EntityData[] entityPool = factory.entityPool;
		bool flag = Plugin.VerboseScan.Value && PlanetwideAmmoSupplyLog.IsDebugEnabled();
		bool flag2 = false;
		result.nearestSupply = -1f;
		for (int i = 1; i < cursor; i++)
		{
			if (buffer[i].id != i)
			{
				continue;
			}
			result.total++;
			if (buffer[i].itemCount >= 5)
			{
				continue;
			}
			result.belowCap++;
			Vector3 pos = Vector3.zero;
			int entityId = buffer[i].entityId;
			if (entityPool != null && entityId > 0 && entityId < entityPool.Length)
			{
				pos = entityPool[entityId].pos;
			}
			if (flag && !flag2)
			{
				result.nearestSupply = AmmoSourcing.NearestAmmoStationDistance(factory, buffer[i].itemId, buffer[i].ammoType, pos);
				flag2 = true;
			}
			int num = buffer[i].itemId;
			if (num == 0)
			{
				num = AmmoSourcing.FindAvailableAmmo(factory, buffer[i].ammoType, pos, radius);
				if (num == 0)
				{
					result.noStock++;
					continue;
				}
			}
			int want = 5 - buffer[i].itemCount;
			int incMoved;
			int num2 = AmmoSourcing.TryPullFromPlanet(factory, num, want, pos, radius, out incMoved);
			if (num2 <= 0)
			{
				result.noStock++;
				continue;
			}
			if (buffer[i].itemId == 0)
			{
				((TurretComponent)(ref buffer[i])).SetNewItem(num, (short)num2, (short)incMoved);
			}
			else
			{
				buffer[i].itemCount += (short)num2;
				buffer[i].itemInc += (short)incMoved;
			}
			result.refilled++;
			result.movedItems += num2;
		}
		return result;
	}

	private static BattleScan RefillBattleBases(DefenseSystem def, PlanetFactory factory, float radius)
	{
		//IL_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_009a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_0144: Unknown result type (might be due to invalid IL or missing references)
		BattleScan result = default(BattleScan);
		ObjectPool<BattleBaseComponent> battleBases = def.battleBases;
		if (battleBases == null || battleBases.buffer == null)
		{
			return result;
		}
		BattleBaseComponent[] buffer = battleBases.buffer;
		int cursor = battleBases.cursor;
		EntityData[] entityPool = factory.entityPool;
		string value = Plugin.FighterItemFilter.Value;
		bool flag = !string.IsNullOrEmpty(value);
		int num3 = default(int);
		for (int i = 1; i < cursor; i++)
		{
			BattleBaseComponent val = buffer[i];
			if (val == null || val.id != i)
			{
				continue;
			}
			StorageComponent storage = val.storage;
			if (storage == null || storage.grids == null)
			{
				continue;
			}
			result.bases++;
			Vector3 pos = Vector3.zero;
			int entityId = val.entityId;
			if (entityPool != null && entityId > 0 && entityId < entityPool.Length)
			{
				pos = entityPool[entityId].pos;
			}
			GRID[] grids = storage.grids;
			for (int j = 0; j < grids.Length; j++)
			{
				int itemId = grids[j].itemId;
				if (itemId <= 0)
				{
					continue;
				}
				int stackSize = grids[j].stackSize;
				if (stackSize > 0 && grids[j].count < stackSize && (!flag || value.IndexOf(itemId.ToString(), StringComparison.Ordinal) >= 0))
				{
					int want = stackSize - grids[j].count;
					int incMoved;
					int num = AmmoSourcing.TryPullFromPlanet(factory, itemId, want, pos, radius, out incMoved);
					if (num > 0)
					{
						int num2 = storage.AddItem(itemId, num, incMoved, ref num3, false);
						result.slotsRefilled++;
						result.movedItems += num2;
					}
				}
			}
		}
		return result;
	}
}
[BepInPlugin("com.zicarius.PlanetwideAmmoSupply", "PlanetwideAmmoSupply", "1.0.0")]
public sealed class Plugin : BaseUnityPlugin
{
	public const string PluginGuid = "com.zicarius.PlanetwideAmmoSupply";

	public const string PluginName = "PlanetwideAmmoSupply";

	public const string PluginVersion = "1.0.0";

	internal static ConfigEntry<bool> Enabled;

	internal static ConfigEntry<bool> SupplyTurrets;

	internal static ConfigEntry<bool> SupplyBattleBases;

	internal static ConfigEntry<bool> PreferHighestAmmoTier;

	internal static ConfigEntry<float> SupplyRadius;

	internal static ConfigEntry<bool> NearestStationFirst;

	internal static ConfigEntry<int> RefillIntervalTicks;

	internal static ConfigEntry<bool> RequireStationSupplyFlag;

	internal static ConfigEntry<string> FighterItemFilter;

	internal static ConfigEntry<bool> VerboseScan;

	internal static ConfigEntry<bool> DebugLog;

	private Harmony harmony;

	private void Awake()
	{
		//IL_029e: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a8: Expected O, but got Unknown
		DebugLog = ((BaseUnityPlugin)this).Config.Bind<bool>("Diagnostics", "DebugLog", false, "Enable verbose diagnostic logging to the BepInEx console.");
		Enabled = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enabled", true, "Master switch. If false the mod is fully inert (vanilla belt supply unchanged).");
		SupplyTurrets = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "SupplyTurrets", true, "Auto-refill turret ammo from the planet's logistics stations.");
		SupplyBattleBases = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "SupplyBattleBases", true, "Auto-refill battle-base ammo and fighters from the planet's logistics stations.");
		PreferHighestAmmoTier = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "PreferHighestAmmoTier", true, "When auto-filling an EMPTY turret, pick the highest available ammo tier (true) or the lowest/cheapest (false). A turret that already holds an ammo item keeps that item's tier - this only chooses the first fill.");
		SupplyRadius = ((BaseUnityPlugin)this).Config.Bind<float>("General", "SupplyRadius", 0f, "Max straight-line distance (metres) from a structure to an eligible station. 0 = planetwide (recommended - matches how PLS/ILS serve a whole planet). Scale: a standard planet is ~200m radius, so distances reach ~400m (opposite side). Rough guide: ~50 = tight cluster, ~150 = large base, ~300 = most of the planet, ~400 = whole standard planet. Small values like 10 are basically 'touching' and will match nothing.");
		NearestStationFirst = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "NearestStationFirst", true, "Pull from the closest eligible station first (true) instead of station build order (false). Pairs naturally with SupplyRadius.");
		RefillIntervalTicks = ((BaseUnityPlugin)this).Config.Bind<int>("General", "RefillIntervalTicks", 60, "Game ticks between refill scans (throttle). ~60 = 1s. Higher = cheaper, lower = more responsive.");
		RequireStationSupplyFlag = ((BaseUnityPlugin)this).Config.Bind<bool>("Advanced", "RequireStationSupplyFlag", false, "If true, only pull from station slots set to 'Supply' (never 'Demand'/'Storage'). False = pull from any slot holding the ammo.");
		FighterItemFilter = ((BaseUnityPlugin)this).Config.Bind<string>("Advanced", "FighterItemFilter", "", "Optional: restrict which fighter/ammo items battle bases pull (empty = everything the base already accepts).");
		VerboseScan = ((BaseUnityPlugin)this).Config.Bind<bool>("Advanced", "VerboseScan", false, "Debug aid (needs DebugLog on): log a periodic scan heartbeat on the active planet (~1 per 5s) showing total/belowCap/refilled/noStock even when nothing moved - so you can see it working and why. Off = only log when ammo actually moves.");
		PlanetwideAmmoSupplyLog.Init(((BaseUnityPlugin)this).Logger, DebugLog);
		PlanetwideAmmoSupplyLog.Info("[config] Enabled=" + Enabled.Value + " SupplyTurrets=" + SupplyTurrets.Value + " SupplyBattleBases=" + SupplyBattleBases.Value + " SupplyRadius=" + SupplyRadius.Value + " RefillIntervalTicks=" + RefillIntervalTicks.Value + " RequireStationSupplyFlag=" + RequireStationSupplyFlag.Value + " PreferHighestAmmoTier=" + PreferHighestAmmoTier.Value + " NearestStationFirst=" + NearestStationFirst.Value + " VerboseScan=" + VerboseScan.Value);
		harmony = new Harmony("com.zicarius.PlanetwideAmmoSupply");
		try
		{
			harmony.PatchAll();
			PlanetwideAmmoSupplyLog.Info("[patch] PatchAll complete.");
		}
		catch (Exception ex)
		{
			PlanetwideAmmoSupplyLog.Error("[patch] PatchAll failed: " + ex);
		}
		if (DebugLog.Value)
		{
			DumpTargetMethodSignatures();
		}
		PlanetwideAmmoSupplyLog.Info("PlanetwideAmmoSupply 1.0.0 loaded.");
	}

	private void Start()
	{
	}

	private void OnDestroy()
	{
		if (harmony != null)
		{
			harmony.UnpatchSelf();
			harmony = null;
		}
		PlanetwideAmmoSupplyLog.Info("PlanetwideAmmoSupply unloaded.");
	}

	private static void DumpTargetMethodSignatures()
	{
		string[][] array = new string[2][]
		{
			new string[2] { "DefenseSystem", "GameTick" },
			new string[2] { "StorageComponent", "AddItem" }
		};
		foreach (string[] array2 in array)
		{
			try
			{
				Type type = AccessTools.TypeByName(array2[0]);
				if (type == null)
				{
					PlanetwideAmmoSupplyLog.Warn("[diag] Type not found: " + array2[0]);
					continue;
				}
				MethodInfo methodInfo = ((array2[0] == "StorageComponent" && array2[1] == "AddItem") ? AccessTools.Method(type, array2[1], new Type[5]
				{
					typeof(int),
					typeof(int),
					typeof(int),
					typeof(int).MakeByRefType(),
					typeof(bool)
				}, (Type[])null) : AccessTools.Method(type, array2[1], (Type[])null, (Type[])null));
				if (methodInfo == null)
				{
					PlanetwideAmmoSupplyLog.Warn("[diag] Method not found: " + array2[0] + "." + array2[1]);
					continue;
				}
				ParameterInfo[] parameters = methodInfo.GetParameters();
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append("[diag] ").Append(array2[0]).Append('.')
					.Append(array2[1])
					.Append('(');
				for (int j = 0; j < parameters.Length; j++)
				{
					if (j > 0)
					{
						stringBuilder.Append(", ");
					}
					stringBuilder.Append(parameters[j].ParameterType.Name).Append(' ').Append(parameters[j].Name);
				}
				stringBuilder.Append(')');
				PlanetwideAmmoSupplyLog.Info(stringBuilder.ToString());
			}
			catch (Exception ex)
			{
				PlanetwideAmmoSupplyLog.Error("[diag] Failed to inspect " + array2[0] + "." + array2[1] + ": " + ex.Message);
			}
		}
		array = new string[6][]
		{
			new string[2] { "DefenseSystem", "turrets" },
			new string[2] { "DefenseSystem", "battleBases" },
			new string[2] { "BattleBaseComponent", "storage" },
			new string[2] { "PlanetFactory", "transport" },
			new string[2] { "PlanetTransport", "stationPool" },
			new string[2] { "StationComponent", "storage" }
		};
		foreach (string[] array3 in array)
		{
			try
			{
				Type type2 = AccessTools.TypeByName(array3[0]);
				if (type2 == null)
				{
					PlanetwideAmmoSupplyLog.Warn("[diag] Type not found: " + array3[0]);
					continue;
				}
				FieldInfo fieldInfo = AccessTools.Field(type2, array3[1]);
				if (fieldInfo == null)
				{
					PlanetwideAmmoSupplyLog.Warn("[diag] Field not found: " + array3[0] + "." + array3[1]);
					continue;
				}
				PlanetwideAmmoSupplyLog.Info("[diag] field " + array3[0] + "." + array3[1] + " : " + fieldInfo.FieldType.Name);
			}
			catch (Exception ex2)
			{
				PlanetwideAmmoSupplyLog.Error("[diag] Failed to inspect field " + array3[0] + "." + array3[1] + ": " + ex2.Message);
			}
		}
	}
}