using System;
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 BepInEx.Logging;
using ChosenViceroyOfTheForest;
using Eremite;
using Eremite.Buildings;
using Eremite.Controller;
using Eremite.Services;
using HarmonyLib;
using JamesGames;
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(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyCompany("EverythingsMoveable")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Mod used as an example of how to use all of it methods")]
[assembly: AssemblyFileVersion("1.1.0.0")]
[assembly: AssemblyInformationalVersion("1.1.0")]
[assembly: AssemblyProduct("EverythingsMoveable")]
[assembly: AssemblyTitle("EverythingsMoveable")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.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 ATS_EverythingsMoveable
{
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "EverythingsMoveable";

		public const string PLUGIN_NAME = "EverythingsMoveable";

		public const string PLUGIN_VERSION = "1.1.0";
	}
}
namespace JamesGames
{
	[HarmonyPatch]
	[BepInPlugin("ATS_EverythingsMoveable", "ATS_EverythingsMoveable", "1.1.0")]
	public class Plugin : BaseUnityPlugin
	{
		private const string GUID = "ATS_EverythingsMoveable";

		private const string NAME = "ATS_EverythingsMoveable";

		private const string VERSION = "1.1.0";

		public static ManualLogSource Log;

		public static Plugin Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			Harmony.CreateAndPatchAll(typeof(Plugin).Assembly, "ATS_EverythingsMoveable");
			Log.LogInfo((object)"ATS_EverythingsMoveable v1.1.0 Plugin loaded");
		}

		[HarmonyPatch(typeof(Hearth), "IsTooCloseToOtherHearth")]
		[HarmonyPrefix]
		private static bool ConstructionService_CanPlaceOnGrid2(Hearth __instance, ref bool __result)
		{
			//IL_0084: 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 (((BuildingState)__instance.state).placed)
			{
				__result = false;
				return false;
			}
			__instance.RecalculateArea();
			foreach (HearthState hearth in GameMB.StateService.Buildings.hearths)
			{
				Building building = GameMB.BuildingsService.GetBuilding(((BuildingState)hearth).id);
				Hearth val = (Hearth)(object)((building is Hearth) ? building : null);
				if (((BuildingState)val.state).lifted)
				{
					continue;
				}
				foreach (Vector2Int item in __instance.area)
				{
					if (val.IsInRange(item))
					{
						__result = true;
						return false;
					}
				}
			}
			__result = false;
			return false;
		}

		[HarmonyPatch(typeof(GameController), "StartGame")]
		[HarmonyPostfix]
		private static void HookEveryGameStart()
		{
			Log.LogInfo((object)"Patching GameController.StartGame");
			Serviceable.EffectsService.EnableAllBuildingsMoving("ATS_EverythingsMoveable");
			BuildingModel[] buildings = SO.Settings.Buildings;
			foreach (BuildingModel val in buildings)
			{
				if (val is HearthModel)
				{
					if (Configs.MovableHearth)
					{
						val.movable = true;
					}
				}
				else if (val is RelicModel)
				{
					if (Configs.MovableRelics)
					{
						val.movable = true;
					}
				}
				else
				{
					val.movable = true;
				}
			}
		}
	}
}
namespace ChosenViceroyOfTheForest
{
	internal static class Configs
	{
		private static ConfigEntry<bool> m_MoveableHearth = Bind("General", "Movable Hearth", defaultValue: true, "When set to true the hearth can be moved after being placed.");

		private static ConfigEntry<bool> m_MovableRelics = Bind("General", "Movable Relics", defaultValue: true, "When set to true runes can be moved (Caches, events... etc)");

		public static bool MovableHearth
		{
			get
			{
				return m_MoveableHearth.Value;
			}
			set
			{
				m_MoveableHearth.Value = value;
				((BaseUnityPlugin)Plugin.Instance).Config.Save();
			}
		}

		public static bool MovableRelics
		{
			get
			{
				return m_MovableRelics.Value;
			}
			set
			{
				m_MovableRelics.Value = value;
				((BaseUnityPlugin)Plugin.Instance).Config.Save();
			}
		}

		private static ConfigEntry<T> Bind<T>(string section, string key, T defaultValue, string description)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			return ((BaseUnityPlugin)Plugin.Instance).Config.Bind<T>(section, key, defaultValue, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()));
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}