using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Xml.Linq;
using HG;
using JetBrains.Annotations;
using RoR2.EntitlementManagement;
using RoR2.Skills;
using UnityEngine;
using UnityEngine.Networking;

namespace RoR2;

public class Loadout
{
	public class BodyLoadoutManager
	{
		private sealed class BodyLoadout
		{
			public BodyIndex bodyIndex;

			public uint skinPreference;

			public uint[] skillPreferences;

			[NotNull]
			public BodyLoadout Clone()
			{
				return new BodyLoadout
				{
					bodyIndex = bodyIndex,
					skinPreference = skinPreference,
					skillPreferences = (uint[])skillPreferences.Clone()
				};
			}

			public bool ValueEquals(BodyLoadout other)
			{
				if (this == other)
				{
					return true;
				}
				if (other == null)
				{
					return false;
				}
				if (bodyIndex.Equals(other.bodyIndex))
				{
					if (skinPreference.Equals(other.skinPreference))
					{
						return ((IStructuralEquatable)skillPreferences).Equals((object)other.skillPreferences, (IEqualityComparer)EqualityComparer<uint>.Default);
					}
					return false;
				}
				return false;
			}

			public uint GetSkillVariant(int skillSlotIndex)
			{
				if ((uint)skillSlotIndex < skillPreferences.Length)
				{
					return skillPreferences[skillSlotIndex];
				}
				return 0u;
			}

			public bool SetSkillVariant(int skillSlotIndex, uint skillVariant)
			{
				if ((uint)skillSlotIndex < skillPreferences.Length)
				{
					skillPreferences[skillSlotIndex] = HGMath.Clamp(skillVariant, 0u, (uint)LookUpMaxSkillVariants(skillSlotIndex));
					return true;
				}
				return false;
			}

			private bool IsSkillVariantValid(int skillSlotIndex)
			{
				SkillFamily skillFamily = GetSkillFamily(skillSlotIndex);
				if (!skillFamily)
				{
					return false;
				}
				if (GetSkillVariant(skillSlotIndex) < skillFamily.variants.Length)
				{
					return true;
				}
				return false;
			}

			private bool IsSkillVariantLocked(int skillSlotIndex, UserProfile userProfile)
			{
				SkillFamily skillFamily = GetSkillFamily(skillSlotIndex);
				if (!skillFamily)
				{
					return false;
				}
				uint skillVariant = GetSkillVariant(skillSlotIndex);
				bool num = (bool)skillFamily.variants[skillVariant].unlockableDef && (bool)skillFamily.variants[skillVariant].unlockableDef.requiredExpansion;
				bool flag = false;
				if (num)
				{
					flag = EntitlementManager.localUserEntitlementTracker.AnyUserHasEntitlement(skillFamily.variants[skillVariant].unlockableDef.requiredExpansion.requiredEntitlement);
				}
				if (!num || flag)
				{
					return !userProfile.HasUnlockable(skillFamily.variants[skillVariant].unlockableDef);
				}
				return true;
			}

			private void ResetSkillVariant(int skillSlotIndex)
			{
				if ((uint)skillSlotIndex < skillPreferences.Length)
				{
					skillPreferences[skillSlotIndex] = GetSkillFamily(skillSlotIndex)?.defaultVariantIndex ?? 0;
				}
			}

			private bool IsSkinValid()
			{
				SkinDef[] bodySkins = BodyCatalog.GetBodySkins(bodyIndex);
				return skinPreference < bodySkins.Length;
			}

			private bool IsSkinLocked(UserProfile userProfile)
			{
				SkinDef safe = ArrayUtils.GetSafe(BodyCatalog.GetBodySkins(bodyIndex), (int)skinPreference);
				if (!safe)
				{
					return true;
				}
				bool num = (bool)safe.unlockableDef && (bool)safe.unlockableDef.requiredExpansion;
				bool flag = false;
				if (num)
				{
					EntitlementDef requiredEntitlement = safe.unlockableDef.requiredExpansion.requiredEntitlement;
					flag = EntitlementManager.localUserEntitlementTracker.AnyUserHasEntitlement(requiredEntitlement);
				}
				if (!num || flag)
				{
					return !userProfile.HasUnlockable(safe.unlockableDef);
				}
				return true;
			}

			private void ResetSkin()
			{
				skinPreference = 0u;
			}

			public void EnforceValidity()
			{
				for (int i = 0; i < skillPreferences.Length; i++)
				{
					if (!IsSkillVariantValid(i))
					{
						ResetSkillVariant(i);
					}
				}
				if (!IsSkinValid())
				{
					ResetSkin();
				}
			}

			public void EnforceUnlockables(UserProfile userProfile)
			{
				bool flag = false;
				for (int i = 0; i < skillPreferences.Length; i++)
				{
					if (IsSkillVariantLocked(i, userProfile))
					{
						ResetSkillVariant(i);
						flag = true;
					}
				}
				if (IsSkinLocked(userProfile))
				{
					ResetSkin();
					flag = true;
				}
				if (flag)
				{
					userProfile.OnLoadoutChanged();
				}
			}

			[CanBeNull]
			private SkillFamily GetSkillFamily(int skillSlotIndex)
			{
				return BodyCatalog.GetBodyPrefabSkillSlots(bodyIndex)[skillSlotIndex].skillFamily;
			}

			public int LookUpMaxSkillVariants(int skillSlotIndex)
			{
				if ((uint)skillSlotIndex < skillPreferences.Length)
				{
					SkillFamily skillFamily = GetSkillFamily(skillSlotIndex);
					if ((object)skillFamily == null)
					{
						return 0;
					}
					return skillFamily.variants.Length;
				}
				return 0;
			}

			public void Serialize(NetworkWriter writer)
			{
				writer.WriteBodyIndex(bodyIndex);
				writer.WritePackedUInt32(skinPreference);
				for (int i = 0; i < skillPreferences.Length; i++)
				{
					writer.WritePackedUInt32(skillPreferences[i]);
				}
			}

			public void Deserialize(NetworkReader reader)
			{
				bodyIndex = reader.ReadBodyIndex();
				if (bodyIndex < (BodyIndex)0)
				{
					bodyIndex = (BodyIndex)0;
				}
				if ((int)bodyIndex >= BodyCatalog.bodyCount)
				{
					bodyIndex = (BodyIndex)(BodyCatalog.bodyCount - 1);
				}
				skinPreference = reader.ReadPackedUInt32();
				Array.Resize(ref skillPreferences, GetSkillSlotCountForBody(bodyIndex));
				for (int i = 0; i < skillPreferences.Length; i++)
				{
					SetSkillVariant(i, reader.ReadPackedUInt32());
				}
			}

			public XElement ToXml(string elementName)
			{
				XElement xElement = new XElement(elementName);
				xElement.SetAttributeValue("bodyName", BodyCatalog.GetBodyName(bodyIndex));
				xElement.Add(new XElement("Skin", skinPreference.ToString()));
				ref BodyInfo reference = ref allBodyInfos[(int)bodyIndex];
				for (int i = 0; i < reference.prefabSkillSlots.Length; i++)
				{
					int skillFamilyIndex = reference.skillFamilyIndices[i];
					SkillFamily skillFamily = SkillCatalog.GetSkillFamily(skillFamilyIndex);
					string skillFamilyName = SkillCatalog.GetSkillFamilyName(skillFamilyIndex);
					string variantName = skillFamily.GetVariantName((int)skillPreferences[i]);
					if (variantName != null)
					{
						XElement xElement2 = new XElement("SkillPreference", variantName);
						xElement2.SetAttributeValue("skillFamily", skillFamilyName);
						xElement.Add(xElement2);
					}
				}
				return xElement;
			}

			public bool FromXml(XElement element)
			{
				uint.TryParse(element.Element("Skin")?.Value ?? string.Empty, out skinPreference);
				string text = element.Attribute("bodyName")?.Value;
				if (text == null)
				{
					return false;
				}
				bodyIndex = BodyCatalog.FindBodyIndex(text);
				if (bodyIndex == BodyIndex.None)
				{
					Debug.LogFormat("Could not find body index for bodyName={0}", text);
					return false;
				}
				GenericSkill[] prefabSkillSlots = allBodyInfos[(int)bodyIndex].prefabSkillSlots;
				skillPreferences = new uint[prefabSkillSlots.Length];
				foreach (XElement item in element.Elements("SkillPreference"))
				{
					string text2 = item.Attribute("skillFamily")?.Value;
					string value = item.Value;
					if (text2 == null)
					{
						continue;
					}
					int num = FindSkillSlotIndex(text2);
					if (num != -1)
					{
						int variantIndex = prefabSkillSlots[num].skillFamily.GetVariantIndex(value);
						if (variantIndex != -1)
						{
							skillPreferences[num] = (uint)variantIndex;
							continue;
						}
						Debug.LogFormat("Could not find variant index for elementSkillFamilyName={0} elementSkillName={1}", text2, value);
					}
					else
					{
						Debug.LogFormat("Could not find skill slot index for elementSkillFamilyName={0} elementSkillName={1}", text2, value);
					}
				}
				return true;
				int FindSkillSlotIndex(string requestedSkillFamilyName)
				{
					for (int i = 0; i < prefabSkillSlots.Length; i++)
					{
						if (SkillCatalog.GetSkillFamilyName(prefabSkillSlots[i].skillFamily.catalogIndex).Equals(requestedSkillFamilyName, StringComparison.Ordinal))
						{
							return i;
						}
					}
					return -1;
				}
			}
		}

		private struct BodyInfo
		{
			public int[] skillFamilyIndices;

			public GenericSkill[] prefabSkillSlots;

			public int skillSlotCount => prefabSkillSlots.Length;
		}

		private BodyLoadout[] modifiedBodyLoadouts = Array.Empty<BodyLoadout>();

		private static BodyLoadout[] defaultBodyLoadouts;

		private static BodyInfo[] allBodyInfos;

		private int FindModifiedBodyLoadoutIndexByBodyIndex(BodyIndex bodyIndex)
		{
			for (int i = 0; i < modifiedBodyLoadouts.Length; i++)
			{
				if (modifiedBodyLoadouts[i].bodyIndex == bodyIndex)
				{
					return i;
				}
			}
			return -1;
		}

		private BodyLoadout GetReadOnlyBodyLoadout(BodyIndex bodyIndex)
		{
			int num = FindModifiedBodyLoadoutIndexByBodyIndex(bodyIndex);
			if (num == -1)
			{
				return defaultBodyLoadouts[(int)bodyIndex];
			}
			return modifiedBodyLoadouts[num];
		}

		private BodyLoadout GetOrCreateModifiedBodyLoadout(BodyIndex bodyIndex)
		{
			int num = FindModifiedBodyLoadoutIndexByBodyIndex(bodyIndex);
			if (num != -1)
			{
				return modifiedBodyLoadouts[num];
			}
			BodyLoadout value = GetDefaultLoadoutForBody(bodyIndex).Clone();
			ArrayUtils.ArrayAppend(ref modifiedBodyLoadouts, in value);
			return value;
		}

		public uint GetSkillVariant(BodyIndex bodyIndex, int skillSlot)
		{
			return GetReadOnlyBodyLoadout(bodyIndex).skillPreferences[skillSlot];
		}

		public void SetSkillVariant(BodyIndex bodyIndex, int skillSlot, uint skillVariant)
		{
			if ((uint)bodyIndex >= BodyCatalog.bodyCount)
			{
				throw new ArgumentOutOfRangeException("bodyIndex", (int)bodyIndex, $"Value provided for 'bodyIndex' is outside range [0, {(int)bodyIndex}]");
			}
			if (GetSkillVariant(bodyIndex, skillSlot) != skillVariant)
			{
				int skillSlotCountForBody = GetSkillSlotCountForBody(bodyIndex);
				if ((uint)skillSlot >= skillSlotCountForBody)
				{
					throw new ArgumentOutOfRangeException("skillSlot", skillSlot, $"Value provided for 'skillSlot' is outside range [0, {skillSlotCountForBody}) for body=[{(int)bodyIndex}]");
				}
				int num = allBodyInfos[(int)bodyIndex].prefabSkillSlots[skillSlot].skillFamily.variants.Length;
				if (skillVariant >= num)
				{
					throw new ArgumentOutOfRangeException("skillVariant", skillVariant, $"Value provided for 'skillVariant' is outside range [0, {num}) for body=[{(int)bodyIndex}] skillSlot=[{skillSlot}]");
				}
				BodyLoadout orCreateModifiedBodyLoadout = GetOrCreateModifiedBodyLoadout(bodyIndex);
				orCreateModifiedBodyLoadout.SetSkillVariant(skillSlot, skillVariant);
				RemoveBodyLoadoutIfDefault(orCreateModifiedBodyLoadout);
			}
		}

		public uint GetSkinIndex(BodyIndex bodyIndex)
		{
			return GetReadOnlyBodyLoadout(bodyIndex).skinPreference;
		}

		public void SetSkinIndex(BodyIndex bodyIndex, uint skinIndex)
		{
			BodyLoadout orCreateModifiedBodyLoadout = GetOrCreateModifiedBodyLoadout(bodyIndex);
			orCreateModifiedBodyLoadout.skinPreference = skinIndex;
			RemoveBodyLoadoutIfDefault(orCreateModifiedBodyLoadout);
		}

		private void RemoveBodyLoadoutIfDefault(BodyLoadout bodyLoadout)
		{
			RemoveBodyLoadoutIfDefault(FindModifiedBodyLoadoutIndexByBodyIndex(bodyLoadout.bodyIndex));
		}

		private void RemoveBodyLoadoutIfDefault(int modifiedBodyLoadoutIndex)
		{
			BodyLoadout obj = modifiedBodyLoadouts[modifiedBodyLoadoutIndex];
			if (obj.ValueEquals(GetDefaultLoadoutForBody(obj.bodyIndex)))
			{
				RemoveBodyLoadoutAt(modifiedBodyLoadoutIndex);
			}
		}

		private void RemoveBodyLoadoutAt(int i)
		{
			ArrayUtils.ArrayRemoveAtAndResize(ref modifiedBodyLoadouts, i);
		}

		private static BodyLoadout GetDefaultLoadoutForBody(BodyIndex bodyIndex)
		{
			return defaultBodyLoadouts[(int)bodyIndex];
		}

		private static int GetSkillSlotCountForBody(BodyIndex bodyIndex)
		{
			return allBodyInfos[(int)bodyIndex].skillSlotCount;
		}

		[SystemInitializer(new Type[]
		{
			typeof(SkillCatalog),
			typeof(BodyCatalog)
		})]
		private static void Init()
		{
			defaultBodyLoadouts = new BodyLoadout[BodyCatalog.bodyCount];
			allBodyInfos = new BodyInfo[defaultBodyLoadouts.Length];
			for (BodyIndex bodyIndex = (BodyIndex)0; (int)bodyIndex < defaultBodyLoadouts.Length; bodyIndex++)
			{
				BodyInfo bodyInfo = default(BodyInfo);
				bodyInfo.prefabSkillSlots = BodyCatalog.GetBodyPrefabBodyComponent(bodyIndex).GetComponents<GenericSkill>();
				bodyInfo.skillFamilyIndices = new int[bodyInfo.skillSlotCount];
				for (int i = 0; i < bodyInfo.prefabSkillSlots.Length; i++)
				{
					bodyInfo.skillFamilyIndices[i] = bodyInfo.prefabSkillSlots[i].skillFamily?.catalogIndex ?? (-1);
				}
				allBodyInfos[(int)bodyIndex] = bodyInfo;
				uint[] array = new uint[bodyInfo.skillSlotCount];
				for (int j = 0; j < bodyInfo.prefabSkillSlots.Length; j++)
				{
					array[j] = bodyInfo.prefabSkillSlots[j].skillFamily.defaultVariantIndex;
				}
				defaultBodyLoadouts[(int)bodyIndex] = new BodyLoadout
				{
					bodyIndex = bodyIndex,
					skinPreference = 0u,
					skillPreferences = array
				};
			}
			GenerateViewables();
		}

		public void Copy(BodyLoadoutManager dest)
		{
			Array.Resize(ref dest.modifiedBodyLoadouts, modifiedBodyLoadouts.Length);
			for (int i = 0; i < modifiedBodyLoadouts.Length; i++)
			{
				dest.modifiedBodyLoadouts[i] = modifiedBodyLoadouts[i].Clone();
			}
		}

		public void Clear()
		{
			modifiedBodyLoadouts = Array.Empty<BodyLoadout>();
		}

		public void Serialize(NetworkWriter writer)
		{
			writer.WritePackedUInt32((uint)modifiedBodyLoadouts.Length);
			for (int i = 0; i < modifiedBodyLoadouts.Length; i++)
			{
				modifiedBodyLoadouts[i].Serialize(writer);
			}
		}

		public void Deserialize(NetworkReader reader)
		{
			try
			{
				int num = (int)reader.ReadPackedUInt32();
				if (num > BodyCatalog.bodyCount)
				{
					num = BodyCatalog.bodyCount;
				}
				Array.Resize(ref modifiedBodyLoadouts, num);
				for (int i = 0; i < num; i++)
				{
					BodyLoadout bodyLoadout = new BodyLoadout();
					bodyLoadout.Deserialize(reader);
					modifiedBodyLoadouts[i] = bodyLoadout;
				}
			}
			catch (Exception)
			{
				modifiedBodyLoadouts = Array.Empty<BodyLoadout>();
				throw;
			}
		}

		public bool ValueEquals(BodyLoadoutManager other)
		{
			if (this == other)
			{
				return true;
			}
			if (other == null)
			{
				return false;
			}
			if (modifiedBodyLoadouts.Length != other.modifiedBodyLoadouts.Length)
			{
				return false;
			}
			for (int i = 0; i < modifiedBodyLoadouts.Length; i++)
			{
				if (!modifiedBodyLoadouts[i].ValueEquals(other.modifiedBodyLoadouts[i]))
				{
					return false;
				}
			}
			return true;
		}

		public XElement ToXml(string elementName)
		{
			XElement xElement = new XElement(elementName);
			for (int i = 0; i < modifiedBodyLoadouts.Length; i++)
			{
				xElement.Add(modifiedBodyLoadouts[i].ToXml("BodyLoadout"));
			}
			return xElement;
		}

		public bool FromXml(XElement element)
		{
			List<BodyLoadout> bodyLoadouts = new List<BodyLoadout>();
			foreach (XElement item in element.Elements("BodyLoadout"))
			{
				BodyLoadout bodyLoadout = new BodyLoadout();
				if (bodyLoadout.FromXml(item) && !BodyLoadoutAlreadyDefined(bodyLoadout.bodyIndex) && !bodyLoadout.ValueEquals(GetDefaultLoadoutForBody(bodyLoadout.bodyIndex)))
				{
					bodyLoadouts.Add(bodyLoadout);
				}
			}
			modifiedBodyLoadouts = bodyLoadouts.ToArray();
			return true;
			bool BodyLoadoutAlreadyDefined(BodyIndex bodyIndex)
			{
				for (int i = 0; i < bodyLoadouts.Count; i++)
				{
					if (bodyLoadouts[i].bodyIndex == bodyIndex)
					{
						return true;
					}
				}
				return false;
			}
		}

		public void EnforceUnlockables(UserProfile userProfile)
		{
			for (int num = modifiedBodyLoadouts.Length - 1; num >= 0; num--)
			{
				modifiedBodyLoadouts[num].EnforceUnlockables(userProfile);
				RemoveBodyLoadoutIfDefault(num);
			}
		}

		public void EnforceValidity()
		{
			for (int num = modifiedBodyLoadouts.Length - 1; num >= 0; num--)
			{
				modifiedBodyLoadouts[num].EnforceValidity();
				RemoveBodyLoadoutIfDefault(num);
			}
		}
	}

	public readonly BodyLoadoutManager bodyLoadoutManager = new BodyLoadoutManager();

	private static readonly Stack<Loadout> instancePool = new Stack<Loadout>();

	public void Serialize(NetworkWriter writer)
	{
		bodyLoadoutManager.Serialize(writer);
	}

	public void Deserialize(NetworkReader reader)
	{
		bodyLoadoutManager.Deserialize(reader);
	}

	public void Copy(Loadout dest)
	{
		bodyLoadoutManager.Copy(dest.bodyLoadoutManager);
	}

	public void Clear()
	{
		bodyLoadoutManager.Clear();
	}

	public bool ValueEquals(Loadout other)
	{
		if (this == other)
		{
			return true;
		}
		if (other == null)
		{
			return false;
		}
		return bodyLoadoutManager.ValueEquals(other.bodyLoadoutManager);
	}

	public XElement ToXml(string elementName)
	{
		XElement xElement = new XElement(elementName);
		xElement.Add(bodyLoadoutManager.ToXml("BodyLoadouts"));
		return xElement;
	}

	public bool FromXml(XElement element)
	{
		bool flag = true;
		XElement xElement = element.Element("BodyLoadouts");
		flag = xElement != null && (flag & bodyLoadoutManager.FromXml(xElement));
		EnforceValidity();
		return flag;
	}

	public void EnforceValidity()
	{
		bodyLoadoutManager.EnforceValidity();
	}

	public void EnforceUnlockables(UserProfile userProfile)
	{
		bodyLoadoutManager.EnforceUnlockables(userProfile);
	}

	private static void GenerateViewables()
	{
		StringBuilder stringBuilder = new StringBuilder();
		ViewablesCatalog.Node node = new ViewablesCatalog.Node("Loadout", isFolder: true);
		ViewablesCatalog.Node parent = new ViewablesCatalog.Node("Bodies", isFolder: true, node);
		for (BodyIndex bodyIndex = (BodyIndex)0; (int)bodyIndex < BodyCatalog.bodyCount; bodyIndex++)
		{
			if (SurvivorCatalog.GetSurvivorIndexFromBodyIndex(bodyIndex) == SurvivorIndex.None)
			{
				continue;
			}
			string bodyName = BodyCatalog.GetBodyName(bodyIndex);
			GenericSkill[] bodyPrefabSkillSlots = BodyCatalog.GetBodyPrefabSkillSlots(bodyIndex);
			ViewablesCatalog.Node parent2 = new ViewablesCatalog.Node(bodyName, isFolder: true, parent);
			for (int i = 0; i < bodyPrefabSkillSlots.Length; i++)
			{
				SkillFamily skillFamily = bodyPrefabSkillSlots[i].skillFamily;
				if (skillFamily.variants.Length <= 1)
				{
					continue;
				}
				string skillFamilyName = SkillCatalog.GetSkillFamilyName(skillFamily.catalogIndex);
				for (uint num = 0u; num < skillFamily.variants.Length; num++)
				{
					ref SkillFamily.Variant reference = ref skillFamily.variants[num];
					UnlockableDef unlockableDef = reference.unlockableDef;
					string skillName = SkillCatalog.GetSkillName(reference.skillDef.skillIndex);
					stringBuilder.Append(skillFamilyName).Append(".").Append(skillName);
					string name = stringBuilder.ToString();
					stringBuilder.Clear();
					ViewablesCatalog.Node variantNode = new ViewablesCatalog.Node(name, isFolder: false, parent2);
					reference.viewableNode = variantNode;
					variantNode.shouldShowUnviewed = (UserProfile userProfile) => !userProfile.HasViewedViewable(variantNode.fullName) && userProfile.HasUnlockable(unlockableDef);
				}
			}
			SkinDef[] bodySkins = BodyCatalog.GetBodySkins(bodyIndex);
			if (bodySkins.Length <= 1)
			{
				continue;
			}
			ViewablesCatalog.Node parent3 = new ViewablesCatalog.Node("Skins", isFolder: true, parent2);
			for (int j = 0; j < bodySkins.Length; j++)
			{
				UnlockableDef unlockableDef2 = bodySkins[j].unlockableDef;
				if ((bool)unlockableDef2)
				{
					ViewablesCatalog.Node skinNode = new ViewablesCatalog.Node(bodySkins[j].name, isFolder: false, parent3);
					skinNode.shouldShowUnviewed = (UserProfile userProfile) => !userProfile.HasViewedViewable(skinNode.fullName) && userProfile.HasUnlockable(unlockableDef2);
				}
			}
		}
		ViewablesCatalog.AddNodeToRoot(node);
	}

	public static Loadout RequestInstance()
	{
		if (instancePool.Count == 0)
		{
			return new Loadout();
		}
		return instancePool.Pop();
	}

	public static Loadout ReturnInstance(Loadout instance)
	{
		instance.Clear();
		instancePool.Push(instance);
		return null;
	}

	[SystemInitializer(new Type[]
	{
		typeof(BodyCatalog),
		typeof(SkillCatalog),
		typeof(SkinCatalog)
	})]
	private static void Init()
	{
	}
}