using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security.Permissions;
using BepInEx;
using HarmonyLib;
using Jotunn;
using Jotunn.Entities;
using Jotunn.Managers;
using Tides.Core;
using Tides.Systems;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Tides")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Tides")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("e3243d22-4307-4008-ba36-9f326008cde5")]
[assembly: AssemblyFileVersion("1.0.2")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.2.0")]
namespace Tides
{
	[BepInPlugin("com.naexn.Tides", "Tides", "1.0.2")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	internal class Tides : BaseUnityPlugin
	{
		public const string PluginGUID = "com.naexn.Tides";

		public const string PluginName = "Tides";

		public const string PluginVersion = "1.0.2";

		public static CustomLocalization Localization = LocalizationManager.Instance.GetLocalization();

		private void Awake()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			Logger.LogInfo((object)"Tides has landed");
			new Harmony("com.naexn.Tides").PatchAll();
		}
	}
}
namespace Tides.Systems
{
	internal class SwampMovementSystem
	{
		internal static float ComputeSwampVariant(Character c, float baseSpeed)
		{
			//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)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)c).transform.position;
			if ((int)WorldGenerator.instance.GetBiome(position) != 2)
			{
				return baseSpeed;
			}
			float groundHeight = ZoneSystem.instance.GetGroundHeight(position);
			float num = 29.9f - groundHeight;
			if (num <= 0f)
			{
				return baseSpeed;
			}
			float num2 = c.m_collider.height / 3f;
			float num3 = Mathf.Clamp01(num / num2);
			return baseSpeed - baseSpeed * baseSpeed * num3 * 0.05f;
		}
	}
	internal class TideSystem
	{
		private static readonly float TidePeriodDays = 0.5175f;

		private static readonly float TideAmplitude = 1.4f;

		private const float OceanBaseY = 30f;

		public static void UpdateTides()
		{
			//IL_00b2: 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_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return;
			}
			float num = (float)EnvMan.instance.GetDay() + EnvMan.instance.GetDayFraction();
			float num2 = Mathf.Sin(num / TidePeriodDays * (float)Math.PI * 2f) * TideAmplitude;
			float num3 = 30f + num2;
			foreach (WaterVolume instance in WaterVolume.Instances)
			{
				if ((Object)(object)instance == (Object)null)
				{
					continue;
				}
				Material material = ((Renderer)instance.m_waterSurface).material;
				if (!((Object)(object)material == (Object)null) && !(((Object)material).name.ToLowerInvariant() != "water (instance)"))
				{
					Vector3 position = ((Component)instance).transform.position;
					position.y = num3;
					((Component)instance).transform.position = position;
					Vector3 position2 = ((Component)instance.m_waterSurface).transform.position;
					position2.y = num3;
					((Component)instance.m_waterSurface).transform.position = position2;
					if (flag)
					{
						Logger.LogInfo((object)$"offset={num2}m, worldDay={num}, Day={EnvMan.instance.GetDay()} + Frac={EnvMan.instance.GetDayFraction()} = WorldDays={(float)EnvMan.instance.GetDay() + EnvMan.instance.GetDayFraction()}, finalY={num3}m , physPos={((Component)instance).transform.position.y}m, visualPos={((Component)instance.m_waterSurface).transform.position.y}m");
						flag = false;
					}
				}
			}
		}
	}
}
namespace Tides.Patches
{
	internal class SwampMovementPatches
	{
		[HarmonyPatch(typeof(Character), "ApplyLiquidResistance")]
		public static class Patch_LiquidResistance_CompareShadow
		{
			private static float _originalSpeed;

			private static void Prefix(ref float speed)
			{
				_originalSpeed = speed;
			}

			private static void Postfix(Character __instance, ref float speed)
			{
				float num = speed;
				float num2 = SwampMovementSystem.ComputeSwampVariant(__instance, _originalSpeed);
				speed = Mathf.Min(num, num2);
			}
		}
	}
	internal class ZNetReadyPatches
	{
		[HarmonyPatch(typeof(ZNet), "Update")]
		internal static class ZNet_Update_Patch
		{
			private static void Postfix()
			{
				TidesManager.Update();
			}
		}

		[HarmonyPatch(typeof(ZNet), "Start")]
		internal static class ZNet_Start_Patch
		{
			private static void Postfix()
			{
				TidesManager.SetWorldReady(ready: true);
			}
		}

		[HarmonyPatch(typeof(ZNet), "OnDestroy")]
		internal static class ZNet_Destroy_Patch
		{
			private static void Prefix()
			{
				TidesManager.SetWorldReady(ready: false);
			}
		}
	}
}
namespace Tides.Core
{
	internal class TidesManager
	{
		private static bool _worldReady;

		public static void SetWorldReady(bool ready)
		{
			_worldReady = ready;
		}

		public static void Update()
		{
			if (_worldReady)
			{
				TideSystem.UpdateTides();
			}
		}
	}
}