using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("VentureValheim.FarmGrid")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("VentureValheim.FarmGrid")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("9574D247-B4C6-45F8-92FC-A52DE6A636C0")]
[assembly: AssemblyFileVersion("0.1.2")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.2.0")]
[module: UnverifiableCode]
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 VentureValheim.FarmGrid
{
	[BepInPlugin("com.orianaventure.mod.VentureFarmGrid", "VentureFarmGrid", "0.1.2")]
	public class FarmGridPlugin : BaseUnityPlugin
	{
		private const string ModName = "VentureFarmGrid";

		private const string ModVersion = "0.1.2";

		private const string Author = "com.orianaventure.mod";

		private const string ModGUID = "com.orianaventure.mod.VentureFarmGrid";

		private static string ConfigFileName = "com.orianaventure.mod.VentureFarmGrid.cfg";

		private static string ConfigFileFullPath;

		private readonly Harmony HarmonyInstance = new Harmony("com.orianaventure.mod.VentureFarmGrid");

		public static readonly ManualLogSource FarmGridLogger;

		private static ConfigEntry<int> CE_FarmGridFixedPartitions;

		private static ConfigEntry<float> CE_PlantSpacing;

		private static ConfigEntry<int> CE_FarmGridSections;

		private static ConfigEntry<float> CE_FarmGridYOffset;

		private static ConfigEntry<Color> CE_FarmGridColor;

		private static ConfigEntry<string> CE_CustomPlants;

		private DateTime _lastReloadTime;

		private const long RELOAD_DELAY = 10000000L;

		public static int GetFarmGridFixedPartitions()
		{
			return CE_FarmGridFixedPartitions.Value;
		}

		public static float GetExtraPlantSpacing()
		{
			return CE_PlantSpacing.Value;
		}

		public static int GetFarmGridSections()
		{
			return Math.Max(0, Math.Min(CE_FarmGridSections.Value, 10));
		}

		public static float GetFarmGridYOffset()
		{
			return CE_FarmGridYOffset.Value;
		}

		public static Color GetFarmGridColor()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return CE_FarmGridColor.Value;
		}

		public static string GetCustomPlants()
		{
			return CE_CustomPlants.Value;
		}

		private void AddConfig<T>(string key, string section, string description, bool synced, T value, ref ConfigEntry<T> configEntry)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			string extendedDescription = GetExtendedDescription(description, synced);
			configEntry = ((BaseUnityPlugin)this).Config.Bind<T>(section, key, value, new ConfigDescription(extendedDescription, (AcceptableValueBase)null, Array.Empty<object>()));
		}

		public string GetExtendedDescription(string description, bool synchronizedSetting)
		{
			return description + (synchronizedSetting ? " [Synced with Server]" : " [Not Synced with Server]");
		}

		public void Awake()
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			AddConfig("FarmGridFixedPartitions", "General", "Fixed number partitions for initial snapping angles. Vanilla uses 16 for build pieces, 0 allows free rotation (int).", synced: false, 16, ref CE_FarmGridFixedPartitions);
			AddConfig("PlantSpacing", "General", "Extra spacing to add to all plants in addition to the plant's needed growth space (float).", synced: false, 0.01f, ref CE_PlantSpacing);
			AddConfig("FarmGridSections", "General", "Amount of grid squares to draw from the center (limited to 10 maximum) (int).", synced: false, 2, ref CE_FarmGridSections);
			AddConfig("FarmGridYOffset", "General", "Grid offset from the ground (float).", synced: false, 0.1f, ref CE_FarmGridYOffset);
			AddConfig("FarmGridColor", "General", "Color of the grid (Color).", synced: false, new Color(0.8f, 0.8f, 0.8f, 0.2f), ref CE_FarmGridColor);
			AddConfig("CustomPlants", "Advanced", "Additional non-Plant prefabs and default overrides (Example: RaspberryBush: 0.5, BlueberryBush: 0.5) (string in format: Prefab:float,Prefab:float).", synced: false, "", ref CE_CustomPlants);
			FarmGridLogger.LogInfo((object)"Snap. Crackle. Pop.");
			FarmGrid.SetupConfigurations();
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			HarmonyInstance.PatchAll(executingAssembly);
			SetupWatcher();
		}

		private void OnDestroy()
		{
			((BaseUnityPlugin)this).Config.Save();
		}

		private void SetupWatcher()
		{
			_lastReloadTime = DateTime.Now;
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(Paths.ConfigPath, ConfigFileName);
			fileSystemWatcher.Changed += ReadConfigValues;
			fileSystemWatcher.Created += ReadConfigValues;
			fileSystemWatcher.Renamed += ReadConfigValues;
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
		}

		private void ReadConfigValues(object sender, FileSystemEventArgs e)
		{
			DateTime now = DateTime.Now;
			long num = now.Ticks - _lastReloadTime.Ticks;
			if (File.Exists(ConfigFileFullPath) && num >= 10000000)
			{
				try
				{
					FarmGridLogger.LogInfo((object)"Attempting to reload configuration...");
					((BaseUnityPlugin)this).Config.Reload();
				}
				catch
				{
					FarmGridLogger.LogError((object)("There was an issue loading " + ConfigFileName));
					return;
				}
				_lastReloadTime = now;
				FarmGrid.SetupConfigurations();
			}
		}

		static FarmGridPlugin()
		{
			string configPath = Paths.ConfigPath;
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			ConfigFileFullPath = configPath + directorySeparatorChar + ConfigFileName;
			FarmGridLogger = Logger.CreateLogSource("VentureFarmGrid");
			CE_FarmGridFixedPartitions = null;
			CE_PlantSpacing = null;
			CE_FarmGridSections = null;
			CE_FarmGridYOffset = null;
			CE_FarmGridColor = null;
			CE_CustomPlants = null;
		}
	}
	public class FarmGrid
	{
		private class PlantObject
		{
			public Vector3 position;

			public float growthSize;

			public PlantObject(Vector3 position, float growthSize)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				this.position = position;
				this.growthSize = growthSize;
			}
		}

		[HarmonyPatch(typeof(Player), "SetupPlacementGhost")]
		public static class Patch_Player_SetupPlacementGhost
		{
			private static void Postfix()
			{
				ResetCache();
				SetGhostPlant();
			}
		}

		[HarmonyPatch(typeof(Player), "UpdatePlacementGhost")]
		public static class Patch_Player_UpdatePlacementGhost
		{
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0084: Expected O, but got Unknown
				//IL_0097: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: Expected O, but got Unknown
				List<CodeInstruction> list = instructions.ToList();
				bool flag = false;
				int num = 0;
				MethodInfo methodInfo = AccessTools.Method(typeof(Player), "FindClosestSnapPoints", (Type[])null, (Type[])null);
				object obj = AccessTools.Method(typeof(FarmGrid), "GetFarmSnapPoints", (Type[])null, (Type[])null);
				for (int i = 0; i < list.Count; i++)
				{
					if (list[i].opcode == OpCodes.Brtrue)
					{
						num = i;
					}
					if (CodeInstructionExtensions.Calls(list[i], methodInfo))
					{
						list.InsertRange(num + 1, (IEnumerable<CodeInstruction>)(object)new CodeInstruction[2]
						{
							new CodeInstruction(OpCodes.Call, obj),
							new CodeInstruction(OpCodes.Brtrue, list[num].operand)
						});
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					FarmGridPlugin.FarmGridLogger.LogWarning((object)"FarmGrid: Failed to patch UpdatePlacementGhost");
				}
				return list;
			}
		}

		[HarmonyPatch(typeof(Player), "TryPlacePiece")]
		public static class Patch_Player_PlacePiece
		{
			private static bool Prefix(ref Player __instance, ref bool __result, Piece piece)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				if (GetPlantObject(__instance.m_placementGhost.GetComponent<Collider>(), out PlantObject plantObject) && HasOverlappingPlants(plantObject.position, plantObject.growthSize))
				{
					__result = false;
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Humanoid), "SetupVisEquipment")]
		public static class Patch_Humanoid_SetupVisEquipment
		{
			private static void Postfix(ref Humanoid __instance)
			{
				if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer && ((Object)(object)Player.m_localPlayer == (Object)null || ((Humanoid)Player.m_localPlayer).m_rightItem == null || ((Humanoid)Player.m_localPlayer).m_rightItem.m_shared == null || ((Humanoid)Player.m_localPlayer).m_rightItem.m_shared.m_name != "$item_cultivator"))
				{
					HideFarmGrid();
					ResetCache();
				}
			}
		}

		[HarmonyPriority(0)]
		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		public static class Patch_ZNetScene_Awake
		{
			private static void Postfix()
			{
				SetupPlantCache();
			}
		}

		private static Dictionary<string, float> customPlants = new Dictionary<string, float>();

		private static readonly Dictionary<string, float> vanillaPlantsDefaults = new Dictionary<string, float>
		{
			{ "BlueberryBush", 0.5f },
			{ "CloudberryBush", 0.5f },
			{ "RaspberryBush", 0.5f },
			{ "Pickable_Dandelion", 0.5f },
			{ "Pickable_Fiddlehead", 0.5f },
			{ "Pickable_Mushroom", 0.5f },
			{ "Pickable_Mushroom_blue", 0.5f },
			{ "Pickable_Mushroom_yellow", 0.5f },
			{ "Pickable_SmokePuff", 0.5f },
			{ "Pickable_Thistle", 0.5f }
		};

		private static Dictionary<string, float> plantsConfiguration = new Dictionary<string, float>();

		private static readonly string[] plantObjectMasks = new string[6] { "Default", "Default_small", "item", "piece", "piece_nonsolid", "static_solid" };

		private static int plantObjectMask = LayerMask.GetMask(plantObjectMasks);

		private static Vector3 plantSnapPoint = Vector3.zero;

		private static GameObject[] farmGrid = null;

		private static bool farmGridVisible = false;

		private static PlantObject plantGhost;

		private static Vector3 plantGhostPosition = Vector3.zero;

		private static Material lineMaterial;

		private static bool freeDraw = true;

		public static void SetupPlantCache()
		{
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				return;
			}
			plantsConfiguration.Clear();
			foreach (GameObject prefab in ZNetScene.instance.m_prefabs)
			{
				Plant component = prefab.GetComponent<Plant>();
				if ((Object)(object)component == (Object)null || plantsConfiguration.ContainsKey(((Object)component).name))
				{
					continue;
				}
				plantsConfiguration.Add(((Object)component).name, component.m_growRadius);
				GameObject[] grownPrefabs = component.m_grownPrefabs;
				foreach (GameObject val in grownPrefabs)
				{
					if (!plantsConfiguration.ContainsKey(((Object)val).name))
					{
						plantsConfiguration.Add(((Object)val).name, component.m_growRadius);
					}
				}
			}
			foreach (KeyValuePair<string, float> vanillaPlantsDefault in vanillaPlantsDefaults)
			{
				if (!plantsConfiguration.ContainsKey(vanillaPlantsDefault.Key))
				{
					plantsConfiguration.Add(vanillaPlantsDefault.Key, vanillaPlantsDefault.Value);
				}
			}
		}

		public static void SetupConfigurations()
		{
			customPlants.Clear();
			string[] array = FarmGridPlugin.GetCustomPlants().Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(new string[1] { ":" }, StringSplitOptions.RemoveEmptyEntries);
				if (array2.Length == 2 && float.TryParse(array2[1].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
				{
					customPlants.Add(array2[0].Trim(), result);
				}
			}
			DestroyFarmGrid();
			ResetCache();
			SetGhostPlant();
		}

		private static bool HasCustomSize(string prefab, out float size)
		{
			string prefabName = Utils.GetPrefabName(prefab);
			size = 0f;
			if (customPlants.ContainsKey(prefabName))
			{
				size = customPlants[prefabName];
				return true;
			}
			if (plantsConfiguration.ContainsKey(prefabName))
			{
				size = plantsConfiguration[prefabName];
				return true;
			}
			return false;
		}

		private static float GetCollisionRadius(PlantObject plant)
		{
			return GetPlantSpacing(plant.growthSize) * (float)(FarmGridPlugin.GetFarmGridSections() + 1);
		}

		private static float GetPlantSpacing(float growthSize)
		{
			return growthSize * 2f + FarmGridPlugin.GetExtraPlantSpacing();
		}

		private static void DrawFarmGrid(Vector3 pos, Vector3 gridDir, float gridSize)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			if (farmGrid == null || (Object)(object)farmGrid[0] == (Object)null)
			{
				InitFarmGrid();
			}
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(gridDir.z, gridDir.y, 0f - gridDir.x);
			int farmGridSections = FarmGridPlugin.GetFarmGridSections();
			for (int i = -farmGridSections; i <= farmGridSections; i++)
			{
				GameObject grid = farmGrid[i + farmGridSections];
				Vector3 position = pos + gridDir * (float)i * gridSize;
				DrawSegments(farmGridSections, gridSize, grid, position, val);
				GameObject grid2 = farmGrid[i + farmGridSections + (farmGridSections * 2 + 1)];
				Vector3 position2 = pos + val * (float)i * gridSize;
				DrawSegments(farmGridSections, gridSize, grid2, position2, gridDir);
			}
			farmGridVisible = true;
		}

		private static void DrawSegments(int farmGridSections, float gridSize, GameObject grid, Vector3 position, Vector3 pivot)
		{
			//IL_0006: 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_0031: 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_003b: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			grid.transform.position = position;
			LineRenderer component = grid.GetComponent<LineRenderer>();
			component.widthMultiplier = 0.015f;
			((Renderer)component).enabled = true;
			float farmGridYOffset = FarmGridPlugin.GetFarmGridYOffset();
			for (int i = -farmGridSections; i <= farmGridSections; i++)
			{
				Vector3 val = position + pivot * (float)i * gridSize;
				float groundHeight = GetGroundHeight(val);
				val.y = groundHeight + farmGridYOffset;
				component.SetPosition(i + farmGridSections, val);
			}
		}

		private static float GetGroundHeight(Vector3 linePos)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return ZoneSystem.instance.GetGroundHeight(linePos);
		}

		public static void DestroyFarmGrid()
		{
			if (farmGrid == null)
			{
				return;
			}
			for (int i = 0; i < farmGrid.Length; i++)
			{
				if (Object.op_Implicit((Object)(object)farmGrid[i]))
				{
					Object.Destroy((Object)(object)farmGrid[i]);
				}
			}
			farmGrid = null;
		}

		private static void InitFarmGrid()
		{
			//IL_0040: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)lineMaterial))
			{
				lineMaterial = Resources.FindObjectsOfTypeAll<Material>().First((Material k) => ((Object)k).name == "Default-Line");
			}
			int farmGridSections = FarmGridPlugin.GetFarmGridSections();
			Color farmGridColor = FarmGridPlugin.GetFarmGridColor();
			farmGrid = (GameObject[])(object)new GameObject[(farmGridSections * 2 + 1) * 2];
			for (int i = 0; i < farmGrid.Length; i++)
			{
				GameObject val = new GameObject();
				LineRenderer obj = val.AddComponent<LineRenderer>();
				((Renderer)obj).material = lineMaterial;
				obj.startColor = farmGridColor;
				obj.endColor = farmGridColor;
				obj.positionCount = farmGridSections * 2 + 1;
				farmGrid[i] = val;
			}
		}

		private static void HideFarmGrid()
		{
			if (farmGridVisible && farmGrid != null && (Object)(object)farmGrid[0] != (Object)null)
			{
				for (int i = 0; i < farmGrid.Length; i++)
				{
					((Renderer)farmGrid[i].GetComponent<LineRenderer>()).enabled = false;
				}
				farmGridVisible = false;
				freeDraw = true;
			}
		}

		private static void ResetCache()
		{
			//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)
			plantGhost = null;
			plantSnapPoint = Vector3.zero;
			freeDraw = true;
		}

		private static void SetGhostPlant()
		{
			//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)
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && !((Object)(object)localPlayer.m_placementGhost == (Object)null) && GetPlantObject(localPlayer.m_placementGhost.GetComponentInChildren<Collider>(), out PlantObject plantObject))
			{
				plantGhost = plantObject;
				plantGhostPosition = plantGhost.position;
			}
		}

		private static bool GetFarmSnapPoints()
		{
			//IL_004c: 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_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			if (plantGhost == null)
			{
				HideFarmGrid();
				ResetCache();
				return false;
			}
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				HideFarmGrid();
				ResetCache();
				return false;
			}
			GameObject placementGhost = Player.m_localPlayer.m_placementGhost;
			if ((Object)(object)placementGhost == (Object)null)
			{
				HideFarmGrid();
				ResetCache();
				return false;
			}
			Vector3 val = plantGhostPosition - placementGhost.transform.position;
			float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
			if (((!farmGridVisible || freeDraw) && sqrMagnitude < 0.0001f) || (farmGridVisible && !freeDraw && (double)sqrMagnitude < 0.02))
			{
				if (plantSnapPoint != Vector3.zero)
				{
					placementGhost.transform.position = plantSnapPoint;
				}
				return true;
			}
			plantSnapPoint = Vector3.zero;
			plantGhost.position = placementGhost.transform.position;
			plantGhostPosition = plantGhost.position;
			List<PlantObject> otherPlants = GetOtherPlants(plantGhost.position, GetCollisionRadius(plantGhost));
			if (otherPlants.Count < 1)
			{
				HideFarmGrid();
				return true;
			}
			if (otherPlants.Count == 1)
			{
				DrawFreeGrid(otherPlants[0]);
			}
			else if (otherPlants.Count > 1)
			{
				DrawFixedGrid(otherPlants);
			}
			return true;
		}

		private static void DrawFreeGrid(PlantObject otherPlant)
		{
			//IL_0055: 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)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: 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_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//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)
			if (!GetFixedGridDir(otherPlant, out var gridDir))
			{
				gridDir = plantGhost.position - otherPlant.position;
				gridDir.y = 0f;
				((Vector3)(ref gridDir)).Normalize();
			}
			freeDraw = true;
			float plantSpacing = GetPlantSpacing(Mathf.Max(plantGhost.growthSize, otherPlant.growthSize));
			plantSnapPoint = otherPlant.position + gridDir * plantSpacing;
			float groundHeight = GetGroundHeight(plantSnapPoint);
			plantSnapPoint.y = groundHeight;
			Player.m_localPlayer.m_placementGhost.transform.position = plantSnapPoint;
			DrawFarmGrid(plantSnapPoint, gridDir, plantSpacing);
		}

		private static void DrawFixedGrid(List<PlantObject> otherPlants)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			if (!GetGridDir(otherPlants, out Vector3 gridDir, out PlantObject chosen, out PlantObject _) || chosen == null)
			{
				DrawFreeGrid(otherPlants[0]);
				return;
			}
			freeDraw = false;
			float plantSpacing = GetPlantSpacing(Mathf.Max(plantGhost.growthSize, chosen.growthSize));
			List<Vector3> gridLocations = GetGridLocations(plantGhost.position, chosen.position, gridDir, plantSpacing);
			plantSnapPoint = gridLocations[0];
			for (int i = 0; i < gridLocations.Count; i++)
			{
				if (!HasOverlappingPlants(gridLocations[i], otherPlants, plantGhost.growthSize))
				{
					plantSnapPoint = gridLocations[i];
					break;
				}
			}
			float groundHeight = GetGroundHeight(plantSnapPoint);
			plantSnapPoint.y = groundHeight;
			Player.m_localPlayer.m_placementGhost.transform.position = plantSnapPoint;
			DrawFarmGrid(plantSnapPoint, gridDir, plantSpacing);
		}

		private static List<Vector3> GetGridLocations(Vector3 position, Vector3 otherPlantPosition, Vector3 gridDir, float gridSize)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: 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_0044: 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_0048: 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_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> list = new List<Vector3>();
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(gridDir.z, gridDir.y, 0f - gridDir.x);
			for (int i = -2; i <= 2; i++)
			{
				for (int j = -2; j <= 2; j++)
				{
					if (i != 0 || j != 0)
					{
						Vector3 item = otherPlantPosition + gridDir * (float)i * gridSize + val * (float)j * gridSize;
						list.Add(item);
					}
				}
			}
			return list.OrderBy(delegate(Vector3 location)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//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_000c: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val2 = location - position;
				return ((Vector3)(ref val2)).sqrMagnitude;
			}).ToList();
		}

		private static bool GetFixedGridDir(PlantObject plant, out Vector3 gridDir)
		{
			//IL_0001: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			gridDir = default(Vector3);
			int farmGridFixedPartitions = FarmGridPlugin.GetFarmGridFixedPartitions();
			if (farmGridFixedPartitions != 0)
			{
				float num = (float)Math.PI * 2f / (float)farmGridFixedPartitions;
				Vector3 val = plantGhost.position - plant.position;
				float num2 = Mathf.Round(Mathf.Atan2(val.z, val.x) / num) * num;
				gridDir.y = 0f;
				gridDir.x = Mathf.Cos(num2);
				gridDir.z = Mathf.Sin(num2);
				gridDir = ((Vector3)(ref gridDir)).normalized;
				return true;
			}
			return false;
		}

		private static bool GetGridDir(List<PlantObject> plantList, out Vector3 gridDir, out PlantObject chosen1, out PlantObject chosen2)
		{
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			//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_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			chosen1 = plantList[0];
			chosen2 = null;
			for (int i = 0; i < 2; i++)
			{
				chosen1 = plantList[i];
				for (int j = 1; j < plantList.Count; j++)
				{
					gridDir = chosen1.position - plantList[j].position;
					gridDir.y = 0f;
					float plantSpacing = GetPlantSpacing(Mathf.Max(Mathf.Max(chosen1.growthSize, plantList[j].growthSize), plantGhost.growthSize));
					float num = ((Vector3)(ref gridDir)).magnitude - plantSpacing;
					if (num > -0.01f && num < 0.01f * plantSpacing)
					{
						chosen2 = plantList[j];
						gridDir = ((Vector3)(ref gridDir)).normalized;
						return true;
					}
				}
			}
			gridDir = Vector3.zero;
			chosen1 = null;
			chosen2 = null;
			return false;
		}

		private static List<PlantObject> GetOtherPlants(Vector3 position, float collisionRadius)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			int count = Physics.OverlapSphereNonAlloc(position, collisionRadius, Piece.s_pieceColliders, plantObjectMask);
			List<Collider> list = Piece.s_pieceColliders.Take(count).OrderBy(delegate(Collider plant)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val = ((Component)plant).transform.position - plantGhost.position;
				return ((Vector3)(ref val)).sqrMagnitude;
			}).ToList();
			List<PlantObject> list2 = new List<PlantObject>();
			for (int i = 0; i < list.Count; i++)
			{
				if (GetPlantObject(list[i], out PlantObject plantObject))
				{
					list2.Add(plantObject);
					if (list2.Count == 24)
					{
						break;
					}
				}
			}
			return list2;
		}

		private static bool HasOverlappingPlants(Vector3 pos, List<PlantObject> otherPlants, float collisionRadius)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < otherPlants.Count; i++)
			{
				Vector3 val = pos - otherPlants[i].position;
				if (((Vector3)(ref val)).magnitude <= collisionRadius + otherPlants[i].growthSize)
				{
					return true;
				}
			}
			return false;
		}

		private static bool HasOverlappingPlants(Vector3 pos, float collisionRadius)
		{
			//IL_0000: 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_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			int num = Physics.OverlapSphereNonAlloc(pos, collisionRadius, Piece.s_pieceColliders, plantObjectMask);
			for (int i = 0; i < num; i++)
			{
				if (GetPlantObject(Piece.s_pieceColliders[i], out PlantObject plantObject))
				{
					Vector3 val = pos - plantObject.position;
					if (((Vector3)(ref val)).magnitude <= collisionRadius + plantObject.growthSize)
					{
						return true;
					}
				}
			}
			return false;
		}

		private static bool GetPlantObject(Collider collider, out PlantObject plantObject)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)collider != (Object)null && HasCustomSize(((Object)((Component)collider).transform.root).name, out var size))
			{
				plantObject = new PlantObject(((Component)collider).transform.position, size);
				return true;
			}
			plantObject = null;
			return false;
		}
	}
}