using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.IO.MemoryMappedFiles;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.NET.Common;
using BepInExResoniteShim;
using CSCore;
using CSCore.CoreAudioAPI;
using CSCore.SoundOut;
using CSCore.Win32;
using Elements.Core;
using FrooxEngine;
using HarmonyLib;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(/*Could not decode attribute arguments.*/)]
[assembly: TargetFramework(".NETCoreApp,Version=v9.0", FrameworkDisplayName = ".NET 9.0")]
[assembly: AssemblyCompany("Knackrack615")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("2.0.0.0")]
[assembly: AssemblyInformationalVersion("2.0.0")]
[assembly: AssemblyProduct("AudioBridge")]
[assembly: AssemblyTitle("AudioBridge")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/knackrack615/AudioBridge")]
[assembly: AssemblyVersion("2.0.0.0")]
[module: RefSafetyRules(11)]
namespace AudioBridge;

public enum MuteTarget
{
	None,
	Host,
	Renderer
}
[ResonitePlugin("knackrack615.audiobridge", "AudioBridge", "2.0.0", "Knackrack615", "https://github.com/knackrack615/AudioBridge")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class AudioBridge : BasePlugin
{
	[Serializable]
	[CompilerGenerated]
	private sealed class <>c
	{
		private sealed class <<OnEnabledChanged>b__9_0>d : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncTaskMethodBuilder <>t__builder;

			public <>c <>4__this;

			private TaskAwaiter <>u__1;

			private void MoveNext()
			{
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				try
				{
					TaskAwaiter awaiter;
					if (num != 0)
					{
						awaiter = global::System.Threading.Tasks.Task.Delay(100).GetAwaiter();
						if (!((TaskAwaiter)(ref awaiter)).IsCompleted)
						{
							num = (<>1__state = 0);
							<>u__1 = awaiter;
							<<OnEnabledChanged>b__9_0>d <<OnEnabledChanged>b__9_0>d = this;
							((AsyncTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<TaskAwaiter, <<OnEnabledChanged>b__9_0>d>(ref awaiter, ref <<OnEnabledChanged>b__9_0>d);
							return;
						}
					}
					else
					{
						awaiter = <>u__1;
						<>u__1 = default(TaskAwaiter);
						num = (<>1__state = -1);
					}
					((TaskAwaiter)(ref awaiter)).GetResult();
					if (ShadowBus.EnsureInit(writer: true))
					{
						UniLog.Log("[AudioBridge] Audio sharing enabled successfully", false);
						ShadowBus.ResetBufferIndices();
						ShadowBus.PublishEnabled(enabled: true);
						ShadowWriterPatch.ResetState();
						if (_currentMuteTarget == MuteTarget.Host)
						{
							global::System.Threading.Tasks.Task.Run((Func<global::System.Threading.Tasks.Task>)([AsyncStateMachine(typeof(<<OnEnabledChanged>b__9_2>d))] [DebuggerStepThrough] () =>
							{
								//IL_0007: Unknown result type (might be due to invalid IL or missing references)
								//IL_000c: Unknown result type (might be due to invalid IL or missing references)
								<<OnEnabledChanged>b__9_2>d <<OnEnabledChanged>b__9_2>d = new <<OnEnabledChanged>b__9_2>d
								{
									<>t__builder = AsyncTaskMethodBuilder.Create(),
									<>4__this = <>9,
									<>1__state = -1
								};
								((AsyncTaskMethodBuilder)(ref <<OnEnabledChanged>b__9_2>d.<>t__builder)).Start<<<OnEnabledChanged>b__9_2>d>(ref <<OnEnabledChanged>b__9_2>d);
								return ((AsyncTaskMethodBuilder)(ref <<OnEnabledChanged>b__9_2>d.<>t__builder)).Task;
							}));
						}
					}
					else
					{
						UniLog.Error("[AudioBridge] Failed to enable audio sharing", true);
					}
				}
				catch (global::System.Exception exception)
				{
					<>1__state = -2;
					((AsyncTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
					return;
				}
				<>1__state = -2;
				((AsyncTaskMethodBuilder)(ref <>t__builder)).SetResult();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
			}
		}

		private sealed class <<OnEnabledChanged>b__9_1>d : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncTaskMethodBuilder <>t__builder;

			public <>c <>4__this;

			private TaskAwaiter <>u__1;

			private void MoveNext()
			{
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				try
				{
					TaskAwaiter awaiter;
					if (num != 0)
					{
						awaiter = global::System.Threading.Tasks.Task.Delay(500).GetAwaiter();
						if (!((TaskAwaiter)(ref awaiter)).IsCompleted)
						{
							num = (<>1__state = 0);
							<>u__1 = awaiter;
							<<OnEnabledChanged>b__9_1>d <<OnEnabledChanged>b__9_1>d = this;
							((AsyncTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<TaskAwaiter, <<OnEnabledChanged>b__9_1>d>(ref awaiter, ref <<OnEnabledChanged>b__9_1>d);
							return;
						}
					}
					else
					{
						awaiter = <>u__1;
						<>u__1 = default(TaskAwaiter);
						num = (<>1__state = -1);
					}
					((TaskAwaiter)(ref awaiter)).GetResult();
					ShadowBus.Shutdown();
					ShadowWriterPatch.ResetState();
					UniLog.Log("[AudioBridge] Audio sharing disabled", false);
				}
				catch (global::System.Exception exception)
				{
					<>1__state = -2;
					((AsyncTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
					return;
				}
				<>1__state = -2;
				((AsyncTaskMethodBuilder)(ref <>t__builder)).SetResult();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
			}
		}

		private sealed class <<OnEnabledChanged>b__9_2>d : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncTaskMethodBuilder <>t__builder;

			public <>c <>4__this;

			private int <i>5__1;

			private TaskAwaiter <>u__1;

			private void MoveNext()
			{
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				try
				{
					if (num != 0)
					{
						<i>5__1 = 0;
						goto IL_00a0;
					}
					TaskAwaiter awaiter = <>u__1;
					<>u__1 = default(TaskAwaiter);
					num = (<>1__state = -1);
					goto IL_0085;
					IL_0085:
					((TaskAwaiter)(ref awaiter)).GetResult();
					<i>5__1++;
					goto IL_00a0;
					IL_00a0:
					if (<i>5__1 < 10 && !ShadowWriterPatch.TryApplyMuteConfiguration(shouldMute: true))
					{
						awaiter = global::System.Threading.Tasks.Task.Delay(500).GetAwaiter();
						if (!((TaskAwaiter)(ref awaiter)).IsCompleted)
						{
							num = (<>1__state = 0);
							<>u__1 = awaiter;
							<<OnEnabledChanged>b__9_2>d <<OnEnabledChanged>b__9_2>d = this;
							((AsyncTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<TaskAwaiter, <<OnEnabledChanged>b__9_2>d>(ref awaiter, ref <<OnEnabledChanged>b__9_2>d);
							return;
						}
						goto IL_0085;
					}
				}
				catch (global::System.Exception exception)
				{
					<>1__state = -2;
					((AsyncTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
					return;
				}
				<>1__state = -2;
				((AsyncTaskMethodBuilder)(ref <>t__builder)).SetResult();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
			}
		}

		public static readonly <>c <>9 = new <>c();

		public static EventHandler <>9__6_2;

		public static Func<ParameterInfo, string> <>9__6_3;

		public static Func<ParameterInfo, string> <>9__6_4;

		public static Func<global::System.Threading.Tasks.Task?> <>9__9_2;

		public static Func<global::System.Threading.Tasks.Task?> <>9__9_0;

		public static Func<global::System.Threading.Tasks.Task?> <>9__9_1;

		internal void <Load>b__6_2(object? sender, EventArgs args)
		{
			_debugLogging = DEBUG_LOGGING.Value;
		}

		internal string <Load>b__6_3(ParameterInfo p)
		{
			return ((MemberInfo)p.ParameterType).Name + " " + p.Name;
		}

		internal string <Load>b__6_4(ParameterInfo p)
		{
			return ((MemberInfo)p.ParameterType).Name + " " + p.Name;
		}

		[AsyncStateMachine(typeof(<<OnEnabledChanged>b__9_0>d))]
		[DebuggerStepThrough]
		internal global::System.Threading.Tasks.Task? <OnEnabledChanged>b__9_0()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			<<OnEnabledChanged>b__9_0>d <<OnEnabledChanged>b__9_0>d = new <<OnEnabledChanged>b__9_0>d
			{
				<>t__builder = AsyncTaskMethodBuilder.Create(),
				<>4__this = this,
				<>1__state = -1
			};
			((AsyncTaskMethodBuilder)(ref <<OnEnabledChanged>b__9_0>d.<>t__builder)).Start<<<OnEnabledChanged>b__9_0>d>(ref <<OnEnabledChanged>b__9_0>d);
			return ((AsyncTaskMethodBuilder)(ref <<OnEnabledChanged>b__9_0>d.<>t__builder)).Task;
		}

		[AsyncStateMachine(typeof(<<OnEnabledChanged>b__9_2>d))]
		[DebuggerStepThrough]
		internal global::System.Threading.Tasks.Task? <OnEnabledChanged>b__9_2()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			<<OnEnabledChanged>b__9_2>d <<OnEnabledChanged>b__9_2>d = new <<OnEnabledChanged>b__9_2>d
			{
				<>t__builder = AsyncTaskMethodBuilder.Create(),
				<>4__this = this,
				<>1__state = -1
			};
			((AsyncTaskMethodBuilder)(ref <<OnEnabledChanged>b__9_2>d.<>t__builder)).Start<<<OnEnabledChanged>b__9_2>d>(ref <<OnEnabledChanged>b__9_2>d);
			return ((AsyncTaskMethodBuilder)(ref <<OnEnabledChanged>b__9_2>d.<>t__builder)).Task;
		}

		[AsyncStateMachine(typeof(<<OnEnabledChanged>b__9_1>d))]
		[DebuggerStepThrough]
		internal global::System.Threading.Tasks.Task? <OnEnabledChanged>b__9_1()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			<<OnEnabledChanged>b__9_1>d <<OnEnabledChanged>b__9_1>d = new <<OnEnabledChanged>b__9_1>d
			{
				<>t__builder = AsyncTaskMethodBuilder.Create(),
				<>4__this = this,
				<>1__state = -1
			};
			((AsyncTaskMethodBuilder)(ref <<OnEnabledChanged>b__9_1>d.<>t__builder)).Start<<<OnEnabledChanged>b__9_1>d>(ref <<OnEnabledChanged>b__9_1>d);
			return ((AsyncTaskMethodBuilder)(ref <<OnEnabledChanged>b__9_1>d.<>t__builder)).Task;
		}
	}

	private static ConfigEntry<bool> ENABLED;

	private static ConfigEntry<MuteTarget> MUTE_TARGET;

	private static ConfigEntry<bool> DEBUG_LOGGING;

	private static MuteTarget _currentMuteTarget = MuteTarget.Host;

	private static bool _isEnabled = false;

	private static bool _debugLogging = false;

	public override void Load()
	{
		//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b1: Expected O, but got Unknown
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Expected O, but got Unknown
		//IL_00e2: 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_00ed: Expected O, but got Unknown
		//IL_05ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_05bb: Expected O, but got Unknown
		//IL_0371: Unknown result type (might be due to invalid IL or missing references)
		//IL_037e: Expected O, but got Unknown
		try
		{
			ENABLED = ((BasePlugin)this).Config.Bind<bool>("General", "Enabled", true, "Enable audio sharing to renderer process?");
			MUTE_TARGET = ((BasePlugin)this).Config.Bind<MuteTarget>("General", "MuteTarget", MuteTarget.Host, "Which process to mute (prevents double audio)?");
			DEBUG_LOGGING = ((BasePlugin)this).Config.Bind<bool>("General", "DebugLogging", false, "Enable debug/verbose logging?");
			UniLog.Log("[AudioBridge] Initializing audio sharing module", false);
			_currentMuteTarget = MUTE_TARGET.Value;
			_isEnabled = ENABLED.Value;
			_debugLogging = DEBUG_LOGGING.Value;
			ENABLED.SettingChanged += (EventHandler)([CompilerGenerated] (object? sender, EventArgs args) =>
			{
				OnEnabledChanged();
			});
			MUTE_TARGET.SettingChanged += (EventHandler)([CompilerGenerated] (object? sender, EventArgs args) =>
			{
				OnMuteTargetChanged();
			});
			ConfigEntry<bool> dEBUG_LOGGING = DEBUG_LOGGING;
			object obj = <>c.<>9__6_2;
			if (obj == null)
			{
				EventHandler val = delegate
				{
					_debugLogging = DEBUG_LOGGING.Value;
				};
				<>c.<>9__6_2 = val;
				obj = (object)val;
			}
			dEBUG_LOGGING.SettingChanged += (EventHandler)obj;
			UniLog.Log($"[AudioBridge] Mute target set to: {_currentMuteTarget}", false);
			UniLog.Log("[AudioBridge] Applying audio driver patches", false);
			Harmony harmonyInstance = ((BasePlugin)this).HarmonyInstance;
			try
			{
				global::System.Type typeFromHandle = typeof(CSCoreAudioOutputDriver);
				global::System.Type typeFromHandle2 = typeof(AudioOutputDriver);
				MethodInfo[] methods = typeFromHandle.GetMethods((BindingFlags)54);
				int num = 0;
				if (_debugLogging)
				{
					UniLog.Log($"[AudioBridge] Found {methods.Length} audio driver methods", false);
				}
				MethodInfo[] array = methods;
				foreach (MethodInfo val2 in array)
				{
					if (!((MemberInfo)val2).Name.Contains("Read") && !((MemberInfo)val2).Name.Contains("read"))
					{
						continue;
					}
					ParameterInfo[] parameters = ((MethodBase)val2).GetParameters();
					string text = string.Join(", ", Enumerable.Select<ParameterInfo, string>((global::System.Collections.Generic.IEnumerable<ParameterInfo>)parameters, (Func<ParameterInfo, string>)((ParameterInfo p) => ((MemberInfo)p.ParameterType).Name + " " + p.Name)));
					if (_debugLogging)
					{
						UniLog.Log($"[AudioBridge] Discovered audio method: {((MemberInfo)val2).Name}({text})", false);
					}
					if (!(((MemberInfo)val2).DeclaringType == typeFromHandle))
					{
						continue;
					}
					try
					{
						string text2 = null;
						if (((MemberInfo)val2).Name == "Read" && parameters.Length == 3)
						{
							if (parameters[0].ParameterType == typeof(float[]))
							{
								text2 = "Read_Float_Postfix";
							}
							else if (parameters[0].ParameterType == typeof(byte[]))
							{
								text2 = "Read_Byte_Postfix";
							}
						}
						else if (((MemberInfo)val2).Name == "ReadAuto")
						{
							text2 = "ReadAuto_Span_Postfix";
						}
						if (text2 == null)
						{
							continue;
						}
						MethodInfo method = typeof(ShadowWriterPatch).GetMethod(text2, (BindingFlags)40);
						if (method != (MethodInfo)null)
						{
							harmonyInstance.Patch((MethodBase)(object)val2, (HarmonyMethod)null, new HarmonyMethod(method), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
							if (_debugLogging)
							{
								UniLog.Log("[AudioBridge] Successfully patched " + ((MemberInfo)val2).Name, false);
							}
							num++;
						}
						else if (_debugLogging)
						{
							UniLog.Log("[AudioBridge] Patch method " + text2 + " not found", false);
						}
					}
					catch (global::System.Exception ex)
					{
						if (_debugLogging)
						{
							UniLog.Log("[AudioBridge] Failed to patch " + ((MemberInfo)val2).Name + ": " + ex.Message, false);
						}
					}
				}
				MethodInfo[] methods2 = typeFromHandle2.GetMethods((BindingFlags)52);
				if (_debugLogging)
				{
					UniLog.Log($"[AudioBridge] Base driver has {methods2.Length} methods", false);
				}
				MethodInfo[] array2 = methods2;
				foreach (MethodInfo val3 in array2)
				{
					if (!((MemberInfo)val3).Name.Contains("Read") && !((MemberInfo)val3).Name.Contains("read") && !(((MemberInfo)val3).Name == "Start"))
					{
						continue;
					}
					ParameterInfo[] parameters2 = ((MethodBase)val3).GetParameters();
					string text3 = string.Join(", ", Enumerable.Select<ParameterInfo, string>((global::System.Collections.Generic.IEnumerable<ParameterInfo>)parameters2, (Func<ParameterInfo, string>)((ParameterInfo p) => ((MemberInfo)p.ParameterType).Name + " " + p.Name)));
					if (_debugLogging)
					{
						UniLog.Log($"[AudioBridge] Found base method: {((MemberInfo)val3).Name}({text3})", false);
					}
					if (((MemberInfo)val3).Name == "Start" && ((MemberInfo)val3).DeclaringType == typeFromHandle2)
					{
						try
						{
							MethodInfo method2 = typeof(ShadowWriterPatch).GetMethod("Start_Base_Postfix", (BindingFlags)40);
							harmonyInstance.Patch((MethodBase)(object)val3, (HarmonyMethod)null, new HarmonyMethod(method2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
							UniLog.Log("[AudioBridge] Patched base Start method", false);
						}
						catch (global::System.Exception ex2)
						{
							UniLog.Log("[AudioBridge] Failed to patch base Start: " + ex2.Message, false);
						}
					}
				}
				if (_debugLogging)
				{
					UniLog.Log($"[AudioBridge] Successfully patched {num} audio methods", false);
				}
			}
			catch (global::System.Exception ex3)
			{
				UniLog.Error("[AudioBridge] Patching failed: " + ex3.Message, true);
			}
			UniLog.Log("[AudioBridge] Audio driver patching completed", false);
			UniLog.Log($"[AudioBridge] Audio sharing enabled: {_isEnabled}", false);
			if (_isEnabled)
			{
				UniLog.Log("[AudioBridge] Initializing audio writer for host process", false);
				UniLog.Log("[AudioBridge] Initializing shared memory audio buffer", false);
				if (ShadowBus.EnsureInit(writer: true))
				{
					UniLog.Log("[AudioBridge] Shared memory audio buffer initialized", false);
					ShadowBus.ResetBufferIndices();
					ShadowBus.PublishEnabled(enabled: true);
					ShadowBus.PublishMuteTarget(_currentMuteTarget);
				}
				else
				{
					UniLog.Error("[AudioBridge] Failed to initialize shared memory buffer", true);
				}
			}
			else
			{
				UniLog.Log("[AudioBridge] Audio sharing is disabled", false);
			}
		}
		catch (global::System.Exception ex4)
		{
			UniLog.Error("[AudioBridge] Initialization failed: " + ex4.Message, true);
			UniLog.Error("[AudioBridge] Stack trace: " + ex4.StackTrace, true);
		}
	}

	internal static void Msg(string s)
	{
		UniLog.Log("[AudioBridge] " + s, false);
	}

	internal static void Err(string s)
	{
		UniLog.Error("[AudioBridge] " + s, false);
	}

	private void OnEnabledChanged()
	{
		bool isEnabled = _isEnabled;
		_isEnabled = ENABLED.Value;
		UniLog.Log($"[AudioBridge] Audio sharing enabled changed from {isEnabled} to {_isEnabled}", false);
		if (_isEnabled && !isEnabled)
		{
			UniLog.Log("[AudioBridge] Enabling audio sharing...", false);
			global::System.Threading.Tasks.Task.Run((Func<global::System.Threading.Tasks.Task>)([AsyncStateMachine(typeof(<>c.<<OnEnabledChanged>b__9_0>d))] [DebuggerStepThrough] () =>
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				<>c.<<OnEnabledChanged>b__9_0>d <<OnEnabledChanged>b__9_0>d = new <>c.<<OnEnabledChanged>b__9_0>d
				{
					<>t__builder = AsyncTaskMethodBuilder.Create(),
					<>4__this = <>c.<>9,
					<>1__state = -1
				};
				((AsyncTaskMethodBuilder)(ref <<OnEnabledChanged>b__9_0>d.<>t__builder)).Start<<>c.<<OnEnabledChanged>b__9_0>d>(ref <<OnEnabledChanged>b__9_0>d);
				return ((AsyncTaskMethodBuilder)(ref <<OnEnabledChanged>b__9_0>d.<>t__builder)).Task;
			}));
		}
		else if (!_isEnabled && isEnabled)
		{
			UniLog.Log("[AudioBridge] Disabling audio sharing...", false);
			if (_currentMuteTarget == MuteTarget.Host)
			{
				ShadowWriterPatch.ApplyMuteConfiguration(shouldMute: false);
			}
			ShadowBus.PublishEnabled(enabled: false);
			global::System.Threading.Tasks.Task.Run((Func<global::System.Threading.Tasks.Task>)([AsyncStateMachine(typeof(<>c.<<OnEnabledChanged>b__9_1>d))] [DebuggerStepThrough] () =>
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				<>c.<<OnEnabledChanged>b__9_1>d <<OnEnabledChanged>b__9_1>d = new <>c.<<OnEnabledChanged>b__9_1>d
				{
					<>t__builder = AsyncTaskMethodBuilder.Create(),
					<>4__this = <>c.<>9,
					<>1__state = -1
				};
				((AsyncTaskMethodBuilder)(ref <<OnEnabledChanged>b__9_1>d.<>t__builder)).Start<<>c.<<OnEnabledChanged>b__9_1>d>(ref <<OnEnabledChanged>b__9_1>d);
				return ((AsyncTaskMethodBuilder)(ref <<OnEnabledChanged>b__9_1>d.<>t__builder)).Task;
			}));
		}
	}

	private void OnMuteTargetChanged()
	{
		MuteTarget currentMuteTarget = _currentMuteTarget;
		_currentMuteTarget = MUTE_TARGET.Value;
		UniLog.Log($"[AudioBridge] Mute target changed from {currentMuteTarget} to {_currentMuteTarget}", false);
		if (_isEnabled)
		{
			ShadowBus.PublishMuteTarget(_currentMuteTarget);
			bool shouldMute = _currentMuteTarget == MuteTarget.Host;
			if (currentMuteTarget == MuteTarget.Host || _currentMuteTarget == MuteTarget.Host)
			{
				ShadowWriterPatch.ApplyMuteConfiguration(shouldMute);
			}
		}
	}

	internal static MuteTarget GetCurrentMuteTarget()
	{
		return _currentMuteTarget;
	}

	internal static bool IsEnabled()
	{
		return _isEnabled;
	}

	internal static bool IsDebugLogging()
	{
		return _debugLogging;
	}
}
internal static class ShadowBus
{
	private const string MMF_NAME = "AudioBridge_SharedMemory";

	private const string MUTEX_NAME = "AudioBridge_SharedMemory_Mutex";

	private const int HEADER_BYTES = 64;

	private const int RING_BYTES = 2097152;

	private const int MMF_BYTES = 2097216;

	private static MemoryMappedFile _mmf;

	private static MemoryMappedViewAccessor _view;

	private static Mutex _mtx;

	private static volatile bool _inited;

	public static bool EnsureInit(bool writer, int sampleRate = 48000, int channels = 2, string sessionId = null)
	{
		//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Expected O, but got Unknown
		//IL_03b7: Unknown result type (might be due to invalid IL or missing references)
		if (_inited)
		{
			return true;
		}
		if (AudioBridge.IsDebugLogging())
		{
			UniLog.Log("[AudioBridge] Initializing shared memory as " + (writer ? "writer" : "reader"), false);
		}
		try
		{
			if (writer)
			{
				if (AudioBridge.IsDebugLogging())
				{
					UniLog.Log("[AudioBridge] Creating shared memory: AudioBridge_SharedMemory", false);
				}
				_mmf = MemoryMappedFile.CreateOrOpen("AudioBridge_SharedMemory", 2097216L, (MemoryMappedFileAccess)0);
				if (AudioBridge.IsDebugLogging())
				{
					UniLog.Log("[AudioBridge] Shared memory created", false);
				}
				if (AudioBridge.IsDebugLogging())
				{
					UniLog.Log("[AudioBridge] Creating synchronization mutex: AudioBridge_SharedMemory_Mutex", false);
				}
				_mtx = new Mutex(false, "AudioBridge_SharedMemory_Mutex");
				if (AudioBridge.IsDebugLogging())
				{
					UniLog.Log("[AudioBridge] Mutex created", false);
				}
				_view = _mmf.CreateViewAccessor(0L, 2097216L, (MemoryMappedFileAccess)0);
				if (AudioBridge.IsDebugLogging())
				{
					UniLog.Log("[AudioBridge] Memory accessor created", false);
				}
				((WaitHandle)_mtx).WaitOne();
				try
				{
					uint num = ((UnmanagedMemoryAccessor)_view).ReadUInt32(0L);
					uint num2 = ((UnmanagedMemoryAccessor)_view).ReadUInt32(4L);
					if (AudioBridge.IsDebugLogging())
					{
						UniLog.Log($"[AudioBridge] Buffer indices: write={num}, read={num2}", false);
					}
					if (num > 2097152 || num2 > 2097152)
					{
						UniLog.Log("[AudioBridge] Resetting buffer indices", false);
						((UnmanagedMemoryAccessor)_view).Write(0L, 0u);
						((UnmanagedMemoryAccessor)_view).Write(4L, 0u);
					}
					((UnmanagedMemoryAccessor)_view).Write(8L, sampleRate);
					((UnmanagedMemoryAccessor)_view).Write(12L, channels);
					((UnmanagedMemoryAccessor)_view).Write(16L, (int)AudioBridge.GetCurrentMuteTarget());
					((UnmanagedMemoryAccessor)_view).Write(20L, AudioBridge.IsEnabled() ? 1 : 0);
					if (!string.IsNullOrEmpty(sessionId))
					{
						WriteSessionId(sessionId);
					}
					if (AudioBridge.IsDebugLogging())
					{
						UniLog.Log($"[AudioBridge] Audio format: {sampleRate}Hz, {channels} channels, SessionID: {sessionId ?? "none"}", false);
					}
				}
				finally
				{
					_mtx.ReleaseMutex();
				}
			}
			else
			{
				UniLog.Log("[AudioBridge] Opening shared memory: AudioBridge_SharedMemory", false);
				bool flag = false;
				global::System.Exception ex = null;
				for (int i = 0; i < 10; i++)
				{
					try
					{
						_mmf = MemoryMappedFile.OpenExisting("AudioBridge_SharedMemory", (MemoryMappedFileRights)6);
						flag = true;
						UniLog.Log($"[AudioBridge] Shared memory opened on attempt {i + 1}", false);
					}
					catch (global::System.Exception ex2)
					{
						ex = ex2;
						if (i < 9)
						{
							if (AudioBridge.IsDebugLogging())
							{
								UniLog.Log($"[AudioBridge] Waiting for shared memory (attempt {i + 1}/10)", false);
							}
							Thread.Sleep(500);
						}
						continue;
					}
					break;
				}
				if (!flag)
				{
					UniLog.Error("[AudioBridge] Failed to open shared memory: " + ex?.Message, true);
					throw new InvalidOperationException("MMF AudioBridge_SharedMemory not found", ex);
				}
				UniLog.Log("[AudioBridge] Opening synchronization mutex", false);
				_mtx = Mutex.OpenExisting("AudioBridge_SharedMemory_Mutex");
				UniLog.Log("[AudioBridge] Mutex opened", false);
				_view = _mmf.CreateViewAccessor(0L, 2097216L, (MemoryMappedFileAccess)0);
				UniLog.Log("[AudioBridge] Memory accessor created", false);
			}
			_inited = true;
			UniLog.Log("[AudioBridge] Shared memory initialization complete", false);
			return true;
		}
		catch (global::System.Exception ex3)
		{
			UniLog.Error("[AudioBridge] Shared memory initialization failed: " + ex3.Message, true);
			UniLog.Error("[AudioBridge] Stack trace: " + ex3.StackTrace, true);
			try
			{
				MemoryMappedViewAccessor view = _view;
				if (view != null)
				{
					((UnmanagedMemoryAccessor)view).Dispose();
				}
			}
			catch
			{
			}
			try
			{
				Mutex mtx = _mtx;
				if (mtx != null)
				{
					((WaitHandle)mtx).Dispose();
				}
			}
			catch
			{
			}
			try
			{
				MemoryMappedFile mmf = _mmf;
				if (mmf != null)
				{
					mmf.Dispose();
				}
			}
			catch
			{
			}
			_view = null;
			_mtx = null;
			_mmf = null;
			return false;
		}
	}

	public static void WriteSessionId(string sessionId)
	{
		if (!_inited || string.IsNullOrEmpty(sessionId))
		{
			return;
		}
		((WaitHandle)_mtx).WaitOne();
		try
		{
			byte[] array = new byte[36];
			((UnmanagedMemoryAccessor)_view).WriteArray<byte>(24L, array, 0, 36);
			byte[] bytes = Encoding.ASCII.GetBytes(sessionId);
			int num = Math.Min(bytes.Length, 36);
			((UnmanagedMemoryAccessor)_view).WriteArray<byte>(24L, bytes, 0, num);
			if (AudioBridge.IsDebugLogging())
			{
				UniLog.Log("[AudioBridge] Written SessionID to shared memory: " + sessionId, false);
			}
		}
		finally
		{
			_mtx.ReleaseMutex();
		}
	}

	public static string ReadSessionId()
	{
		if (!_inited)
		{
			return null;
		}
		((WaitHandle)_mtx).WaitOne();
		try
		{
			byte[] array = new byte[36];
			((UnmanagedMemoryAccessor)_view).ReadArray<byte>(24L, array, 0, 36);
			int num = global::System.Array.IndexOf<byte>(array, (byte)0);
			if (num == -1)
			{
				num = 36;
			}
			if (num == 0)
			{
				return null;
			}
			return Encoding.ASCII.GetString(array, 0, num);
		}
		finally
		{
			_mtx.ReleaseMutex();
		}
	}

	public static void PublishFormat(int sampleRate, int channels, string sessionId = null)
	{
		if (!_inited)
		{
			return;
		}
		((WaitHandle)_mtx).WaitOne();
		try
		{
			if (AudioBridge.IsDebugLogging())
			{
				UniLog.Log($"[AudioBridge] Publishing audio format: {sampleRate}Hz, {channels}ch, SessionID: {sessionId ?? "none"}", false);
			}
			((UnmanagedMemoryAccessor)_view).Write(8L, sampleRate);
			((UnmanagedMemoryAccessor)_view).Write(12L, channels);
			((UnmanagedMemoryAccessor)_view).Write(16L, (int)AudioBridge.GetCurrentMuteTarget());
			if (!string.IsNullOrEmpty(sessionId))
			{
				WriteSessionId(sessionId);
			}
		}
		finally
		{
			_mtx.ReleaseMutex();
		}
	}

	public static void PublishMuteTarget(MuteTarget target)
	{
		if (!_inited)
		{
			return;
		}
		((WaitHandle)_mtx).WaitOne();
		try
		{
			((UnmanagedMemoryAccessor)_view).Write(16L, (int)target);
			if (AudioBridge.IsDebugLogging())
			{
				UniLog.Log($"[AudioBridge] Published mute target: {target}", false);
			}
		}
		finally
		{
			_mtx.ReleaseMutex();
		}
	}

	public static ValueTuple<int, int> ReadFormat()
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		if (!_inited)
		{
			return new ValueTuple<int, int>(48000, 2);
		}
		((WaitHandle)_mtx).WaitOne();
		try
		{
			int num = ((UnmanagedMemoryAccessor)_view).ReadInt32(8L);
			int num2 = ((UnmanagedMemoryAccessor)_view).ReadInt32(12L);
			if (num <= 0 || num2 <= 0)
			{
				return new ValueTuple<int, int>(48000, 2);
			}
			return new ValueTuple<int, int>(num, num2);
		}
		finally
		{
			_mtx.ReleaseMutex();
		}
	}

	public static MuteTarget ReadMuteTarget()
	{
		if (!_inited)
		{
			return MuteTarget.Renderer;
		}
		((WaitHandle)_mtx).WaitOne();
		try
		{
			int num = ((UnmanagedMemoryAccessor)_view).ReadInt32(16L);
			if (num < 0 || num > 2)
			{
				return MuteTarget.Renderer;
			}
			return (MuteTarget)num;
		}
		finally
		{
			_mtx.ReleaseMutex();
		}
	}

	public static void PublishEnabled(bool enabled)
	{
		if (!_inited)
		{
			return;
		}
		((WaitHandle)_mtx).WaitOne();
		try
		{
			((UnmanagedMemoryAccessor)_view).Write(20L, enabled ? 1 : 0);
			if (!enabled)
			{
				((UnmanagedMemoryAccessor)_view).Write(0L, 0u);
				((UnmanagedMemoryAccessor)_view).Write(4L, 0u);
				if (AudioBridge.IsDebugLogging())
				{
					UniLog.Log("[AudioBridge] Reset buffer indices on disable", false);
				}
			}
			if (AudioBridge.IsDebugLogging())
			{
				UniLog.Log($"[AudioBridge] Published enabled state: {enabled}", false);
			}
		}
		finally
		{
			_mtx.ReleaseMutex();
		}
	}

	public static bool ReadEnabled()
	{
		if (!_inited)
		{
			return false;
		}
		((WaitHandle)_mtx).WaitOne();
		try
		{
			return ((UnmanagedMemoryAccessor)_view).ReadInt32(20L) == 1;
		}
		finally
		{
			_mtx.ReleaseMutex();
		}
	}

	public static void ResetBufferIndices()
	{
		if (!_inited)
		{
			return;
		}
		((WaitHandle)_mtx).WaitOne();
		try
		{
			((UnmanagedMemoryAccessor)_view).Write(0L, 0u);
			((UnmanagedMemoryAccessor)_view).Write(4L, 0u);
			if (AudioBridge.IsDebugLogging())
			{
				UniLog.Log("[AudioBridge] Buffer indices reset to 0", false);
			}
		}
		finally
		{
			_mtx.ReleaseMutex();
		}
	}

	public static void Shutdown()
	{
		if (!_inited)
		{
			return;
		}
		UniLog.Log("[AudioBridge] Shutting down shared memory", false);
		_inited = false;
		try
		{
			MemoryMappedViewAccessor view = _view;
			if (view != null)
			{
				((UnmanagedMemoryAccessor)view).Dispose();
			}
		}
		catch
		{
		}
		try
		{
			Mutex mtx = _mtx;
			if (mtx != null)
			{
				((WaitHandle)mtx).Dispose();
			}
		}
		catch
		{
		}
		try
		{
			MemoryMappedFile mmf = _mmf;
			if (mmf != null)
			{
				mmf.Dispose();
			}
		}
		catch
		{
		}
		_view = null;
		_mtx = null;
		_mmf = null;
	}

	public static void WriteFloats(global::System.ReadOnlySpan<float> src)
	{
		if (!_inited || src.IsEmpty)
		{
			return;
		}
		global::System.ReadOnlySpan<byte> readOnlySpan = MemoryMarshal.AsBytes<float>(src);
		((WaitHandle)_mtx).WaitOne();
		try
		{
			uint num = ((UnmanagedMemoryAccessor)_view).ReadUInt32(0L);
			uint num2 = ((UnmanagedMemoryAccessor)_view).ReadUInt32(4L);
			int num3 = (int)((2097152 + num2 - num - 1) % 2097152);
			int num4 = Math.Min(num3, readOnlySpan.Length);
			if (num4 > 0)
			{
				int num5 = (int)(64 + num);
				int num6 = Math.Min(num4, (int)(2097152 - num));
				((UnmanagedMemoryAccessor)_view).WriteArray<byte>((long)num5, readOnlySpan.Slice(0, num6).ToArray(), 0, num6);
				if (num4 > num6)
				{
					MemoryMappedViewAccessor view = _view;
					long num7 = 64L;
					int num8 = num6;
					((UnmanagedMemoryAccessor)view).WriteArray<byte>(num7, readOnlySpan.Slice(num8, num4 - num8).ToArray(), 0, num4 - num6);
				}
				num = (uint)((num + num4) % 2097152);
				((UnmanagedMemoryAccessor)_view).Write(0L, num);
			}
		}
		finally
		{
			_mtx.ReleaseMutex();
		}
	}

	public static int ReadFloats(global::System.Span<float> dst)
	{
		if (!_inited || dst.IsEmpty)
		{
			return 0;
		}
		global::System.Span<byte> span = MemoryMarshal.AsBytes<float>(dst);
		int num = 0;
		((WaitHandle)_mtx).WaitOne();
		try
		{
			uint num2 = ((UnmanagedMemoryAccessor)_view).ReadUInt32(0L);
			uint num3 = ((UnmanagedMemoryAccessor)_view).ReadUInt32(4L);
			int num4 = (int)((2097152 + num2 - num3) % 2097152);
			if (num4 <= 0)
			{
				return 0;
			}
			int num5 = Math.Min(num4, span.Length);
			int num6 = (int)(64 + num3);
			int num7 = Math.Min(num5, (int)(2097152 - num3));
			byte[] array = new byte[num7];
			((UnmanagedMemoryAccessor)_view).ReadArray<byte>((long)num6, array, 0, num7);
			MemoryExtensions.CopyTo<byte>(array, span);
			if (num5 > num7)
			{
				int num8 = num5 - num7;
				byte[] array2 = new byte[num8];
				((UnmanagedMemoryAccessor)_view).ReadArray<byte>(64L, array2, 0, num8);
				int num9 = num7;
				MemoryExtensions.CopyTo<byte>(array2, span.Slice(num9, span.Length - num9));
			}
			num3 = (uint)((num3 + num5) % 2097152);
			((UnmanagedMemoryAccessor)_view).Write(4L, num3);
			num = num5;
		}
		finally
		{
			_mtx.ReleaseMutex();
		}
		return num / 4;
	}
}
internal static class ShadowWriterPatch
{
	private static readonly FieldRef<CSCoreAudioOutputDriver, WasapiOut> _fOut = AccessTools.FieldRefAccess<CSCoreAudioOutputDriver, WasapiOut>("_out");

	private static bool _busInitialized = false;

	private static WasapiOut _currentAudioOutput = null;

	private static bool _isMuted = false;

	private static string _capturedSessionId = null;

	private static bool _shouldMuteHostAudio = false;

	private static bool _loggedUnsupported = false;

	private static bool _loggedByte = false;

	private static bool _loggedAuto = false;

	private static bool _loggedFormat = false;

	private static int _writeCounter = 0;

	private static void Read_Float_Postfix(CSCoreAudioOutputDriver __instance, float[] buffer, int offset, int count, ref int __result)
	{
		try
		{
			if (!AudioBridge.IsEnabled())
			{
				return;
			}
			WasapiOut val = _fOut.Invoke(__instance);
			WaveFormat val2 = ((val != null) ? val.ActualOutputFormat : null);
			if (!_loggedFormat && val2 != null)
			{
				if (AudioBridge.IsDebugLogging())
				{
					UniLog.Log($"[AudioBridge] Audio output detected: {val2.SampleRate}Hz, {val2.Channels}ch, {val2.BitsPerSample}bit", false);
				}
				_loggedFormat = true;
			}
			if (val2 == null || val2.BitsPerSample != 32)
			{
				return;
			}
			int num = Math.Max(0, __result / 4);
			if (num == 0)
			{
				return;
			}
			if (!_busInitialized)
			{
				if (!ShadowBus.EnsureInit(writer: true, val2.SampleRate, val2.Channels, _capturedSessionId))
				{
					return;
				}
				ShadowBus.PublishFormat(val2.SampleRate, val2.Channels, _capturedSessionId);
				_busInitialized = true;
				UniLog.Log("[AudioBridge] Shared memory initialized for audio streaming", false);
			}
			ShadowBus.WriteFloats(global::System.Span<float>.op_Implicit(MemoryExtensions.AsSpan<float>(buffer, offset, num)));
			if (_shouldMuteHostAudio && AudioBridge.GetCurrentMuteTarget() == MuteTarget.Host)
			{
				global::System.Array.Clear((global::System.Array)buffer, offset, num);
			}
			_writeCounter++;
			if (_writeCounter % 1000 == 0 && AudioBridge.IsDebugLogging())
			{
				UniLog.Log($"[AudioBridge] Processed {_writeCounter} audio chunks", false);
			}
		}
		catch (global::System.Exception ex)
		{
			AudioBridge.Err("Audio float processing error: " + ex.Message);
		}
	}

	private static void Read_Byte_Postfix(CSCoreAudioOutputDriver __instance, byte[] buffer, int offset, int count, ref int __result)
	{
		try
		{
			if (!AudioBridge.IsEnabled() || __result <= 0)
			{
				return;
			}
			WasapiOut val = _fOut.Invoke(__instance);
			WaveFormat val2 = ((val != null) ? val.ActualOutputFormat : null);
			if (val2 == null)
			{
				return;
			}
			if (!_loggedByte)
			{
				if (AudioBridge.IsDebugLogging())
				{
					UniLog.Log($"[AudioBridge] Audio output detected (byte mode): {val2.SampleRate}Hz, {val2.Channels}ch, {val2.BitsPerSample}bit", false);
				}
				_loggedByte = true;
			}
			int num = __result;
			int sampleRate = val2.SampleRate;
			int channels = val2.Channels;
			int bitsPerSample = val2.BitsPerSample;
			if (!_busInitialized)
			{
				if (!ShadowBus.EnsureInit(writer: true, sampleRate, channels, _capturedSessionId))
				{
					return;
				}
				ShadowBus.PublishFormat(sampleRate, channels, _capturedSessionId);
				_busInitialized = true;
				UniLog.Log("[AudioBridge] Shared memory initialized for audio streaming", false);
			}
			switch (bitsPerSample)
			{
			case 32:
			{
				float[] array2 = new float[num / 4];
				Buffer.BlockCopy((global::System.Array)buffer, offset, (global::System.Array)array2, 0, num);
				ShadowBus.WriteFloats(global::System.Span<float>.op_Implicit(MemoryExtensions.AsSpan<float>(array2)));
				if (_shouldMuteHostAudio && AudioBridge.GetCurrentMuteTarget() == MuteTarget.Host)
				{
					global::System.Array.Clear((global::System.Array)buffer, offset, num);
				}
				_writeCounter++;
				if (_writeCounter % 1000 == 0 && AudioBridge.IsDebugLogging())
				{
					UniLog.Log($"[AudioBridge] Processed {_writeCounter} audio chunks (32-bit float)", false);
				}
				break;
			}
			case 16:
			{
				int num2 = num / 2;
				float[] array = new float[num2];
				for (int i = 0; i < num2; i++)
				{
					short num3 = BitConverter.ToInt16(buffer, offset + i * 2);
					array[i] = (float)num3 / 32768f;
				}
				ShadowBus.WriteFloats(global::System.Span<float>.op_Implicit(MemoryExtensions.AsSpan<float>(array)));
				if (_shouldMuteHostAudio && AudioBridge.GetCurrentMuteTarget() == MuteTarget.Host)
				{
					global::System.Array.Clear((global::System.Array)buffer, offset, num);
				}
				_writeCounter++;
				if (_writeCounter % 1000 == 0 && AudioBridge.IsDebugLogging())
				{
					UniLog.Log($"[AudioBridge] Processed {_writeCounter} audio chunks (16-bit PCM)", false);
				}
				break;
			}
			case 24:
			{
				int num4 = num / 3;
				float[] array3 = new float[num4];
				for (int j = 0; j < num4; j++)
				{
					int num5 = (buffer[offset + j * 3] << 8) | (buffer[offset + j * 3 + 1] << 16) | (buffer[offset + j * 3 + 2] << 24);
					num5 >>= 8;
					array3[j] = (float)num5 / 8388608f;
				}
				ShadowBus.WriteFloats(global::System.Span<float>.op_Implicit(MemoryExtensions.AsSpan<float>(array3)));
				if (_shouldMuteHostAudio && AudioBridge.GetCurrentMuteTarget() == MuteTarget.Host)
				{
					global::System.Array.Clear((global::System.Array)buffer, offset, num);
				}
				_writeCounter++;
				if (_writeCounter % 1000 == 0 && AudioBridge.IsDebugLogging())
				{
					UniLog.Log($"[AudioBridge] Processed {_writeCounter} audio chunks (24-bit PCM)", false);
				}
				break;
			}
			default:
				if (!_loggedUnsupported && AudioBridge.IsDebugLogging())
				{
					UniLog.Log($"[AudioBridge] Unsupported audio format: {bitsPerSample}-bit", false);
					_loggedUnsupported = true;
				}
				break;
			}
		}
		catch (global::System.Exception ex)
		{
			AudioBridge.Err("Audio byte processing error: " + ex.Message);
		}
	}

	private static void ReadAuto_Span_Postfix(CSCoreAudioOutputDriver __instance, ref int __result)
	{
		try
		{
			if (!_loggedAuto && AudioBridge.IsDebugLogging())
			{
				UniLog.Log("[AudioBridge] Auto-read method detected", false);
				_loggedAuto = true;
			}
		}
		catch (global::System.Exception ex)
		{
			AudioBridge.Err("Auto-read processing error: " + ex.Message);
		}
	}

	private static void Start_Base_Postfix(AudioOutputDriver __instance, string context)
	{
		try
		{
			if (AudioBridge.IsDebugLogging())
			{
				UniLog.Log("[AudioBridge] Audio driver started with context: " + context, false);
			}
			try
			{
				FieldInfo val = AccessTools.Field(typeof(AudioOutputDriver), "System") ?? AccessTools.Field(typeof(AudioOutputDriver), "system") ?? AccessTools.Field(typeof(AudioOutputDriver), "_system");
				if (val != (FieldInfo)null)
				{
					object value = val.GetValue((object)__instance);
					if (value != null)
					{
						FieldInfo val2 = AccessTools.Field(value.GetType(), "Engine") ?? AccessTools.Field(value.GetType(), "engine") ?? AccessTools.Field(value.GetType(), "_engine");
						if (val2 != (FieldInfo)null)
						{
							object value2 = val2.GetValue(value);
							if (value2 != null)
							{
								PropertyInfo val3 = AccessTools.Property(value2.GetType(), "UniqueSessionID");
								if (val3 != (PropertyInfo)null)
								{
									object value3 = val3.GetValue(value2);
									if (value3 != null)
									{
										_capturedSessionId = value3.ToString();
										if (AudioBridge.IsDebugLogging())
										{
											UniLog.Log("[AudioBridge] Captured Engine SessionID: " + _capturedSessionId, false);
										}
										if (_busInitialized && _capturedSessionId != null)
										{
											ShadowBus.WriteSessionId(_capturedSessionId);
										}
									}
								}
							}
						}
					}
				}
			}
			catch (global::System.Exception ex)
			{
				if (AudioBridge.IsDebugLogging())
				{
					UniLog.Log("[AudioBridge] Could not capture SessionID: " + ex.Message, false);
				}
			}
			CSCoreAudioOutputDriver val4 = (CSCoreAudioOutputDriver)(object)((__instance is CSCoreAudioOutputDriver) ? __instance : null);
			if (val4 == null)
			{
				return;
			}
			WasapiOut val5 = _fOut.Invoke(val4);
			if (val5 == null)
			{
				return;
			}
			WaveFormat actualOutputFormat = val5.ActualOutputFormat;
			if (actualOutputFormat != null && AudioBridge.IsDebugLogging())
			{
				UniLog.Log($"[AudioBridge] Audio device format: {actualOutputFormat.SampleRate}Hz, {actualOutputFormat.Channels}ch, {actualOutputFormat.BitsPerSample}bit", false);
			}
			MMDevice device = val5.Device;
			if (device != (MMDevice)null)
			{
				if (AudioBridge.IsDebugLogging())
				{
					UniLog.Log("[AudioBridge] Audio device: " + device.FriendlyName, false);
				}
				_currentAudioOutput = val5;
				if (AudioBridge.IsEnabled() && AudioBridge.GetCurrentMuteTarget() == MuteTarget.Host)
				{
					UniLog.Log("[AudioBridge] Applying Host mute configuration on audio start", false);
					ApplyMuteConfiguration(shouldMute: true);
				}
			}
		}
		catch (global::System.Exception ex2)
		{
			AudioBridge.Err("Audio start error: " + ex2.Message);
		}
	}

	internal static bool TryApplyMuteConfiguration(bool shouldMute)
	{
		if (_currentAudioOutput == null || _currentAudioOutput.Device == (MMDevice)null)
		{
			UniLog.Log("[AudioBridge] No audio device available to mute/unmute yet", false);
			return false;
		}
		ApplyMuteConfiguration(shouldMute);
		return true;
	}

	internal static void ApplyMuteConfiguration(bool shouldMute)
	{
		_shouldMuteHostAudio = shouldMute;
		UniLog.Log("[AudioBridge] Host audio buffer muting " + (shouldMute ? "enabled" : "disabled"), false);
		if (_currentAudioOutput == null || _currentAudioOutput.Device == (MMDevice)null)
		{
			UniLog.Log("[AudioBridge] No audio device available for session muting (buffer muting will still work)", false);
			return;
		}
		try
		{
			AudioSessionManager2 val = AudioSessionManager2.FromMMDevice(_currentAudioOutput.Device);
			try
			{
				AudioSessionEnumerator sessionEnumerator = val.GetSessionEnumerator();
				try
				{
					uint id = (uint)Process.GetCurrentProcess().Id;
					bool flag = false;
					global::System.Collections.Generic.IEnumerator<AudioSessionControl> enumerator = sessionEnumerator.GetEnumerator();
					try
					{
						while (((global::System.Collections.IEnumerator)enumerator).MoveNext())
						{
							AudioSessionControl current = enumerator.Current;
							AudioSessionControl2 val2 = ((ComObject)current).QueryInterface<AudioSessionControl2>();
							try
							{
								if (val2.ProcessID != id)
								{
									continue;
								}
								flag = true;
								SimpleAudioVolume val3 = ((ComObject)current).QueryInterface<SimpleAudioVolume>();
								try
								{
									val3.MasterVolume = (shouldMute ? 0f : 1f);
									_isMuted = shouldMute;
									if (AudioBridge.IsDebugLogging())
									{
										UniLog.Log($"[AudioBridge] Host audio session found for PID {id}, {(shouldMute ? "muted" : "unmuted")} at session level", false);
									}
									if (AudioBridge.IsDebugLogging())
									{
										try
										{
											string sessionIdentifier = val2.SessionIdentifier;
											string displayName = ((AudioSessionControl)val2).DisplayName;
											UniLog.Log("[AudioBridge] Session details - ID: " + sessionIdentifier + ", Name: " + displayName, false);
										}
										catch
										{
										}
									}
								}
								finally
								{
									((global::System.IDisposable)val3)?.Dispose();
								}
								break;
							}
							finally
							{
								((global::System.IDisposable)val2)?.Dispose();
							}
						}
					}
					finally
					{
						((global::System.IDisposable)enumerator)?.Dispose();
					}
					if (!flag && AudioBridge.IsDebugLogging())
					{
						UniLog.Log($"[AudioBridge] No audio session found for PID {id}, using buffer-level muting only", false);
					}
				}
				finally
				{
					((global::System.IDisposable)sessionEnumerator)?.Dispose();
				}
			}
			finally
			{
				((global::System.IDisposable)val)?.Dispose();
			}
		}
		catch (global::System.Exception ex)
		{
			AudioBridge.Err("Session muting failed (buffer muting still active): " + ex.Message);
		}
	}

	internal static void ResetState()
	{
		UniLog.Log("[AudioBridge] Resetting audio writer state", false);
		_busInitialized = false;
		_isMuted = false;
		_loggedFormat = false;
		_loggedByte = false;
		_loggedAuto = false;
		_writeCounter = 0;
	}
}
public static class PluginMetadata
{
	public const string GUID = "knackrack615.audiobridge";

	public const string NAME = "AudioBridge";

	public const string VERSION = "2.0.0";

	public const string AUTHORS = "Knackrack615";

	public const string REPOSITORY_URL = "https://github.com/knackrack615/AudioBridge";
}