using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using HarmonyLib;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyCompany("AllUpgradesMod")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("AllUpgradesMod")]
[assembly: AssemblyTitle("AllUpgradesMod")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace AllUpgradesMod;

[BepInPlugin("com.pmadd.unlimitedupgrades", "Unlimited Upgrades Mod", "1.0.0")]
public class UnlimitedUpgradesPlugin : BaseUnityPlugin
{
	private void Awake()
	{
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		new Harmony("com.pmadd.unlimitedupgrades").PatchAll();
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Unlimited Upgrades Mod loaded successfully!");
	}
}
[HarmonyPatch(typeof(Faction), "ApplyTraitsTo")]
public static class Faction_ApplyTraitsTo_Patch
{
	public static void Prefix(Faction __instance, Unit u)
	{
		if ((Object)(object)u != (Object)null && (Object)(object)u.modifiers != (Object)null)
		{
			u.modifiers.statMaxSlotted = 100;
		}
	}
}
[HarmonyPatch(typeof(CUIFleetConfigPanel), "PopulatePanelWithFaction")]
public static class CUIFleetConfigPanel_PopulatePanelWithFaction_Patch
{
	public static Dictionary<string, int> ScrollOffsets = new Dictionary<string, int>();

	public static bool Prefix(CUIFleetConfigPanel __instance, Faction f)
	{
		if ((Object)(object)f == (Object)null)
		{
			return true;
		}
		((Behaviour)__instance.numUnitsLabel).enabled = false;
		if (Object.op_Implicit((Object)(object)__instance.unitBlueprint))
		{
			((UIWidget)__instance.wireframeTexture).mainTexture = (Texture)(object)__instance.unitBlueprint.hudOutlineTexture;
			__instance.descriptionLabel.text = __instance.unitBlueprint.description;
			int num = 0;
			for (int i = 0; i < f.currentFleet.Count; i++)
			{
				if ((Object)(object)((Component)f.currentFleet[i]).GetComponent<Unit>().blueprint == (Object)(object)__instance.unitBlueprint)
				{
					num++;
				}
			}
			if (num > 1)
			{
				__instance.headerLabel.text = num + "x " + __instance.unitBlueprint.displayName + "S";
			}
			else
			{
				__instance.headerLabel.text = "1x " + __instance.unitBlueprint.displayName;
			}
		}
		UnitConfig configByID = f.GetConfigByID(__instance.unitConfigTag);
		if (configByID != null)
		{
			if (!ScrollOffsets.TryGetValue(__instance.unitConfigTag, out var value))
			{
				value = 0;
				ScrollOffsets[__instance.unitConfigTag] = 0;
			}
			int num2 = configByID.unitModifiers.Count + 1;
			int num3 = Mathf.Max(0, num2 - __instance.modifierButtons.Count);
			if (value > num3)
			{
				value = num3;
				ScrollOffsets[__instance.unitConfigTag] = value;
			}
			for (int j = 0; j < __instance.modifierButtons.Count; j++)
			{
				int num4 = value + j;
				((CUIFleetConfigButton)__instance.modifierButtons[j]).index = num4;
				UnitModifier modifier = null;
				if (num4 < configByID.unitModifiers.Count)
				{
					modifier = configByID.unitModifiers[num4];
				}
				__instance.modifierButtons[j].SetModifier(modifier);
			}
			for (int k = 0; k < configByID.weaponAssignments.Count; k++)
			{
				if (k < __instance.weaponButtons.Count)
				{
					__instance.weaponButtons[k].SetBlueprint(configByID.weaponAssignments[k].weaponBlueprint);
				}
			}
		}
		else
		{
			Debug.LogError((object)"Null unit config!");
		}
		return false;
	}
}
[HarmonyPatch(typeof(CUIFleetConfigPanel), "Update")]
public static class CUIFleetConfigPanel_Update_Patch
{
	public static void Postfix(CUIFleetConfigPanel __instance)
	{
		if (Controls.menuMouseControl)
		{
			UICamera.selectedObject = null;
		}
		GameObject hoveredObject = UICamera.hoveredObject;
		if ((Object)(object)hoveredObject != (Object)null)
		{
			CUIFleetConfigPanelModifierButton component = hoveredObject.GetComponent<CUIFleetConfigPanelModifierButton>();
			if ((Object)(object)component != (Object)null && (Object)(object)((CUIFleetConfigButton)component).configPanel == (Object)(object)__instance)
			{
				float axis = Input.GetAxis("Mouse ScrollWheel");
				if (axis != 0f)
				{
					Scroll(__instance, (!(axis > 0f)) ? 1 : (-1));
				}
			}
		}
		GameObject selectedObject = UICamera.selectedObject;
		if (!((Object)(object)selectedObject != (Object)null))
		{
			return;
		}
		CUIFleetConfigPanelModifierButton component2 = selectedObject.GetComponent<CUIFleetConfigPanelModifierButton>();
		if (!((Object)(object)component2 != (Object)null) || !((Object)(object)((CUIFleetConfigButton)component2).configPanel == (Object)(object)__instance))
		{
			return;
		}
		int num = __instance.modifierButtons.IndexOf(component2);
		if (num == __instance.modifierButtons.Count - 1)
		{
			if (Input.GetKeyDown((KeyCode)275) || Input.GetKeyDown((KeyCode)100) || Controls.player.GetButtonDown("Menu Right"))
			{
				Scroll(__instance, 1);
			}
		}
		else if (num == 0 && (Input.GetKeyDown((KeyCode)276) || Input.GetKeyDown((KeyCode)97) || Controls.player.GetButtonDown("Menu Left")))
		{
			Scroll(__instance, -1);
		}
	}

	private static void Scroll(CUIFleetConfigPanel panel, int direction)
	{
		UnitConfig configByID = Campaign.playerFaction.GetConfigByID(panel.unitConfigTag);
		if (configByID != null)
		{
			CUIFleetConfigPanel_PopulatePanelWithFaction_Patch.ScrollOffsets.TryGetValue(panel.unitConfigTag, out var value);
			int num = configByID.unitModifiers.Count + 1;
			int num2 = Mathf.Max(0, num - panel.modifierButtons.Count);
			int num3 = Mathf.Clamp(value + direction, 0, num2);
			if (num3 != value)
			{
				CUIFleetConfigPanel_PopulatePanelWithFaction_Patch.ScrollOffsets[panel.unitConfigTag] = num3;
				panel.Populate();
				AudioMenu.playToggle = true;
			}
		}
	}
}
[HarmonyPatch(typeof(CUIFleetConfigModifierPanel), "OnModifierButtonClicked")]
public static class CUIFleetConfigModifierPanel_OnModifierButtonClicked_Patch
{
	public static bool Prefix(CUIFleetConfigModifierPanel __instance, CUIModifierButton button)
	{
		//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f4: 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)
		if (button.isLocked)
		{
			if (Campaign.playerFaction.CanPurchaseModifier(button.prefab))
			{
				MethodInfo? method = typeof(CUIFleetConfigModifierPanel).GetMethod("Purchase", BindingFlags.Instance | BindingFlags.NonPublic);
				typeof(CUIFleetConfigModifierPanel).GetField("_nextPurchasedModifier", BindingFlags.Static | BindingFlags.NonPublic).SetValue(null, button.prefab);
				typeof(CUIFleetConfigModifierPanel).GetField("_nextButton", BindingFlags.Static | BindingFlags.NonPublic).SetValue(null, button);
				method.Invoke(__instance, null);
			}
			else if (Campaign.playerFaction.upgradeTokens < button.prefab.upgradeTokenCost)
			{
				CUIFavorWidget.lastFlashTime = Time.time;
				Messenger<string, Color>.Broadcast("RequestToast", $"THIS UPGRADE REQUIRES {button.prefab.upgradeTokenCost} FAVOR", CockpitToast.notificationColor);
				AudioCockpit.PlayNegatory();
			}
			return false;
		}
		if ((button.prefab.allowedUnitTypes & CUIFleetConfigModifierPanel.nextBlueprint.prefab.unitType) == 0)
		{
			Messenger<string, Color>.Broadcast("RequestToast", "THIS UPGRADE CANNOT BE EQUIPPED ON THIS CLASS OF WARSHIP", CockpitToast.notificationColor);
			AudioCockpit.PlayNegatory();
			return false;
		}
		UnitConfig configByID = Campaign.playerFaction.GetConfigByID(CUIFleetConfigModifierPanel.nextTag);
		if (configByID != null)
		{
			if (configByID.unitModifiers.Contains(button.prefab))
			{
				configByID.unitModifiers.Remove(button.prefab);
				AudioMenu.playCancel = true;
			}
			else
			{
				int nextModifierIndex = CUIFleetConfigModifierPanel.nextModifierIndex;
				if (nextModifierIndex >= 0 && nextModifierIndex < configByID.unitModifiers.Count && (Object)(object)configByID.unitModifiers[nextModifierIndex] == (Object)null)
				{
					configByID.unitModifiers[nextModifierIndex] = button.prefab;
				}
				else
				{
					configByID.unitModifiers.Add(button.prefab);
				}
				AudioMenu.playUpgradeEquipped = true;
			}
			Campaign.SavePlayerFaction(false);
			__instance.Populate();
		}
		return false;
	}
}
[HarmonyPatch(typeof(CUIFleetConfigModifierPanel), "OnConfirmPurchaseClicked")]
public static class CUIFleetConfigModifierPanel_OnConfirmPurchaseClicked_Patch
{
	public static bool Prefix(CUIFleetConfigModifierPanel __instance)
	{
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Expected O, but got Unknown
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Expected O, but got Unknown
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//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)
		UnitModifier val = (UnitModifier)typeof(CUIFleetConfigModifierPanel).GetField("_nextPurchasedModifier", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
		CUIModifierButton val2 = (CUIModifierButton)typeof(CUIFleetConfigModifierPanel).GetField("_nextButton", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
		Campaign.playerFaction.PurchaseModifier(val);
		if ((val.allowedUnitTypes & CUIFleetConfigModifierPanel.nextBlueprint.prefab.unitType) != 0)
		{
			AudioMenu.playUpgradeEquipped = true;
			UnitConfig configByID = Campaign.playerFaction.GetConfigByID(CUIFleetConfigModifierPanel.nextTag);
			if (configByID != null)
			{
				int nextModifierIndex = CUIFleetConfigModifierPanel.nextModifierIndex;
				if (nextModifierIndex >= 0 && nextModifierIndex < configByID.unitModifiers.Count && (Object)(object)configByID.unitModifiers[nextModifierIndex] == (Object)null)
				{
					configByID.unitModifiers[nextModifierIndex] = val;
				}
				else
				{
					configByID.unitModifiers.Add(val);
				}
			}
		}
		else
		{
			AudioMenu.playUpgradePurchased = true;
		}
		Campaign.SavePlayerFaction(false);
		Game.Instance.menuSubstate = (MenuSubstate)262144;
		CUIFleetConfigMenu.Instance.state = (State)2;
		__instance.Populate();
		if ((Object)(object)val2 != (Object)null)
		{
			UICamera.selectedObject = ((Component)val2).gameObject;
		}
		return false;
	}
}
[HarmonyPatch(typeof(UnitModifier), "AddNewInstanceTo")]
public static class UnitModifier_AddNewInstanceTo_Patch
{
	public static bool Prefix(UnitModifier prefab, Unit u, ref UnitModifier __result)
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)prefab == (Object)null || (Object)(object)u == (Object)null)
		{
			return true;
		}
		if ((prefab.allowedUnitTypes & u.unitType) == 0)
		{
			Debug.LogWarning((object)$"Blocking incompatible modifier {((Object)prefab).name} from being added to unit {((Object)u).name} (type: {u.unitType})");
			__result = null;
			return false;
		}
		return true;
	}
}