using System;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net.Sockets;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using HarmonyLib;
using Il2CppSLZ.Bonelab;
using Il2CppSLZ.Marrow.Audio;
using MelonLoader;
using Microsoft.CodeAnalysis;
using MusicAttenuation;
using UnityEngine.Audio;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(Core), "MusicAttenuation", "1.0.0", "notnotnotswipez", null)]
[assembly: MelonGame("Stress Level Zero", "BONELAB")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("MusicAttenuation")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("MusicAttenuation")]
[assembly: AssemblyTitle("MusicAttenuation")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: TargetPlatform("Windows10.0.17763.0")]
[assembly: SupportedOSPlatform("Windows10.0.17763.0")]
[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 MusicAttenuation
{
	public class Core : MelonMod
	{
		[HarmonyPatch(typeof(AudioMixer), "SetFloat")]
		public class AudioMixerFloatDebugPatch
		{
			public static bool Prefix(AudioMixer __instance, string name, float value)
			{
				if (name == MUSIC_MIXER_NAME && isPlaying && playerInitializedOnce)
				{
					LAST_MUSIC_MIXER_VALUE = value;
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(UIRig), "Awake")]
		public class UIRigAwakePatch
		{
			public static void Prefix(UIRig __instance)
			{
				if (!playerInitializedOnce && isPlaying)
				{
					ForceStopMusic();
				}
				playerInitializedOnce = true;
			}
		}

		private static string prevLatestValue = "NONE";

		private static string latestValue = "NONE";

		private static string MUSIC_LISTENER_PROGRAM_FOLDER_PATH = Path.Combine(MelonUtils.UserDataDirectory, "MusicAttenuationProgram");

		private static string MUSIC_LISTENER_PROGRAM_PATH = Path.Combine(MUSIC_LISTENER_PROGRAM_FOLDER_PATH, "MusicListener.exe");

		private static string MUSIC_MIXER_NAME = "channel_Music";

		private static float LAST_MUSIC_MIXER_VALUE = 0f;

		private static bool isPlaying = false;

		private static bool playerInitializedOnce = false;

		public override void OnInitializeMelon()
		{
			ExtractListenerIfPossible();
			RunListener();
			ConnectTCP();
		}

		private void ExtractListenerIfPossible()
		{
			if (!Directory.Exists(MUSIC_LISTENER_PROGRAM_FOLDER_PATH))
			{
				Directory.CreateDirectory(MUSIC_LISTENER_PROGRAM_FOLDER_PATH);
			}
			if (File.Exists(MUSIC_LISTENER_PROGRAM_PATH))
			{
				return;
			}
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string name = executingAssembly.GetManifestResourceNames().First((string x) => x.Contains("MusicListener"));
			using Stream stream = executingAssembly.GetManifestResourceStream(name);
			using FileStream destination = File.Create(MUSIC_LISTENER_PROGRAM_PATH);
			stream.CopyTo(destination);
		}

		public override void OnUpdate()
		{
			if (!(prevLatestValue != latestValue))
			{
				return;
			}
			prevLatestValue = latestValue;
			if (latestValue.Contains("Playing"))
			{
				if (playerInitializedOnce)
				{
					ForceStopMusic();
				}
				isPlaying = true;
			}
			else
			{
				isPlaying = false;
				if (playerInitializedOnce)
				{
					Audio3dManager.diegeticMusic.audioMixer.SetFloat(MUSIC_MIXER_NAME, LAST_MUSIC_MIXER_VALUE);
				}
			}
		}

		public static void ForceStopMusic()
		{
			float lAST_MUSIC_MIXER_VALUE = default(float);
			Audio3dManager.diegeticMusic.audioMixer.GetFloat(MUSIC_MIXER_NAME, ref lAST_MUSIC_MIXER_VALUE);
			LAST_MUSIC_MIXER_VALUE = lAST_MUSIC_MIXER_VALUE;
			Audio3dManager.diegeticMusic.audioMixer.SetFloat(MUSIC_MIXER_NAME, -30f);
		}

		private void RunListener()
		{
			Thread thread = new Thread((ThreadStart)delegate
			{
				Process process = new Process();
				process.StartInfo.FileName = "cmd.exe";
				process.StartInfo.Arguments = "/c start \"\" \"" + MUSIC_LISTENER_PROGRAM_PATH + "\"";
				process.StartInfo.UseShellExecute = true;
				process.StartInfo.CreateNoWindow = true;
				process.Start();
			});
			thread.Start();
		}

		private void ConnectTCP()
		{
			Thread thread = new Thread((ThreadStart)delegate
			{
				using TcpClient tcpClient = new TcpClient();
				tcpClient.Connect("127.0.0.1", 45565);
				using NetworkStream networkStream = tcpClient.GetStream();
				byte[] array = new byte[1024];
				while (tcpClient.Connected)
				{
					int count = networkStream.Read(array, 0, array.Length);
					latestValue = Encoding.UTF8.GetString(array, 0, count);
				}
			});
			thread.Start();
		}
	}
}