using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using DG.Tweening;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Localization;
using UnityEngine.Localization.Settings;
using UnityEngine.Localization.Tables;
using UnityEngine.ResourceManagement.AsyncOperations;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("KinkoCraft.FarmerOwl")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("Farmer Owl")]
[assembly: AssemblyTitle("KinkoCraft.FarmerOwl")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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 KinkoCraft.FarmerOwl
{
	public abstract class FarmerStateBase : StateBase<HelperCleanerStateMachine>
	{
		protected HelperCleaner Owner => base.stateMachine.Owner;

		protected HelperBase Helper => (HelperBase)(object)base.stateMachine.Owner;

		protected ContainerNet Container => ((HelperBase)base.stateMachine.Owner).containerRef.containerNet;

		protected FarmerStateBase(HelperCleanerStateMachine sm)
			: base(sm)
		{
		}

		protected void GoTo(StateBase<HelperCleanerStateMachine> next)
		{
			base.stateMachine.ChangeState(next);
		}

		public override void ExecutePerFrame()
		{
			Owner.SetAnimatorMoveSpeed();
		}

		public override void OnExit()
		{
		}

		public override void ExecutePerSecond()
		{
		}
	}
	public class FarmerIdleState : FarmerStateBase
	{
		private readonly FarmTask presetTask;

		public FarmerIdleState(HelperCleanerStateMachine sm, FarmTask presetTask = null)
			: base(sm)
		{
			this.presetTask = presetTask;
		}

		public override void OnEnter()
		{
			FarmTask farmTask = presetTask ?? FarmScheduler.GetNextTask(base.Owner);
			if (farmTask != null)
			{
				GoTo(new FarmerMoveToBedState(((StateBase<HelperCleanerStateMachine>)this).stateMachine, farmTask));
			}
			else
			{
				GoTo(new FarmerReturnHomeState(((StateBase<HelperCleanerStateMachine>)this).stateMachine));
			}
		}
	}
	public class FarmerMoveToBedState : FarmerStateBase
	{
		private readonly FarmTask task;

		private Vector3 movePos;

		public FarmerMoveToBedState(HelperCleanerStateMachine sm, FarmTask task)
			: base(sm)
		{
			//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)
			this.task = task;
			movePos = task.movePos;
		}

		public override void OnEnter()
		{
			HelperCleaner owner = base.Owner;
			owner.OnDespawn = (Action)Delegate.Combine(owner.OnDespawn, new Action(Unsubscribe));
			FurnitureManager instance = FurnitureManager.Instance;
			instance.OnFurniturePlaced = (Action)Delegate.Combine(instance.OnFurniturePlaced, new Action(OnFurniturePlaced));
		}

		public override void OnExit()
		{
			Unsubscribe();
		}

		private void Unsubscribe()
		{
			FurnitureManager instance = FurnitureManager.Instance;
			instance.OnFurniturePlaced = (Action)Delegate.Remove(instance.OnFurniturePlaced, new Action(OnFurniturePlaced));
			HelperCleaner owner = base.Owner;
			owner.OnDespawn = (Action)Delegate.Remove(owner.OnDespawn, new Action(Unsubscribe));
		}

		private void OnFurniturePlaced()
		{
			((MonoBehaviour)base.Owner).StartCoroutine(Recalculate());
		}

		private IEnumerator Recalculate()
		{
			yield return (object)new WaitForSeconds(1f);
			Vector3 val = default(Vector3);
			if (HelpersManager.Instance.GetReachablePointOnNavMesh(base.Helper, movePos, ref val, 20f))
			{
				movePos = val;
			}
		}

		public override void ExecutePerFrame()
		{
			//IL_0016: 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_0021: 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)
			base.Owner.SetAnimatorMoveSpeed();
			if (Vector2.Distance(FlatDistanceExtension.xz(((Component)base.Owner).transform.position), FlatDistanceExtension.xz(movePos)) <= ((HelperBase)base.Owner).targetDetectDistance)
			{
				GoTo(new FarmerWorkState(((StateBase<HelperCleanerStateMachine>)this).stateMachine, task));
			}
		}

		public override void ExecutePerSecond()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (base.Owner.CanMove())
			{
				((HelperBase)base.Owner).agent.SetDestination(movePos);
			}
		}
	}
	public class FarmerWorkState : FarmerStateBase
	{
		private static int _plowHits = -1;

		private readonly FarmTask task;

		public FarmerWorkState(HelperCleanerStateMachine sm, FarmTask task)
			: base(sm)
		{
			this.task = task;
		}

		public override void OnEnter()
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			((HelperBase)base.Owner).animator.SetBool("Cleanup", true);
			((HelperBase)base.Owner).agent.isStopped = true;
			IEnumerator enumerator = task.kind switch
			{
				FarmTask.Kind.Plow => PlowRoutine(task.bed, task.item), 
				FarmTask.Kind.Plant => PlantRoutine(task.bed, task.item), 
				FarmTask.Kind.Fertilize => FertilizeRoutine(task.bed), 
				FarmTask.Kind.Water => WaterRoutine(task.bed, task.item), 
				FarmTask.Kind.Harvest => HarvestRoutine(task.bed), 
				_ => throw new NotImplementedException("Unknown farm task kind"), 
			};
			((MonoBehaviour)base.Owner).StartCoroutine(enumerator);
			ShortcutExtensions.DOLookAt(((Component)base.Owner).transform, ((Component)task.bed).transform.position, 0.5f, (AxisConstraint)4, (Vector3?)null);
		}

		public override void OnExit()
		{
			((Behaviour)((HelperBase)base.Owner).agent).enabled = true;
			((HelperBase)base.Owner).agent.isStopped = false;
			((HelperBase)base.Owner).animator.SetBool("Cleanup", false);
		}

		private IEnumerator PlowRoutine(GardenBed bed, Item hoe)
		{
			//IL_0015: 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)
			if ((int)bed.state.Value == 0 && !bed.isInactive.Value)
			{
				bed.PlowBedServerRpc((byte)PlowHits());
				ConsumeDurability(hoe.id);
				yield return (object)new WaitForSeconds(1f);
			}
			Done();
		}

		private IEnumerator PlantRoutine(GardenBed bed, Item seed)
		{
			//IL_0015: 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)
			Item val = default(Item);
			if ((int)bed.state.Value == 1 && bed.currentSeedId.Value == 0 && !bed.isInactive.Value && base.Container.GetItemById(seed.id, ref val, false) && val.amount > 0 && GardenManager.Instance.IsSeed((uint)val.dataId))
			{
				PlantData plantData = GardenManager.Instance.GetPlantData((uint)val.dataId);
				if ((Object)(object)plantData != (Object)null)
				{
					val.amount--;
					bed.rarity = val.rarity;
					if (val.amount == 0)
					{
						base.Container.RemoveItemById(val.id);
					}
					else
					{
						base.Container.SetItemById(val.id, val);
					}
					bed.currentSeedId.Value = val.dataId;
					bed.remainingGrowTime = (int)plantData.growTime;
					bed.state.Value = (State)2;
					Game instance = Game.Instance;
					if (instance != null)
					{
						instance.InvokeGameEvent((GameEvent)73, (uint)val.dataId, 1);
					}
					yield return (object)new WaitForSeconds(1f);
				}
			}
			Done();
		}

		private IEnumerator FertilizeRoutine(GardenBed bed)
		{
			if (!bed.isFertilized.Value && IsGrowable(bed) && base.Container.GetItemAmount((ushort)280) != 0)
			{
				base.Container.RemoveAmount((ushort)280, (ushort)1);
				bed.isFertilized.Value = true;
				yield return (object)new WaitForSeconds(1f);
			}
			Done();
		}

		private IEnumerator WaterRoutine(GardenBed bed, Item can)
		{
			//IL_0015: 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)
			Item val = default(Item);
			if (!bed.isWatered.Value && IsGrowable(bed) && base.Container.GetItemById(can.id, ref val, false) && val.charge > 0)
			{
				if (val.charge > 1)
				{
					val.charge--;
					base.Container.SetItemById(val.id, val);
				}
				else
				{
					base.Container.RemoveItemById(val.id);
				}
				bed.isWatered.Value = true;
				yield return (object)new WaitForSeconds(1f);
			}
			Done();
		}

		private IEnumerator HarvestRoutine(GardenBed bed)
		{
			if ((int)bed.state.Value == 3 && bed.currentSeedId.Value != 0 && !bed.isInactive.Value)
			{
				PlantData plantData = GardenManager.Instance.GetPlantData((uint)bed.currentSeedId.Value);
				if ((Object)(object)plantData != (Object)null && (Object)(object)plantData.grownPlantItem != (Object)null)
				{
					ItemData grownPlantItem = plantData.grownPlantItem;
					Item val = default(Item);
					((Item)(ref val))..ctor(grownPlantItem);
					val.amount = plantData.takeAmount;
					Item val2 = val;
					if (grownPlantItem.hasRarity && (int)bed.rarity != 255)
					{
						val2.rarity = bed.rarity;
					}
					if (!grownPlantItem.quest && bed.isFertilized.Value)
					{
						val2.amount = (ushort)Mathf.CeilToInt(1.5f * (float)(int)val2.amount);
					}
					base.Container.AddNewItem(val2, ((Component)bed).transform.position, false);
					bed.state.Value = (State)0;
					Game instance = Game.Instance;
					if (instance != null)
					{
						instance.InvokeGameEvent((GameEvent)74, (uint)grownPlantItem.id, 1);
					}
					yield return (object)new WaitForSeconds(1f);
				}
			}
			Done();
		}

		private static bool IsGrowable(GardenBed bed)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Invalid comparison between Unknown and I4
			if (!bed.isInactive.Value)
			{
				if ((int)bed.state.Value != 1)
				{
					return (int)bed.state.Value == 2;
				}
				return true;
			}
			return false;
		}

		private void ConsumeDurability(uint toolId)
		{
			//IL_0016: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			Item val = default(Item);
			ItemData val2 = default(ItemData);
			if (base.Container.GetItemById(toolId, ref val, false) && ItemManager.Instance.GetItemData((uint)val.dataId, ref val2))
			{
				if (val.durability > val2.durabilityPerHit)
				{
					val.durability -= val2.durabilityPerHit;
					base.Container.SetItemById(val.id, val);
				}
				else
				{
					base.Container.RemoveItemById(val.id);
				}
			}
		}

		private static int PlowHits()
		{
			if (_plowHits > 0)
			{
				return _plowHits;
			}
			_plowHits = 2;
			GardenBed[] array = GardenManager.Instance?.gardenBeds;
			if (array != null && array.Length != 0)
			{
				FieldInfo field = typeof(GardenBed).GetField("targetHoeHitCount", BindingFlags.Instance | BindingFlags.NonPublic);
				if (field != null)
				{
					_plowHits = Mathf.Clamp((int)field.GetValue(array[0]), 1, 100);
				}
			}
			return _plowHits;
		}

		private void Done()
		{
			GoTo(new FarmerIdleState(((StateBase<HelperCleanerStateMachine>)this).stateMachine));
		}
	}
	public class FarmerReturnHomeState : FarmerStateBase
	{
		public FarmerReturnHomeState(HelperCleanerStateMachine sm)
			: base(sm)
		{
		}

		public override void OnEnter()
		{
			((StateBase<HelperCleanerStateMachine>)this).ExecutePerSecond();
		}

		public override void ExecutePerSecond()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: 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)
			if (base.Owner.CanMove() && ((Behaviour)((HelperBase)base.Owner).agent).isActiveAndEnabled)
			{
				((HelperBase)base.Owner).agent.SetDestination(((HelperBase)base.Owner).defaultPos);
			}
			if (Vector3.Distance(((Component)base.Owner).transform.position, ((HelperBase)base.Owner).defaultPos) <= ((HelperBase)base.Owner).targetDetectDistance)
			{
				GoTo(new FarmerNestState(((StateBase<HelperCleanerStateMachine>)this).stateMachine));
			}
		}
	}
	public class FarmerNestState : FarmerStateBase
	{
		private const float JumpDuration = 1.2f;

		private readonly bool jumpOnEnter;

		private bool jumped;

		private FarmTask pendingTask;

		public FarmerNestState(HelperCleanerStateMachine sm, bool jumpOnEnter = true)
			: base(sm)
		{
			this.jumpOnEnter = jumpOnEnter;
		}

		public override void OnEnter()
		{
			//IL_0036: 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_0069: 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)
			((Behaviour)((HelperBase)base.Owner).agent).enabled = false;
			((HelperBase)base.Owner).animator.SetBool("NestSit", true);
			if (jumpOnEnter)
			{
				Jump(((HelperBase)base.Owner).defaultPos);
			}
			if (PlayerManager.Instance.isLocalPlayerSpawned)
			{
				SoundManager.Instance.PlayServerRpc((SoundEvent)8010, ((Component)base.Owner).transform.position, false, default(ServerRpcParams));
			}
		}

		public override void ExecutePerSecond()
		{
			if (!jumped && ((HelperBase)base.Owner).isActivated)
			{
				pendingTask = FarmScheduler.GetNextTask(base.Owner);
				if (pendingTask != null)
				{
					((MonoBehaviour)base.Owner).StartCoroutine(JumpOff());
				}
			}
		}

		private IEnumerator JumpOff()
		{
			jumped = true;
			Jump(((HelperBase)base.Owner).landingPos.position);
			((HelperBase)base.Owner).animator.SetBool("NestSit", false);
			if (PlayerManager.Instance.isLocalPlayerSpawned)
			{
				SoundManager.Instance.PlayServerRpc((SoundEvent)8000, ((Component)base.Owner).transform.position, false, default(ServerRpcParams));
			}
			yield return (object)new WaitForSeconds(1.2f);
			((Behaviour)((HelperBase)base.Owner).agent).enabled = true;
			GoTo(new FarmerIdleState(((StateBase<HelperCleanerStateMachine>)this).stateMachine, pendingTask));
		}

		private void Jump(Vector3 endPos)
		{
			//IL_0020: 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)
			((HelperBase)base.Owner).networkAnimator.SetTrigger("Jump");
			ShortcutExtensions.DOJump(((Component)base.Owner).transform, endPos, 1f, 1, 1.2f, false);
			ShortcutExtensions.DORotate(((Component)base.Owner).transform, ((HelperBase)base.Owner).defaultRot, 1.2f, (RotateMode)0);
		}
	}
	public class FarmTask
	{
		public enum Kind
		{
			Plow,
			Plant,
			Fertilize,
			Water,
			Harvest
		}

		public readonly Vector3 movePos;

		public readonly GardenBed bed;

		public readonly Kind kind;

		public readonly Item item;

		public FarmTask(GardenBed bed, Kind kind, Item item = default(Item))
		{
			//IL_0015: 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)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			this.bed = bed;
			this.kind = kind;
			this.item = item;
			movePos = ((Component)bed).transform.position;
		}
	}
	internal static class FarmScheduler
	{
		public static FarmTask GetNextTask(HelperCleaner owner)
		{
			//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_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: 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_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Invalid comparison between Unknown and I4
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Invalid comparison between Unknown and I4
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			GardenManager instance = GardenManager.Instance;
			if ((Object)(object)instance == (Object)null || instance.gardenBeds == null)
			{
				return null;
			}
			ContainerNet containerNet = ((HelperBase)owner).containerRef.containerNet;
			if ((Object)(object)containerNet == (Object)null)
			{
				return null;
			}
			List<Item> source = StringExtension.ToList<Item>(containerNet.items);
			Item val = ((IEnumerable<Item>)source).FirstOrDefault((Func<Item, bool>)IsHoe);
			Item val2 = ((IEnumerable<Item>)source).FirstOrDefault((Func<Item, bool>)IsPlantableSeed);
			Item val3 = ((IEnumerable<Item>)source).FirstOrDefault((Func<Item, bool>)IsWateringCan);
			bool flag = val.id != 0;
			bool flag2 = val2.id != 0;
			bool flag3 = val3.id != 0;
			bool flag4 = containerNet.GetItemAmount((ushort)280) != 0;
			bool flag5 = !containerNet.IsFull();
			if (!(flag || flag2 || flag3 || flag4 || flag5))
			{
				return null;
			}
			GardenBed[] gardenBeds = instance.gardenBeds;
			if (flag5)
			{
				GardenBed[] array = gardenBeds;
				foreach (GardenBed val4 in array)
				{
					if (Active(val4) && (int)val4.state.Value == 3 && val4.currentSeedId.Value != 0)
					{
						return new FarmTask(val4, FarmTask.Kind.Harvest);
					}
				}
			}
			if (flag2)
			{
				GardenBed[] array = gardenBeds;
				foreach (GardenBed val5 in array)
				{
					if (Active(val5) && (int)val5.state.Value == 1 && val5.currentSeedId.Value == 0)
					{
						return new FarmTask(val5, FarmTask.Kind.Plant, val2);
					}
				}
			}
			if (flag)
			{
				GardenBed[] array = gardenBeds;
				foreach (GardenBed val6 in array)
				{
					if (Active(val6) && (int)val6.state.Value == 0)
					{
						return new FarmTask(val6, FarmTask.Kind.Plow, val);
					}
				}
			}
			if (flag4)
			{
				GardenBed[] array = gardenBeds;
				foreach (GardenBed val7 in array)
				{
					if (Active(val7) && !val7.isFertilized.Value && Growable(val7))
					{
						return new FarmTask(val7, FarmTask.Kind.Fertilize);
					}
				}
			}
			if (flag3)
			{
				GardenBed[] array = gardenBeds;
				foreach (GardenBed val8 in array)
				{
					if (Active(val8) && !val8.isWatered.Value && Growable(val8))
					{
						return new FarmTask(val8, FarmTask.Kind.Water, val3);
					}
				}
			}
			return null;
		}

		private static bool Active(GardenBed bed)
		{
			if ((Object)(object)bed != (Object)null)
			{
				return !bed.isInactive.Value;
			}
			return false;
		}

		private static bool Growable(GardenBed bed)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Invalid comparison between Unknown and I4
			if ((int)bed.state.Value != 1)
			{
				return (int)bed.state.Value == 2;
			}
			return true;
		}

		public static bool IsHoe(Item item)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: 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)
			if (item.amount > 0)
			{
				if (item.dataId != 302)
				{
					return item.dataId == 307;
				}
				return true;
			}
			return false;
		}

		public static bool IsWateringCan(Item item)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (item.dataId == 303)
			{
				return item.charge > 0;
			}
			return false;
		}

		public static bool IsPlantableSeed(Item item)
		{
			//IL_0000: 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)
			if (item.amount > 0 && (Object)(object)GardenManager.Instance != (Object)null)
			{
				return GardenManager.Instance.IsSeed((uint)item.dataId);
			}
			return false;
		}
	}
	internal static class Ids
	{
		public const ushort CleanerHouse = 1156;

		public const ushort Compost = 280;

		public const ushort Hoe = 302;

		public const ushort ProHoe = 307;

		public const ushort WateringCan = 303;

		public const ushort FarmerOwlHouse = 47801;

		public const string OwlMarker = "FarmerOwl_Helper";

		public const string ItemNameKey = "ItemDataNameFarmerOwlHouse";

		public const string ItemDescrKey = "ItemDataDescrFarmerOwlHouse";

		public const string OwlTitleKey = "InteractiveNameFarmerOwl";

		public const string HouseName = "Farmer Owl House";

		public const string HouseDescr = "A farmer owl that plows, plants seeds, waters, fertilizes and harvests your garden beds.";

		public const string OwlName = "Farmer Owl";
	}
	public class ItemRegistrationPatch
	{
		[HarmonyPatch(typeof(ItemManager), "Awake")]
		[HarmonyPrefix]
		private static void AddFarmerOwlHouse(ItemManager __instance)
		{
			//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_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: 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_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: 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_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Expected O, but got Unknown
			ItemData val = ((IEnumerable<ItemData>)__instance.itemDataHub.itemData).FirstOrDefault((Func<ItemData, bool>)((ItemData d) => d.id == 1156));
			if ((Object)(object)val == (Object)null)
			{
				FarmerOwlPlugin.Log.LogWarning((object)"Cleaner House item not found; Farmer Owl House not registered.");
				return;
			}
			ItemData element = new ItemData
			{
				id = 47801,
				name = "ItemDataNameFarmerOwlHouse",
				itemDescription = "ItemDataDescrFarmerOwlHouse",
				icon = val.icon,
				type = (Type)10,
				maxStack = 1,
				price = 1800,
				shopItem = true,
				levelDependant = 0,
				collectiblePrefab = val.collectiblePrefab,
				fpPrefab = val.fpPrefab,
				tpPrefab = val.tpPrefab,
				netPrefab = val.netPrefab
			};
			__instance.itemDataHub.itemData = __instance.itemDataHub.itemData.Append(element).ToArray();
			FarmerOwlPlugin.Log.LogInfo((object)"Registered Farmer Owl House item.");
		}
	}
	public class PrefabPatch
	{
		private static readonly Color FarmerGreen = new Color(0.192f, 1f, 0.086f);

		private static CodeMatch InstantiateReturning(Type returnType)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			return new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => i.opcode == OpCodes.Call && (i.operand as MethodInfo)?.Name == "Instantiate" && (i.operand as MethodInfo)?.ReturnType == returnType), (string)null);
		}

		[HarmonyPatch(typeof(FurnitureManager), "OnNetworkSpawn")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Furniture_OnNetworkSpawn(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1] { InstantiateReturning(typeof(GameObject)) }).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[3]
			{
				new CodeInstruction(OpCodes.Ldloc_2, (object)null),
				new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(SavedDevice), "itemDataId")),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(PrefabPatch), "InstantiateFurnitureOnLoad", (Type[])null, (Type[])null))
			}).RemoveInstruction()
				.Instructions();
		}

		[HarmonyPatch(typeof(FurnitureManager), "PlaceFurnitureServerRpc", new Type[]
		{
			typeof(uint),
			typeof(Vector3),
			typeof(Quaternion),
			typeof(ServerRpcParams)
		})]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PlaceFurniture_Free(IEnumerable<CodeInstruction> instructions)
		{
			return RouteInstantiateThroughDataId(instructions);
		}

		[HarmonyPatch(typeof(FurnitureManager), "PlaceFurnitureServerRpc", new Type[]
		{
			typeof(uint),
			typeof(ushort),
			typeof(ServerRpcParams)
		})]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PlaceFurniture_Slot(IEnumerable<CodeInstruction> instructions)
		{
			return RouteInstantiateThroughDataId(instructions);
		}

		private static IEnumerable<CodeInstruction> RouteInstantiateThroughDataId(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1] { InstantiateReturning(typeof(GameObject)) }).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[3]
			{
				new CodeInstruction(OpCodes.Ldloc_2, (object)null),
				new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(Item), "dataId")),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(PrefabPatch), "InstantiateFurniture", (Type[])null, (Type[])null))
			}).RemoveInstruction()
				.Instructions();
		}

		[HarmonyPatch(typeof(HelperHouse), "OnNetworkSpawn")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Helper_OnNetworkSpawn(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1] { InstantiateReturning(typeof(HelperBase)) }).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[3]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(HelperHouse), "furniture")),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(PrefabPatch), "InstantiateHelper", (Type[])null, (Type[])null))
			}).RemoveInstruction()
				.Instructions();
		}

		public static GameObject InstantiateFurnitureOnLoad(GameObject original, Vector3 pos, Quaternion rot, Transform parent, uint itemId)
		{
			//IL_0001: 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)
			GameObject val = Object.Instantiate<GameObject>(original, pos, rot, parent);
			if (itemId == 47801)
			{
				TintHouse(val);
			}
			return val;
		}

		public static GameObject InstantiateFurniture(GameObject original, Vector3 pos, Quaternion rot, uint itemId)
		{
			//IL_0001: 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)
			GameObject val = Object.Instantiate<GameObject>(original, pos, rot);
			if (itemId == 47801)
			{
				TintHouse(val);
			}
			return val;
		}

		public static HelperBase InstantiateHelper(HelperBase original, Vector3 pos, Quaternion rot, Furniture source)
		{
			//IL_0001: 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)
			HelperBase val = Object.Instantiate<HelperBase>(original, pos, rot);
			if ((Object)(object)val != (Object)null && source.itemData.id == 47801)
			{
				TintSkinned(((Component)val).transform.Find("HalloweenOwl_Gr/coat_low"));
				TintSkinned(((Component)val).transform.Find("HalloweenOwl_Gr/hood_low"));
				((Object)val).name = "FarmerOwl_Helper";
				((Component)val).GetComponent<Interactive>().ObjectTitle = "InteractiveNameFarmerOwl";
			}
			return val;
		}

		private static void TintHouse(GameObject house)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			Transform val = house.transform.Find("Container/Owls_Nest/Owls_Nest/Owls_Nest");
			if ((Object)(object)val != (Object)null)
			{
				((Renderer)((Component)val).GetComponent<MeshRenderer>()).material.color = FarmerGreen;
			}
			Furniture component = house.GetComponent<Furniture>();
			ItemData itemData = default(ItemData);
			if ((Object)(object)component != (Object)null && ItemManager.Instance.GetItemData(47801u, ref itemData))
			{
				component.itemData = itemData;
			}
		}

		private static void TintSkinned(Transform t)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			SkinnedMeshRenderer val = (((Object)(object)t != (Object)null) ? ((Component)t).GetComponent<SkinnedMeshRenderer>() : null);
			if ((Object)(object)val != (Object)null)
			{
				((Renderer)val).material.color = FarmerGreen;
			}
		}
	}
	internal static class StateMachineAccess
	{
		private static readonly FieldInfo SmField = typeof(HelperCleaner).GetField("stateMachine", BindingFlags.Instance | BindingFlags.NonPublic);

		private static readonly FieldInfo IsTransition = typeof(HelperCleanerStateMachine).GetField("isTransition", BindingFlags.Instance | BindingFlags.NonPublic);

		private static readonly FieldInfo CurrentState = typeof(HelperCleanerStateMachine).GetField("<CurrentState>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic);

		private static readonly FieldInfo PreviousState = typeof(HelperCleanerStateMachine).GetField("<PreviousState>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic);

		public static HelperCleanerStateMachine Of(HelperCleaner cleaner)
		{
			object? obj = SmField?.GetValue(cleaner);
			return (HelperCleanerStateMachine)((obj is HelperCleanerStateMachine) ? obj : null);
		}

		public static void ForceTransition(HelperCleanerStateMachine sm, StateBase<HelperCleanerStateMachine> newState)
		{
			sm.Owner.currentStateName = ((object)newState).GetType().Name;
			IsTransition.SetValue(sm, true);
			sm.CurrentState.OnExit();
			PreviousState.SetValue(sm, sm.CurrentState);
			CurrentState.SetValue(sm, newState);
			sm.CurrentState.OnEnter();
			IsTransition.SetValue(sm, false);
		}
	}
	internal class HelperRoutingPatch
	{
		[HarmonyPatch(typeof(HelperCleaner), "OnNetworkSpawn")]
		[HarmonyPostfix]
		private static void OnNetworkSpawn(HelperCleaner __instance)
		{
			if (((NetworkBehaviour)__instance).IsServer && !(((Object)((Component)__instance).gameObject).name != "FarmerOwl_Helper"))
			{
				HelperCleanerStateMachine val = StateMachineAccess.Of(__instance);
				if (val != null)
				{
					val.SetInitState((StateBase<HelperCleanerStateMachine>)new FarmerNestState(val, jumpOnEnter: false));
				}
			}
		}

		[HarmonyPatch(typeof(HelperCleaner), "Activate")]
		[HarmonyPrefix]
		private static bool Activate(HelperCleaner __instance)
		{
			if (!((NetworkBehaviour)__instance).IsServer)
			{
				return true;
			}
			HelperCleanerStateMachine val = StateMachineAccess.Of(__instance);
			if (val == null || !(val.CurrentState is FarmerStateBase))
			{
				return true;
			}
			((HelperBase)__instance).isActivated = true;
			if (val.CurrentState is FarmerReturnHomeState)
			{
				val.ChangeState((StateBase<HelperCleanerStateMachine>)new FarmerIdleState(val));
			}
			return false;
		}

		[HarmonyPatch(typeof(HelperCleaner), "Deactivate")]
		[HarmonyPrefix]
		private static bool Deactivate(HelperCleaner __instance)
		{
			if (!((NetworkBehaviour)__instance).IsServer)
			{
				return true;
			}
			HelperCleanerStateMachine val = StateMachineAccess.Of(__instance);
			if (val == null || !(val.CurrentState is FarmerStateBase))
			{
				return true;
			}
			val.ChangeState((StateBase<HelperCleanerStateMachine>)new FarmerReturnHomeState(val));
			HelpersManager.Instance.RemoveFromTaskList((HelperBase)(object)__instance);
			((HelperBase)__instance).isActivated = false;
			return false;
		}

		[HarmonyPatch(typeof(HelperCleaner), "CheckContainerChanged")]
		[HarmonyPrefix]
		private static bool CheckContainerChanged(HelperCleaner __instance)
		{
			if (!((NetworkBehaviour)__instance).IsServer)
			{
				return true;
			}
			HelperCleanerStateMachine val = StateMachineAccess.Of(__instance);
			if (val == null || !(val.CurrentState is FarmerStateBase))
			{
				return true;
			}
			if (val.CurrentState is FarmerMoveToBedState)
			{
				val.ChangeState((StateBase<HelperCleanerStateMachine>)new FarmerIdleState(val));
			}
			return false;
		}
	}
	internal class StateMachinePatch
	{
		[HarmonyPatch(typeof(HelperCleanerStateMachine), "ChangeState")]
		[HarmonyPrefix]
		private static bool ChangeState(HelperCleanerStateMachine __instance, StateBase<HelperCleanerStateMachine> newState)
		{
			if (!((HelperBase)__instance.Owner).isActivated && newState is FarmerNestState)
			{
				StateMachineAccess.ForceTransition(__instance, newState);
				return false;
			}
			return true;
		}
	}
	internal static class PluginMeta
	{
		public const string Guid = "KinkoCraft.FarmerOwl";

		public const string Name = "Farmer Owl";

		public const string Version = "1.0.0";
	}
	[BepInPlugin("KinkoCraft.FarmerOwl", "Farmer Owl", "1.0.0")]
	public class FarmerOwlPlugin : BaseUnityPlugin
	{
		internal static ManualLogSource Log;

		private void Awake()
		{
			//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_0025: 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)
			Log = ((BaseUnityPlugin)this).Logger;
			Harmony val = new Harmony("KinkoCraft.FarmerOwl");
			val.PatchAll(typeof(ItemRegistrationPatch));
			val.PatchAll(typeof(PrefabPatch));
			val.PatchAll(typeof(HelperRoutingPatch));
			val.PatchAll(typeof(StateMachinePatch));
			((MonoBehaviour)this).StartCoroutine(RegisterLocalization());
			LocalizationSettings.SelectedLocaleChanged += OnLocaleChanged;
			Log.LogInfo((object)"Farmer Owl v1.0.0 loaded.");
		}

		private void OnDestroy()
		{
			LocalizationSettings.SelectedLocaleChanged -= OnLocaleChanged;
		}

		private void OnLocaleChanged(Locale locale)
		{
			((MonoBehaviour)this).StartCoroutine(RegisterLocalization());
		}

		private IEnumerator RegisterLocalization()
		{
			AsyncOperationHandle<LocalizationSettings> init = LocalizationSettings.InitializationOperation;
			while (!init.IsDone)
			{
				yield return null;
			}
			Locale locale = LocalizationSettings.SelectedLocale;
			if (!((Object)(object)locale == (Object)null))
			{
				LocalizedDatabase<StringTable, StringTableEntry> db = (LocalizedDatabase<StringTable, StringTableEntry>)(object)LocalizationSettings.StringDatabase;
				AsyncOperationHandle<StringTable> itemTableOp = db.GetTableAsync(TableReference.op_Implicit("ItemData"), locale);
				while (!itemTableOp.IsDone)
				{
					yield return null;
				}
				SetEntry(itemTableOp.Result, "ItemDataNameFarmerOwlHouse", "Farmer Owl House");
				SetEntry(itemTableOp.Result, "ItemDataDescrFarmerOwlHouse", "A farmer owl that plows, plants seeds, waters, fertilizes and harvests your garden beds.");
				AsyncOperationHandle<StringTable> interactiveTableOp = db.GetTableAsync(TableReference.op_Implicit("Interactive"), locale);
				while (!interactiveTableOp.IsDone)
				{
					yield return null;
				}
				SetEntry(interactiveTableOp.Result, "InteractiveNameFarmerOwl", "Farmer Owl");
			}
		}

		private static void SetEntry(StringTable table, string key, string value)
		{
			if (!((Object)(object)table == (Object)null))
			{
				StringTableEntry entry = ((DetailedLocalizationTable<StringTableEntry>)(object)table).GetEntry(key);
				if (entry == null)
				{
					((DetailedLocalizationTable<StringTableEntry>)(object)table).AddEntry(key, value);
				}
				else
				{
					entry.Value = value;
				}
			}
		}
	}
}