using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using Microsoft.CodeAnalysis;
using ServersideQoL.Utilities;
using UnityEngine;

[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("ArgusMagnus")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("ArgusMagnus")]
[assembly: AssemblyDescription("Show in-game time on signs, set default sign color and put signs showing the remaining fermentation time on fermenters")]
[assembly: AssemblyFileVersion("2.3.0.0")]
[assembly: AssemblyInformationalVersion("2.3.0+2e3f9ec58eb6242e0f6159ce758d539a6d41fdf7")]
[assembly: AssemblyProduct("ServersideQoL.Signs")]
[assembly: AssemblyTitle("ServersideQoL.Signs")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/ArgusMagnus/ValheimServersideQoL")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.3.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[CompilerGenerated]
internal sealed class <>z__ReadOnlyArray<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Length;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => _items.Length;

	T IReadOnlyList<T>.this[int index] => _items[index];

	int ICollection<T>.Count => _items.Length;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlyArray(T[] items)
	{
		_items = items;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return ((IEnumerable)_items).GetEnumerator();
	}

	void ICollection.CopyTo(Array array, int index)
	{
		((ICollection)_items).CopyTo(array, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return ((IList)_items).Contains(value);
	}

	int IList.IndexOf(object value)
	{
		return ((IList)_items).IndexOf(value);
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return ((IEnumerable<T>)_items).GetEnumerator();
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return ((ICollection<T>)_items).Contains(item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		((ICollection<T>)_items).CopyTo(array, arrayIndex);
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		return ((IList<T>)_items).IndexOf(item);
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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]
	[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;
		}
	}
	[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 ServersideQoL.Signs
{
	public sealed class Config : ConfigBase<Config>
	{
		public sealed class AdvancedConfig
		{
			public sealed class ProcessingDelaysConfig
			{
				public float TimeSigns { get; init; } = 0.5f;
			}

			public ProcessingDelaysConfig ProcessingDelays { get; init; } = new ProcessingDelaysConfig();
		}

		internal const string NotSetDefaultColor = "black";

		public override ConfigEntry<bool> Enabled { get; } = ConfigBase<Config>.BindEx<bool>(cfg, true, "Enables/disables the entire mod", (IAcceptableValueBase<bool>)null, (Deprecated<Config>)null, "Enabled");

		public ConfigEntry<string> DefaultColor { get; } = ConfigBase<Config>.BindEx<string>(cfg, "black", "Default color for signs", (IAcceptableValueBase<string>)(object)new AcceptableValueList<string>(new string[8] { "black", "blue", "green", "orange", "purple", "red", "white", "yellow" }), (Deprecated<Config>)null, "DefaultColor");

		public ConfigEntry<bool> TimeSigns { get; } = ConfigBase<Config>.BindEx<bool>(cfg, true, FormattableString.Invariant($"True to update sign texts which contain time emojis (any of {string.Concat(SignProcessor.ClockEmojis)}) with the in-game time"), (IAcceptableValueBase<bool>)null, (Deprecated<Config>)null, "TimeSigns");

		public ConfigEntry<string> TimeSignsPlaceholder { get; } = ConfigBase<Config>.BindEx<string>(cfg, "", "Optional text that will be recognized in addition to time emojis and replaced with the in-game time on signs", (IAcceptableValueBase<string>)null, (Deprecated<Config>)null, "TimeSignsPlaceholder");

		public ConfigEntry<bool> FermenterSigns { get; } = ConfigBase<Config>.BindEx<bool>(cfg, false, "True to automatically put a sign on the tap side of fermenters, showing the content and the remaining fermentation time", (IAcceptableValueBase<bool>)null, (Deprecated<Config>)null, "FermenterSigns");

		public YamlConfigEntry<AdvancedConfig> Advanced { get; } = ConfigBase<Config>.BindYaml<AdvancedConfig>(cfg, "Advanced");

		public Config(ConfigFile cfg, Logger logger)
			: base(cfg, logger)
		{
		}
	}
	[Processor("0daf063a-639c-4797-9a0d-c8fd7e7e420c")]
	[RunBefore<SignProcessor>]
	public sealed class FermenterSignProcessor : Processor<FermenterSignProcessor.PrefabInfo>
	{
		public sealed record PrefabInfo(Fermenter Fermenter) : ProcessorPrefabInfo()
		{
			public (Vector3 Direction, float Distance, float Height) Placement { get; } = GetPlacement(Fermenter);

			private static (Vector3, float, float) GetPlacement(Fermenter fermenter)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: 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_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: 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_0058: 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_0069: 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)
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_0196: Unknown result type (might be due to invalid IL or missing references)
				//IL_0185: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0103: Unknown result type (might be due to invalid IL or missing references)
				//IL_0108: Unknown result type (might be due to invalid IL or missing references)
				//IL_010d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0112: 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_011e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0123: Unknown result type (might be due to invalid IL or missing references)
				//IL_0128: Unknown result type (might be due to invalid IL or missing references)
				//IL_012c: Unknown result type (might be due to invalid IL or missing references)
				//IL_013c: Unknown result type (might be due to invalid IL or missing references)
				//IL_014c: Unknown result type (might be due to invalid IL or missing references)
				//IL_014e: Unknown result type (might be due to invalid IL or missing references)
				Transform transform = ((Component)fermenter).transform;
				Vector3 val = (Object.op_Implicit((Object)(object)fermenter.m_tapSwitch) ? transform.InverseTransformPoint(((Component)fermenter.m_tapSwitch).transform.position) : Vector3.forward);
				Vector3 val2 = default(Vector3);
				((Vector3)(ref val2))..ctor(val.x, 0f, val.z);
				val2 = ((((Vector3)(ref val2)).sqrMagnitude > 0.0001f) ? ((Vector3)(ref val2)).normalized : Vector3.forward);
				Vector3 val3 = default(Vector3);
				((Vector3)(ref val3))..ctor(val2.z, 0f, 0f - val2.x);
				float num = float.MaxValue;
				float num2 = float.MinValue;
				float num3 = 0f;
				MeshFilter[] componentsInChildren = ((Component)fermenter).GetComponentsInChildren<MeshFilter>(true);
				foreach (MeshFilter val4 in componentsInChildren)
				{
					if (Object.op_Implicit((Object)(object)val4.sharedMesh))
					{
						Bounds bounds = val4.sharedMesh.bounds;
						for (int j = 0; j < 8; j++)
						{
							Vector3 val5 = ((Bounds)(ref bounds)).center + Vector3.Scale(((Bounds)(ref bounds)).extents, new Vector3((float)(((j & 1) != 0) ? 1 : (-1)), (float)(((j & 2) != 0) ? 1 : (-1)), (float)(((j & 4) != 0) ? 1 : (-1))));
							val5 = transform.InverseTransformPoint(((Component)val4).transform.TransformPoint(val5));
							num = Mathf.Min(num, val5.y);
							num2 = Mathf.Max(num2, val5.y);
							num3 = Mathf.Max(num3, Mathf.Abs(Vector3.Dot(val5, val3)));
						}
					}
				}
				if (num > num2)
				{
					return (val2, 0.6f, 0.8f);
				}
				return (val2, num3 + 0.05f, (num + num2) / 2f);
			}

			[CompilerGenerated]
			public override string ToString()
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append("PrefabInfo");
				stringBuilder.Append(" { ");
				if (((ProcessorPrefabInfo)this).PrintMembers(stringBuilder))
				{
					stringBuilder.Append(' ');
				}
				stringBuilder.Append('}');
				return stringBuilder.ToString();
			}

			[CompilerGenerated]
			protected override bool PrintMembers(StringBuilder builder)
			{
				if (((ProcessorPrefabInfo)this).PrintMembers(builder))
				{
					builder.Append(", ");
				}
				builder.Append("Fermenter = ");
				builder.Append(Fermenter);
				builder.Append(", Placement = ");
				builder.Append(Placement.ToString());
				return true;
			}

			[CompilerGenerated]
			public override int GetHashCode()
			{
				return (((ProcessorPrefabInfo)this).GetHashCode() * -1521134295 + EqualityComparer<Fermenter>.Default.GetHashCode(Fermenter)) * -1521134295 + EqualityComparer<(Vector3, float, float)>.Default.GetHashCode(Placement);
			}

			[CompilerGenerated]
			public sealed override bool Equals(ProcessorPrefabInfo? other)
			{
				return ((object)this).Equals((object?)other);
			}

			[CompilerGenerated]
			public bool Equals(PrefabInfo? other)
			{
				if ((object)this != other)
				{
					if (((ProcessorPrefabInfo)this).Equals((ProcessorPrefabInfo)(object)other) && EqualityComparer<Fermenter>.Default.Equals(Fermenter, other.Fermenter))
					{
						return EqualityComparer<(Vector3, float, float)>.Default.Equals(Placement, other.Placement);
					}
					return false;
				}
				return true;
			}

			[CompilerGenerated]
			private PrefabInfo(PrefabInfo original)
				: base((ProcessorPrefabInfo)(object)original)
			{
				Fermenter = original.Fermenter;
				Placement = original.Placement;
			}
		}

		public const string Id = "0daf063a-639c-4797-9a0d-c8fd7e7e420c";

		private const float UpdateInterval = 5f;

		private readonly Dictionary<ServersideQoLZDO, ServersideQoLZDO> _signsByFermenters = new Dictionary<ServersideQoLZDO, ServersideQoLZDO>();

		protected override void Initialize()
		{
			foreach (ServersideQoLZDO value in _signsByFermenters.Values)
			{
				value.Destroy();
			}
			_signsByFermenters.Clear();
		}

		protected override bool ClaimExclusive(ServersideQoLZDO zdo)
		{
			return false;
		}

		protected override ProcessResult Process(ServersideQoLZDO zdo, IReadOnlyList<Peer> peers, PrefabInfo prefabInfo)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: 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)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: 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_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			if (ConfigBase<Config>.Instance.FermenterSigns.Value)
			{
				ZDOVars vars = zdo.Vars;
				PlayerID val = default(PlayerID);
				val = ((ZDOVars)(ref vars)).GetCreator(val);
				if (((PlayerID)(ref val)).Value != 0L)
				{
					if (!_signsByFermenters.TryGetValue(zdo, out ServersideQoLZDO value))
					{
						(Vector3 Direction, float Distance, float Height) placement = prefabInfo.Placement;
						Vector3 item = placement.Direction;
						float item2 = placement.Distance;
						float item3 = placement.Height;
						item = zdo.ZDO.GetRotation() * item;
						Vector3 val2 = zdo.ZDO.GetPosition() + item * item2;
						val2.y += item3;
						Vector3 val3 = val2;
						int sign = Prefabs.Sign;
						Quaternion val4 = Quaternion.LookRotation(item);
						value = ((Processor)this).PlacePiece(val3, sign, ((Quaternion)(ref val4)).eulerAngles.y);
						value.Fields<WearNTear>().Set((Func<Expression<Func<WearNTear, bool>>>)(() => (WearNTear x) => x.m_supports), false, "C:\\repos\\Valheim.ServersideQoL\\ServersideQoL.Signs\\FermenterSignProcessor.cs", 72);
						_signsByFermenters.Add(zdo, value);
						zdo.Destroyed += OnFermenterDestroyed;
					}
					ProcessResult result = (ProcessResult)0;
					vars = zdo.Vars;
					int content = ((ZDOVars)(ref vars)).GetContent(0);
					string text;
					if (content == 0)
					{
						text = Localization.instance.Localize("$piece_container_empty");
					}
					else
					{
						ItemConversion val5 = ((IEnumerable<ItemConversion>)prefabInfo.Fermenter.m_conversion).FirstOrDefault((Func<ItemConversion, bool>)((ItemConversion x) => StringExtensionMethods.GetStableHashCode(((Object)((Component)x.m_from).gameObject).name) == content));
						if (val5 == null)
						{
							text = "Invalid";
						}
						else
						{
							string text2 = Localization.instance.Localize(val5.m_from.m_itemData.m_shared.m_name);
							float num = zdo.Fields<Fermenter>().GetFloat((Func<Expression<Func<Fermenter, float>>>)(() => (Fermenter x) => x.m_fermentationDuration), "C:\\repos\\Valheim.ServersideQoL\\ServersideQoL.Signs\\FermenterSignProcessor.cs", 89);
							vars = zdo.Vars;
							DateTime startTime = ((ZDOVars)(ref vars)).GetStartTime(default(DateTime));
							if (startTime.Ticks != 0L)
							{
								num -= (float)(ZNet.instance.GetTime() - startTime).TotalSeconds;
							}
							if (num < 0f)
							{
								text = text2 + "<br>" + Localization.instance.Localize("$piece_fermenter_ready");
							}
							else
							{
								TimeSpan timeSpan = TimeSpan.FromSeconds(Mathf.Ceil(num));
								text = FormattableString.Invariant($"{text2}<br>{(int)timeSpan.TotalMinutes}:{timeSpan.Seconds:D2}");
								result = ((Processor)this).ScheduleReprocessing(Mathf.Min(5f, num + 0.1f));
							}
						}
					}
					vars = value.Vars;
					string text3 = ((ZDOVars)(ref vars)).GetText("");
					Match match = Processor.Instance<SignProcessor>().DefaultColorRegex.Match(text3);
					if (match != null && match.Success)
					{
						text = match.Value + text;
					}
					if (text3 != text)
					{
						vars = value.Vars;
						((ZDOVars)(ref vars)).SetText(text, "C:\\repos\\Valheim.ServersideQoL\\ServersideQoL.Signs\\FermenterSignProcessor.cs", 109);
					}
					return result;
				}
			}
			return (ProcessResult)2;
		}

		private void OnFermenterDestroyed(ServersideQoLZDO zdo)
		{
			if (_signsByFermenters.Remove(zdo, out ServersideQoLZDO value))
			{
				value.Destroy();
			}
		}
	}
	[Processor("806bdb85-c857-4154-a246-a0b1d0917987")]
	public sealed class SignProcessor : Processor<ProcessorPrefabInfo<Sign>>
	{
		public const string Id = "806bdb85-c857-4154-a246-a0b1d0917987";

		private Regex _clockRegex;

		private string? _timeText;

		internal static IReadOnlyList<string> ClockEmojis { get; } = new <>z__ReadOnlyArray<string>(new string[24]
		{
			"\ud83d\udd5b", "\ud83d\udd67", "\ud83d\udd50", "\ud83d\udd5c", "\ud83d\udd51", "\ud83d\udd5d", "\ud83d\udd52", "\ud83d\udd5e", "\ud83d\udd53", "\ud83d\udd5f",
			"\ud83d\udd54", "\ud83d\udd60", "\ud83d\udd55", "\ud83d\udd61", "\ud83d\udd56", "\ud83d\udd62", "\ud83d\udd57", "\ud83d\udd63", "\ud83d\udd58", "\ud83d\udd64",
			"\ud83d\udd59", "\ud83d\udd65", "\ud83d\udd5a", "\ud83d\udd66"
		});

		internal Regex DefaultColorRegex { get; } = new Regex("<color=[^>]+ d>");

		[MemberNotNull("_clockRegex")]
		protected override void Initialize()
		{
			_clockRegex = (string.IsNullOrEmpty(ConfigBase<Config>.Instance.TimeSignsPlaceholder.Value) ? new Regex("(?:" + string.Join("|", ClockEmojis.Select(Regex.Escape)) + ")(?:\\s*\\d\\d\\:\\d\\d)?") : new Regex("(?:" + string.Join("|", ClockEmojis.Prepend(ConfigBase<Config>.Instance.TimeSignsPlaceholder.Value).Select(Regex.Escape)) + ")(?:\\s*\\d\\d\\:\\d\\d)?"));
		}

		protected override void PreProcess(PeersEnumerable peers)
		{
			_timeText = null;
		}

		protected override ProcessResult Process(ServersideQoLZDO zdo, IReadOnlyList<Peer> peers, ProcessorPrefabInfo<Sign> prefabInfo)
		{
			//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_0020: 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_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			Config instance = ConfigBase<Config>.Instance;
			ProcessResult result = (ProcessResult)0;
			ZDOVars vars = zdo.Vars;
			string text = ((ZDOVars)(ref vars)).GetText("");
			if (instance.TimeSigns.Value)
			{
				string text2 = _clockRegex.Replace(text, delegate
				{
					//IL_0020: Unknown result type (might be due to invalid IL or missing references)
					//IL_0025: Unknown result type (might be due to invalid IL or missing references)
					result = ((Processor)this).ScheduleReprocessing(ConfigBase<Config>.Instance.Advanced.Value.ProcessingDelays.TimeSigns);
					if (_timeText == null)
					{
						float dayFraction = EnvMan.instance.GetDayFraction();
						int index = (int)Math.Floor((float)(ClockEmojis.Count * 2) * dayFraction) % ClockEmojis.Count;
						TimeSpan timeSpan = TimeSpan.FromDays(dayFraction);
						_timeText = $"{ClockEmojis[index]} {timeSpan:hh\\:mm}";
					}
					return _timeText;
				});
				if (text2 != text)
				{
					vars = zdo.Vars;
					((ZDOVars)(ref vars)).SetText(text = text2, "C:\\repos\\Valheim.ServersideQoL\\ServersideQoL.Signs\\SignProcessor.cs", 52);
				}
			}
			bool found = false;
			string text3 = DefaultColorRegex.Replace(text, delegate
			{
				found = true;
				string value2 = ConfigBase<Config>.Instance.DefaultColor.Value;
				return (value2 != null && value2.Length > 0 && !(value2 == "black")) ? ("<color=\"" + ConfigBase<Config>.Instance.DefaultColor.Value + "\" d>") : "";
			}, 1);
			if (!found)
			{
				string value = ConfigBase<Config>.Instance.DefaultColor.Value;
				if (value != null && value.Length > 0 && !(value == "black"))
				{
					text3 = "<color=\"" + ConfigBase<Config>.Instance.DefaultColor.Value + "\" d>" + text;
				}
			}
			if (text3 != text)
			{
				vars = zdo.Vars;
				((ZDOVars)(ref vars)).SetText(text = text3, "C:\\repos\\Valheim.ServersideQoL\\ServersideQoL.Signs\\SignProcessor.cs", 71);
			}
			return result;
		}
	}
	[BepInPlugin("ArgusMagnus.ServersideQoL.Signs", "ServersideQoL.Signs", "2.3.0")]
	public sealed class SignsPlugin : ServersideQoLPluginBase<SignsPlugin, Config>
	{
		public const string Author = "ArgusMagnus";

		public const string PluginName = "ServersideQoL.Signs";

		public const string PluginGuid = "ArgusMagnus.ServersideQoL.Signs";

		public const string PluginVersion = "2.3.0";

		public const string PluginInformationalVersion = "2.3.0";

		private DateTimeOffset BuildTimestamp { get; } = new DateTimeOffset(639273810398967363L, default(TimeSpan));

		protected override Config CreateConfigSingleton(ConfigFile configFile, Logger logger)
		{
			return new Config(configFile, logger);
		}

		protected override void RegisterProcessors(IProcessorCollection processors)
		{
			processors.Add<SignProcessor>().Add<FermenterSignProcessor>();
		}

		private void Awake()
		{
		}
	}
}