using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
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 CSCore;
using CSCore.CoreAudioAPI;
using CSCore.SoundIn;
using CSCore.SoundOut;
using CSCore.Streams;
using Steamworks;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("DEPOVoiceChat")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("DEPOVoiceChat")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("04bd0ec2-8038-494e-a523-c810f2f5b373")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace DEPOVoiceChat;

public static class Localization
{
	public enum Language
	{
		English,
		Russian,
		Spanish,
		French,
		Chinese,
		Japanese
	}

	private static readonly Dictionary<string, Dictionary<Language, string>> texts = new Dictionary<string, Dictionary<Language, string>>
	{
		{
			"connected_clients",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Connected clients:"
				},
				{
					Language.Russian,
					"Подключено клиентов:"
				},
				{
					Language.Spanish,
					"Clientes conectados:"
				},
				{
					Language.Chinese,
					"已连接的客户端："
				},
				{
					Language.Japanese,
					"接続中のクライアント："
				},
				{
					Language.French,
					"Clients connectés :"
				}
			}
		},
		{
			"volume_players",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Volume players"
				},
				{
					Language.Russian,
					"Громкость игроков"
				},
				{
					Language.Spanish,
					"Volumen de jugadores"
				},
				{
					Language.Chinese,
					"玩家音量"
				},
				{
					Language.Japanese,
					"プレイヤーの音量"
				},
				{
					Language.French,
					"Volume des joueurs"
				}
			}
		},
		{
			"volume_microphone",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Volume microphone"
				},
				{
					Language.Russian,
					"Громкость микрофона"
				},
				{
					Language.Spanish,
					"Volumen del micrófono"
				},
				{
					Language.Chinese,
					"麦克风音量"
				},
				{
					Language.Japanese,
					"マイクの音量"
				},
				{
					Language.French,
					"Volume du micro"
				}
			}
		},
		{
			"hear_myself",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Hear myself"
				},
				{
					Language.Russian,
					"Слушать себя"
				},
				{
					Language.Spanish,
					"Escucharme a mí mismo"
				},
				{
					Language.Chinese,
					"听自己的声音"
				},
				{
					Language.Japanese,
					"自分の声を聞く"
				},
				{
					Language.French,
					"S'entendre soi-même"
				}
			}
		},
		{
			"select_microphone",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Select microphone"
				},
				{
					Language.Russian,
					"Выбрать микрофон"
				},
				{
					Language.Spanish,
					"Seleccionar micrófono"
				},
				{
					Language.Chinese,
					"选择麦克风"
				},
				{
					Language.Japanese,
					"マイクを選択"
				},
				{
					Language.French,
					"Sélectionner le micro"
				}
			}
		},
		{
			"keybinds",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Keybinds:"
				},
				{
					Language.Russian,
					"Назначение клавиш:"
				},
				{
					Language.Spanish,
					"Asignación de teclas:"
				},
				{
					Language.Chinese,
					"按键绑定："
				},
				{
					Language.Japanese,
					"キー割り当て："
				},
				{
					Language.French,
					"Raccourcis clavier :"
				}
			}
		},
		{
			"open_close_menu",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Open/Close menu"
				},
				{
					Language.Russian,
					"Открыть/Закрыть меню"
				},
				{
					Language.Spanish,
					"Abrir/Cerrar menú"
				},
				{
					Language.Chinese,
					"打开/关闭菜单"
				},
				{
					Language.Japanese,
					"メニューを開閉"
				},
				{
					Language.French,
					"Ouvrir/Fermer le menu"
				}
			}
		},
		{
			"push_to_talk",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Push-to-talk"
				},
				{
					Language.Russian,
					"Нажать, чтобы разговаривать"
				},
				{
					Language.Spanish,
					"Pulsar para hablar"
				},
				{
					Language.Chinese,
					"按键发言"
				},
				{
					Language.Japanese,
					"プッシュ・トゥ・トーク"
				},
				{
					Language.French,
					"Appuyer pour parler"
				}
			}
		},
		{
			"close",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Close"
				},
				{
					Language.Russian,
					"Закрыть"
				},
				{
					Language.Spanish,
					"Cerrar"
				},
				{
					Language.Chinese,
					"关闭"
				},
				{
					Language.Japanese,
					"閉じる"
				},
				{
					Language.French,
					"Fermer"
				}
			}
		},
		{
			"microphone_mode",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Microphone mode:"
				},
				{
					Language.Russian,
					"Режим микрофона:"
				},
				{
					Language.Spanish,
					"Modo micrófono:"
				},
				{
					Language.Chinese,
					"麦克风模式："
				},
				{
					Language.Japanese,
					"マイクモード："
				},
				{
					Language.French,
					"Mode micro :"
				}
			}
		},
		{
			"threshold",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Voice threshold"
				},
				{
					Language.Russian,
					"Порог громкости"
				},
				{
					Language.Spanish,
					"Umbral de voz"
				},
				{
					Language.Chinese,
					"语音激活阈值"
				},
				{
					Language.Japanese,
					"音声認識しきい値"
				},
				{
					Language.French,
					"Seuil de voix"
				}
			}
		},
		{
			"voicechat_menu",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Voicechat Menu"
				},
				{
					Language.Russian,
					"Меню голосового чата"
				},
				{
					Language.Spanish,
					"Menú de Voicechat"
				},
				{
					Language.Chinese,
					"语音聊天菜单"
				},
				{
					Language.Japanese,
					"ボイスチャットメニュー"
				},
				{
					Language.French,
					"Menu de chat vocal"
				}
			}
		},
		{
			"voice_activation",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Voice Activation"
				},
				{
					Language.Russian,
					"Активация голосом"
				},
				{
					Language.Spanish,
					"Activación por voz"
				},
				{
					Language.Chinese,
					"语音激活"
				},
				{
					Language.Japanese,
					"音声アクティベーション"
				},
				{
					Language.French,
					"Activation vocale"
				}
			}
		},
		{
			"buffer_size",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Buffer size (ms)"
				},
				{
					Language.Russian,
					"Размер буфера (мс)"
				},
				{
					Language.Spanish,
					"Tamaño del búfer (ms)"
				},
				{
					Language.Chinese,
					"缓冲区大小（毫秒）"
				},
				{
					Language.Japanese,
					"バッファサイズ（ms）"
				},
				{
					Language.French,
					"Taille du tampon (ms)"
				}
			}
		},
		{
			"buffer_current",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Current buffer:"
				},
				{
					Language.Russian,
					"Текущий буфер:"
				},
				{
					Language.Spanish,
					"Búfer actual:"
				},
				{
					Language.Chinese,
					"当前缓冲："
				},
				{
					Language.Japanese,
					"現在のバッファ："
				},
				{
					Language.French,
					"Tampon actuel :"
				}
			}
		},
		{
			"language",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Language"
				},
				{
					Language.Russian,
					"Язык"
				},
				{
					Language.Spanish,
					"Idioma"
				},
				{
					Language.Chinese,
					"语言"
				},
				{
					Language.Japanese,
					"言語"
				},
				{
					Language.French,
					"Langue"
				}
			}
		},
		{
			"speaking",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Speaking..."
				},
				{
					Language.Russian,
					"Говорит..."
				},
				{
					Language.Spanish,
					"Hablando..."
				},
				{
					Language.Chinese,
					"正在讲话..."
				},
				{
					Language.Japanese,
					"話しています..."
				},
				{
					Language.French,
					"Parle..."
				}
			}
		}
	};

	public static Language CurrentLanguage { get; private set; } = Language.English;


	public static string T(string key)
	{
		if (texts.TryGetValue(key, out var value) && value.TryGetValue(CurrentLanguage, out var value2))
		{
			return value2;
		}
		return key;
	}

	public static void SetLanguage(string lang)
	{
		switch (lang)
		{
		case "English":
			CurrentLanguage = Language.English;
			break;
		case "Russian (Русский)":
			CurrentLanguage = Language.Russian;
			break;
		case "Spanish (Español)":
			CurrentLanguage = Language.Spanish;
			break;
		case "French (Français)":
			CurrentLanguage = Language.French;
			break;
		case "Chinese (中文)":
			CurrentLanguage = Language.Chinese;
			break;
		case "Japanese (日本語)":
			CurrentLanguage = Language.Japanese;
			break;
		default:
			CurrentLanguage = Language.English;
			break;
		}
	}
}
[BepInPlugin("ru.makorddev.depovoicechat", "Voicechat", "1.0.0")]
public class Main : BaseUnityPlugin
{
	public static IPEndPoint ServerEP;

	private readonly CancellationTokenSource cts = new CancellationTokenSource();

	private UI ui;

	private async void Awake()
	{
		Debug.Log((object)"[VoiceChat] VoiceChat loaded.");
		try
		{
			IPAddress[] addr = null;
			int retries = 3;
			while (retries-- > 0)
			{
				try
				{
					addr = await Dns.GetHostAddressesAsync("busiatep.ru");
					if (addr.Length != 0)
					{
						break;
					}
				}
				catch
				{
					await Task.Delay(1000);
				}
			}
			if (addr == null || addr.Length == 0)
			{
				Debug.LogError((object)"[VoiceChat] DNS failed after retries.");
				ServerEP = new IPEndPoint(IPAddress.Loopback, 6001);
			}
			else
			{
				ServerEP = new IPEndPoint(addr[0], 6001);
			}
		}
		catch (Exception ex)
		{
			Debug.LogError((object)("[VoiceChat] DNS exception: " + ex));
			ServerEP = new IPEndPoint(IPAddress.Loopback, 6001);
		}
		try
		{
			SettingsManager.Load();
		}
		catch
		{
			Debug.LogError((object)"[VoiceChat] Failed to load settings.");
		}
		try
		{
			VoiceManager.InitDevices();
		}
		catch
		{
			Debug.LogError((object)"[VoiceChat] Failed to init devices.");
		}
		InitializeSteam();
		SceneManager.activeSceneChanged += OnSceneChanged;
		try
		{
			Localization.SetLanguage(SettingsManager.CurrentSettings.language);
		}
		catch
		{
			Debug.LogWarning((object)"[VoiceChat] Failed to set language.");
		}
		GameObject uiObj = new GameObject("VoiceChatUI");
		ui = uiObj.AddComponent<UI>();
		Object.DontDestroyOnLoad((Object)(object)uiObj);
	}

	private async void Start()
	{
		VoiceManager.SetInstanceId(Guid.NewGuid().ToString());
		bool connected = false;
		int attempts = 3;
		while (!connected && attempts-- > 0)
		{
			try
			{
				connected = await NetworkManager.Connect();
			}
			catch (Exception ex)
			{
				Debug.LogWarning((object)("[VoiceChat] Connect attempt failed: " + ex));
			}
			if (!connected)
			{
				await Task.Delay(2000);
			}
		}
		if (!connected)
		{
			Debug.LogError((object)"[VoiceChat] Failed to connect to server after retries.");
			return;
		}
		NetworkManager.OnReconnected += delegate
		{
			try
			{
				VoiceManager.RestartUdp();
			}
			catch (Exception ex4)
			{
				Debug.LogWarning((object)("[VoiceChat] Failed to restart UDP: " + ex4));
			}
		};
		try
		{
			if (VoiceManager.MicDevices.Length != 0)
			{
				int idx = Mathf.Clamp(SettingsManager.CurrentSettings.selectedMicIndex, 0, VoiceManager.MicDevices.Length - 1);
				VoiceManager.StartCapture(idx);
			}
		}
		catch (Exception ex2)
		{
			Debug.LogError((object)("[VoiceChat] Failed to start mic capture: " + ex2));
		}
		try
		{
			await VoiceManager.StartReceiving(cts.Token);
		}
		catch (Exception ex3)
		{
			Debug.LogError((object)("[VoiceChat] Failed to start receiving voice: " + ex3));
		}
	}

	private void OnDestroy()
	{
		try
		{
			cts?.Cancel();
		}
		catch
		{
		}
		try
		{
			NetworkManager.Disconnect();
		}
		catch
		{
		}
		try
		{
			VoiceManager.StopCapture();
		}
		catch
		{
		}
		try
		{
			VoiceManager.StopReceiving();
		}
		catch
		{
		}
		try
		{
			VoiceManager.StopVoiceStream();
		}
		catch
		{
		}
		GameObject val = GameObject.Find("Dispatcher");
		if ((Object)(object)val != (Object)null)
		{
			try
			{
				Object.Destroy((Object)(object)val);
			}
			catch
			{
			}
		}
	}

	private void Update()
	{
		try
		{
			SpeakingIndicator.UpdateSpeakingIndicators();
			ui?.UpdateUI();
		}
		catch (Exception ex)
		{
			Debug.LogError((object)("[VoiceChat] Update error: " + ex));
		}
	}

	private void OnGUI()
	{
		ui?.DrawUI();
	}

	private void OnSceneChanged(Scene oldScene, Scene newScene)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Expected O, but got Unknown
		Task.Run(async delegate
		{
			try
			{
				string msg = $"INFO|{SteamUser.GetSteamID().m_SteamID}|{SteamFriends.GetPersonaName()}|{((Scene)(ref newScene)).name}";
				await NetworkManager.SendMessage(msg);
			}
			catch
			{
				Debug.LogWarning((object)"[VoiceChat] Failed to send scene info.");
			}
		});
		if ((Object)(object)GameObject.Find("Dispatcher") == (Object)null)
		{
			GameObject val = new GameObject("Dispatcher");
			try
			{
				val.AddComponent<UnityMainThreadDispatcher>();
			}
			catch
			{
			}
			Object.DontDestroyOnLoad((Object)(object)val);
		}
	}

	private void InitializeSteam()
	{
		try
		{
			if (!SteamAPI.Init())
			{
				Debug.LogError((object)"[VoiceChat] SteamAPI init failed!");
			}
		}
		catch (Exception ex)
		{
			Debug.LogError((object)("[VoiceChat] SteamAPI exception: " + ex));
		}
	}
}
public static class NetworkManager
{
	public enum ConnectionState
	{
		Disconnected,
		Connecting,
		Connected
	}

	private static TcpClient tcpClient;

	private static NetworkStream stream;

	private static CancellationTokenSource cts;

	private static CancellationTokenSource monitorCts;

	private static readonly string serverIp = "busiatep.ru";

	private static readonly int serverPort = 6000;

	private static readonly int heartbeatInterval = 5000;

	private static string lastMessage = "";

	private static readonly object msgLock = new object();

	private static bool reconnecting = false;

	public static ConnectionState State { get; private set; } = ConnectionState.Disconnected;


	public static Dictionary<string, string> ClientList { get; private set; } = new Dictionary<string, string>();


	public static TcpClient Client => tcpClient;

	public static NetworkStream Stream => stream;

	public static event Action OnReconnected;

	public static async Task<bool> Connect()
	{
		if (State == ConnectionState.Connecting || State == ConnectionState.Connected)
		{
			return State == ConnectionState.Connected;
		}
		State = ConnectionState.Connecting;
		Cleanup();
		cts = new CancellationTokenSource();
		CancellationToken token = cts.Token;
		try
		{
			tcpClient = new TcpClient();
			await tcpClient.ConnectAsync(serverIp, serverPort);
			stream = tcpClient.GetStream();
			Debug.Log((object)"[VoiceChat] TCP connected.");
			object arg = SteamUser.GetSteamID().m_SteamID;
			string personaName = SteamFriends.GetPersonaName();
			Scene activeScene = SceneManager.GetActiveScene();
			string info = $"INFO|{arg}|{personaName}|{((Scene)(ref activeScene)).name}";
			await SendMessage(info);
			if (!(await WaitForResponse("CLIENTS|", 2000)))
			{
				Debug.LogWarning((object)"[VoiceChat] CLIENTS response timeout.");
			}
			Task.Run(() => HeartbeatLoop(token), token);
			Task.Run(() => ReceiveLoop(token), token);
			State = ConnectionState.Connected;
			StartMonitor();
			return true;
		}
		catch (Exception ex)
		{
			Debug.LogError((object)("[VoiceChat] Connect error: " + ex));
			Disconnect();
			StartReconnectLoop();
			return false;
		}
	}

	private static void StartMonitor()
	{
		monitorCts?.Cancel();
		monitorCts = new CancellationTokenSource();
		CancellationToken token = monitorCts.Token;
		Task.Run(async delegate
		{
			while (!token.IsCancellationRequested)
			{
				try
				{
					await Task.Delay(3000, token);
					if (State != ConnectionState.Connected && !reconnecting)
					{
						Debug.LogWarning((object)"[VoiceChat] Connection lost. Trying to reconnect...");
						StartReconnectLoop();
					}
				}
				catch (TaskCanceledException)
				{
					break;
				}
				catch (Exception ex2)
				{
					Debug.LogError((object)("[VoiceChat] Monitor error: " + ex2));
				}
			}
		}, token);
	}

	private static void StartReconnectLoop()
	{
		if (reconnecting)
		{
			return;
		}
		reconnecting = true;
		Task.Run(async delegate
		{
			int delay = 3000;
			while (State != ConnectionState.Connected)
			{
				Debug.Log((object)$"[VoiceChat] Reconnecting in {delay / 1000}s...");
				await Task.Delay(delay);
				if (await Connect())
				{
					reconnecting = false;
					NetworkManager.OnReconnected?.Invoke();
					return;
				}
				delay = Math.Min(delay + 3000, 10000);
			}
			reconnecting = false;
		});
	}

	public static async Task SendMessage(string msg)
	{
		if (tcpClient != null && tcpClient.Connected)
		{
			byte[] data = Encoding.UTF8.GetBytes(msg);
			try
			{
				await stream.WriteAsync(data, 0, data.Length);
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[VoiceChat] Failed to send TCP message: " + ex));
				Disconnect();
				StartReconnectLoop();
			}
		}
		else if (!reconnecting)
		{
			StartReconnectLoop();
		}
	}

	private static async Task HeartbeatLoop(CancellationToken token)
	{
		try
		{
			while (!token.IsCancellationRequested)
			{
				await Task.Delay(heartbeatInterval, token).ContinueWith(delegate
				{
				});
				if (token.IsCancellationRequested)
				{
					break;
				}
				await SendMessage("HEARTBEAT");
			}
		}
		catch (TaskCanceledException)
		{
		}
		catch (Exception ex2)
		{
			Debug.LogError((object)("[VoiceChat] HeartbeatLoop error: " + ex2));
		}
	}

	private static async Task ReceiveLoop(CancellationToken token)
	{
		byte[] buffer = new byte[4096];
		try
		{
			while (!token.IsCancellationRequested)
			{
				int read = await stream.ReadAsync(buffer, 0, buffer.Length, token);
				if (read == 0)
				{
					break;
				}
				string message = Encoding.UTF8.GetString(buffer, 0, read);
				HandleServerMessage(message);
			}
		}
		catch (TaskCanceledException)
		{
		}
		catch (Exception ex2)
		{
			Debug.LogWarning((object)("[VoiceChat] ReceiveLoop error: " + ex2));
		}
		finally
		{
			Debug.LogWarning((object)"[VoiceChat] TCP connection lost. Disconnecting...");
			Disconnect();
			StartReconnectLoop();
		}
	}

	private static void HandleServerMessage(string message)
	{
		//IL_010f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0114: Unknown result type (might be due to invalid IL or missing references)
		lock (msgLock)
		{
			lastMessage = message;
		}
		try
		{
			if (message.StartsWith("CLIENTS"))
			{
				ClientList.Clear();
				string[] array = message.Split(new char[1] { '|' });
				if (array.Length <= 1)
				{
					return;
				}
				string[] array2 = array[1].Split(new char[1] { ',' });
				foreach (string text in array2)
				{
					string[] array3 = text.Split(new char[1] { ':' });
					if (array3.Length == 2)
					{
						ClientList[array3[0]] = array3[1];
					}
				}
			}
			else
			{
				if (!message.StartsWith("SPEAKING|"))
				{
					return;
				}
				string[] array4 = message.Split(new char[1] { '|' });
				if (array4.Length == 4)
				{
					string text2 = array4[1];
					string name = array4[2];
					Scene activeScene = SceneManager.GetActiveScene();
					if (((Scene)(ref activeScene)).name == text2)
					{
						VoiceManager.AllowScenePlayback(text2, name);
					}
				}
			}
		}
		catch (Exception ex)
		{
			Debug.LogWarning((object)("[VoiceChat] HandleServerMessage error: " + ex));
		}
	}

	public static async Task<bool> WaitForResponse(string expected, int timeoutMs)
	{
		int waited = 0;
		while (waited < timeoutMs)
		{
			string msg;
			lock (msgLock)
			{
				msg = lastMessage;
			}
			if (msg.Contains(expected))
			{
				return true;
			}
			await Task.Delay(10);
			waited += 10;
			msg = null;
		}
		return false;
	}

	public static void Disconnect()
	{
		try
		{
			State = ConnectionState.Disconnected;
			cts?.Cancel();
			monitorCts?.Cancel();
			stream?.Close();
			tcpClient?.Close();
			tcpClient = null;
			stream = null;
			cts = null;
			monitorCts = null;
		}
		catch
		{
		}
	}

	private static void Cleanup()
	{
		try
		{
			cts?.Cancel();
			monitorCts?.Cancel();
			stream?.Close();
			tcpClient?.Close();
			tcpClient = null;
			stream = null;
			cts = null;
			monitorCts = null;
		}
		catch
		{
		}
	}
}
public enum MicMode
{
	PushToTalk,
	VoiceActivation
}
[Serializable]
public class VoiceSettings
{
	public float selfVolume = 1f;

	public float playersVolume = 1f;

	public bool hearSelf = false;

	public int selectedMicIndex = 0;

	public KeyCode menuToggleKey = (KeyCode)113;

	public KeyCode pushToTalkKey = (KeyCode)114;

	public MicMode micMode = MicMode.PushToTalk;

	public float voiceThresholdDb = -5f;

	public string language = "English";

	public int bufferSizeMs = 20;
}
public static class SettingsManager
{
	private static readonly string settingsPath = Path.Combine(Application.persistentDataPath, "voicechat_settings.json");

	public static VoiceSettings CurrentSettings { get; private set; } = new VoiceSettings();


	public static void Load()
	{
		if (File.Exists(settingsPath))
		{
			try
			{
				string text = File.ReadAllText(settingsPath);
				CurrentSettings = JsonUtility.FromJson<VoiceSettings>(text);
			}
			catch
			{
				CurrentSettings = new VoiceSettings();
			}
		}
		Localization.SetLanguage(CurrentSettings.language);
	}

	public static void Save()
	{
		try
		{
			string contents = JsonUtility.ToJson((object)CurrentSettings, true);
			File.WriteAllText(settingsPath, contents);
		}
		catch
		{
		}
	}
}
public class SpeakingIndicator : MonoBehaviour
{
	public static readonly Dictionary<string, float> speakingPlayers = new Dictionary<string, float>();

	public static readonly Dictionary<string, Coroutine> activeCoroutines = new Dictionary<string, Coroutine>();

	public static readonly object lockObj = new object();

	public static string speakText = "[" + Localization.T("speaking") + "]";

	private static string oldSpeakText;

	private const float silenceTimeout = 1f;

	public static void UpdateSpeakingIndicators()
	{
		float time = Time.time;
		List<string> list = new List<string>();
		if (speakText != "[" + Localization.T("speaking") + "]")
		{
			UpdateSpeakText();
		}
		lock (lockObj)
		{
			foreach (KeyValuePair<string, float> speakingPlayer in speakingPlayers)
			{
				if (time - speakingPlayer.Value > 1f)
				{
					list.Add(speakingPlayer.Key);
				}
			}
			foreach (string item in list)
			{
				speakingPlayers.Remove(item);
			}
		}
		foreach (string item2 in list)
		{
			RemoveIndicator(item2);
		}
	}

	public static void UpdateSpeakText()
	{
		oldSpeakText = speakText;
		speakText = "[" + Localization.T("speaking") + "]";
		UnityMainThreadDispatcher.Enqueue(delegate
		{
			Text[] array = Object.FindObjectsOfType<Text>(true);
			Text[] array2 = array;
			foreach (Text val in array2)
			{
				if (!string.IsNullOrEmpty(oldSpeakText) && val.text.Contains(oldSpeakText))
				{
					val.text = val.text.Replace(oldSpeakText, speakText);
				}
			}
		});
	}

	public static void OnPlayerSpeaking(string name)
	{
		if (string.IsNullOrEmpty(name))
		{
			Debug.LogWarning((object)"[SpeakingIndicator] OnPlayerSpeaking called with null or empty name");
			return;
		}
		bool flag = false;
		lock (lockObj)
		{
			speakingPlayers[name] = Time.time;
			if (!activeCoroutines.ContainsKey(name))
			{
				flag = true;
			}
		}
		if (!flag)
		{
			return;
		}
		UnityMainThreadDispatcher.Enqueue(delegate
		{
			Coroutine value = StartAddIndicatorCoroutine(name);
			lock (lockObj)
			{
				activeCoroutines[name] = value;
			}
		});
	}

	private static Coroutine StartAddIndicatorCoroutine(string playerName)
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Expected O, but got Unknown
		GameObject val = new GameObject("DispatcherCoroutine_" + playerName);
		DispatcherCoroutineRunner dispatcherCoroutineRunner = val.AddComponent<DispatcherCoroutineRunner>();
		return ((MonoBehaviour)dispatcherCoroutineRunner).StartCoroutine(dispatcherCoroutineRunner.AddIndicatorCoroutine(playerName));
	}

	private static void RemoveIndicator(string playerName)
	{
		UnityMainThreadDispatcher.Enqueue(delegate
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			GameObject val = new GameObject("DispatcherRemove_" + playerName);
			DispatcherCoroutineRunner dispatcherCoroutineRunner = val.AddComponent<DispatcherCoroutineRunner>();
			((MonoBehaviour)dispatcherCoroutineRunner).StartCoroutine(dispatcherCoroutineRunner.RemoveIndicatorCoroutine(playerName));
		});
	}

	public static Text FindTextForPlayer(string playerName)
	{
		Text[] source = Object.FindObjectsOfType<Text>(true);
		Text val = ((IEnumerable<Text>)source).FirstOrDefault((Func<Text, bool>)((Text t) => ((Object)t).name.Contains("NameJugador") && t.text.Contains(playerName)));
		if ((Object)(object)val == (Object)null)
		{
			Debug.LogWarning((object)("[SpeakingIndicator] FindTextForPlayer: Could not find Text for '" + playerName + "'"));
		}
		return val;
	}
}
public class DispatcherCoroutineRunner : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <AddIndicatorCoroutine>d__0 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public string playerName;

		public DispatcherCoroutineRunner <>4__this;

		private Text <playerText>5__1;

		private Outline <outline>5__2;

		private bool <stillSpeaking>5__3;

		private object <>s__4;

		private bool <>s__5;

		private object <>s__6;

		private bool <>s__7;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <AddIndicatorCoroutine>d__0(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<playerText>5__1 = null;
			<outline>5__2 = null;
			<>s__4 = null;
			<>s__6 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Expected O, but got Unknown
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<playerText>5__1 = SpeakingIndicator.FindTextForPlayer(playerName);
				if ((Object)(object)<playerText>5__1 == (Object)null)
				{
					return false;
				}
				if (!<playerText>5__1.text.Contains(SpeakingIndicator.speakText))
				{
					Text obj = <playerText>5__1;
					obj.text = obj.text + " " + SpeakingIndicator.speakText;
				}
				<outline>5__2 = ((Component)<playerText>5__1).GetComponent<Outline>();
				if ((Object)(object)<outline>5__2 != (Object)null)
				{
					((Behaviour)<outline>5__2).enabled = false;
					<>2__current = (object)new WaitForSeconds(0.01f);
					<>1__state = 1;
					return true;
				}
				goto IL_0180;
			case 1:
				<>1__state = -1;
				((Behaviour)<outline>5__2).enabled = true;
				goto IL_0180;
			case 2:
				<>1__state = -1;
				goto IL_0180;
			case 3:
				{
					<>1__state = -1;
					((Behaviour)<outline>5__2).enabled = true;
					break;
				}
				IL_0180:
				<>s__4 = SpeakingIndicator.lockObj;
				<>s__5 = false;
				try
				{
					Monitor.Enter(<>s__4, ref <>s__5);
					<stillSpeaking>5__3 = SpeakingIndicator.speakingPlayers.ContainsKey(playerName);
				}
				finally
				{
					if (<>s__5)
					{
						Monitor.Exit(<>s__4);
					}
				}
				<>s__4 = null;
				if (<stillSpeaking>5__3)
				{
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				if ((Object)(object)<playerText>5__1 != (Object)null && <playerText>5__1.text.Contains(SpeakingIndicator.speakText))
				{
					<playerText>5__1.text = <playerText>5__1.text.Replace(" " + SpeakingIndicator.speakText, "");
				}
				if ((Object)(object)<outline>5__2 != (Object)null)
				{
					((Behaviour)<outline>5__2).enabled = false;
					<>2__current = (object)new WaitForSeconds(0.01f);
					<>1__state = 3;
					return true;
				}
				break;
			}
			<>s__6 = SpeakingIndicator.lockObj;
			<>s__7 = false;
			try
			{
				Monitor.Enter(<>s__6, ref <>s__7);
				SpeakingIndicator.activeCoroutines.Remove(playerName);
			}
			finally
			{
				if (<>s__7)
				{
					Monitor.Exit(<>s__6);
				}
			}
			<>s__6 = null;
			VoiceManager.RemoveFromSpeaking(playerName);
			Object.Destroy((Object)(object)((Component)<>4__this).gameObject);
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <RemoveIndicatorCoroutine>d__1 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public string playerName;

		public DispatcherCoroutineRunner <>4__this;

		private Text <playerText>5__1;

		private Outline <outline>5__2;

		private object <>s__3;

		private bool <>s__4;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <RemoveIndicatorCoroutine>d__1(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<playerText>5__1 = null;
			<outline>5__2 = null;
			<>s__3 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
			{
				<>1__state = -1;
				<playerText>5__1 = SpeakingIndicator.FindTextForPlayer(playerName);
				if ((Object)(object)<playerText>5__1 != (Object)null && <playerText>5__1.text.Contains(SpeakingIndicator.speakText))
				{
					<playerText>5__1.text = <playerText>5__1.text.Replace(" " + SpeakingIndicator.speakText, "");
				}
				Text obj = <playerText>5__1;
				<outline>5__2 = ((obj != null) ? ((Component)obj).GetComponent<Outline>() : null);
				if ((Object)(object)<outline>5__2 != (Object)null)
				{
					((Behaviour)<outline>5__2).enabled = false;
					<>2__current = (object)new WaitForSeconds(0.01f);
					<>1__state = 1;
					return true;
				}
				break;
			}
			case 1:
				<>1__state = -1;
				((Behaviour)<outline>5__2).enabled = true;
				break;
			}
			<>s__3 = SpeakingIndicator.lockObj;
			<>s__4 = false;
			try
			{
				Monitor.Enter(<>s__3, ref <>s__4);
				SpeakingIndicator.activeCoroutines.Remove(playerName);
			}
			finally
			{
				if (<>s__4)
				{
					Monitor.Exit(<>s__3);
				}
			}
			<>s__3 = null;
			VoiceManager.RemoveFromSpeaking(playerName);
			Object.Destroy((Object)(object)((Component)<>4__this).gameObject);
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[IteratorStateMachine(typeof(<AddIndicatorCoroutine>d__0))]
	public IEnumerator AddIndicatorCoroutine(string playerName)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <AddIndicatorCoroutine>d__0(0)
		{
			<>4__this = this,
			playerName = playerName
		};
	}

	[IteratorStateMachine(typeof(<RemoveIndicatorCoroutine>d__1))]
	public IEnumerator RemoveIndicatorCoroutine(string playerName)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <RemoveIndicatorCoroutine>d__1(0)
		{
			<>4__this = this,
			playerName = playerName
		};
	}
}
public class UI : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <WaitForKeyPressed>d__17 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Action<KeyCode> callback;

		public UI <>4__this;

		private IEnumerator <>s__1;

		private KeyCode <kcode>5__2;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <WaitForKeyPressed>d__17(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>s__1 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//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)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.waitingKey = true;
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (<>4__this.waitingKey)
			{
				<>s__1 = Enum.GetValues(typeof(KeyCode)).GetEnumerator();
				try
				{
					while (<>s__1.MoveNext())
					{
						<kcode>5__2 = (KeyCode)<>s__1.Current;
						if (Input.GetKeyDown(<kcode>5__2))
						{
							callback(<kcode>5__2);
							SettingsManager.Save();
							<>4__this.waitingKey = false;
							break;
						}
					}
				}
				finally
				{
					if (<>s__1 is IDisposable disposable)
					{
						disposable.Dispose();
					}
				}
				<>s__1 = null;
				<>2__current = null;
				<>1__state = 1;
				return true;
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	private bool waitingKey = false;

	private readonly CancellationTokenSource cts = new CancellationTokenSource();

	public bool ShowMenu { get; set; } = false;


	public Rect MenuRect { get; set; } = new Rect((float)(Screen.width - 500), 100f, 400f, 600f);


	public bool MicDropdownOpen { get; set; } = false;


	public void UpdateUI()
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		Scene activeScene = SceneManager.GetActiveScene();
		if (!(((Scene)(ref activeScene)).name != "menus"))
		{
			return;
		}
		if (Input.GetKeyDown(SettingsManager.CurrentSettings.menuToggleKey))
		{
			ShowMenu = !ShowMenu;
			if (!ShowMenu)
			{
				MicDropdownOpen = false;
			}
		}
		if (SettingsManager.CurrentSettings.micMode == MicMode.PushToTalk)
		{
			if (Input.GetKeyDown(SettingsManager.CurrentSettings.pushToTalkKey))
			{
				VoiceManager.StartVoiceStream(cts.Token);
			}
			if (Input.GetKeyUp(SettingsManager.CurrentSettings.pushToTalkKey))
			{
				VoiceManager.StopVoiceStream();
			}
		}
	}

	public void DrawUI()
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_0048: Expected O, but got Unknown
		//IL_0043: 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_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: Invalid comparison between Unknown and I4
		//IL_0089: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: Invalid comparison between Unknown and I4
		if (ShowMenu)
		{
			GUI.color = Color.white;
			GUI.enabled = true;
			MenuRect = GUI.Window(0, MenuRect, new WindowFunction(DrawClientMenu), Localization.T("voicechat_menu"));
			Rect menuRect = MenuRect;
			if (((Rect)(ref menuRect)).Contains(Event.current.mousePosition) && ((int)Event.current.type == 0 || (int)Event.current.type == 1 || (int)Event.current.type == 3))
			{
				Event.current.Use();
			}
			if (MicDropdownOpen)
			{
				DrawMicDropdown();
			}
		}
	}

	private void DrawMicDropdown()
	{
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: 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_007a: Unknown result type (might be due to invalid IL or missing references)
		float num = 260f;
		float num2 = 24f;
		float num3 = Mathf.Min(num2 * (float)VoiceManager.MicDevices.Length, 6f * num2);
		Rect menuRect = MenuRect;
		float num4 = ((Rect)(ref menuRect)).x - num;
		menuRect = MenuRect;
		float num5 = ((Rect)(ref menuRect)).y + 190f;
		GUI.Box(new Rect(num4, num5, num, num3), "");
		Rect val = default(Rect);
		for (int i = 0; i < VoiceManager.MicDevices.Length; i++)
		{
			((Rect)(ref val))..ctor(num4, num5 + (float)i * num2, num, num2);
			if (GUI.Button(val, VoiceManager.MicDevices[i]))
			{
				SettingsManager.CurrentSettings.selectedMicIndex = i;
				SettingsManager.Save();
				VoiceManager.StopCapture();
				if (SettingsManager.CurrentSettings.hearSelf)
				{
					VoiceManager.StartCapture(i);
				}
				MicDropdownOpen = false;
			}
		}
	}

	[IteratorStateMachine(typeof(<WaitForKeyPressed>d__17))]
	public IEnumerator WaitForKeyPressed(Action<KeyCode> callback)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <WaitForKeyPressed>d__17(0)
		{
			<>4__this = this,
			callback = callback
		};
	}

	private void DrawClientMenu(int windowID)
	{
		//IL_0211: Unknown result type (might be due to invalid IL or missing references)
		//IL_0246: Unknown result type (might be due to invalid IL or missing references)
		GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
		GUILayout.Label(string.Format("{0} {1}", Localization.T("connected_clients"), NetworkManager.ClientList.Count), Array.Empty<GUILayoutOption>());
		GUILayout.Label(Localization.T("volume_players"), Array.Empty<GUILayoutOption>());
		float num = GUILayout.HorizontalSlider(SettingsManager.CurrentSettings.playersVolume, 0f, 1f, Array.Empty<GUILayoutOption>());
		if (Math.Abs(num - SettingsManager.CurrentSettings.playersVolume) > 0.001f)
		{
			SettingsManager.CurrentSettings.playersVolume = num;
			VoiceManager.UpdatePlayersVolume(num);
			SettingsManager.Save();
		}
		GUILayout.Label(Localization.T("volume_microphone"), Array.Empty<GUILayoutOption>());
		float num2 = GUILayout.HorizontalSlider(SettingsManager.CurrentSettings.selfVolume, 0f, 1f, Array.Empty<GUILayoutOption>());
		if (Math.Abs(num2 - SettingsManager.CurrentSettings.selfVolume) > 0.001f)
		{
			SettingsManager.CurrentSettings.selfVolume = num2;
			VoiceManager.UpdateSelfVolume(num2);
			SettingsManager.Save();
		}
		bool flag = GUILayout.Toggle(SettingsManager.CurrentSettings.hearSelf, Localization.T("hear_myself"), Array.Empty<GUILayoutOption>());
		if (flag != SettingsManager.CurrentSettings.hearSelf)
		{
			SettingsManager.CurrentSettings.hearSelf = flag;
			SettingsManager.Save();
			VoiceManager.StopCapture();
			if (flag)
			{
				VoiceManager.StartCapture(SettingsManager.CurrentSettings.selectedMicIndex);
			}
		}
		GUILayout.Space(8f);
		GUILayout.Label(Localization.T("select_microphone"), Array.Empty<GUILayoutOption>());
		if (GUILayout.Button((VoiceManager.MicDevices.Length != 0) ? VoiceManager.MicDevices[SettingsManager.CurrentSettings.selectedMicIndex] : "No microphone", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(260f) }))
		{
			MicDropdownOpen = !MicDropdownOpen;
		}
		GUILayout.Space(8f);
		GUILayout.Label(Localization.T("keybinds"), Array.Empty<GUILayoutOption>());
		DrawKeybind("open_close_menu", SettingsManager.CurrentSettings.menuToggleKey, delegate(KeyCode k)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			SettingsManager.CurrentSettings.menuToggleKey = k;
		});
		DrawKeybind("push_to_talk", SettingsManager.CurrentSettings.pushToTalkKey, delegate(KeyCode k)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			SettingsManager.CurrentSettings.pushToTalkKey = k;
		});
		GUILayout.Space(8f);
		GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		GUILayout.Label(Localization.T("buffer_size"), Array.Empty<GUILayoutOption>());
		int bufferSizeMs = SettingsManager.CurrentSettings.bufferSizeMs;
		int num3 = (int)GUILayout.HorizontalSlider((float)bufferSizeMs, 10f, 100f, Array.Empty<GUILayoutOption>());
		GUILayout.EndHorizontal();
		GUILayout.Label(string.Format("{0} {1} ms", Localization.T("buffer_current"), num3), Array.Empty<GUILayoutOption>());
		if (num3 != bufferSizeMs)
		{
			SettingsManager.CurrentSettings.bufferSizeMs = num3;
			SettingsManager.Save();
		}
		GUILayout.Space(8f);
		GUILayout.Label(Localization.T("language"), Array.Empty<GUILayoutOption>());
		string[] array = new string[6] { "English", "Russian (Русский)", "Spanish (Español)", "French (Français)", "Chinese (中文)", "Japanese (日本語)" };
		int num4 = Array.IndexOf(array, SettingsManager.CurrentSettings.language);
		if (num4 == -1)
		{
			num4 = 0;
		}
		int num5 = 3;
		int num6 = Mathf.CeilToInt((float)array.Length / (float)num5);
		int num7 = num4;
		for (int i = 0; i < num6; i++)
		{
			int num8 = i * num5;
			int num9 = Mathf.Min(num8 + num5, array.Length);
			string[] array2 = new string[num9 - num8];
			Array.Copy(array, num8, array2, 0, array2.Length);
			int num10 = GUILayout.Toolbar(Array.IndexOf(array2, array[num7]), array2, Array.Empty<GUILayoutOption>());
			if (num10 != Array.IndexOf(array2, array[num7]))
			{
				num7 = num8 + num10;
			}
		}
		if (num7 != num4)
		{
			SettingsManager.CurrentSettings.language = array[num7];
			Localization.SetLanguage(SettingsManager.CurrentSettings.language);
			SpeakingIndicator.UpdateSpeakText();
			SettingsManager.Save();
		}
		if (GUILayout.Button(Localization.T("close"), Array.Empty<GUILayoutOption>()))
		{
			ShowMenu = false;
			MicDropdownOpen = false;
		}
		GUILayout.EndVertical();
		GUI.DragWindow();
	}

	private void DrawKeybind(string labelKey, KeyCode currentKey, Action<KeyCode> onKeyPressed)
	{
		GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		GUILayout.Label(Localization.T(labelKey), Array.Empty<GUILayoutOption>());
		if (GUILayout.Button(((object)(KeyCode)(ref currentKey)).ToString(), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(100f) }) && !waitingKey)
		{
			((MonoBehaviour)this).StartCoroutine(WaitForKeyPressed(onKeyPressed));
		}
		GUILayout.EndHorizontal();
	}
}
public class UnityMainThreadDispatcher : MonoBehaviour
{
	private static readonly Queue<Action> actions = new Queue<Action>();

	public static void Enqueue(Action action)
	{
		lock (actions)
		{
			actions.Enqueue(action);
		}
	}

	private void Update()
	{
		lock (actions)
		{
			while (actions.Count > 0)
			{
				actions.Dequeue()();
			}
		}
	}
}
public static class VoiceManager
{
	private static WasapiCapture capture;

	private static SoundInSource soundInSource;

	private static IWaveSource waveSource;

	private static WasapiOut playback;

	private static MMDeviceEnumerator deviceEnum;

	private static string allowedScene;

	private static readonly object lockObj = new object();

	public static readonly List<string> speaking = new List<string>();

	private static bool streaming = false;

	private static int udpReceivePort;

	private static Thread udpReceiveThread;

	private static bool receiving = false;

	private static UdpClient udpClient;

	private static Thread keepAliveThreadSend;

	private static bool keepAliveSendRunning = false;

	private static WasapiOut playersPlayback;

	private static string instanceId;

	private static readonly CancellationTokenSource cts = new CancellationTokenSource();

	public static string[] MicDevices { get; private set; } = Array.Empty<string>();


	public static MMDevice[] CaptureDevices { get; private set; } = Array.Empty<MMDevice>();


	public static void RemoveFromSpeaking(string name)
	{
		lock (lockObj)
		{
			speaking.Remove(name);
		}
	}

	private static async void SendUdpPunch()
	{
		try
		{
			if (!streaming)
			{
				byte[] punch = new byte[1];
				udpClient?.Send(punch, punch.Length, Main.ServerEP);
				await Task.Delay(500);
			}
		}
		catch (Exception ex)
		{
			Exception e = ex;
			Debug.LogWarning((object)("[VoiceChat] UDP punch failed: " + e.Message));
		}
	}

	private static void StartUdpKeepAliveSend()
	{
		if (keepAliveSendRunning)
		{
			return;
		}
		keepAliveSendRunning = true;
		keepAliveThreadSend = new Thread((ThreadStart)async delegate
		{
			while (keepAliveSendRunning)
			{
				await Task.Delay(20000);
				try
				{
					SendUdpPunch();
				}
				catch (Exception ex)
				{
					Debug.LogWarning((object)("[VoiceChat] KeepAliveSend: " + ex.Message));
				}
			}
		})
		{
			IsBackground = true
		};
		keepAliveThreadSend.Start();
	}

	public static void InitDevices()
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Expected O, but got Unknown
		try
		{
			deviceEnum = new MMDeviceEnumerator();
			MMDeviceCollection val = deviceEnum.EnumAudioEndpoints((DataFlow)1, (DeviceState)1);
			List<string> list = new List<string>();
			List<MMDevice> list2 = new List<MMDevice>();
			foreach (MMDevice item in val)
			{
				list.Add(item.FriendlyName);
				list2.Add(item);
			}
			MicDevices = list.ToArray();
			CaptureDevices = list2.ToArray();
		}
		catch (Exception ex)
		{
			Debug.LogError((object)("[VoiceChat] CSCore: InitDevices failed: " + ex.Message));
			MicDevices = Array.Empty<string>();
			CaptureDevices = Array.Empty<MMDevice>();
		}
	}

	public static void StartCapture(int deviceIndex)
	{
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Expected O, but got Unknown
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: Expected O, but got Unknown
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a2: Expected O, but got Unknown
		try
		{
			StopCapture();
			if (SettingsManager.CurrentSettings.hearSelf && CaptureDevices.Length != 0 && deviceIndex >= 0 && deviceIndex < CaptureDevices.Length)
			{
				MMDevice device = CaptureDevices[deviceIndex];
				capture = new WasapiCapture
				{
					Device = device
				};
				capture.Initialize();
				soundInSource = new SoundInSource((ISoundIn)(object)capture)
				{
					FillWithZeros = true
				};
				waveSource = FluentExtensions.ToWaveSource(FluentExtensions.ToSampleSource((IWaveSource)(object)soundInSource), 16);
				playback = new WasapiOut();
				playback.Initialize(waveSource);
				playback.Volume = SettingsManager.CurrentSettings.selfVolume;
				capture.Start();
				playback.Play();
			}
		}
		catch (Exception ex)
		{
			Debug.LogError((object)("[VoiceChat] VoiceManager: StartCapture failed: " + ex.Message));
			StopCapture();
		}
	}

	public static void StopCapture()
	{
		try
		{
			WasapiCapture obj = capture;
			if (obj != null)
			{
				obj.Stop();
			}
		}
		catch
		{
		}
		try
		{
			WasapiOut obj3 = playback;
			if (obj3 != null)
			{
				obj3.Stop();
			}
		}
		catch
		{
		}
		try
		{
			WasapiCapture obj5 = capture;
			if (obj5 != null)
			{
				obj5.Dispose();
			}
		}
		catch
		{
		}
		try
		{
			WasapiOut obj7 = playback;
			if (obj7 != null)
			{
				obj7.Dispose();
			}
		}
		catch
		{
		}
		try
		{
			SoundInSource obj9 = soundInSource;
			if (obj9 != null)
			{
				obj9.Dispose();
			}
		}
		catch
		{
		}
		try
		{
			((IDisposable)waveSource)?.Dispose();
		}
		catch
		{
		}
		capture = null;
		playback = null;
		soundInSource = null;
		waveSource = null;
	}

	public static void SetInstanceId(string instanceid)
	{
		instanceId = instanceid;
	}

	public static async Task StartVoiceStream(CancellationToken token)
	{
		StopVoiceStream();
		streaming = true;
		try
		{
			if (NetworkManager.State != NetworkManager.ConnectionState.Connected)
			{
				Debug.LogWarning((object)"[VoiceChat] TCP connection missing, trying reconnect...");
				if (!(await NetworkManager.Connect()))
				{
					Debug.LogError((object)"[VoiceChat] failed to reconnect tcp.");
					streaming = false;
					return;
				}
			}
			if (udpClient == null)
			{
				udpClient = new UdpClient(0);
				udpReceivePort = ((IPEndPoint)udpClient.Client.LocalEndPoint).Port;
				udpClient.Client.ReceiveTimeout = 1000;
				udpClient.Client.SendTimeout = 1000;
			}
			await NetworkManager.SendMessage("SPEAK_REQUEST");
			if (!(await NetworkManager.WaitForResponse("SPEAK_OK", 500)))
			{
				Debug.LogError((object)"[VoiceChat] failed to request speak.");
				streaming = false;
				return;
			}
			string localSteamID = SteamUser.GetSteamID().m_SteamID.ToString();
			await NetworkManager.SendMessage($"UDP_INFO|{localSteamID}|{udpReceivePort}|{instanceId}");
			Task.Run(() => SendAudioLoop(token), token);
		}
		catch (Exception ex)
		{
			Debug.LogError((object)("[VoiceChat] error starting voice stream: " + ex));
			streaming = false;
		}
	}

	public static void StopVoiceStream()
	{
		if (streaming)
		{
			streaming = false;
		}
	}

	public static async Task StartReceiving(CancellationToken token)
	{
		if (receiving)
		{
			return;
		}
		try
		{
			if (udpClient == null)
			{
				udpClient = new UdpClient(0);
			}
			udpReceivePort = ((IPEndPoint)udpClient.Client.LocalEndPoint).Port;
			receiving = true;
			udpClient.Client.ReceiveTimeout = 1000;
			udpClient.Client.SendTimeout = 1000;
			string steamID = SteamUser.GetSteamID().m_SteamID.ToString();
			await NetworkManager.SendMessage($"UDP_INFO|{steamID}|{udpReceivePort}|{instanceId}");
			StartUdpKeepAliveSend();
			Task.Run(() => ReceiveAudioLoop(token), token);
		}
		catch (Exception ex)
		{
			Debug.LogError((object)("[VoiceChat] failed to start udp receive: " + ex.Message));
		}
	}

	public static void StopReceiving()
	{
		try
		{
			receiving = false;
			keepAliveSendRunning = false;
			if (keepAliveThreadSend != null)
			{
				try
				{
					keepAliveThreadSend.Join(500);
				}
				catch
				{
				}
				keepAliveThreadSend = null;
			}
			try
			{
				udpClient?.Close();
			}
			catch
			{
			}
			if (udpReceiveThread != null)
			{
				try
				{
					udpReceiveThread.Join(500);
				}
				catch
				{
				}
				udpReceiveThread = null;
			}
		}
		catch (Exception ex)
		{
			Debug.LogError((object)("[VoiceChat] error stopping udp receive: " + ex.Message));
		}
	}

	private static async Task ReceiveAudioLoop(CancellationToken token)
	{
		IPEndPoint remoteEP = new IPEndPoint(IPAddress.Any, 0);
		WaveFormat format = new WaveFormat(48000, 16, 1);
		int bufferSize = format.BytesPerSecond * SettingsManager.CurrentSettings.bufferSizeMs / 1000;
		WriteableBufferingSource bufferSource = new WriteableBufferingSource(format, bufferSize)
		{
			FillWithZeros = true
		};
		try
		{
			playersPlayback = new WasapiOut();
			playersPlayback.Initialize((IWaveSource)(object)bufferSource);
			playersPlayback.Volume = SettingsManager.CurrentSettings.playersVolume;
			playersPlayback.Play();
			while (receiving && !token.IsCancellationRequested)
			{
				try
				{
					byte[] data = udpClient.Receive(ref remoteEP);
					if (data != null && data.Length != 0)
					{
						bufferSource.Write(data, 0, data.Length);
					}
					UnityMainThreadDispatcher.Enqueue(delegate
					{
						lock (lockObj)
						{
							foreach (string item in speaking)
							{
								SpeakingIndicator.OnPlayerSpeaking(item);
							}
						}
					});
				}
				catch (SocketException ex) when (ex.SocketErrorCode == SocketError.TimedOut)
				{
				}
				catch (ObjectDisposedException)
				{
					break;
				}
				await Task.Delay(1, token);
			}
		}
		catch (OperationCanceledException)
		{
		}
		catch (Exception ex4)
		{
			Debug.LogError((object)("[VoiceChat] ReceiveAudioLoop fatal: " + ex4));
		}
		finally
		{
			try
			{
				WasapiOut obj = playersPlayback;
				if (obj != null)
				{
					obj.Stop();
				}
			}
			catch
			{
			}
			try
			{
				WasapiOut obj3 = playersPlayback;
				if (obj3 != null)
				{
					obj3.Dispose();
				}
			}
			catch
			{
			}
		}
	}

	private static async Task SendAudioLoop(CancellationToken token)
	{
		WasapiCapture micCapture = null;
		SoundInSource source = null;
		try
		{
			micCapture = new WasapiCapture();
			micCapture.Initialize();
			source = new SoundInSource((ISoundIn)(object)micCapture)
			{
				FillWithZeros = false
			};
			WaveFormat targetFormat = new WaveFormat(48000, 16, 1);
			IWaveSource converted = FluentExtensions.ToWaveSource(FluentExtensions.ChangeSampleRate(FluentExtensions.ToMono(FluentExtensions.ToSampleSource((IWaveSource)(object)source)), targetFormat.SampleRate), 16);
			micCapture.Start();
			byte[] buffer = new byte[((IAudioSource)converted).WaveFormat.BytesPerSecond * SettingsManager.CurrentSettings.bufferSizeMs / 1000];
			while (streaming && !token.IsCancellationRequested)
			{
				int read = ((IReadableAudioSource<byte>)(object)converted).Read(buffer, 0, buffer.Length);
				bool sendData = true;
				if (SettingsManager.CurrentSettings.micMode == MicMode.VoiceActivation)
				{
					float rms = 0f;
					for (int i = 0; i < read && i + 1 < read; i += 2)
					{
						short sample = (short)(buffer[i] | (buffer[i + 1] << 8));
						float f = (float)sample / 32768f;
						rms += f * f;
					}
					if (read > 0)
					{
						rms = Mathf.Sqrt(rms / (float)(read / 2));
					}
					float db = 20f * Mathf.Log10(Mathf.Max(rms, 0.0001f));
					sendData = db >= SettingsManager.CurrentSettings.voiceThresholdDb;
				}
				if (sendData && read > 0)
				{
					try
					{
						udpClient?.Send(buffer, read, Main.ServerEP);
					}
					catch (Exception ex3)
					{
						Exception ex2 = ex3;
						Debug.LogWarning((object)("[VoiceChat] UDP send failed: " + ex2.Message));
					}
				}
				await Task.Delay(10, token);
			}
		}
		catch (OperationCanceledException)
		{
		}
		catch (Exception ex3)
		{
			Exception ex = ex3;
			Debug.LogError((object)("[VoiceChat] udp capture error: " + ex.Message));
		}
		finally
		{
			SoundInSource obj = source;
			if (obj != null)
			{
				obj.Dispose();
			}
			WasapiCapture obj2 = micCapture;
			if (obj2 != null)
			{
				obj2.Dispose();
			}
		}
	}

	public static void RestartUdp()
	{
		StopReceiving();
		keepAliveSendRunning = false;
		if (keepAliveThreadSend != null)
		{
			try
			{
				keepAliveThreadSend.Join(500);
			}
			catch
			{
			}
			keepAliveThreadSend = null;
		}
		try
		{
			udpClient?.Close();
		}
		catch
		{
		}
		udpClient = null;
		receiving = false;
		StartReceiving(cts.Token);
	}

	public static void UpdatePlayersVolume(float volume)
	{
		if (playersPlayback != null)
		{
			playersPlayback.Volume = volume;
		}
	}

	public static void UpdateSelfVolume(float volume)
	{
		if (playback != null)
		{
			playback.Volume = volume;
		}
	}

	public static void AllowScenePlayback(string scene, string name)
	{
		if (scene == "menus")
		{
			return;
		}
		lock (lockObj)
		{
			allowedScene = scene;
			if (!speaking.Contains(name))
			{
				speaking.Add(name);
			}
		}
	}

	public static bool IsAllowed(string scene)
	{
		return allowedScene != null && allowedScene == scene;
	}
}