using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using ValheimClientLogger.Utils;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("ValheimClientLogger")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("Valheim Client Logger")]
[assembly: AssemblyTitle("ValheimClientLogger")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.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 ValheimClientLogger
{
	[BepInPlugin("com.paim.valheimlogger.client", "Valheim Client Logger", "1.0.0")]
	public class ValheimClientLogger : BaseUnityPlugin
	{
		public const string PluginGUID = "com.paim.valheimlogger.client";

		public const string PluginName = "Valheim Client Logger";

		public const string PluginVersion = "1.0.0";

		public const string ServerPluginGUID = "com.paim.valheimlogger";

		private readonly Harmony _harmony = new Harmony("com.paim.valheimlogger.client");

		public static ConfigEntry<bool> EnableDebugLogs;

		public static ConfigEntry<string> ServerName;

		public static ManualLogSource StaticLogger { get; private set; }

		private void Awake()
		{
			StaticLogger = ((BaseUnityPlugin)this).Logger;
			LoadConfiguration();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Valheim Client Logger v1.0.0 is loading...");
			try
			{
				_harmony.PatchAll();
				((BaseUnityPlugin)this).Logger.LogInfo((object)"All Harmony patches applied successfully");
				IEnumerable<MethodBase> patchedMethods = _harmony.GetPatchedMethods();
				((BaseUnityPlugin)this).Logger.LogInfo((object)"=== PATCHED METHODS ===");
				foreach (MethodBase item in patchedMethods)
				{
					((BaseUnityPlugin)this).Logger.LogInfo((object)("  Patched: " + item.DeclaringType?.Name + "." + item.Name));
				}
				((BaseUnityPlugin)this).Logger.LogInfo((object)"=== END PATCHED METHODS ===");
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("Failed to apply Harmony patches: " + ex.Message + "\n" + ex.StackTrace));
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Valheim Client Logger v1.0.0 loaded successfully!");
		}

		private void LoadConfiguration()
		{
			ServerName = ((BaseUnityPlugin)this).Config.Bind<string>("Server", "Name", "Tios Doteiros", "Nome do servidor que aparecerá nos eventos enviados");
			EnableDebugLogs = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "EnableDebugLogs", true, "Habilita logs de debug detalhados (útil para troubleshooting)");
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Configuration loaded:");
			((BaseUnityPlugin)this).Logger.LogInfo((object)("  Server Name: " + ServerName.Value));
			((BaseUnityPlugin)this).Logger.LogInfo((object)$"  Debug Logs: {EnableDebugLogs.Value}");
		}

		public static void SendEventToServer(string eventType, Dictionary<string, object> eventData)
		{
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			try
			{
				if (ZRoutedRpc.instance == null)
				{
					ManualLogSource staticLogger = StaticLogger;
					if (staticLogger != null)
					{
						staticLogger.LogWarning((object)"ZRoutedRpc not ready, cannot send event");
					}
					return;
				}
				if ((Object)(object)ZNet.instance == (Object)null)
				{
					ManualLogSource staticLogger2 = StaticLogger;
					if (staticLogger2 != null)
					{
						staticLogger2.LogWarning((object)"ZNet not ready, skipping event send");
					}
					return;
				}
				if (ZNet.instance.IsServer() && !ZNet.instance.IsDedicated())
				{
					ManualLogSource staticLogger3 = StaticLogger;
					if (staticLogger3 != null)
					{
						staticLogger3.LogDebug((object)"Running as local host, skipping event send to avoid loop");
					}
					return;
				}
				string text = JsonHelper.Serialize(eventData);
				if (EnableDebugLogs.Value)
				{
					ManualLogSource staticLogger4 = StaticLogger;
					if (staticLogger4 != null)
					{
						staticLogger4.LogDebug((object)("[CLIENT] Sending event to server: " + eventType));
					}
					ManualLogSource staticLogger5 = StaticLogger;
					if (staticLogger5 != null)
					{
						staticLogger5.LogDebug((object)("[CLIENT] Event data: " + text));
					}
				}
				ZPackage val = new ZPackage();
				val.Write(eventType);
				val.Write(text);
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "com.paim.valheimlogger.LogEvent", new object[1] { val });
				ManualLogSource staticLogger6 = StaticLogger;
				if (staticLogger6 != null)
				{
					staticLogger6.LogInfo((object)("[CLIENT] Event sent to server: " + eventType));
				}
			}
			catch (Exception ex)
			{
				ManualLogSource staticLogger7 = StaticLogger;
				if (staticLogger7 != null)
				{
					staticLogger7.LogError((object)("Error sending event to server: " + ex.Message + "\n" + ex.StackTrace));
				}
			}
		}

		private void OnDestroy()
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Valheim Client Logger is shutting down...");
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Valheim Client Logger shutdown complete");
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "ValheimClientLogger";

		public const string PLUGIN_NAME = "Valheim Client Logger";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace ValheimClientLogger.Utils
{
	public static class JsonHelper
	{
		public static string Serialize(Dictionary<string, object> dict)
		{
			if (dict == null)
			{
				return "null";
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("{");
			bool flag = true;
			foreach (KeyValuePair<string, object> item in dict)
			{
				if (!flag)
				{
					stringBuilder.Append(",");
				}
				stringBuilder.Append("\"");
				stringBuilder.Append(EscapeString(item.Key));
				stringBuilder.Append("\":");
				stringBuilder.Append(SerializeValue(item.Value));
				flag = false;
			}
			stringBuilder.Append("}");
			return stringBuilder.ToString();
		}

		private static string SerializeValue(object value)
		{
			if (value == null)
			{
				return "null";
			}
			if (value is string str)
			{
				return "\"" + EscapeString(str) + "\"";
			}
			if (value is bool)
			{
				if (!(bool)value)
				{
					return "false";
				}
				return "true";
			}
			if (value is int || value is long || value is float || value is double)
			{
				return value.ToString().Replace(",", ".");
			}
			if (value is Dictionary<string, object> dict)
			{
				return Serialize(dict);
			}
			return "\"" + EscapeString(value.ToString()) + "\"";
		}

		private static string EscapeString(string str)
		{
			if (string.IsNullOrEmpty(str))
			{
				return "";
			}
			return str.Replace("\\", "\\\\").Replace("\"", "\\\"").Replace("\n", "\\n")
				.Replace("\r", "\\r")
				.Replace("\t", "\\t");
		}
	}
}
namespace ValheimClientLogger.Patches
{
	[HarmonyPatch(typeof(Character), "OnDeath")]
	public static class Patch_Character_OnDeath
	{
		[HarmonyPostfix]
		public static void Postfix(Character __instance)
		{
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)__instance == (Object)null || __instance.IsPlayer())
				{
					return;
				}
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null)
				{
					return;
				}
				object? obj = typeof(Character).GetField("m_lastHit", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(__instance);
				HitData val = (HitData)((obj is HitData) ? obj : null);
				if (val == null)
				{
					return;
				}
				Character attacker = val.GetAttacker();
				if ((Object)(object)attacker == (Object)null || !attacker.IsPlayer())
				{
					return;
				}
				Player val2 = (Player)(object)((attacker is Player) ? attacker : null);
				if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2 != (Object)(object)localPlayer))
				{
					string text = ((Object)((Component)__instance).gameObject).name.Replace("(Clone)", "").Trim();
					string hoverName = __instance.GetHoverName();
					ManualLogSource staticLogger = ValheimClientLogger.StaticLogger;
					if (staticLogger != null)
					{
						staticLogger.LogInfo((object)("[CLIENT] Mob killed: " + text + " (" + hoverName + ") by " + val2.GetPlayerName()));
					}
					Dictionary<string, object> eventData = new Dictionary<string, object>
					{
						["timestamp"] = DateTime.UtcNow.ToString("o"),
						["serverName"] = ValheimClientLogger.ServerName.Value,
						["eventType"] = "mob_kill",
						["playerName"] = val2.GetPlayerName(),
						["playerID"] = val2.GetPlayerID().ToString(),
						["details"] = new Dictionary<string, object>
						{
							["mobName"] = text,
							["mobDisplayName"] = hoverName,
							["mobLevel"] = __instance.GetLevel(),
							["mobMaxHealth"] = __instance.GetMaxHealth(),
							["position"] = new Dictionary<string, object>
							{
								["x"] = ((Component)__instance).transform.position.x,
								["y"] = ((Component)__instance).transform.position.y,
								["z"] = ((Component)__instance).transform.position.z
							},
							["isBoss"] = __instance.IsBoss()
						}
					};
					ValheimClientLogger.SendEventToServer("mob_kill", eventData);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource staticLogger2 = ValheimClientLogger.StaticLogger;
				if (staticLogger2 != null)
				{
					staticLogger2.LogError((object)("Error in Patch_Character_OnDeath: " + ex.Message + "\n" + ex.StackTrace));
				}
			}
		}
	}
	[HarmonyPatch(typeof(Humanoid), "Pickup")]
	public static class Patch_Humanoid_Pickup
	{
		[HarmonyPostfix]
		public static void Postfix(Humanoid __instance, GameObject go, bool __result)
		{
		}
	}
	[HarmonyPatch(typeof(Player), "OnSpawned")]
	public static class Patch_Player_Login
	{
		public static bool _hasLogged;

		[HarmonyPostfix]
		public static void Postfix(Player __instance)
		{
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: 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)
			try
			{
				if (_hasLogged)
				{
					return;
				}
				if (!((Object)(object)__instance == (Object)null) && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
				{
					_hasLogged = true;
					ManualLogSource staticLogger = ValheimClientLogger.StaticLogger;
					if (staticLogger != null)
					{
						staticLogger.LogInfo((object)("[CLIENT] Player logged in: " + __instance.GetPlayerName()));
					}
					Dictionary<string, object> eventData = new Dictionary<string, object>
					{
						["timestamp"] = DateTime.UtcNow.ToString("o"),
						["serverName"] = ValheimClientLogger.ServerName.Value,
						["eventType"] = "player_login",
						["playerName"] = __instance.GetPlayerName(),
						["playerID"] = __instance.GetPlayerID().ToString(),
						["details"] = new Dictionary<string, object> { ["position"] = new Dictionary<string, object>
						{
							["x"] = ((Component)__instance).transform.position.x,
							["y"] = ((Component)__instance).transform.position.y,
							["z"] = ((Component)__instance).transform.position.z
						} }
					};
					ValheimClientLogger.SendEventToServer("player_login", eventData);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource staticLogger2 = ValheimClientLogger.StaticLogger;
				if (staticLogger2 != null)
				{
					staticLogger2.LogError((object)("Error in Patch_Player_Login: " + ex.Message + "\n" + ex.StackTrace));
				}
			}
		}
	}
	[HarmonyPatch(typeof(Game), "Logout")]
	public static class Patch_Player_Logout
	{
		[HarmonyPrefix]
		public static void Prefix()
		{
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Player localPlayer = Player.m_localPlayer;
				if (!((Object)(object)localPlayer == (Object)null))
				{
					ManualLogSource staticLogger = ValheimClientLogger.StaticLogger;
					if (staticLogger != null)
					{
						staticLogger.LogInfo((object)("[CLIENT] Player logging out: " + localPlayer.GetPlayerName()));
					}
					Dictionary<string, object> eventData = new Dictionary<string, object>
					{
						["timestamp"] = DateTime.UtcNow.ToString("o"),
						["serverName"] = ValheimClientLogger.ServerName.Value,
						["eventType"] = "player_logout",
						["playerName"] = localPlayer.GetPlayerName(),
						["playerID"] = localPlayer.GetPlayerID().ToString(),
						["details"] = new Dictionary<string, object>
						{
							["position"] = new Dictionary<string, object>
							{
								["x"] = ((Component)localPlayer).transform.position.x,
								["y"] = ((Component)localPlayer).transform.position.y,
								["z"] = ((Component)localPlayer).transform.position.z
							},
							["playTime"] = Time.time
						}
					};
					ValheimClientLogger.SendEventToServer("player_logout", eventData);
					Patch_Player_Login._hasLogged = false;
					Patch_Skills_RaiseSkill.ResetTracking();
					Thread.Sleep(500);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource staticLogger2 = ValheimClientLogger.StaticLogger;
				if (staticLogger2 != null)
				{
					staticLogger2.LogError((object)("Error in Patch_Player_Logout: " + ex.Message + "\n" + ex.StackTrace));
				}
			}
		}
	}
	[HarmonyPatch(typeof(Skills), "RaiseSkill")]
	public static class Patch_Skills_RaiseSkill
	{
		private static Dictionary<SkillType, int> _lastLoggedLevel = new Dictionary<SkillType, int>();

		public static void ResetTracking()
		{
			_lastLoggedLevel.Clear();
		}

		[HarmonyPostfix]
		public static void Postfix(Skills __instance, SkillType skillType, float factor)
		{
			//IL_0071: 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_0091: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				object? obj = typeof(Skills).GetField("m_player", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(__instance);
				Player val = (Player)((obj is Player) ? obj : null);
				if ((Object)(object)val == (Object)null || (Object)(object)val != (Object)(object)Player.m_localPlayer || !(typeof(Skills).GetField("m_skillData", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(__instance) is Dictionary<SkillType, Skill> dictionary) || !dictionary.ContainsKey(skillType))
				{
					return;
				}
				int num = (int)dictionary[skillType].m_level;
				if (!_lastLoggedLevel.ContainsKey(skillType) || _lastLoggedLevel[skillType] < num)
				{
					int num2 = (_lastLoggedLevel.ContainsKey(skillType) ? _lastLoggedLevel[skillType] : (num - 1));
					_lastLoggedLevel[skillType] = num;
					ManualLogSource staticLogger = ValheimClientLogger.StaticLogger;
					if (staticLogger != null)
					{
						staticLogger.LogInfo((object)$"[CLIENT] Skill level up: {skillType} reached level {num} (was {num2})");
					}
					Dictionary<string, object> eventData = new Dictionary<string, object>
					{
						["timestamp"] = DateTime.UtcNow.ToString("o"),
						["serverName"] = ValheimClientLogger.ServerName.Value,
						["eventType"] = "skill_level_up",
						["playerName"] = val.GetPlayerName(),
						["playerID"] = val.GetPlayerID().ToString(),
						["details"] = new Dictionary<string, object>
						{
							["skillType"] = ((object)(SkillType)(ref skillType)).ToString(),
							["newLevel"] = num,
							["previousLevel"] = num2
						}
					};
					ValheimClientLogger.SendEventToServer("skill_raise", eventData);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource staticLogger2 = ValheimClientLogger.StaticLogger;
				if (staticLogger2 != null)
				{
					staticLogger2.LogError((object)("Error in Patch_Skills_RaiseSkill: " + ex.Message + "\n" + ex.StackTrace));
				}
			}
		}
	}
}