using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Net.Http;
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 System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
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("addzeey.PeakShock")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.5.0")]
[assembly: AssemblyInformationalVersion("0.1.5+7124d3ac273467a88dba3e808a05475cae2aa94f")]
[assembly: AssemblyProduct("addzeey.PeakShock")]
[assembly: AssemblyTitle("PeakShock")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.5.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.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]
	[Microsoft.CodeAnalysis.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]
	[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;
		}
	}
}
public interface IShockController
{
	void EnqueueShock(int intensity, int duration, string? code = null);
}
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace PeakShock
{
	internal class ShockRequestQueue : IDisposable
	{
		private ConcurrentQueue<Func<Task>> _taskQueue;

		private SemaphoreSlim _signal;

		private CancellationTokenSource _cts;

		private Task _worker;

		private readonly object _lock = new object();

		private bool _disposed;

		public ShockRequestQueue()
		{
			Start();
		}

		public void Enqueue(Func<Task> task)
		{
			if (_disposed)
			{
				throw new ObjectDisposedException("ShockRequestQueue");
			}
			_taskQueue.Enqueue(task);
			_signal.Release();
		}

		public void Enqueue<T>(Func<T, Task> task, T args)
		{
			Func<T, Task> task2 = task;
			T args2 = args;
			if (_disposed)
			{
				throw new ObjectDisposedException("ShockRequestQueue");
			}
			_taskQueue.Enqueue(() => task2(args2));
			_signal.Release();
		}

		public void Start()
		{
			_taskQueue = new ConcurrentQueue<Func<Task>>();
			_signal = new SemaphoreSlim(0);
			_cts = new CancellationTokenSource();
			_worker = Task.Run((Func<Task?>)ProcessQueueAsync);
		}

		private async Task ProcessQueueAsync()
		{
			while (!_cts.Token.IsCancellationRequested)
			{
				await _signal.WaitAsync(_cts.Token);
				if (_taskQueue.TryDequeue(out Func<Task> result))
				{
					try
					{
						await result();
					}
					catch (Exception ex)
					{
						Plugin.Log.LogError((object)ex.ToString());
					}
				}
			}
		}

		public async Task StopAsync()
		{
			if (_disposed)
			{
				return;
			}
			_cts.Cancel();
			_signal.Release();
			try
			{
				await _worker;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)ex.ToString());
			}
		}

		public async Task ResetAsync()
		{
			lock (_lock)
			{
				if (!_worker.IsCompleted)
				{
					StopAsync().Wait();
				}
				Start();
			}
		}

		public void Dispose()
		{
			if (!_disposed)
			{
				StopAsync().Wait();
				_cts.Dispose();
				_signal.Dispose();
				_disposed = true;
			}
		}
	}
	public class OpenShockController : IShockController
	{
		private readonly ShockRequestQueue _queue = new ShockRequestQueue();

		private readonly string _apiUrl;

		private readonly string _deviceId;

		private readonly string _apiKey;

		private readonly HttpClient _client = new HttpClient();

		private DateTime _lastShockTime = DateTime.MinValue;

		private TimeSpan ShockCooldown => TimeSpan.FromSeconds(1.0 + (double)Math.Max(0f, Plugin.ShockCooldownSeconds.Value));

		public OpenShockController()
		{
			_apiUrl = Plugin.OpenShockApiUrl.Value;
			_deviceId = Plugin.OpenShockDeviceId.Value;
			_apiKey = Plugin.OpenShockApiKey.Value;
		}

		public void EnqueueShock(int intensity, int duration, string? code = null)
		{
			string code2 = code;
			DateTime utcNow = DateTime.UtcNow;
			if (utcNow - _lastShockTime < ShockCooldown)
			{
				Plugin.Log.LogInfo((object)"[PeakShock] OpenShock shock skipped due to cooldown.");
				return;
			}
			_lastShockTime = utcNow;
			_queue.Enqueue(() => TriggerShockInternal(intensity, duration, code2));
		}

		private async Task TriggerShockInternal(int intensity, int duration, string? code)
		{
			int num = Math.Clamp(duration * 1000, 300, 65535);
			if (string.IsNullOrEmpty(_apiUrl) || string.IsNullOrEmpty(_apiKey))
			{
				Plugin.Log.LogWarning((object)$"[PeakShock] Would send OpenShock (intensity={intensity}, duration={num}), but OpenShock credentials are not set.");
				return;
			}
			string text = ((!string.IsNullOrEmpty(code)) ? code : _deviceId);
			if (string.IsNullOrEmpty(text))
			{
				Plugin.Log.LogWarning((object)"[PeakShock] No deviceId or share code provided for OpenShock.");
				return;
			}
			Plugin.Log.LogInfo((object)$"[PeakShock] Sending OpenShock: id={text}, intensity={intensity}, duration={num}");
			var anon = new
			{
				Shocks = new[]
				{
					new
					{
						Id = text,
						Type = 1,
						Intensity = intensity,
						Duration = num
					}
				},
				CustomName = "Integrations.PeakShock"
			};
			string content = JsonConvert.SerializeObject((object)anon);
			StringContent content2 = new StringContent(content, Encoding.UTF8, "application/json");
			HttpRequestMessage httpRequestMessage = new HttpRequestMessage(HttpMethod.Post, _apiUrl + "/2/shockers/control")
			{
				Content = content2
			};
			httpRequestMessage.Headers.Add("OpenShockToken", _apiKey);
			httpRequestMessage.Headers.Add("User-Agent", "PeakShock/" + Plugin.Version);
			try
			{
				HttpResponseMessage response = await _client.SendAsync(httpRequestMessage);
				if (!response.IsSuccessStatusCode)
				{
					string arg = await response.Content.ReadAsStringAsync();
					Plugin.Log.LogError((object)$"OpenShock API error: {response.StatusCode} {arg}");
				}
			}
			catch (Exception arg2)
			{
				Plugin.Log.LogError((object)$"OpenShock API exception: {arg2}");
			}
		}
	}
	public class PiShockController : IShockController
	{
		private readonly HttpClient _client = new HttpClient();

		private readonly ShockRequestQueue _queue = new ShockRequestQueue();

		private DateTime _lastShockTime = DateTime.MinValue;

		private TimeSpan ShockCooldown => TimeSpan.FromSeconds(1f + Math.Max(0f, Plugin.ShockCooldownSeconds.Value));

		public void TriggerShock(int intensity, int duration = 1, string? shareCode = null)
		{
			DateTime utcNow = DateTime.UtcNow;
			if (utcNow - _lastShockTime < ShockCooldown)
			{
				Plugin.Log.LogInfo((object)"[PeakShock] Shock skipped due to cooldown.");
				return;
			}
			_lastShockTime = utcNow;
			string code = shareCode ?? Plugin.PiShockShareCode.Value;
			Plugin.Log.LogInfo((object)$"[PeakShock] Enqueue shock: intensity={intensity}, duration={duration}, code={code}");
			_queue.Enqueue(() => TriggerShockInternal(intensity, duration, code));
		}

		public void EnqueueShock(int intensity, int duration, string? code = null)
		{
			TriggerShock(intensity, duration, code);
		}

		private async Task TriggerShockInternal(int intensity, int duration, string code)
		{
			string value = Plugin.PiShockUserName.Value;
			string value2 = Plugin.PiShockAPIKey.Value;
			if (string.IsNullOrEmpty(value) || string.IsNullOrEmpty(value2) || string.IsNullOrEmpty(code))
			{
				Plugin.Log.LogWarning((object)$"[PeakShock] Would send shock (intensity={intensity}, duration={duration}, code={code}), but PiShock credentials are not set.");
				return;
			}
			Plugin.Log.LogInfo((object)$"[PeakShock] Sending shock: intensity={intensity}, duration={duration}, code={code}");
			string content = JsonConvert.SerializeObject((object)new
			{
				Username = value,
				APIKey = value2,
				Code = code,
				Intensity = intensity,
				Duration = duration,
				Op = 0
			});
			StringContent content2 = new StringContent(content, Encoding.UTF8, "application/json");
			try
			{
				Plugin.Log.LogInfo((object)$"[PeakShock] Sending request to PiShock API: {value}, Intensity={intensity}, Duration={duration}");
				HttpResponseMessage httpResponseMessage = await _client.PostAsync("https://do.pishock.com/api/apioperate/", content2);
				if (!httpResponseMessage.IsSuccessStatusCode)
				{
					Plugin.Log.LogError((object)$"PiShock API error: {httpResponseMessage.StatusCode}");
				}
			}
			catch (Exception arg)
			{
				Plugin.Log.LogError((object)$"PiShock API exception: {arg}");
			}
		}
	}
	[BepInPlugin("addzeey.PeakShock", "PeakShock", "0.1.5")]
	public class Plugin : BaseUnityPlugin
	{
		public enum ShockProvider
		{
			PiShock,
			OpenShock
		}

		public const string PluginVersion = "0.1.5";

		private Harmony? _harmony;

		public const string Id = "addzeey.PeakShock";

		internal static ManualLogSource Log { get; private set; }

		internal static ConfigFile CFG { get; private set; }

		internal static PiShockController PiShockController { get; private set; }

		internal static ConfigEntry<string> PiShockUserName { get; private set; }

		internal static ConfigEntry<string> PiShockAPIKey { get; private set; }

		internal static ConfigEntry<string> PiShockShareCode { get; private set; }

		internal static ConfigEntry<int> MinShock { get; private set; }

		internal static ConfigEntry<int> MaxShock { get; private set; }

		internal static ConfigEntry<int> DeathShock { get; private set; }

		internal static ConfigEntry<int> DeathDuration { get; private set; }

		internal static ConfigEntry<bool> EnableInjuryShock { get; private set; }

		internal static ConfigEntry<bool> EnablePoisonShock { get; private set; }

		internal static ConfigEntry<bool> EnableColdShock { get; private set; }

		internal static ConfigEntry<bool> EnableHotShock { get; private set; }

		internal static ConfigEntry<float> ShockCooldownSeconds { get; private set; }

		internal static ConfigEntry<ShockProvider> ShockProviderType { get; private set; }

		internal static ConfigEntry<string> OpenShockApiUrl { get; private set; }

		internal static ConfigEntry<string> OpenShockDeviceId { get; private set; }

		internal static ConfigEntry<string> OpenShockApiKey { get; private set; }

		internal static IShockController ShockController { get; private set; }

		public static string Name => "PeakShock";

		public static string Version => "0.1.5";

		private void Awake()
		{
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			CFG = ((BaseUnityPlugin)this).Config;
			PiShockUserName = CFG.Bind<string>("PiShock", "UserName", "", "Your PiShock username");
			PiShockAPIKey = CFG.Bind<string>("PiShock", "APIKey", "", "Your PiShock API Key");
			PiShockShareCode = CFG.Bind<string>("PiShock", "ShareCode", "", "Your PiShock ShareCode");
			MinShock = CFG.Bind<int>("Shock", "MinShock", 10, "Minimum shock intensity (1-100)");
			MaxShock = CFG.Bind<int>("Shock", "MaxShock", 100, "Maximum shock intensity (1-100)");
			DeathShock = CFG.Bind<int>("Shock", "DeathShock", 80, "Shock intensity on death (1-100)");
			DeathDuration = CFG.Bind<int>("Shock", "DeathDuration", 2, "Shock duration on death (seconds)");
			EnableInjuryShock = CFG.Bind<bool>("ShockTypes", "EnableInjuryShock", true, "Enable shock for Injury damage");
			EnablePoisonShock = CFG.Bind<bool>("ShockTypes", "EnablePoisonShock", false, "Enable shock for Poison damage");
			EnableColdShock = CFG.Bind<bool>("ShockTypes", "EnableColdShock", false, "Enable shock for Cold damage");
			EnableHotShock = CFG.Bind<bool>("ShockTypes", "EnableHotShock", false, "Enable shock for Hot/Fire damage");
			ShockCooldownSeconds = CFG.Bind<float>("Shock", "ShockCooldownSeconds", 2f, "Minimum seconds between shocks (prevents shock spam)");
			ShockProviderType = CFG.Bind<ShockProvider>("Shock", "Provider", ShockProvider.PiShock, "Choose PiShock or OpenShock");
			OpenShockApiUrl = CFG.Bind<string>("OpenShock", "ApiUrl", "https://api.openshock.app", "OpenShock API URL");
			OpenShockDeviceId = CFG.Bind<string>("OpenShock", "DeviceId", "", "OpenShock Device ID");
			OpenShockApiKey = CFG.Bind<string>("OpenShock", "ApiKey", "", "OpenShock API Key");
			Log.LogInfo((object)$"[PeakShock] Config:\nMinShock={MinShock.Value}\nMaxShock={MaxShock.Value}\nDeathShock={DeathShock.Value}\nDeathDuration={DeathDuration.Value}\nEnableInjuryShock={EnableInjuryShock.Value}\nEnablePoisonShock={EnablePoisonShock.Value}\nEnableColdShock={EnableColdShock.Value}\nEnableHotShock={EnableHotShock.Value}\nShockCooldownSeconds={ShockCooldownSeconds.Value}");
			if (ShockProviderType.Value == ShockProvider.PiShock)
			{
				ShockController = new PiShockController();
				Log.LogInfo((object)"[PeakShock] Initialized PiShockController");
			}
			else
			{
				ShockController = new OpenShockController();
				Log.LogInfo((object)"[PeakShock] Initialized OpenShockController");
			}
			_harmony = new Harmony("com.yourname.PeakShock");
			_harmony.PatchAll(Assembly.GetExecutingAssembly());
			Log.LogInfo((object)("Plugin " + Name + " is loaded!"));
		}
	}
}
namespace PeakShock.PeakShock.Patches
{
	[HarmonyPatch(typeof(Character), "RPCA_Die")]
	public class CharacterDeathPatch
	{
		[HarmonyPostfix]
		public static void Postfix(Character __instance)
		{
			if (__instance.IsLocal)
			{
				int intensity = Plugin.DeathShock.Value;
				int duration = Plugin.DeathDuration.Value;
				Plugin.Log.LogInfo((object)$"[PeakShock] Player died. Triggering death shock: {intensity}% for {duration}s");
				Task.Run(delegate
				{
					Plugin.ShockController.EnqueueShock(intensity, duration);
				});
			}
		}
	}
	[HarmonyPatch(typeof(CharacterAfflictions), "AddStatus")]
	public class CharacterAfflictions_AddStatus_Patch
	{
		private static readonly Dictionary<STATUSTYPE, bool> ShockTypeEnabled = new Dictionary<STATUSTYPE, bool>
		{
			{
				(STATUSTYPE)1,
				false
			},
			{
				(STATUSTYPE)0,
				Plugin.EnableInjuryShock.Value
			},
			{
				(STATUSTYPE)3,
				Plugin.EnablePoisonShock.Value
			},
			{
				(STATUSTYPE)2,
				Plugin.EnableColdShock.Value
			},
			{
				(STATUSTYPE)8,
				Plugin.EnableHotShock.Value
			}
		};

		[HarmonyPostfix]
		public static void Postfix(CharacterAfflictions __instance, STATUSTYPE statusType, float amount, bool fromRPC)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Invalid comparison between I4 and Unknown
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.character.IsLocal || (Object)(object)__instance.character != (Object)(object)Character.localCharacter || amount <= 0f)
			{
				return;
			}
			if (__instance.character.data.dead || __instance.character.data.fullyPassedOut || __instance.character.data.passedOut)
			{
				Plugin.Log.LogInfo((object)$"[PeakShock] Ignored status effect shock ({statusType}) because player is dead or passed out.");
				return;
			}
			int value = Plugin.MinShock.Value;
			int value2 = Plugin.MaxShock.Value;
			float num = 0f;
			if (amount < 0.01f)
			{
				num += amount;
				if (num > 0.01f)
				{
					Plugin.Log.LogInfo((object)$"[PeakShock] Accumulated damage {num} exceeds threshold, triggering shock.");
					int intensity = Mathf.Clamp(Mathf.RoundToInt(num * (float)value2), value, value2);
					Task.Run(delegate
					{
						Plugin.ShockController.EnqueueShock(intensity, 1);
					});
					num = 0f;
				}
			}
			else
			{
				if (1 == (int)statusType)
				{
					return;
				}
				if (!ShockTypeEnabled.TryGetValue(statusType, out var value3) || !value3)
				{
					Plugin.Log.LogInfo((object)$"[PeakShock] Ignored status effect shock for {statusType} because it is disabled.");
					return;
				}
				int intensity2 = Mathf.Clamp(Mathf.RoundToInt(amount * (float)value2), value, value2);
				Plugin.Log.LogInfo((object)$"[PeakShock] Status effect {statusType} damage: {amount}, shock: {intensity2}%");
				Task.Run(delegate
				{
					Plugin.ShockController.EnqueueShock(intensity2, 1);
				});
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}