using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using FishNet.Object;
using HarmonyLib;
using MelonLoader;
using MelonLoader.Preferences;
using Microsoft.CodeAnalysis;
using ScheduleOne;
using ScheduleOne.Skating;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(MethedUpSkateboards), "MethedUpSkateboards", "1.1.0", "moddy", null)]
[assembly: MelonGame("TVGS", "Schedule I")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("MethedUpSkateboards")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("MethedUpSkateboards")]
[assembly: AssemblyTitle("MethedUpSkateboards")]
[assembly: NeutralResourcesLanguage("en-US")]
[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;
		}
	}
}
public class MethedUpSkateboards : MelonMod
{
	private class SkateboardOriginalValues
	{
		public float TopSpeed_Kmh;

		public float PushForceMultiplier;

		public float BrakeForce;

		public float TurnForce;

		public float AirMovementForce;

		public float PushDelay;

		public float HoverForce;

		public float JumpForce;

		public float JumpDuration_Max;
	}

	[HarmonyPatch(typeof(Skateboard_Equippable), "Mount")]
	private class PatchMount
	{
		private static void Postfix(Skateboard_Equippable __instance)
		{
			if (!Instance.enabledMod.Value)
			{
				return;
			}
			Skateboard activeSkateboard = __instance.ActiveSkateboard;
			if (!((Object)(object)activeSkateboard == (Object)null))
			{
				int instanceID = ((Object)activeSkateboard).GetInstanceID();
				SkateboardOriginalValues value = new SkateboardOriginalValues
				{
					TopSpeed_Kmh = activeSkateboard.TopSpeed_Kmh,
					PushForceMultiplier = activeSkateboard.PushForceMultiplier,
					BrakeForce = activeSkateboard.BrakeForce,
					TurnForce = activeSkateboard.TurnForce,
					AirMovementForce = activeSkateboard.AirMovementForce,
					PushDelay = activeSkateboard.PushDelay,
					HoverForce = activeSkateboard.HoverForce,
					JumpForce = activeSkateboard.JumpForce,
					JumpDuration_Max = activeSkateboard.JumpDuration_Max
				};
				Instance.originalValues[instanceID] = value;
				activeSkateboard.TopSpeed_Kmh *= Instance.speedMultiplier.Value;
				activeSkateboard.PushForceMultiplier *= Instance.pushForceMultiplier.Value;
				activeSkateboard.BrakeForce *= Instance.brakeForceMultiplier.Value;
				activeSkateboard.TurnForce *= Instance.turnForceMultiplier.Value;
				activeSkateboard.AirMovementForce *= Instance.airMovementForceMultiplier.Value;
				activeSkateboard.PushDelay *= Instance.pushDelayMultiplier.Value;
				activeSkateboard.HoverForce *= Instance.hoverForceMultiplier.Value;
				activeSkateboard.JumpForce *= Instance.jumpForceMultiplier.Value;
				activeSkateboard.JumpDuration_Max *= Instance.jumpDurationMultiplier.Value;
				if (Instance.enableTrickMode.Value)
				{
					activeSkateboard.AirMovementEnabled = true;
					activeSkateboard.AirMovementForce *= 2f;
				}
				MelonLogger.Msg($"Modified skateboard with ID {instanceID} - Speed: {activeSkateboard.TopSpeed_Kmh} km/h");
			}
		}
	}

	[HarmonyPatch(typeof(Skateboard_Equippable), "Dismount")]
	private class PatchDismount
	{
		private static void Prefix(Skateboard_Equippable __instance)
		{
			if (!Instance.enabledMod.Value)
			{
				return;
			}
			Skateboard activeSkateboard = __instance.ActiveSkateboard;
			if (!((Object)(object)activeSkateboard == (Object)null))
			{
				int instanceID = ((Object)activeSkateboard).GetInstanceID();
				if (Instance.originalValues.ContainsKey(instanceID))
				{
					Instance.originalValues.Remove(instanceID);
				}
				lastDismountTime = Time.time;
			}
		}
	}

	[HarmonyPatch(typeof(Skateboard), "get_TopSpeed_Ms")]
	private class PatchTopSpeedMs
	{
		private static void Postfix(ref float __result)
		{
			if (Instance.enabledMod.Value)
			{
				__result *= Instance.speedMultiplier.Value;
			}
		}
	}

	[HarmonyPatch(typeof(Skateboard), "UpdateHover")]
	private class PatchUpdateHover
	{
		private static void Prefix(Skateboard __instance)
		{
			if (Instance.enabledMod.Value && ((NetworkBehaviour)__instance).IsOwner && Instance.enableTrickMode.Value && __instance.AirTime > 0.2f)
			{
				__instance.HoverForce *= 1.1f;
			}
		}

		private static void Postfix(Skateboard __instance)
		{
			if (Instance.enabledMod.Value && ((NetworkBehaviour)__instance).IsOwner && Instance.enableTrickMode.Value && __instance.AirTime > 0.2f)
			{
				__instance.HoverForce /= 1.1f;
			}
		}
	}

	[HarmonyPatch(typeof(Skateboard_Equippable), "Update")]
	private class PatchUpdate
	{
		private static bool Prefix(Skateboard_Equippable __instance)
		{
			if (!Instance.enabledMod.Value)
			{
				return true;
			}
			if (Instance.instantMount.Value)
			{
				if (GameInput.GetButton((ButtonCode)0) && !__instance.blockDismount)
				{
					if (!__instance.IsRiding)
					{
						float num = Time.time - lastDismountTime;
						if (num < 0.5f)
						{
							return false;
						}
						if ((Object)(object)__instance.ModelContainer != (Object)null)
						{
							((Component)__instance.ModelContainer).gameObject.SetActive(false);
						}
						__instance.Mount();
					}
					else if (GameInput.GetButtonDown((ButtonCode)0))
					{
						if ((Object)(object)__instance.ModelContainer != (Object)null)
						{
							((Component)__instance.ModelContainer).gameObject.SetActive(true);
						}
						__instance.Dismount();
					}
				}
				return false;
			}
			return true;
		}
	}

	private MelonPreferences_Category configCategory;

	private MelonPreferences_Entry<bool> enabledMod;

	private MelonPreferences_Entry<float> speedMultiplier;

	private MelonPreferences_Entry<float> pushForceMultiplier;

	private MelonPreferences_Entry<float> airMovementForceMultiplier;

	private MelonPreferences_Entry<float> brakeForceMultiplier;

	private MelonPreferences_Entry<float> jumpForceMultiplier;

	private MelonPreferences_Entry<float> turnForceMultiplier;

	private MelonPreferences_Entry<float> pushDelayMultiplier;

	private MelonPreferences_Entry<float> hoverForceMultiplier;

	private MelonPreferences_Entry<float> jumpDurationMultiplier;

	private MelonPreferences_Entry<bool> enableTrickMode;

	private MelonPreferences_Entry<bool> instantMount;

	private Dictionary<int, SkateboardOriginalValues> originalValues = new Dictionary<int, SkateboardOriginalValues>();

	private const float REMOUNT_DELAY = 0.5f;

	private static float lastDismountTime;

	public static MethedUpSkateboards Instance { get; private set; }

	public override void OnInitializeMelon()
	{
		configCategory = MelonPreferences.CreateCategory("MethedUpSkateboards");
		enabledMod = configCategory.CreateEntry<bool>("EnableMod", true, "Enable/Disable the mod", (string)null, false, false, (ValueValidator)null, (string)null);
		speedMultiplier = configCategory.CreateEntry<float>("SpeedMultiplier", 2f, "Speed multiplier", (string)null, false, false, (ValueValidator)null, (string)null);
		pushForceMultiplier = configCategory.CreateEntry<float>("PushForceMultiplier", 1.5f, "Push force multiplier", (string)null, false, false, (ValueValidator)null, (string)null);
		airMovementForceMultiplier = configCategory.CreateEntry<float>("AirMovementForceMultiplier", 1.5f, "Air movement force multiplier", (string)null, false, false, (ValueValidator)null, (string)null);
		brakeForceMultiplier = configCategory.CreateEntry<float>("BrakeForceMultiplier", 1f, "Brake force multiplier", (string)null, false, false, (ValueValidator)null, (string)null);
		jumpForceMultiplier = configCategory.CreateEntry<float>("JumpForceMultiplier", 1.5f, "Jump force multiplier", (string)null, false, false, (ValueValidator)null, (string)null);
		turnForceMultiplier = configCategory.CreateEntry<float>("TurnForceMultiplier", 1.2f, "Turn force multiplier", (string)null, false, false, (ValueValidator)null, (string)null);
		pushDelayMultiplier = configCategory.CreateEntry<float>("PushDelayMultiplier", 0.7f, "Push delay multiplier (lower = faster pushes)", (string)null, false, false, (ValueValidator)null, (string)null);
		hoverForceMultiplier = configCategory.CreateEntry<float>("HoverForceMultiplier", 1.25f, "Hover force multiplier", (string)null, false, false, (ValueValidator)null, (string)null);
		jumpDurationMultiplier = configCategory.CreateEntry<float>("JumpDurationMultiplier", 1.2f, "Jump duration multiplier", (string)null, false, false, (ValueValidator)null, (string)null);
		enableTrickMode = configCategory.CreateEntry<bool>("EnableTrickMode", false, "Enable trick mode (increases air control)", (string)null, false, false, (ValueValidator)null, (string)null);
		instantMount = configCategory.CreateEntry<bool>("InstantMount", true, "Enable instant mounting (no delay)", (string)null, false, false, (ValueValidator)null, (string)null);
		((MelonBase)this).LoggerInstance.Msg("MethedUpSkateboards initialized!");
	}

	public override void OnApplicationStart()
	{
		Instance = this;
	}
}