using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using DM;
using FhpSLib;
using HarmonyLib;
using Landfall.TABS;
using SI;
using SIComponents;
using SLMA;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("StitchedItems")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("GeeztJeez")]
[assembly: AssemblyProduct("StitchedItems")]
[assembly: AssemblyCopyright("Copyright © 4Ever")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("7acfaef0-7669-4401-8bff-5a9a02e18c75")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace SI
{
	public static class Manager
	{
		public static string comment;

		public static void Init(LandfallContentDatabase db)
		{
			UTI.LoadBundle("stitchitemsbundle");
			Sprite val = UTI.LoadTexture2Sprite("icon_items");
			string categoryName = "Stitched Items";
			GameObject val2 = UTI.LoadGmObj("EmptyPropItem");
			int startId = 99999999;
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			comment = "Custom Clothes";
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			UTI.ICat.SetTag(UPool.MyPool.AddObject("SmartSkinnedPropScale", val2, true, (HideFlags)52, val, UTI.IDScan(UTI.assetType.Ability, startId), true), categoryName, (TagType)0);
			UTI.ICat.SetTag(UPool.MyPool.AddObject("SmartSkinnedPropRotation", val2, true, (HideFlags)52, val, UTI.IDScan(UTI.assetType.Ability, startId), true), categoryName, (TagType)0);
			UTI.ICat.SetTag(UPool.MyPool.AddObject("SmartSkinnedPropPosition", val2, true, (HideFlags)52, val, UTI.IDScan(UTI.assetType.Ability, startId), true), categoryName, (TagType)0);
		}

		public static void SetItemObject(GameObject itemObject)
		{
			if ((Object)(object)itemObject == (Object)(object)UPool.MyPool.GetObject("SmartSkinnedPropScale"))
			{
				itemObject.AddComponent<SmartSkinnedPropBehaviour>().smartType = SmartSkinnedPropBehaviour.SmartType.Scale;
			}
			if ((Object)(object)itemObject == (Object)(object)UPool.MyPool.GetObject("SmartSkinnedPropRotation"))
			{
				itemObject.AddComponent<SmartSkinnedPropBehaviour>().smartType = SmartSkinnedPropBehaviour.SmartType.Rotation;
			}
			if ((Object)(object)itemObject == (Object)(object)UPool.MyPool.GetObject("SmartSkinnedPropPosition"))
			{
				itemObject.AddComponent<SmartSkinnedPropBehaviour>().smartType = SmartSkinnedPropBehaviour.SmartType.Position;
			}
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("GeeztJeez.StitchedItems", "StitchedItems", "1.0.0")]
	internal class Loader : BaseUnityPlugin
	{
		public static string modName;

		public static bool DebugEnabled;

		public static string modtitle;

		private void ApplyHarmony()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				new Harmony(modName).PatchAll(Assembly.GetExecutingAssembly());
				Log(" Harmony patched successfully!");
			}
			catch (Exception ex)
			{
				LogError("Harmony patch failed: " + ex);
				Log("Please contact Geezt Jeez or try reloading the game for proper installation...");
			}
		}

		static Loader()
		{
			DebugEnabled = false;
			modtitle = "Stitched Items";
			modName = "StitchedItems";
		}

		public static void Log(string message)
		{
			if (DebugEnabled)
			{
				Debug.Log((object)$"[{modName}] {message}");
			}
		}

		public static void LogWarning(string message)
		{
			if (DebugEnabled)
			{
				Debug.LogWarning((object)$"[{modName}] {message}");
			}
		}

		public static void LogError(string message)
		{
			if (DebugEnabled)
			{
				Debug.LogError((object)$"[{modName}] {message}");
			}
		}

		private void Awake()
		{
			ApplyHarmony();
			((MonoBehaviour)this).StartCoroutine(Call());
		}

		private IEnumerator Call()
		{
			yield return (object)new WaitUntil((Func<bool>)(() => (Object)(object)Object.FindObjectOfType<ServiceLocator>() != (Object)null));
			yield return (object)new WaitUntil((Func<bool>)(() => ServiceLocator.GetService<ISaveLoaderService>() != null));
			Log($"Loading {modtitle}!");
			SLMALoader.GetInstance();
			Manager.Init(ContentDatabase.Instance().LandfallContentDatabase);
			GameObject[] array = Resources.FindObjectsOfTypeAll<GameObject>();
			for (int num = 0; num < array.Length; num++)
			{
				Manager.SetItemObject(array[num]);
			}
			Log($"Loaded {modtitle} Successfully!");
		}
	}
	public static class UTI
	{
		public static class ICat
		{
			public static void SetTag(GameObject item, string categoryName = "Technical Items", TagType tagType = (TagType)0)
			{
				//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					if ((Object)(object)item == (Object)null)
					{
						Loader.LogWarning("[SetTag] Provided item is null.");
						return;
					}
					CharacterItem componentInChildren = item.GetComponentInChildren<CharacterItem>();
					if ((Object)(object)componentInChildren == (Object)null)
					{
						Loader.LogWarning("[SetTag] CharacterItem not found in children.");
						return;
					}
					if (componentInChildren.tags == null)
					{
						componentInChildren.tags = new List<Tag>();
					}
					string uniqueValue = categoryName;
					int num = 0;
					while (componentInChildren.tags.Exists((Tag tag) => tag.value == uniqueValue))
					{
						num++;
						uniqueValue = $"{categoryName}_{num}";
						if (num > 999999)
						{
							Loader.LogError("[SetTag] Failed to generate a unique tag value after 999999 attempts.");
							return;
						}
					}
					componentInChildren.tags.Add(new Tag
					{
						tagType = tagType,
						value = uniqueValue
					});
				}
				catch (Exception ex)
				{
					Loader.LogError("[SetTag] Exception occurred: " + ex.Message);
				}
			}
		}

		public enum assetType
		{
			Prop,
			Ability
		}

		public static string comment;

		public static AssetBundle bundle;

		private static Dictionary<DatabaseID, GameObject> CombatMoves
		{
			get
			{
				Dictionary<DatabaseID, GameObject> dictionary = HelpLibrary.m_combatMoves;
				if (dictionary == null)
				{
					dictionary = (HelpLibrary.m_combatMoves = new Dictionary<DatabaseID, GameObject>());
				}
				return dictionary;
			}
		}

		private static Dictionary<DatabaseID, GameObject> CharacterProps
		{
			get
			{
				Dictionary<DatabaseID, GameObject> dictionary = HelpLibrary.m_characterProps;
				if (dictionary == null)
				{
					dictionary = (HelpLibrary.m_characterProps = new Dictionary<DatabaseID, GameObject>());
				}
				return dictionary;
			}
		}

		public static void LoadBundle(string assetBundleName)
		{
			Stream manifestResourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(assetBundleName);
			if (manifestResourceStream == null)
			{
				Loader.LogError("[LoadBundle] Failed to find resource: " + assetBundleName);
			}
			else if (!manifestResourceStream.CanRead)
			{
				Loader.LogError("[LoadBundle] Resource stream is not readable: " + assetBundleName);
			}
			else
			{
				bundle = AssetBundle.LoadFromStream(manifestResourceStream);
			}
		}

		public static Sprite LoadTexture2Sprite(string name)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = (Texture2D)bundle.LoadAsset(name);
			((Texture)val).filterMode = (FilterMode)0;
			return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
		}

		public static GameObject LoadGmObj(string name)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			return (GameObject)bundle.LoadAsset(name);
		}

		private static bool IsOccupied(DatabaseID id)
		{
			//IL_0005: 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)
			if (!CombatMoves.ContainsKey(id))
			{
				return CharacterProps.ContainsKey(id);
			}
			return true;
		}

		public static int IDScan(assetType type, int startId = 1)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			int num = Math.Max(1, startId);
			DatabaseID id = default(DatabaseID);
			((DatabaseID)(ref id))..ctor(num);
			while (IsOccupied(id))
			{
				Loader.LogWarning($"[IDChecker] ID {num} in use, trying {num + 1}…");
				num++;
				((DatabaseID)(ref id))..ctor(num);
			}
			Loader.Log($"[IDChecker] Found free ID: {num}");
			return num;
		}
	}
}
namespace SIComponents
{
	public class StitchedClothingBehaviour : MonoBehaviour
	{
		public Transform UnitBone;

		public string BoneName;

		public List<Transform> ClothingBones = new List<Transform>();
	}
}
namespace TIHarmonyPatches
{
	[HarmonyPatch(typeof(Stitcher), "StitchUnitEditor")]
	internal static class StitcherHarmonyPatch
	{
		private static readonly Dictionary<Transform, Transform> ClothMasters;

		private static bool Prefix(GameObject sourceClothing, GameObject targetAvatar, TransformCatalog boneCatalog, ref GameObject[] __result)
		{
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			sourceClothing.SetActive(true);
			SkinnedMeshRenderer[] componentsInChildren = sourceClothing.GetComponentsInChildren<SkinnedMeshRenderer>(true);
			__result = (GameObject[])(object)new GameObject[componentsInChildren.Length];
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				SkinnedMeshRenderer val = componentsInChildren[i];
				Transform[] bones = val.bones;
				foreach (Transform val2 in bones)
				{
					if (!((Object)(object)val2 == (Object)null) && ((Dictionary<string, Transform>)(object)boneCatalog).TryGetValue(((Object)val2).name, out Transform value))
					{
						Transform orCreateMaster = GetOrCreateMaster(value);
						Transform orCreatePropContainer = GetOrCreatePropContainer(orCreateMaster, sourceClothing);
						if ((Object)(object)val2.parent != (Object)(object)orCreatePropContainer)
						{
							val2.SetParent(orCreatePropContainer, true);
						}
						StitchedClothingBehaviour component = ((Component)orCreateMaster).GetComponent<StitchedClothingBehaviour>();
						if (!component.ClothingBones.Contains(val2))
						{
							component.ClothingBones.Add(val2);
						}
						val2.localPosition = Vector3.zero;
						val2.localRotation = Quaternion.identity;
						val2.localScale = Vector3.one;
					}
				}
				if ((Object)(object)val.rootBone != (Object)null && ((Dictionary<string, Transform>)(object)boneCatalog).TryGetValue(((Object)val.rootBone).name, out Transform value2))
				{
					Transform orCreatePropContainer2 = GetOrCreatePropContainer(GetOrCreateMaster(value2), sourceClothing);
					if ((Object)(object)val.rootBone.parent != (Object)(object)orCreatePropContainer2)
					{
						val.rootBone.SetParent(orCreatePropContainer2, true);
					}
				}
				__result[i] = ((Component)val).gameObject;
			}
			sourceClothing.transform.SetParent(targetAvatar.transform, false);
			return false;
		}

		private static Transform GetOrCreateMaster(Transform unitBone)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: 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)
			if (ClothMasters.TryGetValue(unitBone, out var value))
			{
				return value;
			}
			GameObject val = new GameObject(((Object)unitBone).name + "ClothMaster");
			value = val.transform;
			value.SetParent(unitBone, false);
			value.localPosition = Vector3.zero;
			value.localRotation = Quaternion.identity;
			value.localScale = Vector3.one;
			StitchedClothingBehaviour stitchedClothingBehaviour = val.AddComponent<StitchedClothingBehaviour>();
			stitchedClothingBehaviour.UnitBone = unitBone;
			stitchedClothingBehaviour.BoneName = ((Object)unitBone).name;
			ClothMasters.Add(unitBone, value);
			return value;
		}

		static StitcherHarmonyPatch()
		{
			ClothMasters = new Dictionary<Transform, Transform>();
		}

		private static Transform GetOrCreatePropContainer(Transform clothMaster, GameObject sourceClothing)
		{
			//IL_0030: 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)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			string text = ((Object)sourceClothing).name + "_" + ((Object)sourceClothing).GetInstanceID();
			Transform val = clothMaster.Find(text);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			val = new GameObject(text).transform;
			val.SetParent(clothMaster, false);
			val.localPosition = Vector3.zero;
			val.localRotation = Quaternion.identity;
			val.localScale = Vector3.one;
			return val;
		}
	}
	[HarmonyPatch(typeof(CharacterItem), "Equip", new Type[]
	{
		typeof(GameObject),
		typeof(PropItemData),
		typeof(TransformCatalog),
		typeof(Team),
		typeof(bool)
	})]
	public static class CharacterItemEquipHarmonyPatch
	{
		private static readonly FieldInfo GameObjectsField = AccessTools.Field(typeof(CharacterItem), "m_gameObjects");

		private static bool Prefix(CharacterItem __instance, GameObject unitRoot, PropItemData propData, TransformCatalog catalog, Team team, bool isUnitEditor, ref GameObject[] __result)
		{
			unitRoot.GetComponent<UnitRig>();
			if ((Object)(object)((Component)__instance).GetComponentInChildren<SkinnedMeshRenderer>() != (Object)null)
			{
				__instance.Equip();
				GameObject[] array = Stitcher.StitchUnitEditor(((Component)__instance).gameObject, unitRoot, catalog);
				GameObjectsField.SetValue(__instance, array);
				__result = array;
				return true;
			}
			return true;
		}
	}
}
namespace SIComponents
{
	public class SmartSkinnedPropBehaviour : MonoBehaviour
	{
		public enum SmartType
		{
			Scale,
			Position,
			Rotation
		}

		public int propBoneId;

		public int stitcherId;

		public SmartType smartType;

		public Vector3 values;

		public GameObject objectToAffect;

		private IEnumerator Start()
		{
			SetSettings();
			objectToAffect = ((Component)((Component)((Component)this).transform.root).GetComponentsInChildren<StitchedClothingBehaviour>()[stitcherId].ClothingBones.ToArray()[propBoneId]).gameObject;
			while ((Object)(object)objectToAffect == (Object)null)
			{
				Loader.Log("Fetching object...");
				yield return null;
			}
			if (Object.op_Implicit((Object)(object)objectToAffect))
			{
				if (smartType == SmartType.Scale)
				{
					objectToAffect.transform.localScale = values;
				}
				else if (smartType == SmartType.Position)
				{
					objectToAffect.transform.localPosition = values;
				}
				else
				{
					objectToAffect.transform.localRotation = Quaternion.Euler(values);
				}
			}
			((MonoBehaviour)this).StartCoroutine(MonitorPosition());
		}

		private void SetSettings()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: 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)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			Vector3 localScale = ((Component)this).transform.localScale;
			stitcherId = Mathf.RoundToInt(localScale.x);
			propBoneId = Mathf.RoundToInt(localScale.y);
			values = ((Component)this).transform.localPosition;
		}

		private IEnumerator MonitorPosition()
		{
			((Component)this).transform.hasChanged = false;
			while (true)
			{
				if (((Component)this).transform.hasChanged)
				{
					((Component)this).transform.hasChanged = false;
					if (values != ((Component)this).transform.localPosition)
					{
						values = ((Component)this).transform.localPosition;
						if (Object.op_Implicit((Object)(object)objectToAffect))
						{
							switch (smartType)
							{
							case SmartType.Scale:
								objectToAffect.transform.localScale = values;
								break;
							case SmartType.Position:
								objectToAffect.transform.localPosition = values;
								break;
							case SmartType.Rotation:
								objectToAffect.transform.localRotation = Quaternion.Euler(values);
								break;
							}
						}
					}
				}
				yield return (object)new WaitForSeconds(0.1f);
			}
		}
	}
}