using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using EquinoxsModUtils;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("Recycler")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("Recycler")]
[assembly: AssemblyTitle("Recycler")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Recycler
{
	[BepInPlugin("com.certifried.recycler", "Recycler", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class RecyclerPlugin : BaseUnityPlugin
	{
		public const string GUID = "com.certifried.recycler";

		public const string NAME = "Recycler";

		public const string VERSION = "1.0.0";

		private static RecyclerPlugin instance;

		private Harmony harmony;

		public static ConfigEntry<float> BasicEfficiency;

		public static ConfigEntry<float> AdvancedEfficiency;

		public static ConfigEntry<float> QuantumEfficiency;

		public static ConfigEntry<float> RecycleTime;

		public static ConfigEntry<bool> AllowOrganic;

		public static ConfigEntry<float> BonusChance;

		private static Dictionary<string, RecycleRecipe> recycleRecipes = new Dictionary<string, RecycleRecipe>();

		private static bool recipesBuilt = false;

		public static int TotalItemsRecycled = 0;

		public static int TotalResourcesRecovered = 0;

		private void Awake()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			instance = this;
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Recycler v1.0.0 loading...");
			InitializeConfig();
			harmony = new Harmony("com.certifried.recycler");
			harmony.PatchAll();
			Events.GameDefinesLoaded += OnGameDefinesLoaded;
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Recycler loaded successfully!");
		}

		private void InitializeConfig()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Expected O, but got Unknown
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Expected O, but got Unknown
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Expected O, but got Unknown
			BasicEfficiency = ((BaseUnityPlugin)this).Config.Bind<float>("Efficiency", "BasicRecycler", 0.25f, new ConfigDescription("Resource recovery rate for Basic Recycler (0.25 = 25%)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 1f), Array.Empty<object>()));
			AdvancedEfficiency = ((BaseUnityPlugin)this).Config.Bind<float>("Efficiency", "AdvancedRecycler", 0.5f, new ConfigDescription("Resource recovery rate for Advanced Recycler", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 1f), Array.Empty<object>()));
			QuantumEfficiency = ((BaseUnityPlugin)this).Config.Bind<float>("Efficiency", "QuantumRecycler", 0.75f, new ConfigDescription("Resource recovery rate for Quantum Recycler", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 1f), Array.Empty<object>()));
			RecycleTime = ((BaseUnityPlugin)this).Config.Bind<float>("Processing", "RecycleTime", 5f, new ConfigDescription("Base time in seconds to recycle one item", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 30f), Array.Empty<object>()));
			AllowOrganic = ((BaseUnityPlugin)this).Config.Bind<bool>("Processing", "AllowOrganic", true, "Allow recycling of organic materials (produces compost for BioProcessing)");
			BonusChance = ((BaseUnityPlugin)this).Config.Bind<float>("Processing", "BonusChance", 0.1f, new ConfigDescription("Chance to recover rare components as bonus", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 0.5f), Array.Empty<object>()));
		}

		private void OnGameDefinesLoaded()
		{
			if (!recipesBuilt)
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Building recycling recipe database...");
				BuildRecycleDatabase();
				((BaseUnityPlugin)this).Logger.LogInfo((object)$"Created {recycleRecipes.Count} recycling recipes");
				recipesBuilt = true;
			}
		}

		private void OnDestroy()
		{
			Harmony obj = harmony;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
			Events.GameDefinesLoaded -= OnGameDefinesLoaded;
		}

		private void BuildRecycleDatabase()
		{
			try
			{
				AddDefaultRecipes();
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("Error building recycle database: " + ex.Message));
			}
		}

		private void AddDefaultRecipes()
		{
			AddRecipe("Inserter", new(string, int)[2]
			{
				("Iron Ingot", 2),
				("Copper Ingot", 1)
			});
			AddRecipe("Conveyor Belt", new(string, int)[1] { ("Iron Ingot", 1) });
			AddRecipe("Smelter", new(string, int)[2]
			{
				("Iron Ingot", 5),
				("Copper Ingot", 2)
			});
			AddRecipe("Assembler", new(string, int)[2]
			{
				("Iron Ingot", 8),
				("Copper Ingot", 4)
			});
		}

		private void AddRecipe(string inputName, (string resource, int quantity)[] outputs)
		{
			RecycleRecipe recycleRecipe = new RecycleRecipe
			{
				InputResourceName = inputName,
				InputQuantity = 1,
				Outputs = new List<RecycleOutput>(),
				IsOrganic = IsOrganicMaterial(inputName)
			};
			for (int i = 0; i < outputs.Length; i++)
			{
				var (resourceName, quantity) = outputs[i];
				recycleRecipe.Outputs.Add(new RecycleOutput
				{
					ResourceName = resourceName,
					Quantity = quantity,
					IsGuaranteed = true
				});
			}
			recycleRecipes[inputName] = recycleRecipe;
		}

		private bool IsOrganicMaterial(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return false;
			}
			string text = name.ToLower();
			return text.Contains("plant") || text.Contains("seed") || text.Contains("kindlevine") || text.Contains("shiverthorn") || text.Contains("organic") || text.Contains("fiber");
		}

		public static bool CanRecycle(string resourceName)
		{
			if (string.IsNullOrEmpty(resourceName))
			{
				return false;
			}
			if (!recycleRecipes.ContainsKey(resourceName))
			{
				return false;
			}
			RecycleRecipe recycleRecipe = recycleRecipes[resourceName];
			if (recycleRecipe.IsOrganic && !AllowOrganic.Value)
			{
				return false;
			}
			return true;
		}

		public static RecycleResult Recycle(string resourceName, int quantity, RecyclerTier tier)
		{
			if (!CanRecycle(resourceName))
			{
				return null;
			}
			RecycleRecipe recycleRecipe = recycleRecipes[resourceName];
			float efficiency = GetEfficiency(tier);
			RecycleResult recycleResult = new RecycleResult
			{
				InputResourceName = resourceName,
				InputQuantity = quantity,
				Outputs = new List<RecycleOutput>(),
				Tier = tier
			};
			foreach (RecycleOutput output in recycleRecipe.Outputs)
			{
				int num = Mathf.RoundToInt((float)(output.Quantity * quantity) * efficiency / (float)recycleRecipe.InputQuantity);
				if (num > 0)
				{
					recycleResult.Outputs.Add(new RecycleOutput
					{
						ResourceName = output.ResourceName,
						Quantity = num,
						IsGuaranteed = true
					});
					TotalResourcesRecovered += num;
				}
			}
			if (Random.value < BonusChance.Value)
			{
				recycleResult.BonusReceived = true;
			}
			if (recycleRecipe.IsOrganic)
			{
				recycleResult.ProducesCompost = true;
				recycleResult.CompostQuantity = Mathf.Max(1, quantity / 4);
			}
			float num2 = 1f - efficiency;
			if (num2 > 0f)
			{
				recycleResult.ScrapQuantity = Mathf.Max(1, Mathf.RoundToInt((float)quantity * num2));
			}
			TotalItemsRecycled += quantity;
			return recycleResult;
		}

		public static float GetEfficiency(RecyclerTier tier)
		{
			return tier switch
			{
				RecyclerTier.Basic => BasicEfficiency.Value, 
				RecyclerTier.Advanced => AdvancedEfficiency.Value, 
				RecyclerTier.Quantum => QuantumEfficiency.Value, 
				RecyclerTier.Perfect => 1f, 
				_ => 0.25f, 
			};
		}

		public static float GetProcessingTime(RecyclerTier tier)
		{
			float value = RecycleTime.Value;
			return tier switch
			{
				RecyclerTier.Basic => value * 1.5f, 
				RecyclerTier.Advanced => value, 
				RecyclerTier.Quantum => value * 0.75f, 
				RecyclerTier.Perfect => value * 0.5f, 
				_ => value, 
			};
		}

		public static void Log(string message)
		{
			RecyclerPlugin recyclerPlugin = instance;
			if (recyclerPlugin != null)
			{
				((BaseUnityPlugin)recyclerPlugin).Logger.LogInfo((object)message);
			}
		}

		public static void LogWarning(string message)
		{
			RecyclerPlugin recyclerPlugin = instance;
			if (recyclerPlugin != null)
			{
				((BaseUnityPlugin)recyclerPlugin).Logger.LogWarning((object)message);
			}
		}

		public static RecycleRecipe GetRecipe(string resourceName)
		{
			if (string.IsNullOrEmpty(resourceName))
			{
				return null;
			}
			RecycleRecipe value;
			return recycleRecipes.TryGetValue(resourceName, out value) ? value : null;
		}

		public static IEnumerable<RecycleRecipe> GetAllRecipes()
		{
			return recycleRecipes.Values;
		}
	}
	public enum RecyclerTier
	{
		Basic,
		Advanced,
		Quantum,
		Perfect
	}
	public class RecycleRecipe
	{
		public string InputResourceName;

		public int InputQuantity;

		public List<RecycleOutput> Outputs;

		public bool IsOrganic;
	}
	public class RecycleOutput
	{
		public string ResourceName;

		public int Quantity;

		public bool IsGuaranteed;

		public float BonusChance;
	}
	public class RecycleResult
	{
		public string InputResourceName;

		public int InputQuantity;

		public List<RecycleOutput> Outputs;

		public RecyclerTier Tier;

		public int ScrapQuantity;

		public bool BonusReceived;

		public bool ProducesCompost;

		public int CompostQuantity;
	}
}