using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text.Json;
using System.Text.Json.Serialization;
using AssetBundleLoader;
using FashionableStructures;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.Attributes;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppRUMBLE.MoveSystem;
using Il2CppSystem.Collections;
using MelonLoader;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UniverseLib.Runtime.Il2Cpp;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(main), "FashionableStructures", "0.1.0", "Tamrell", null)]
[assembly: MelonGame("Buckethead Entertainment", "RUMBLE")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyCopyright("Copyright © AlienWare 2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("15220484-bea8-4b8e-ac8c-41ff723ec2f0")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("FashionableStructures")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("FashionableStructures")]
[assembly: AssemblyTitle("FashionableStructures")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace FashionableStructures
{
	public class main : MelonMod
	{
		[HarmonyPatch(typeof(Structure), "OnFetchFromPool")]
		public static class StructureRespawn
		{
			private static void Postfix(ref Structure __instance)
			{
				if (Instance.configs == null)
				{
					MelonLogger.Error("No configuration loaded, cannot load asset bundles.");
					return;
				}
				GameObject gameObject = ((Component)__instance.processableComponent).gameObject;
				switch (((Object)gameObject).name)
				{
				case "LargeRock":
					Instance.AttachAccessoriesToStructure(Instance.configs.LargeRock, gameObject, "LargeRock");
					break;
				case "Pillar":
					Instance.AttachAccessoriesToStructure(Instance.configs.Pillar, ((Component)gameObject.transform.FindChild("Pillar")).gameObject, "Pillar");
					break;
				case "Disc":
					Instance.AttachAccessoriesToStructure(Instance.configs.Disk, ((Component)gameObject.transform.FindChild("Structure_Disc")).gameObject, "Disc");
					break;
				case "Wall":
					Instance.AttachAccessoriesToStructure(Instance.configs.Wall, ((Component)gameObject.transform.FindChild("Wall")).gameObject, "Wall");
					break;
				case "RockCube":
					Instance.AttachAccessoriesToStructure(Instance.configs.Cube, ((Component)gameObject.transform.FindChild("RockCube")).gameObject, "Cube");
					break;
				case "Ball":
					Instance.AttachAccessoriesToStructure(Instance.configs.Ball, ((Component)gameObject.transform.FindChild("Ball")).gameObject, "Ball");
					break;
				}
			}
		}

		public class Structure
		{
			[JsonPropertyName("assetBundle")]
			public string AssetBundle { get; set; }

			[JsonPropertyName("assetName")]
			public string AssetName { get; set; }

			[JsonPropertyName("placementOptions")]
			public List<PlacementOption> PlacementOptions { get; set; }

			[JsonPropertyName("probability")]
			public float Probability { get; set; }
		}

		public class PlacementOption
		{
			[JsonPropertyName("position")]
			public List<float> Position { get; set; }

			[JsonPropertyName("rotation")]
			public List<float> Rotation { get; set; }

			[JsonPropertyName("scale")]
			public List<float> Scale { get; set; }
		}

		public class Config
		{
			[JsonPropertyName("Disk")]
			public List<List<Structure>> Disk { get; set; }

			[JsonPropertyName("Pillar")]
			public List<List<Structure>> Pillar { get; set; }

			[JsonPropertyName("Ball")]
			public List<List<Structure>> Ball { get; set; }

			[JsonPropertyName("Cube")]
			public List<List<Structure>> Cube { get; set; }

			[JsonPropertyName("Wall")]
			public List<List<Structure>> Wall { get; set; }

			[JsonPropertyName("LargeRock")]
			public List<List<Structure>> LargeRock { get; set; }
		}

		private Config? configs;

		private Dictionary<string, AssetBundle> assetBundles = new Dictionary<string, AssetBundle>();

		public static main Instance { get; private set; }

		public override void OnApplicationStart()
		{
			((MelonBase)this).OnApplicationStart();
			Instance = this;
			loadConfigs();
			LoadAllAssetBundles();
		}

		private void AttachAccessoriesToStructure(List<List<Structure>> accessoryBundles, GameObject struc, string structureName)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			IEnumerator enumerator = struc.transform.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					Transform val = (Transform)enumerator.Current;
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
			}
			finally
			{
				if (enumerator is IDisposable disposable)
				{
					disposable.Dispose();
				}
			}
			List<Structure> list = accessoryBundles[Random.Range(0, accessoryBundles.Count)];
			foreach (Structure item in list)
			{
				if (assetBundles.TryGetValue(item.AssetBundle, out AssetBundle value))
				{
					if (!(item.Probability < Random.value))
					{
						GameObject val2 = Object.Instantiate<GameObject>(value.LoadAsset<GameObject>(item.AssetName), struc.transform);
						((Object)val2).name = item.AssetName;
						if ((Object)(object)val2 == (Object)null)
						{
							MelonLogger.Error("Failed to load asset '" + item.AssetName + "'.");
							continue;
						}
						PlacementOption placementOption = item.PlacementOptions[Random.Range(0, item.PlacementOptions.Count)];
						val2.transform.localPosition = new Vector3(placementOption.Position[0], placementOption.Position[1], placementOption.Position[2]);
						val2.transform.localRotation = new Quaternion(placementOption.Rotation[0], placementOption.Rotation[1], placementOption.Rotation[2], placementOption.Rotation[3]);
						val2.transform.localScale = new Vector3(placementOption.Scale[0], placementOption.Scale[1], placementOption.Scale[2]);
						MelonLogger.Msg($"Asset '{item.AssetName}' attached to {structureName}.");
					}
				}
				else
				{
					MelonLogger.Error("Asset bundle '" + item.AssetBundle + "' not loaded.");
				}
			}
		}

		private void loadConfigs()
		{
			try
			{
				string json = File.ReadAllText("UserData\\FashionableStructures\\config.json");
				configs = JsonSerializer.Deserialize<Config>(json);
				if (configs == null)
				{
					MelonLogger.Msg("Config file is corrupted or empty");
				}
			}
			catch (Exception ex)
			{
				MelonLogger.Msg("An error occurred: " + ex.Message);
			}
		}

		private void LoadAllAssetBundles()
		{
			if (configs == null)
			{
				MelonLogger.Error("No configuration loaded, cannot load asset bundles.");
				return;
			}
			List<List<Structure>>[] array = new List<List<Structure>>[6] { configs.Disk, configs.Pillar, configs.Ball, configs.Cube, configs.Wall, configs.LargeRock };
			foreach (List<List<Structure>> list in array)
			{
				foreach (List<Structure> item in list)
				{
					foreach (Structure item2 in item)
					{
						if (!assetBundles.ContainsKey(item2.AssetBundle))
						{
							string text = Path.Combine("UserData", "FashionableStructures", "FashionableAssets", item2.AssetBundle);
							AssetBundle assetBundle = AssetBundle.LoadFromFile(text);
							if ((Object)(object)assetBundle == (Object)null)
							{
								MelonLogger.Msg("Could not load asset bundle from: " + text);
								continue;
							}
							assetBundles[item2.AssetBundle] = assetBundle;
							MelonLogger.Msg("Asset bundle loaded successfully from: " + text);
						}
					}
				}
			}
		}
	}
}
namespace UniverseLib.Runtime.Il2Cpp
{
	public static class ICallManager
	{
		private static readonly Dictionary<string, Delegate> iCallCache = new Dictionary<string, Delegate>();

		private static readonly Dictionary<string, Delegate> unreliableCache = new Dictionary<string, Delegate>();

		public static T GetICall<T>(string signature) where T : Delegate
		{
			if (iCallCache.ContainsKey(signature))
			{
				return (T)iCallCache[signature];
			}
			IntPtr intPtr = IL2CPP.il2cpp_resolve_icall(signature);
			if (intPtr == IntPtr.Zero)
			{
				throw new MissingMethodException("Could not find any iCall with the signature '" + signature + "'!");
			}
			Delegate delegateForFunctionPointer = Marshal.GetDelegateForFunctionPointer(intPtr, typeof(T));
			iCallCache.Add(signature, delegateForFunctionPointer);
			return (T)delegateForFunctionPointer;
		}

		public static T GetICallUnreliable<T>(params string[] possibleSignatures) where T : Delegate
		{
			string text = possibleSignatures.First();
			if (unreliableCache.ContainsKey(text))
			{
				return (T)unreliableCache[text];
			}
			foreach (string text2 in possibleSignatures)
			{
				IntPtr intPtr = IL2CPP.il2cpp_resolve_icall(text2);
				if (intPtr != IntPtr.Zero)
				{
					T val = (T)Marshal.GetDelegateForFunctionPointer(intPtr, typeof(T));
					unreliableCache.Add(text, val);
					return val;
				}
			}
			throw new MissingMethodException("Could not find any iCall from list of provided signatures starting with '" + text + "'!");
		}
	}
}
namespace AssetBundleLoader
{
	public class AssetBundle : Object
	{
		internal delegate IntPtr d_LoadFromFile(IntPtr path, uint crc, ulong offset);

		private delegate IntPtr d_LoadFromMemory(IntPtr binary, uint crc);

		public delegate IntPtr d_GetAllLoadedAssetBundles_Native();

		internal delegate IntPtr d_LoadAssetWithSubAssets_Internal(IntPtr _this, IntPtr name, IntPtr type);

		internal delegate IntPtr d_LoadAsset_Internal(IntPtr _this, IntPtr name, IntPtr type);

		internal delegate void d_Unload(IntPtr _this, bool unloadAllLoadedObjects);

		public readonly IntPtr m_bundlePtr = IntPtr.Zero;

		static AssetBundle()
		{
			ClassInjector.RegisterTypeInIl2Cpp<AssetBundle>();
		}

		[HideFromIl2Cpp]
		public static AssetBundle LoadFromFile(string path)
		{
			MelonLogger.Msg(Directory.GetCurrentDirectory());
			IntPtr intPtr = ICallManager.GetICallUnreliable<d_LoadFromFile>(new string[2] { "UnityEngine.AssetBundle::LoadFromFile_Internal", "UnityEngine.AssetBundle::LoadFromFile" })(IL2CPP.ManagedStringToIl2Cpp(path), 0u, 0uL);
			MelonLogger.Msg((object)(nint)intPtr);
			return (intPtr != IntPtr.Zero) ? new AssetBundle(intPtr) : null;
		}

		[HideFromIl2Cpp]
		public static AssetBundle LoadFromMemory(byte[] binary, uint crc = 0u)
		{
			IntPtr intPtr = ICallManager.GetICallUnreliable<d_LoadFromMemory>(new string[2] { "UnityEngine.AssetBundle::LoadFromMemory_Internal", "UnityEngine.AssetBundle::LoadFromMemory" })(((Il2CppObjectBase)Il2CppStructArray<byte>.op_Implicit(binary)).Pointer, crc);
			return (intPtr != IntPtr.Zero) ? new AssetBundle(intPtr) : null;
		}

		[HideFromIl2Cpp]
		public static AssetBundle[] GetAllLoadedAssetBundles()
		{
			IntPtr intPtr = ICallManager.GetICall<d_GetAllLoadedAssetBundles_Native>("UnityEngine.AssetBundle::GetAllLoadedAssetBundles_Native")();
			return (intPtr != IntPtr.Zero) ? Il2CppArrayBase<AssetBundle>.op_Implicit((Il2CppArrayBase<AssetBundle>)(object)new Il2CppReferenceArray<AssetBundle>(intPtr)) : null;
		}

		public AssetBundle(IntPtr ptr)
			: base(ptr)
		{
			m_bundlePtr = ptr;
		}

		[HideFromIl2Cpp]
		public Object[] LoadAllAssets()
		{
			IntPtr intPtr = ICallManager.GetICall<d_LoadAssetWithSubAssets_Internal>("UnityEngine.AssetBundle::LoadAssetWithSubAssets_Internal")(m_bundlePtr, IL2CPP.ManagedStringToIl2Cpp(""), ((Il2CppObjectBase)Il2CppType.Of<Object>()).Pointer);
			return (Object[])((intPtr != IntPtr.Zero) ? ((Array)Il2CppArrayBase<Object>.op_Implicit((Il2CppArrayBase<Object>)(object)new Il2CppReferenceArray<Object>(intPtr))) : ((Array)new Object[0]));
		}

		[HideFromIl2Cpp]
		public T LoadAsset<T>(string name) where T : Object
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			IntPtr intPtr = ICallManager.GetICall<d_LoadAsset_Internal>("UnityEngine.AssetBundle::LoadAsset_Internal")(m_bundlePtr, IL2CPP.ManagedStringToIl2Cpp(name), ((Il2CppObjectBase)Il2CppType.Of<T>()).Pointer);
			return (intPtr != IntPtr.Zero) ? ((Il2CppObjectBase)new Object(intPtr)).TryCast<T>() : default(T);
		}

		[HideFromIl2Cpp]
		public void Unload(bool unloadAllLoadedObjects)
		{
			ICallManager.GetICall<d_Unload>("UnityEngine.AssetBundle::Unload")(m_bundlePtr, unloadAllLoadedObjects);
		}
	}
}