using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace LeanNet;

[BepInPlugin("CacoFFF.valheim.LeanNet", "Lean Networking", "1.0.0")]
public class LeanNet : BaseUnityPlugin
{
	public class ZDOUpdateLogger
	{
		private static uint DataRevision;

		public static void ZDOPreUpdate(ZDO zDO)
		{
			if (zDO != null)
			{
				DataRevision = zDO.DataRevision;
			}
		}

		public static void ZDOPostUpdate(ZDO zDO, string ObjectName)
		{
			if (zDO != null && zDO.IsOwner() && zDO.DataRevision != DataRevision)
			{
				ZLog.Log((object)("Net update: " + ObjectName));
			}
		}
	}

	[HarmonyPatch(typeof(MonoUpdaters), "FixedUpdate")]
	public class GetWorldDeltaTimeFixed
	{
		private static void Prefix()
		{
			DeltaTimeFixedPhysics = Time.fixedDeltaTime;
			ZDORevisionFreeze.Reset();
			UpdateState(0f);
		}
	}

	[HarmonyPatch(typeof(MonoUpdaters), "LateUpdate")]
	public class GetWorldDeltaTimeLate
	{
		private static void Prefix()
		{
			float deltaTime = (DeltaTimePhysics = Time.deltaTime);
			ZDORevisionFreeze.Reset();
			UpdateState(deltaTime);
		}
	}

	[HarmonyPatch(typeof(ZDO), "IncreaseDataRevision")]
	public class ZDORevisionFreeze
	{
		public static int Freeze;

		public static int Force;

		public static uint DataRevision;

		public static void Reset()
		{
			Freeze = 0;
			Force = 0;
			DataRevision = 0u;
		}

		public static bool IsFreezing()
		{
			if (Freeze > 0)
			{
				return Force <= 0;
			}
			return false;
		}

		public static bool IsForcing()
		{
			return Force > 0;
		}

		private static bool Prefix()
		{
			return !IsFreezing();
		}
	}

	[HarmonyPatch(typeof(ZDO), "Set", new Type[]
	{
		typeof(int),
		typeof(Vector3)
	})]
	public class ZDOUpdateDiscard_Vec3
	{
		private static bool Prefix(ref ZDO __instance, int hash, Vector3 value)
		{
			//IL_0023: 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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (!Enabled.Value)
			{
				return true;
			}
			if (ZDORevisionFreeze.IsForcing())
			{
				return true;
			}
			Vector3 val = default(Vector3);
			if (__instance.GetVec3(hash, ref val))
			{
				Vector3 val2 = val - value;
				if (((Vector3)(ref val2)).sqrMagnitude < Vec3CullSizeSq)
				{
					return false;
				}
			}
			return true;
		}
	}

	[HarmonyPatch(typeof(ZDO), "Set", new Type[]
	{
		typeof(int),
		typeof(Quaternion)
	})]
	public class ZDOUpdateDiscard_Quat
	{
		private static bool Prefix(ref ZDO __instance, int hash, Quaternion value)
		{
			//IL_001a: 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)
			if (!Enabled.Value)
			{
				return true;
			}
			if (ZDORevisionFreeze.IsForcing())
			{
				return true;
			}
			if (Quaternion.Dot(__instance.GetQuaternion(hash, value), value) > 0.98f)
			{
				return false;
			}
			return true;
		}
	}

	[HarmonyPatch(typeof(ZSyncTransform), "CustomLateUpdate")]
	public class PhysicsSyncReducer
	{
		private static bool Freezing;

		private static bool Forcing;

		private static void Prefix(ref ZSyncTransform __instance, ref ZNetView ___m_nview)
		{
			if (!Enabled.Value)
			{
				return;
			}
			ZDO zDO = ___m_nview.GetZDO();
			float num = default(float);
			if (!zDO.GetFloat(ZDOVars.s_rudder, ref num))
			{
				float num2 = NetRatePhysics.Value;
				if (!__instance.m_syncPosition)
				{
					num2 *= 2f;
				}
				Forcing = ShouldUpdateZDO(zDO, 0.5f, DeltaTimePhysics);
				Freezing = !Forcing && !ShouldUpdateZDO(zDO, num2, DeltaTimePhysics);
				if (Forcing)
				{
					ZDORevisionFreeze.Force++;
				}
				if (Freezing)
				{
					ZDORevisionFreeze.Freeze++;
				}
			}
		}

		private static void Postfix(ref ZSyncTransform __instance, ref ZNetView ___m_nview)
		{
			if (Freezing)
			{
				Freezing = false;
				ZDORevisionFreeze.Freeze--;
			}
			if (Forcing)
			{
				Forcing = false;
				ZDORevisionFreeze.Force--;
			}
		}
	}

	[HarmonyPatch]
	[HarmonyPatch(typeof(Character), "CustomFixedUpdate")]
	public class CharacterNetOptimizator
	{
		public static bool Freezing;

		public static bool Forcing;

		[HarmonyPrefix]
		private static void CustomFixedUpdatePrefix(ref Character __instance, float dt, ref ZNetView ___m_nview)
		{
			if (Enabled.Value && !__instance.IsPlayer())
			{
				ZDO zDO = ___m_nview.GetZDO();
				Forcing = ShouldUpdateZDO(zDO, 0.5f, DeltaTimePhysics);
				Freezing = !Forcing && !ShouldUpdateZDO(zDO, NetRateNPC.Value, DeltaTimePhysics);
				if (Forcing)
				{
					ZDORevisionFreeze.Force++;
				}
				if (Freezing)
				{
					ZDORevisionFreeze.Freeze++;
				}
			}
		}

		[HarmonyPostfix]
		private static void CustomFixedUpdatePostfix(ref Character __instance, ref ZNetView ___m_nview)
		{
			if (Freezing)
			{
				Freezing = false;
				ZDORevisionFreeze.Freeze--;
			}
			if (Forcing)
			{
				Forcing = false;
				ZDORevisionFreeze.Force--;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("UpdateGroundTilt")]
		private static void UpdateGroundTiltPrefix(float dt)
		{
			if (Enabled.Value)
			{
				ZDORevisionFreeze.Freeze++;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("UpdateGroundTilt")]
		private static void UpdateGroundTiltPostfix(ref Character __instance)
		{
			if (Enabled.Value)
			{
				ZDORevisionFreeze.Freeze--;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("SyncVelocity")]
		private static bool SyncVelocityPrefix(ref Rigidbody ___m_body, ref Vector3 ___m_bodyVelocityCached)
		{
			//IL_0019: 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)
			//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)
			if (!Enabled.Value)
			{
				return true;
			}
			if (ZDORevisionFreeze.IsForcing())
			{
				return true;
			}
			Vector3 val = ___m_body.velocity - ___m_bodyVelocityCached;
			if (((Vector3)(ref val)).sqrMagnitude <= Vec3CullSizeSq)
			{
				return false;
			}
			return true;
		}
	}

	public static ConfigEntry<bool> Enabled;

	public static ConfigEntry<float> NetRatePhysics;

	public static ConfigEntry<float> NetRateNPC;

	public static ConfigEntry<float> Vec3CullSize;

	private Harmony _harmony;

	public static double NetTime = 0.0;

	public static float DeltaTimeFixedPhysics = 0.02f;

	public static float DeltaTimePhysics = 0.01f;

	public static float Vec3CullSizeSq = 0.00025f;

	private void Awake()
	{
		Enabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Global", "Enabled", true, "Global toggle, this option does not require a game restart.");
		NetRatePhysics = ((BaseUnityPlugin)this).Config.Bind<float>("Global", "NetRatePhysics", 8f, "Update frequency for physics objects, such as dropped items and projectiles.");
		NetRateNPC = ((BaseUnityPlugin)this).Config.Bind<float>("Global", "NetRateNPC", 8f, "Update frequency for NPC's.");
		Vec3CullSize = ((BaseUnityPlugin)this).Config.Bind<float>("Global", "Vec3CullSize", 0.05f, "Cull Vector3 updates if the magnitude of the offset is smaller than this.");
		_harmony = Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), (string)null);
	}

	public static void UpdateState(float DeltaTime)
	{
		if (NetRatePhysics.Value < 4f)
		{
			NetRatePhysics.Value = 4f;
		}
		if (NetRateNPC.Value < 4f)
		{
			NetRateNPC.Value = 4f;
		}
		if (Vec3CullSize.Value > 0.2f)
		{
			Vec3CullSize.Value = 0.2f;
		}
		Vec3CullSizeSq = Vec3CullSize.Value * Vec3CullSize.Value;
		NetTime += DeltaTime;
		if (DeltaTime > 100f)
		{
			NetTime -= DeltaTime;
		}
		ZDORevisionFreeze.Freeze = 0;
		ZDORevisionFreeze.Force = 0;
	}

	public static double GetZDOTime(ZDO zDO)
	{
		return NetTime + 0.023 * (double)(((ZDOID)(ref zDO.m_uid)).ID & 0xFFFu);
	}

	public static bool ShouldUpdateZDO(ZDO zDO, float NetRate, float DeltaTime)
	{
		double zDOTime = GetZDOTime(zDO);
		double num = zDOTime + (double)DeltaTime;
		return Mathf.RoundToInt((float)(zDOTime * (double)NetRate)) != Mathf.RoundToInt((float)(num * (double)NetRate));
	}
}