using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using HutongGames.PlayMaker;
using HutongGames.PlayMaker.Actions;
using Microsoft.CodeAnalysis;
using Silksong.FsmUtil;
using Silksong.FsmUtil.Actions;
using TuneWeaver.Data;
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("TuneWeaver")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.1.0")]
[assembly: AssemblyInformationalVersion("0.1.1+700ca7bdd4a6ebec87e4b7278d748df8ec507656")]
[assembly: AssemblyProduct("TuneWeaver")]
[assembly: AssemblyTitle("TuneWeaver")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/GamingInfinite/TuneWeaver")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
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;
		}
	}
}
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	[Microsoft.CodeAnalysis.Embedded]
	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")]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace TuneWeaver
{
	[BepInPlugin("io.github.gaminginfinite.tuneweaver", "TuneWeaver", "0.1.1")]
	public class TuneWeaverPlugin : BaseUnityPlugin
	{
		public static ManualLogSource logSource;

		public static Harmony harmony;

		public static List<SongData> AllSongs = new List<SongData>();

		public static Action ActivationCheck = delegate
		{
			if (ActiveSongData != null)
			{
				logSource.LogInfo((object)(ActiveSongData.id ?? ""));
			}
		};

		private static SongData? _activeSongData;

		public const string Id = "io.github.gaminginfinite.tuneweaver";

		public static SongData? ActiveSongData
		{
			get
			{
				return _activeSongData;
			}
			set
			{
				_activeSongData = value ?? AllSongs.FirstOrDefault((SongData s) => s.isActive);
			}
		}

		public static string Name => "TuneWeaver";

		public static string Version => "0.1.1";

		private void Awake()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Plugin " + Name + " (io.github.gaminginfinite.tuneweaver) has loaded!"));
			logSource = ((BaseUnityPlugin)this).Logger;
			harmony = new Harmony("voidbaroness.tuneweaver");
			harmony.PatchAll();
		}

		public static SongData RegisterSong(string id, AudioClip audioClip)
		{
			SongData songData = new SongData(id, audioClip);
			AllSongs.Add(songData);
			return songData;
		}
	}
}
namespace TuneWeaver.Patches
{
	[HarmonyPatch(typeof(PlayMakerFSM), "Start")]
	public class NeedolinPatch
	{
		[HarmonyPostfix]
		public static void Postfix(PlayMakerFSM __instance)
		{
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Expected O, but got Unknown
			bool flag = ((Object)__instance).name.Contains("RestBench") && __instance.FsmName == "Bench Control";
			if (!((__instance != null && ((Object)__instance).name == "Hero_Hornet(Clone)" && __instance.FsmName == "Silk Specials") || flag))
			{
				return;
			}
			Fsm fsm = __instance.Fsm;
			Fsm val;
			if (flag)
			{
				RunFSM action2 = FsmUtil.GetAction<RunFSM>(fsm, "Needolin Sub", 0);
				val = ((action2 != null) ? action2.fsmTemplateControl.RunFsm : null);
			}
			else
			{
				RunFSM action3 = FsmUtil.GetAction<RunFSM>(fsm, "Needolin Sub", 2);
				val = ((action3 != null) ? action3.fsmTemplateControl.RunFsm : null);
			}
			FsmState state = val.GetState("Start Needolin");
			FsmState state2 = val.GetState("Start Needolin Benched");
			FsmState startNeedolinProper = val.GetState("Start Needolin Proper");
			val.GetState("Cancelable");
			FsmState state3 = val.GetState("Set Silk Drain Time");
			FsmState state4 = val.GetState("Play Needolin");
			FsmState state5 = val.GetState("Play Needolin Benched");
			FsmState val2 = FsmUtil.AddState(val, "Tune Weaver");
			FsmUtil.AddTransition(val2, "FINISHED", startNeedolinProper.Name);
			FsmUtil.ChangeTransition(state3, "FINISHED", val2.Name);
			FsmBool atBench = val.GetFsmBool("At Bench");
			AudioClip defaultHornetNeedolin = (AudioClip)FsmUtil.GetAction<StartNeedolinAudioLoop>(startNeedolinProper, 6).DefaultClip.Value;
			FsmString needolinClip = val.GetFsmString("Play Clip");
			DelegateAction<Action> val3 = new DelegateAction<Action>
			{
				Method = delegate(Action action)
				{
					TuneWeaverPlugin.ActivationCheck();
					SongData activeSongData3 = TuneWeaverPlugin.ActiveSongData;
					if (activeSongData3 == null)
					{
						needolinClip.Value = (atBench.Value ? "NeedolinSit Start" : "Needolin Start");
					}
					else if (activeSongData3.SitStartAnimName == "" && atBench.Value)
					{
						needolinClip.Value = "NeedolinSit Start";
					}
					else if (activeSongData3.StandStartAnimName == "" && !atBench.Value)
					{
						needolinClip.Value = "Needolin Start";
					}
					else
					{
						needolinClip.Value = (atBench.Value ? activeSongData3.SitStartAnimName : activeSongData3.StandStartAnimName);
					}
					action();
				}
			};
			val3.Arg = ((FsmStateAction)val3).Finish;
			DelegateAction<Action> val4 = new DelegateAction<Action>
			{
				Method = delegate(Action action)
				{
					TuneWeaverPlugin.ActivationCheck();
					SongData activeSongData2 = TuneWeaverPlugin.ActiveSongData;
					if (activeSongData2 == null)
					{
						needolinClip.Value = (atBench.Value ? "NeedolinSit Play" : "Needolin Play");
					}
					else if (activeSongData2.SitAnimName == "" && atBench.Value)
					{
						needolinClip.Value = "NeedolinSit Play";
					}
					else if (activeSongData2.StandAnimName == "" && !atBench.Value)
					{
						needolinClip.Value = "Needolin Play";
					}
					else
					{
						needolinClip.Value = (atBench.Value ? activeSongData2.SitAnimName : activeSongData2.StandAnimName);
					}
					action();
				}
			};
			val4.Arg = ((FsmStateAction)val4).Finish;
			FsmUtil.ReplaceAction(state, (FsmStateAction)(object)val3, 6);
			FsmUtil.ReplaceAction(state2, (FsmStateAction)(object)val3, 2);
			FsmUtil.ReplaceAction(state4, (FsmStateAction)(object)val4, 4);
			FsmUtil.ReplaceAction(state5, (FsmStateAction)(object)val4, 2);
			FsmUtil.AddLambdaMethod(val2, (Action<Action>)delegate(Action finish)
			{
				TuneWeaverPlugin.ActivationCheck();
				SongData activeSongData = TuneWeaverPlugin.ActiveSongData;
				if (activeSongData == null)
				{
					FsmUtil.GetAction<StartNeedolinAudioLoop>(startNeedolinProper, 6).DefaultClip.Value = (Object)(object)defaultHornetNeedolin;
				}
				else
				{
					AudioClip audioClip = activeSongData.audioClip;
					FsmUtil.GetAction<StartNeedolinAudioLoop>(startNeedolinProper, 6).DefaultClip.Value = (Object)(object)audioClip;
				}
				finish();
			});
		}
	}
}
namespace TuneWeaver.Data
{
	public class SongData
	{
		public string id = "";

		public bool isActive;

		public AudioClip audioClip;

		public string StandStartAnimName = "";

		public string SitStartAnimName = "";

		public string StandAnimName = "";

		public string SitAnimName = "";

		public SongData(string id, AudioClip audioClip)
		{
			this.id = id;
			this.audioClip = audioClip;
		}

		public void AssignAnims(string startStand = "", string startSit = "", string playStand = "", string playSit = "")
		{
			StandStartAnimName = startStand;
			StandAnimName = playStand;
			SitStartAnimName = startSit;
			SitAnimName = playSit;
		}

		public void Activate()
		{
			isActive = true;
			TuneWeaverPlugin.ActiveSongData = this;
		}

		public void Deactivate()
		{
			isActive = false;
			TuneWeaverPlugin.ActiveSongData = null;
		}
	}
}