using System;
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 BepInEx;
using HarmonyLib;
using PotionCraft.ManagersSystem;
using PotionCraft.ManagersSystem.Potion.Entities;
using PotionCraft.ManagersSystem.SaveLoad;
using PotionCraft.ObjectBased;
using PotionCraft.ObjectBased.AlchemyMachine;
using PotionCraft.ObjectBased.AlchemyMachine.Settings;
using PotionCraft.ObjectBased.AlchemyMachineProduct;
using PotionCraft.ObjectBased.UIElements.Bookmarks;
using PotionCraft.ObjectBased.UIElements.Books;
using PotionCraft.ObjectBased.UIElements.Books.RecipeBook;
using PotionCraft.ObjectBased.UIElements.FinishLegendarySubstanceMenu;
using PotionCraft.QuestSystem.DesiredItems;
using PotionCraft.SaveFileSystem;
using PotionCraft.ScriptableObjects;
using PotionCraft.ScriptableObjects.AlchemyMachineProducts;
using PotionCraft.Settings;
using PotionCraft.Utils.CustomAnimator;
using UnityEngine;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.NamingConventions;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("LegendaryRecipeDefiner")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("LegendaryRecipeDefiner")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("92e81ed6-c52c-46a2-b007-7dbcacf5ee64")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace LegendaryRecipeDefiner;

[BepInPlugin("fgvb.potioncraft.legendaryrecipedefiner", "LegendaryRecipeDefiner", "1.0.3.0")]
public class LegendaryRecipeDefiner : BaseUnityPlugin
{
	[Serializable]
	public enum MachinePart
	{
		Unknown = -1,
		RightRetort,
		RightDripper,
		RhombusVessel,
		TriangularVessel,
		RightFurnace,
		DoubleVessel,
		FloorVessel,
		LeftDripper,
		LeftRetort,
		SpiralVessel,
		LeftFurnace,
		TripletVesselLeft,
		TripletVesselCenter,
		TripletVesselRight,
		Last
	}

	[Serializable]
	public class LRDSettings
	{
		public string entry = "recipes_1.0";

		public bool error_off_entry = false;

		public bool allow_less_ingredients = true;

		public bool allow_more_ingredients = true;

		public bool allow_no_ingredients = true;
	}

	[Serializable]
	public class SerializedUpdate
	{
		public MachinePart part;

		public List<string> components;

		public SerializedUpdate()
		{
			part = MachinePart.Unknown;
			components = new List<string>();
		}

		public SerializedUpdate(MachinePart part__, List<string> components__)
		{
			part = part__;
			components = components__;
		}
	}

	[Serializable]
	public class SerializedRecipe
	{
		public string name = "";

		public List<SerializedUpdate> recipe = new List<SerializedUpdate>();
	}

	[Serializable]
	public class SerializedRecipeList
	{
		public List<SerializedRecipe> recipes = new List<SerializedRecipe>();
	}

	[Serializable]
	public class SerializedSafeBookmark
	{
		public float positionX;

		public float positionY;

		public int prefabIndex;

		public bool isMirrored;

		public int index;

		public SerializedSafeBookmark()
		{
			positionX = -1f;
			positionY = -1f;
			prefabIndex = -1;
			isMirrored = false;
			index = -1;
		}

		public SerializedSafeBookmark(float x, float y, int prefab, bool mirrored, int rail)
		{
			positionX = x;
			positionY = y;
			prefabIndex = prefab;
			isMirrored = mirrored;
			index = rail;
		}

		public SerializedBookmark ToDefault(ref int rail)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			SerializedBookmark val = new SerializedBookmark();
			val.position = new Vector2(positionX, positionY);
			val.prefabIndex = prefabIndex;
			val.isMirrored = isMirrored;
			rail = index;
			return val;
		}
	}

	[Serializable]
	public class SerializedSavedRecipe
	{
		public SerializedRecipe content = null;

		public SerializedSafeBookmark mark = new SerializedSafeBookmark();
	}

	[Serializable]
	public class SerializedSafeLedgeTargetData
	{
		public bool isItemOnLedge = false;

		public float ledgePositionX = 0f;

		public float ledgePositionY = 0f;

		public int itemIndexOnLedge = -1;

		public SerializedSafeLedgeTargetData()
		{
		}

		public SerializedSafeLedgeTargetData(bool _isItemOnLedge, Vector2 ledgePosition, int _itemIndexOnLedge)
		{
			//IL_0034: 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)
			isItemOnLedge = _isItemOnLedge;
			ledgePositionX = ledgePosition.x;
			ledgePositionY = ledgePosition.y;
			itemIndexOnLedge = _itemIndexOnLedge;
		}

		public static SerializedLedgeTargetData SafeToNormal(SerializedSafeLedgeTargetData value)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			SerializedLedgeTargetData val = new SerializedLedgeTargetData();
			val.isItemOnLedge = value.isItemOnLedge;
			val.ledgePosition = new Vector2(value.ledgePositionX, value.ledgePositionY);
			val.itemIndexOnLedge = value.itemIndexOnLedge;
			return val;
		}
	}

	[Serializable]
	public class SerializedSafeItemFromInventory
	{
		public string typeName = "";

		public float positionX = -1f;

		public float positionY = 0f;

		public float eulerAnglesX = 0f;

		public float eulerAnglesY = 0f;

		public float eulerAnglesZ = 0f;

		public string inventoryItemName = "";

		public List<SerializedSafeLedgeTargetData> ledgeDataList = null;

		public string data = "";

		public SerializedSafeItemFromInventory()
		{
		}

		public SerializedSafeItemFromInventory(string _typeName, Vector2 position, Vector3 eulerAngles, string _inventoryItemName, List<SerializedLedgeTargetData> _ledgeDataList, string _data)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			typeName = _typeName;
			positionX = position.x;
			positionY = position.y;
			eulerAnglesX = eulerAngles.x;
			eulerAnglesY = eulerAngles.y;
			eulerAnglesZ = eulerAngles.z;
			inventoryItemName = _inventoryItemName;
			if (_ledgeDataList != null)
			{
				ledgeDataList = new List<SerializedSafeLedgeTargetData>();
				foreach (SerializedLedgeTargetData _ledgeData in _ledgeDataList)
				{
					ledgeDataList.Add(new SerializedSafeLedgeTargetData(_ledgeData.isItemOnLedge, _ledgeData.ledgePosition, _ledgeData.itemIndexOnLedge));
				}
			}
			data = _data;
		}

		public static SerializedItemFromInventory SafeToNormal(SerializedSafeItemFromInventory value)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			SerializedItemFromInventory val = new SerializedItemFromInventory();
			val.typeName = value.typeName;
			val.position = new Vector2(value.positionX, value.positionY);
			val.eulerAngles = new Vector3(value.eulerAnglesX, value.eulerAnglesY, value.eulerAnglesZ);
			val.inventoryItemName = value.inventoryItemName;
			val.ledgeDataList = new List<SerializedLedgeTargetData>();
			if (value.ledgeDataList != null)
			{
				foreach (SerializedSafeLedgeTargetData ledgeData in value.ledgeDataList)
				{
					val.ledgeDataList.Add(SerializedSafeLedgeTargetData.SafeToNormal(ledgeData));
				}
			}
			val.data = value.data;
			return val;
		}
	}

	[Serializable]
	public class SafeColor
	{
		public float r = 0f;

		public float g = 0f;

		public float b = 0f;

		public float a = 1f;

		public SafeColor()
		{
		}

		public SafeColor(Color color)
		{
			//IL_0035: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			r = color.r;
			g = color.g;
			b = color.b;
			a = color.a;
		}

		public Color ToColor()
		{
			//IL_0019: 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_0021: Unknown result type (might be due to invalid IL or missing references)
			return new Color(r, g, b, a);
		}
	}

	[Serializable]
	public class SafeColorList
	{
		public List<SafeColor> colorsList = new List<SafeColor>();
	}

	[Serializable]
	public class SafeSkinSettings
	{
		public string currentIconName = string.Empty;

		public SafeColor currentIconColor1;

		public SafeColor currentIconColor2;

		public SafeColor currentIconColor3;

		public SafeColor currentIconColor4;

		public string currentCustomTitle = string.Empty;

		public bool isCurrentTitleCustom;

		public string currentDescription = string.Empty;

		public bool isCurrentIconCustom;

		public bool isCurrentIconColor1Custom;

		public bool isCurrentIconColor2Custom;

		public bool isCurrentIconColor3Custom;

		public bool isCurrentIconColor4Custom;

		public int colorsCount;

		public SafeSkinSettings()
		{
		}

		public SafeSkinSettings(SerializedAlchemyMachineProductSkinSettings settings)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			currentIconName = settings.currentIconName;
			currentIconColor1 = new SafeColor(settings.currentIconColor1);
			currentIconColor2 = new SafeColor(settings.currentIconColor2);
			currentIconColor3 = new SafeColor(settings.currentIconColor3);
			currentIconColor4 = new SafeColor(settings.currentIconColor4);
			currentCustomTitle = settings.currentCustomTitle;
			isCurrentTitleCustom = settings.isCurrentTitleCustom;
			currentDescription = settings.currentDescription;
			isCurrentIconCustom = settings.isCurrentIconCustom;
			isCurrentIconColor1Custom = settings.isCurrentIconColor1Custom;
			isCurrentIconColor2Custom = settings.isCurrentIconColor2Custom;
			isCurrentIconColor3Custom = settings.isCurrentIconColor3Custom;
			isCurrentIconColor4Custom = settings.isCurrentIconColor4Custom;
			colorsCount = settings.colorsCount;
		}

		public SerializedAlchemyMachineProductSkinSettings ToSettings()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			SerializedAlchemyMachineProductSkinSettings val = new SerializedAlchemyMachineProductSkinSettings();
			val.currentIconName = currentIconName;
			val.currentIconColor1 = currentIconColor1.ToColor();
			val.currentIconColor2 = currentIconColor2.ToColor();
			val.currentIconColor3 = currentIconColor3.ToColor();
			val.currentIconColor4 = currentIconColor4.ToColor();
			val.currentCustomTitle = currentCustomTitle;
			val.isCurrentTitleCustom = isCurrentTitleCustom;
			val.currentDescription = currentDescription;
			val.isCurrentIconCustom = isCurrentIconCustom;
			val.isCurrentIconColor1Custom = isCurrentIconColor1Custom;
			val.isCurrentIconColor2Custom = isCurrentIconColor2Custom;
			val.isCurrentIconColor3Custom = isCurrentIconColor3Custom;
			val.isCurrentIconColor4Custom = isCurrentIconColor4Custom;
			val.colorsCount = colorsCount;
			return val;
		}
	}

	[Serializable]
	public class SafeComponentList
	{
		public List<SerializedRecipeReagent> components = new List<SerializedRecipeReagent>();

		public List<AlchemyMachineSlot> componentsSlots = new List<AlchemyMachineSlot>();
	}

	[Serializable]
	public class SerializedSafeRecipeData
	{
		public string name = "";

		public List<SafeColorList> colorsList = null;

		public SafeSkinSettings skinSettings = null;

		public SafeComponentList usedComponents = null;

		public RecipeBookPageContentType type;

		public SerializedSafeRecipeData()
		{
		}

		public SerializedSafeRecipeData(SerializedAlchemyMachineProductRecipeData data)
		{
			//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)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			name = data.name;
			colorsList = new List<SafeColorList>();
			foreach (ColorsList colors in data.colorsList)
			{
				SafeColorList safeColorList = new SafeColorList();
				foreach (Color color in colors.colors)
				{
					safeColorList.colorsList.Add(new SafeColor(color));
				}
				colorsList.Add(safeColorList);
			}
			skinSettings = new SafeSkinSettings(data.skinSettings);
			usedComponents = new SafeComponentList();
			usedComponents.components = data.usedComponents.GetComponents();
			usedComponents.componentsSlots = data.usedComponents.GetComponentsSlots();
			type = data.GetRecipeBookPageContentType();
		}

		public SerializedAlchemyMachineProductRecipeData ToData()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			SerializedAlchemyMachineProductRecipeData val = new SerializedAlchemyMachineProductRecipeData(type);
			val.name = name;
			val.colorsList = new List<ColorsList>();
			foreach (SafeColorList colors in colorsList)
			{
				ColorsList val2 = new ColorsList();
				foreach (SafeColor colors2 in colors.colorsList)
				{
					val2.colors.Add(colors2.ToColor());
				}
				val.colorsList.Add(val2);
			}
			val.skinSettings = skinSettings.ToSettings();
			val.usedComponents = new SerializedCompositeAlchemySubstanceComponents(usedComponents.components, usedComponents.componentsSlots);
			return val;
		}
	}

	[Serializable]
	public class SerializedState
	{
		public List<SerializedSavedRecipe> recipes = new List<SerializedSavedRecipe>();

		public SerializedSafeItemFromInventory currentMachineContent = null;

		public SerializedSafeRecipeData currentMachineRecipe = null;

		public SerializedRecipe previousRecipe = null;

		public bool productChanged = false;
	}

	public class PartUpdate
	{
		public MachinePart partID = MachinePart.Unknown;

		public PotionEffect[] effects = (PotionEffect[])(object)new PotionEffect[0];

		public AlchemyMachineProduct product = null;

		public PartUpdate()
		{
		}

		public PartUpdate(MachinePart partID__, PotionEffect[] effects__, AlchemyMachineProduct product__ = null)
		{
			partID = partID__;
			effects = effects__;
			product = product__;
		}
	}

	public const string pluginGuid = "fgvb.potioncraft.legendaryrecipedefiner";

	public const string pluginName = "LegendaryRecipeDefiner";

	public const string pluginVersion = "1.0.3.0";

	protected static string current_directory = "";

	protected static string currentLoadedFile = "";

	protected static string currentSavedFile = "";

	private static string stringToBeSaved = "";

	private static IDeserializer deserializer;

	private static ISerializer serializer;

	private static int lastMinimum = -1;

	private static bool hasSubstanceLoadedExternally = false;

	private static LRDSettings settings = null;

	public static LRDSettings Settings => settings;

	public static LegendaryRecipeDefiner Instance { get; set; } = null;


	private void Awake()
	{
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Expected O, but got Unknown
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Expected O, but got Unknown
		if (!Object.op_Implicit((Object)(object)Instance))
		{
			Instance = this;
			Harmony.CreateAndPatchAll(typeof(LegendaryRecipeDefiner), (string)null);
			deserializer = ((BuilderSkeleton<DeserializerBuilder>)new DeserializerBuilder()).WithNamingConvention(CamelCaseNamingConvention.Instance).Build();
			serializer = ((BuilderSkeleton<SerializerBuilder>)new SerializerBuilder()).WithNamingConvention(CamelCaseNamingConvention.Instance).Build();
			current_directory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			CreateStructure();
			VerifyDataIntegrity();
		}
	}

	private static void CreateStructure()
	{
		string path = current_directory + "/settings.yml";
		if (!File.Exists(path))
		{
			File.WriteAllText(path, serializer.Serialize((object)new LRDSettings()));
		}
		string config = File.ReadAllText(path);
		settings = ParseConfig(config);
		path = current_directory + "/Recipe Blueprints";
		if (!Directory.Exists(path))
		{
			Directory.CreateDirectory(path);
			string[] files = Directory.GetFiles(current_directory, "*.yml", SearchOption.TopDirectoryOnly);
			string[] array = files;
			foreach (string text in array)
			{
				string text2 = text.Substring(text.LastIndexOf('\\') + 1);
				if (text2 != "settings.yml")
				{
					File.Move(text, path + "/" + text2);
				}
			}
		}
		path = current_directory + "/Saved Recipes";
		if (!Directory.Exists(path))
		{
			Directory.CreateDirectory(path);
		}
	}

	private static void VerifyDataIntegrity()
	{
		string path = current_directory + "/Recipe Blueprints";
		string[] files = Directory.GetFiles(path, "*.json", SearchOption.AllDirectories);
		string[] array = files;
		foreach (string text in array)
		{
			SerializedRecipeList serializedRecipeList = deserializer.Deserialize<SerializedRecipeList>(File.ReadAllText(text));
			string path2 = text.Substring(0, text.LastIndexOf(".")) + ".yml";
			File.WriteAllText(path2, serializer.Serialize((object)serializedRecipeList));
			File.Delete(text);
		}
		path = current_directory + "/Saved Recipes";
		files = Directory.GetFiles(path, "*.json", SearchOption.AllDirectories);
		string[] array2 = files;
		foreach (string text2 in array2)
		{
			SerializedState serializedState = deserializer.Deserialize<SerializedState>(File.ReadAllText(text2));
			string path3 = text2.Substring(0, text2.LastIndexOf(".")) + ".yml";
			File.WriteAllText(path3, serializer.Serialize((object)serializedState));
			File.Delete(text2);
		}
	}

	public static LRDSettings ParseConfig(string config)
	{
		return deserializer.Deserialize<LRDSettings>(config);
	}

	public static InventoryItem GetMachinePart(LegendaryRecipe recipe, MachinePart partID)
	{
		return (InventoryItem)(partID switch
		{
			MachinePart.Unknown => null, 
			MachinePart.RightRetort => recipe.rightRetort, 
			MachinePart.RightDripper => recipe.rightDripper, 
			MachinePart.RhombusVessel => recipe.rhombusVessel, 
			MachinePart.TriangularVessel => recipe.triangularVessel, 
			MachinePart.RightFurnace => recipe.rightFurnace, 
			MachinePart.DoubleVessel => recipe.doubleVessel, 
			MachinePart.FloorVessel => recipe.floorVessel, 
			MachinePart.LeftDripper => recipe.leftDripper, 
			MachinePart.LeftRetort => recipe.leftRetort, 
			MachinePart.SpiralVessel => recipe.spiralVessel, 
			MachinePart.LeftFurnace => recipe.leftFurnace, 
			MachinePart.TripletVesselLeft => recipe.tripletVesselLeft, 
			MachinePart.TripletVesselCenter => recipe.tripletVesselCenter, 
			MachinePart.TripletVesselRight => recipe.tripletVesselRight, 
			_ => null, 
		});
	}

	public static void SetMachinePart(LegendaryRecipe recipe, MachinePart partID, InventoryItem value)
	{
		switch (partID)
		{
		case MachinePart.Unknown:
			break;
		case MachinePart.RightRetort:
			recipe.rightRetort = value;
			break;
		case MachinePart.RightDripper:
			recipe.rightDripper = value;
			break;
		case MachinePart.RhombusVessel:
			recipe.rhombusVessel = value;
			break;
		case MachinePart.TriangularVessel:
			recipe.triangularVessel = value;
			break;
		case MachinePart.RightFurnace:
			recipe.rightFurnace = value;
			break;
		case MachinePart.DoubleVessel:
			recipe.doubleVessel = value;
			break;
		case MachinePart.FloorVessel:
			recipe.floorVessel = value;
			break;
		case MachinePart.LeftDripper:
			recipe.leftDripper = value;
			break;
		case MachinePart.LeftRetort:
			recipe.leftRetort = value;
			break;
		case MachinePart.SpiralVessel:
			recipe.spiralVessel = value;
			break;
		case MachinePart.LeftFurnace:
			recipe.leftFurnace = value;
			break;
		case MachinePart.TripletVesselLeft:
			recipe.tripletVesselLeft = value;
			break;
		case MachinePart.TripletVesselCenter:
			recipe.tripletVesselCenter = value;
			break;
		case MachinePart.TripletVesselRight:
			recipe.tripletVesselRight = value;
			break;
		}
	}

	public static List<string> ProductToList(InventoryItem product)
	{
		if ((Object)(object)product == (Object)null)
		{
			return new List<string>();
		}
		List<string> list = new List<string>();
		list.Add(((Object)((product is AlchemyMachineProduct) ? product : null)).name);
		return list;
	}

	public static List<string> PotionToElementsList(InventoryItem item)
	{
		if ((Object)(object)item == (Object)null)
		{
			return new List<string>();
		}
		List<string> list = new List<string>();
		PotionEffect[] effects = ((DesiredItemPotionEffectsScriptableObject)((item is DesiredItemPotionEffectsScriptableObject) ? item : null)).effects;
		foreach (PotionEffect val in effects)
		{
			list.Add(((Object)val).name);
		}
		return list;
	}

	public static SerializedRecipe SerializeRecipe(string name)
	{
		LegendaryRecipe byName = LegendaryRecipe.GetByName(name, false, true);
		if ((Object)(object)byName == (Object)null || name == "")
		{
			return null;
		}
		SerializedRecipe serializedRecipe = new SerializedRecipe();
		serializedRecipe.name = name;
		serializedRecipe.recipe.Add(new SerializedUpdate(MachinePart.RightRetort, PotionToElementsList(byName.rightRetort)));
		serializedRecipe.recipe.Add(new SerializedUpdate(MachinePart.RightDripper, PotionToElementsList(byName.rightDripper)));
		serializedRecipe.recipe.Add(new SerializedUpdate(MachinePart.RhombusVessel, PotionToElementsList(byName.rhombusVessel)));
		serializedRecipe.recipe.Add(new SerializedUpdate(MachinePart.TriangularVessel, PotionToElementsList(byName.triangularVessel)));
		serializedRecipe.recipe.Add(new SerializedUpdate(MachinePart.RightFurnace, ProductToList(byName.rightFurnace)));
		serializedRecipe.recipe.Add(new SerializedUpdate(MachinePart.DoubleVessel, PotionToElementsList(byName.doubleVessel)));
		serializedRecipe.recipe.Add(new SerializedUpdate(MachinePart.FloorVessel, PotionToElementsList(byName.floorVessel)));
		serializedRecipe.recipe.Add(new SerializedUpdate(MachinePart.LeftDripper, PotionToElementsList(byName.leftDripper)));
		serializedRecipe.recipe.Add(new SerializedUpdate(MachinePart.LeftRetort, PotionToElementsList(byName.leftRetort)));
		serializedRecipe.recipe.Add(new SerializedUpdate(MachinePart.SpiralVessel, PotionToElementsList(byName.spiralVessel)));
		serializedRecipe.recipe.Add(new SerializedUpdate(MachinePart.LeftFurnace, ProductToList(byName.leftFurnace)));
		serializedRecipe.recipe.Add(new SerializedUpdate(MachinePart.TripletVesselLeft, PotionToElementsList(byName.tripletVesselLeft)));
		serializedRecipe.recipe.Add(new SerializedUpdate(MachinePart.TripletVesselCenter, PotionToElementsList(byName.tripletVesselCenter)));
		serializedRecipe.recipe.Add(new SerializedUpdate(MachinePart.TripletVesselRight, PotionToElementsList(byName.tripletVesselRight)));
		return serializedRecipe;
	}

	public static void CreateNewLegendaryRecipe(string name, PartUpdate[] updates)
	{
	}

	public static void ChangeLegendaryRecipeSelect(string name, PartUpdate[] updates)
	{
		//IL_0171: Unknown result type (might be due to invalid IL or missing references)
		//IL_0178: Expected O, but got Unknown
		LegendaryRecipe byName = LegendaryRecipe.GetByName(name, false, true);
		if ((Object)(object)byName == (Object)null)
		{
			if (name != "")
			{
				CreateNewLegendaryRecipe(name, updates);
			}
			return;
		}
		foreach (PartUpdate partUpdate in updates)
		{
			if (partUpdate.partID == MachinePart.RightFurnace || partUpdate.partID == MachinePart.LeftFurnace)
			{
				SetMachinePart(byName, partUpdate.partID, (InventoryItem)(object)partUpdate.product);
				continue;
			}
			if (partUpdate.effects == null || partUpdate.effects.Length == 0)
			{
				SetMachinePart(byName, partUpdate.partID, null);
				continue;
			}
			PotionEffect[] effects = (PotionEffect[])((partUpdate.effects.Length <= 5) ? ((Array)partUpdate.effects) : ((Array)new PotionEffect[5]
			{
				partUpdate.effects[0],
				partUpdate.effects[1],
				partUpdate.effects[2],
				partUpdate.effects[3],
				partUpdate.effects[4]
			}));
			InventoryItem machinePart = GetMachinePart(byName, partUpdate.partID);
			if (Object.op_Implicit((Object)(object)((machinePart is DesiredItemPotionEffectsScriptableObject) ? machinePart : null)))
			{
				InventoryItem machinePart2 = GetMachinePart(byName, partUpdate.partID);
				((DesiredItemPotionEffectsScriptableObject)((machinePart2 is DesiredItemPotionEffectsScriptableObject) ? machinePart2 : null)).effects = effects;
			}
			else if (settings.allow_more_ingredients)
			{
				DesiredItemPotionEffectsScriptableObject val = (DesiredItemPotionEffectsScriptableObject)ScriptableObject.CreateInstance(typeof(DesiredItemPotionEffectsScriptableObject));
				val.effects = effects;
				val.noMoreEffects = true;
				SetMachinePart(byName, partUpdate.partID, (InventoryItem)(object)val);
			}
		}
	}

	public static void DeserializeRecipes(string yamlLocation)
	{
		if (!File.Exists(yamlLocation))
		{
			if (settings.error_off_entry)
			{
				Debug.LogError((object)("No alternative recipe YAML could be found at " + yamlLocation + "."));
			}
			return;
		}
		SerializedRecipeList serializedRecipeList = deserializer.Deserialize<SerializedRecipeList>(File.ReadAllText(yamlLocation));
		List<PartUpdate> list = new List<PartUpdate>();
		List<PotionEffect> list2 = new List<PotionEffect>();
		foreach (SerializedRecipe recipe in serializedRecipeList.recipes)
		{
			bool[] array = new bool[14];
			if (recipe.recipe != null)
			{
				foreach (SerializedUpdate item in recipe.recipe)
				{
					if (item.part == MachinePart.Unknown)
					{
						continue;
					}
					if (item.part == MachinePart.RightFurnace || item.part == MachinePart.LeftFurnace)
					{
						string text = ((item.components.Count > 0) ? item.components[0] : null);
						list.Add(new PartUpdate(item.part, null, (text == null || text == "") ? null : AlchemyMachineProduct.GetByName(text, false, true)));
					}
					else
					{
						foreach (string component in item.components)
						{
							list2.Add(PotionEffect.GetByName(component, true, true, (List<PotionEffect>)null));
						}
						list.Add(new PartUpdate(item.part, list2.ToArray()));
						list2.Clear();
					}
					array[(int)item.part] = true;
				}
			}
			for (int i = 0; i < 14; i++)
			{
				if (!array[i])
				{
					list.Add(new PartUpdate((MachinePart)i, null));
				}
			}
			if (list.Count > 0)
			{
				ChangeLegendaryRecipeSelect(recipe.name, list.ToArray());
				list.Clear();
			}
		}
	}

	[HarmonyPatch(typeof(AlchemyMachineObject), "GetSuitableLegendaryRecipe")]
	[HarmonyPrefix]
	private static bool PreLegendaryCheck()
	{
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: 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)
		AlchemyMachineObject alchemyMachine = Managers.Ingredient.alchemyMachineSubManager.alchemyMachine;
		LegendaryRecipe val = null;
		foreach (LegendaryRecipe allLegendaryRecipe in LegendaryRecipe.allLegendaryRecipes)
		{
			bool flag = false;
			for (int i = 0; i < alchemyMachine.slots.Length; i++)
			{
				AlchemyMachineSlot val2 = (AlchemyMachineSlot)i;
				if (!alchemyMachine.IsSuitableItemInSlot(allLegendaryRecipe.DesiredItemPerSlot(val2), val2))
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				val = allLegendaryRecipe;
				break;
			}
		}
		if (Object.op_Implicit((Object)(object)val) && alchemyMachine.tooFewIngredients != 0 && settings.allow_less_ingredients)
		{
			lastMinimum = alchemyMachine.tooFewIngredients;
			alchemyMachine.tooFewIngredients = 0;
		}
		else if (!Object.op_Implicit((Object)(object)val) && alchemyMachine.tooFewIngredients == 0)
		{
			alchemyMachine.tooFewIngredients = lastMinimum;
		}
		return Object.op_Implicit((Object)(object)val);
	}

	[HarmonyPatch(typeof(AlchemyMachineObject), "OnBrewAnimationDone")]
	[HarmonyPostfix]
	private static void PostBrew()
	{
		AlchemyMachineObject alchemyMachine = Managers.Ingredient.alchemyMachineSubManager.alchemyMachine;
		if (alchemyMachine.tooFewIngredients == 0)
		{
			alchemyMachine.tooFewIngredients = lastMinimum;
		}
	}

	public static void AddSavedRecipes(SerializedState state)
	{
		foreach (SerializedSavedRecipe recipe in state.recipes)
		{
			int rail = -1;
			recipe.mark.ToDefault(ref rail);
			SerializedRecipe content = recipe.content;
			RecipeBook instance = RecipeBook.Instance;
			IRecipeBookPageContent value = SerializedRecipe.DeserializeRecipe(content);
			instance.savedRecipes[rail] = value;
			instance.UpdateBookmarkIcon(rail);
		}
	}

	public static void RemoveSavedRecipes(List<IRecipeBookPageContent> removedRecipes)
	{
		foreach (IRecipeBookPageContent removedRecipe in removedRecipes)
		{
			RecipeBook.Instance.EraseRecipe(removedRecipe);
		}
	}

	[HarmonyPatch(typeof(SaveLoadManager), "LoadFile")]
	[HarmonyPrefix]
	private static bool BeforeFileLoad(File saveFile)
	{
		DeserializeRecipes(current_directory + "/Recipe Blueprints/" + settings.entry + ".yml");
		string text = saveFile.url.Substring(saveFile.url.LastIndexOf('/') + 1);
		currentLoadedFile = text.Substring(0, text.Length - 7);
		return true;
	}

	[HarmonyPatch(typeof(SaveLoadManager), "SaveProgressToPool")]
	[HarmonyPrefix]
	private static void BeforeFileSave()
	{
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Invalid comparison between Unknown and I4
		//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0236: Unknown result type (might be due to invalid IL or missing references)
		//IL_0240: Expected O, but got Unknown
		int num = -1;
		List<IRecipeBookPageContent> savedRecipes = RecipeBook.Instance.savedRecipes;
		List<IRecipeBookPageContent> list = new List<IRecipeBookPageContent>();
		List<SerializedSavedRecipe> list2 = new List<SerializedSavedRecipe>();
		foreach (IRecipeBookPageContent item in savedRecipes)
		{
			num++;
			if (item == null)
			{
				continue;
			}
			RecipeBookPageContentType recipeBookPageContentType = item.GetRecipeBookPageContentType();
			RecipeBookPageContentType val = recipeBookPageContentType;
			if (val - 2 <= 1)
			{
				BookmarkControllersGroupController bookmarkControllersGroupController = ((Book)RecipeBook.Instance).bookmarkControllersGroupController;
				Bookmark bookmarkByIndex = bookmarkControllersGroupController.GetBookmarkByIndex(num);
				if (((Component)bookmarkByIndex).gameObject.activeSelf)
				{
					SerializedSavedRecipe serializedSavedRecipe = new SerializedSavedRecipe();
					SerializedBookmark serialized = bookmarkByIndex.GetSerialized();
					serializedSavedRecipe.content = item.GetSerializedRecipe();
					serializedSavedRecipe.mark = new SerializedSafeBookmark(serialized.position.x, serialized.position.y, serialized.prefabIndex, serialized.isMirrored, num);
					list.Add(item);
					list2.Add(serializedSavedRecipe);
				}
				else
				{
					((Component)bookmarkByIndex).gameObject.SetActive(true);
				}
			}
		}
		SerializedState serializedState = new SerializedState();
		serializedState.recipes = list2;
		if ((Object)(object)Managers.Ingredient.alchemyMachineSubManager.alchemyMachine != (Object)null)
		{
			serializedState.previousRecipe = ((FinishLegendarySubstanceWindow.Instance.previousAlchemyMachineProductRecipe == null) ? null : FinishLegendarySubstanceWindow.Instance.previousAlchemyMachineProductRecipe.GetSerializedRecipe());
			serializedState.productChanged = FinishLegendarySubstanceWindow.Instance.alchemyMachineProductChangedAfterSavingRecipe;
			if ((Object)(object)Managers.Ingredient.alchemyMachineSubManager.alchemyMachine.alchemyMachineBox.resultItemSpawner.SpawnedItem != (Object)null)
			{
				SerializedItemFromInventory serializedItemFromInventory = ((ItemFromInventory)Managers.Ingredient.alchemyMachineSubManager.alchemyMachine.alchemyMachineBox.resultItemSpawner.SpawnedItem).GetSerializedItemFromInventory();
				serializedState.currentMachineContent = new SerializedSafeItemFromInventory(serializedItemFromInventory.typeName, serializedItemFromInventory.position, serializedItemFromInventory.eulerAngles, serializedItemFromInventory.inventoryItemName, serializedItemFromInventory.ledgeDataList, serializedItemFromInventory.data);
				serializedState.currentMachineRecipe = new SerializedSafeRecipeData((SerializedAlchemyMachineProductRecipeData)Managers.Ingredient.alchemyMachineSubManager.alchemyMachine.alchemyMachineBox.resultItemSpawner.SpawnedInventoryItem.GetSerializedRecipeData().Clone());
				AlchemyMachineProductItem spawnedItem = Managers.Ingredient.alchemyMachineSubManager.alchemyMachine.alchemyMachineBox.resultItemSpawner.SpawnedItem;
				((ItemFromInventory)spawnedItem).DestroyItem();
				Managers.Ingredient.alchemyMachineSubManager.alchemyMachine.alchemyMachineBox.resultItemSpawner.SpawnedInventoryItem = null;
			}
			FinishLegendarySubstanceWindow.Instance.previousAlchemyMachineProductRecipe = null;
			FinishLegendarySubstanceWindow.Instance.alchemyMachineProductChangedAfterSavingRecipe = true;
			FinishLegendarySubstanceWindow.Instance.Show(false, true);
		}
		string text = serializer.Serialize((object)serializedState);
		stringToBeSaved = text;
		RemoveSavedRecipes(list);
	}

	[HarmonyPatch(typeof(SaveLoadManager), "SaveProgressToPool")]
	[HarmonyPostfix]
	private static void OnFileSave(File __result)
	{
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: 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)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Invalid comparison between Unknown and I4
		int num = -1;
		List<IRecipeBookPageContent> savedRecipes = RecipeBook.Instance.savedRecipes;
		foreach (IRecipeBookPageContent item in savedRecipes)
		{
			num++;
			if (item != null)
			{
				RecipeBookPageContentType recipeBookPageContentType = item.GetRecipeBookPageContentType();
				RecipeBookPageContentType val = recipeBookPageContentType;
				if (val - 2 <= 1)
				{
					((Component)((Book)RecipeBook.Instance).bookmarkControllersGroupController.GetBookmarkByIndex(num)).gameObject.SetActive(false);
				}
			}
		}
		string text = __result.url.Substring(__result.url.LastIndexOf('/') + 1);
		currentSavedFile = text.Substring(0, text.Length - 7);
		string path = current_directory + "/Saved Recipes/" + settings.entry + " - " + currentSavedFile + ".yml";
		File.WriteAllText(path, stringToBeSaved);
		SerializedState serializedState = deserializer.Deserialize<SerializedState>(stringToBeSaved);
		AddSavedRecipes(serializedState);
		if ((Object)(object)Managers.Ingredient.alchemyMachineSubManager.alchemyMachine != (Object)null)
		{
			Managers.SaveLoad.SelectedProgressState.previousAlchemyMachineProductRecipe = serializedState.previousRecipe;
			Managers.SaveLoad.SelectedProgressState.alchemyMachineProductChangedAfterSavingRecipe = serializedState.productChanged;
			if (serializedState.currentMachineContent != null)
			{
				Managers.SaveLoad.SelectedProgressState.serializedCurrentAlchemyMachineProduct = serializedState.currentMachineRecipe.ToData();
				Managers.SaveLoad.SelectedProgressState.withSpawnedProduct = true;
				SerializedItemFromInventory val2 = SerializedSafeItemFromInventory.SafeToNormal(serializedState.currentMachineContent);
				AlchemyMachineProductItem.SpawnFromSerializedData(val2, (RoomIndex)3);
				Managers.Ingredient.alchemyMachineSubManager.alchemyMachine.brewAnimationMainController.StartAnimation();
				Managers.Ingredient.alchemyMachineSubManager.alchemyMachine.brewAnimationMainController.progressTime = Settings<BrewAnimationControllerSettings>.Asset.totalAnimationTime - 0.1f;
				hasSubstanceLoadedExternally = true;
				Managers.Ingredient.alchemyMachineSubManager.alchemyMachine.alchemyMachineBox.resultItemSpawner.OnLoad();
				hasSubstanceLoadedExternally = false;
			}
			FinishLegendarySubstanceWindow.Instance.OnLoad();
		}
	}

	[HarmonyPatch(typeof(RecipeBook), "OnLoad")]
	[HarmonyPostfix]
	private static void PostRecipeInit()
	{
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: 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)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Invalid comparison between Unknown and I4
		int num = -1;
		List<IRecipeBookPageContent> savedRecipes = RecipeBook.Instance.savedRecipes;
		foreach (IRecipeBookPageContent item in savedRecipes)
		{
			num++;
			if (item != null)
			{
				RecipeBookPageContentType recipeBookPageContentType = item.GetRecipeBookPageContentType();
				RecipeBookPageContentType val = recipeBookPageContentType;
				if (val - 2 <= 1)
				{
					((Component)((Book)RecipeBook.Instance).bookmarkControllersGroupController.GetBookmarkByIndex(num)).gameObject.SetActive(false);
				}
			}
		}
		string path = current_directory + "/Saved Recipes/" + settings.entry + " - " + currentLoadedFile + ".yml";
		if (File.Exists(path))
		{
			SerializedState state = deserializer.Deserialize<SerializedState>(File.ReadAllText(path));
			AddSavedRecipes(state);
		}
	}

	[HarmonyPatch(typeof(ResultItemSpawner), "OnLoad")]
	[HarmonyPrefix]
	private static void PreLegendarySpawn()
	{
		if (hasSubstanceLoadedExternally)
		{
			return;
		}
		string path = current_directory + "/Saved Recipes/" + settings.entry + " - " + currentLoadedFile + ".yml";
		if (!File.Exists(path))
		{
			return;
		}
		SerializedState serializedState = deserializer.Deserialize<SerializedState>(File.ReadAllText(path));
		if ((Object)(object)Managers.Ingredient.alchemyMachineSubManager.alchemyMachine != (Object)null)
		{
			Managers.SaveLoad.SelectedProgressState.previousAlchemyMachineProductRecipe = serializedState.previousRecipe;
			Managers.SaveLoad.SelectedProgressState.alchemyMachineProductChangedAfterSavingRecipe = serializedState.productChanged;
			if (serializedState.currentMachineContent != null)
			{
				Managers.SaveLoad.SelectedProgressState.withSpawnedProduct = true;
				Managers.SaveLoad.SelectedProgressState.serializedCurrentAlchemyMachineProduct = serializedState.currentMachineRecipe.ToData();
				SerializedItemFromInventory val = SerializedSafeItemFromInventory.SafeToNormal(serializedState.currentMachineContent);
				AlchemyMachineProductItem.SpawnFromSerializedData(val, (RoomIndex)3);
			}
		}
	}

	[HarmonyPatch(typeof(File), "Remove")]
	[HarmonyPostfix]
	private static void PostSaveDelete(File __instance)
	{
		string text = __instance.url.Substring(__instance.url.LastIndexOf('/') + 1);
		string text2 = text.Substring(0, text.Length - 7);
		string path = current_directory + "/Saved Recipes/" + settings.entry + " - " + text2 + ".yml";
		if (File.Exists(path))
		{
			File.Delete(path);
		}
	}

	[HarmonyPatch(typeof(AlchemyMachineObject), "GetIngredientsCount")]
	[HarmonyPostfix]
	private static void PostIngredientCheck(ref int __result)
	{
		if (__result == 0 && settings.allow_no_ingredients)
		{
			__result = 1;
		}
	}
}