using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using BingBongAI.Ai;
using BingBongAI.BingBong;
using BingBongAI.Brain;
using BingBongAI.Game;
using BingBongAI.Net;
using BingBongAI.Pigs;
using BingBongAI.Secrets;
using BingBongAI.UI;
using BingBongAI.Voice;
using ExitGames.Client.Photon;
using GuineaPigsAndTreats;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Peak.Afflictions;
using Photon.Pun;
using Photon.Realtime;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.Networking;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using Zorro.Core;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("CavyCrew.BingBongAI")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.9.1.0")]
[assembly: AssemblyInformationalVersion("0.9.1")]
[assembly: AssemblyProduct("CavyCrew.BingBongAI")]
[assembly: AssemblyTitle("Bing Bong AI")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.9.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[CompilerGenerated]
internal sealed class <>z__ReadOnlyArray<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Length;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => _items.Length;

	T IReadOnlyList<T>.this[int index] => _items[index];

	int ICollection<T>.Count => _items.Length;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlyArray(T[] items)
	{
		_items = items;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return ((IEnumerable)_items).GetEnumerator();
	}

	void ICollection.CopyTo(Array array, int index)
	{
		((ICollection)_items).CopyTo(array, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return ((IList)_items).Contains(value);
	}

	int IList.IndexOf(object value)
	{
		return ((IList)_items).IndexOf(value);
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return ((IEnumerable<T>)_items).GetEnumerator();
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return ((ICollection<T>)_items).Contains(item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		((ICollection<T>)_items).CopyTo(array, arrayIndex);
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		return ((IList<T>)_items).IndexOf(item);
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	[Embedded]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	[Embedded]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace BingBongAI
{
	internal static class GameHooks
	{
		private sealed class Hook(MethodBase? original)
		{
			public MethodBase? Original { get; } = original;

			public HarmonyMethod? Prefix { get; set; }

			public HarmonyMethod? Postfix { get; set; }

			public Exception? Error { get; set; }
		}

		private static readonly List<string> s_broken = new List<string>();

		public static IReadOnlyList<string> Broken => s_broken;

		public static void PatchAll(Harmony harmony)
		{
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Expected O, but got Unknown
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Expected O, but got Unknown
			int num = 0;
			Type[] typesFromAssembly = AccessTools.GetTypesFromAssembly(typeof(Plugin).Assembly);
			foreach (Type type in typesFromAssembly)
			{
				HarmonyMethod val;
				List<MethodInfo> declaredMethods;
				try
				{
					if (!type.IsDefined(typeof(HarmonyPatch), inherit: false))
					{
						continue;
					}
					val = ((HarmonyAttribute)(((MemberInfo)type).GetCustomAttributes<HarmonyPatch>(inherit: false).FirstOrDefault()?)).info;
					declaredMethods = AccessTools.GetDeclaredMethods(type);
					goto IL_0076;
				}
				catch (Exception e)
				{
					num++;
					Fail(type.Name, e);
				}
				continue;
				IL_0076:
				Dictionary<string, Hook> dictionary = new Dictionary<string, Hook>();
				Hook value3;
				foreach (MethodInfo item in declaredMethods)
				{
					string key = type.Name + "." + item.Name;
					try
					{
						bool flag = item.IsDefined(typeof(HarmonyPrefix), inherit: false) || item.Name == "Prefix";
						bool flag2 = item.IsDefined(typeof(HarmonyPostfix), inherit: false) || item.Name == "Postfix";
						if (!flag && !flag2)
						{
							continue;
						}
						HarmonyMethod val2 = ((HarmonyAttribute)(((MemberInfo)item).GetCustomAttributes<HarmonyPatch>(inherit: false).FirstOrDefault()?)).info ?? val;
						Type type2 = val2?.declaringType ?? val?.declaringType;
						string text = val2?.methodName ?? val?.methodName;
						if (type2 == null || text == null)
						{
							throw new InvalidOperationException("no target method");
						}
						key = type2.Name + "." + text;
						MethodType? val3 = val2?.methodType;
						bool flag3;
						if (val3.HasValue)
						{
							MethodType valueOrDefault = val3.GetValueOrDefault();
							if ((int)valueOrDefault != 0)
							{
								flag3 = false;
								goto IL_01d8;
							}
						}
						flag3 = true;
						goto IL_01d8;
						IL_01d8:
						if (!flag3)
						{
							throw new NotSupportedException($"method type {val2.methodType}");
						}
						MethodInfo original = AccessTools.Method(type2, text, val2?.argumentTypes, (Type[])null) ?? throw new MissingMethodException(type2.FullName, text);
						if (!dictionary.TryGetValue(key, out var value))
						{
							value = (dictionary[key] = new Hook(original));
						}
						if (flag)
						{
							value.Prefix = new HarmonyMethod(item);
						}
						if (flag2)
						{
							value.Postfix = new HarmonyMethod(item);
						}
					}
					catch (Exception ex)
					{
						if (!dictionary.TryGetValue(key, out var value2))
						{
							value2 = (dictionary[key] = new Hook(null));
						}
						value3 = value2;
						if (value3.Error == null)
						{
							Exception ex2 = (value3.Error = ex);
						}
					}
				}
				foreach (KeyValuePair<string, Hook> item2 in dictionary)
				{
					item2.Deconstruct(out var key2, out value3);
					string text2 = key2;
					Hook hook3 = value3;
					num++;
					if (hook3.Error != null || hook3.Original == null)
					{
						Fail(text2, hook3.Error ?? new MissingMethodException(text2));
						continue;
					}
					try
					{
						harmony.Patch(hook3.Original, hook3.Prefix, hook3.Postfix, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					}
					catch (Exception e2)
					{
						Fail(text2, e2);
						try
						{
							harmony.Unpatch(hook3.Original, (HarmonyPatchType)0, harmony.Id);
						}
						catch (Exception)
						{
						}
					}
				}
			}
			Plugin.Log.LogInfo((object)$"Game hooks: {num - s_broken.Count} of {num} in place.");
		}

		public static void Start(string what, Action start)
		{
			try
			{
				start();
			}
			catch (Exception e)
			{
				Fail(what, e);
			}
		}

		private static void Fail(string what, Exception e)
		{
			s_broken.Add(what);
			Plugin.Log.LogWarning((object)("Could not hook into " + what + " (has the game updated?): " + e.GetType().Name + ": " + e.Message + ". The rest of the mod works without it."));
		}
	}
	internal sealed class Hotkeys : MonoBehaviour
	{
		private sealed class ParsedKey(Func<string> setting, Key fallback)
		{
			private string? _parsedName;

			private Key _key;

			private Key Current
			{
				get
				{
					//IL_006a: Unknown result type (might be due to invalid IL or missing references)
					//IL_003f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0044: Unknown result type (might be due to invalid IL or missing references)
					//IL_0055: Unknown result type (might be due to invalid IL or missing references)
					//IL_0031: Unknown result type (might be due to invalid IL or missing references)
					//IL_0035: 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)
					string text = setting();
					if (text != _parsedName)
					{
						_parsedName = text;
						if (Enum.TryParse<Key>(text.Trim(), ignoreCase: true, out Key result) && (int)result != 0)
						{
							_key = result;
						}
						else
						{
							_key = fallback;
							Plugin.Log.LogWarning((object)$"Unknown key '{text}', using {fallback}.");
						}
					}
					return _key;
				}
			}

			public bool WasPressed(Keyboard keyboard)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				return ((ButtonControl)keyboard[Current]).wasPressedThisFrame;
			}

			public bool IsHeld(Keyboard keyboard)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				return ((ButtonControl)keyboard[Current]).isPressed;
			}
		}

		private const float MinTalkSeconds = 0.35f;

		private const float TalkDistance = 25f;

		private readonly ParsedKey _settings = new ParsedKey(() => Plugin.SettingsKey.Value, (Key)99);

		private readonly ParsedKey _ask = new ParsedKey(() => Plugin.AskKey.Value, (Key)34);

		private readonly ParsedKey _talk = new ParsedKey(() => Plugin.TalkKey.Value, (Key)39);

		private Guid _talkId;

		private MicRecorder? _recorder;

		private void Update()
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Invalid comparison between Unknown and I4
			Keyboard current = Keyboard.current;
			if (current == null)
			{
				return;
			}
			if (_recorder != null)
			{
				if (!_talk.IsHeld(current) || _recorder.IsFull)
				{
					FinishRecording();
				}
				return;
			}
			if (_settings.WasPressed(current))
			{
				if (SettingsWindow.IsOpen)
				{
					SettingsWindow.CloseWindow();
				}
				else if (!AnyOtherWindowBlocks())
				{
					SettingsWindow.Toggle();
				}
				return;
			}
			bool flag = _ask.WasPressed(current);
			bool flag2 = _talk.WasPressed(current);
			if ((!flag && !flag2) || AnyOtherWindowBlocks() || (int)Cursor.lockState != 1 || (flag && HandsScroll()))
			{
				return;
			}
			BingBongPlace bingBongPlace = BingBongPlace.OfLocalScout() ?? LyingNearby();
			if (bingBongPlace == null)
			{
				if (Plugin.AiEnabled.Value)
				{
					Messages.Show(Lang.Get("msg.no_bingbong", ("m", 25)));
				}
			}
			else if (!Plugin.AiEnabled.Value)
			{
				(string, object)[] array = new(string, object)[3]
				{
					("key", Plugin.SettingsKey.Value.ToUpperInvariant()),
					("tab", Lang.Get("settings.tab_behaviour")),
					("setting", Lang.Get("settings.enabled"))
				};
				Player current2 = BingBongAI.Net.Brain.Current;
				Messages.Show((current2 != null && !current2.IsLocal) ? Lang.Get("msg.ai_off_lobby", array.Append(("who", BingBongAI.Net.Brain.NameOf(current2))).ToArray()) : Lang.Get("msg.ai_off", array));
			}
			else if (!BingBongBrain.IsConfigured && !BingBongAI.Net.Brain.Remote)
			{
				Messages.Show(Lang.Get("msg.not_configured", ("key", Plugin.SettingsKey.Value.ToUpperInvariant())));
			}
			else if (flag)
			{
				AskWindow.Open(bingBongPlace.Id);
			}
			else
			{
				StartRecording(bingBongPlace);
			}
		}

		private void OnDisable()
		{
			_recorder?.Dispose();
			_recorder = null;
		}

		private BingBongPlace? TalkedBingBong()
		{
			return BingBongPlace.Find(_talkId);
		}

		private void StartRecording(BingBongPlace place)
		{
			string item = Plugin.SettingsKey.Value.ToUpperInvariant();
			if (!BingBongAI.Net.Brain.Remote && !ListenService.Enabled)
			{
				Messages.Show(Lang.Get("msg.listen_off", ("key", item)));
				return;
			}
			if (!BingBongAI.Net.Brain.Remote && !ListenService.IsConfigured)
			{
				Messages.Show(Lang.Get("msg.listen_not_configured", ("key", item)));
				return;
			}
			try
			{
				_recorder = ListenService.StartRecording();
				Plugin.Verbose("Listening on '" + ((_recorder.DeviceName.Length > 0) ? _recorder.DeviceName : "Windows default") + "'.");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Could not start the microphone: " + ex.Message));
				Messages.Show(Lang.Get("msg.mic_failed", ("detail", ex.Message)));
				return;
			}
			_talkId = place.Id;
			BingBongSpeech.For(place).ShowListening();
		}

		private async void FinishRecording()
		{
			MicRecorder recorder = _recorder;
			_recorder = null;
			BingBongSpeech speech = null;
			try
			{
				bool flag = recorder.Elapsed.TotalSeconds < 0.3499999940395355;
				short[] samples = recorder.Stop();
				BingBongPlace bingBongPlace = TalkedBingBong();
				if (bingBongPlace != null)
				{
					speech = BingBongSpeech.For(bingBongPlace);
				}
				if (flag)
				{
					if ((Object)(object)speech != (Object)null)
					{
						speech.StopThinking();
					}
					Messages.Show(Lang.Get("msg.hold_to_talk", ("talk", Plugin.TalkKey.Value.ToUpperInvariant())));
					return;
				}
				if (BingBongAI.Net.Brain.Remote)
				{
					if (bingBongPlace == null)
					{
						Messages.Show(Lang.Get("msg.listen_gone"));
					}
					else if (ListenService.IsSilence(samples))
					{
						if ((Object)(object)speech != (Object)null)
						{
							speech.StopThinking();
						}
						Messages.Show(Lang.Get("msg.not_heard"));
					}
					else
					{
						BrainNet.AskByVoice(bingBongPlace, samples, 16000);
					}
					return;
				}
				if ((Object)(object)speech != (Object)null)
				{
					speech.ShowThinking();
				}
				string text = await ListenService.RecognizeAsync(samples);
				if (text == null)
				{
					if ((Object)(object)speech != (Object)null)
					{
						speech.StopThinking();
					}
					Messages.Show(Lang.Get("msg.not_heard"));
					return;
				}
				Messages.Show(Lang.Get("msg.heard", ("text", text)));
				bingBongPlace = TalkedBingBong();
				if (bingBongPlace == null)
				{
					if ((Object)(object)speech != (Object)null)
					{
						speech.StopThinking();
					}
					Messages.Show(Lang.Get("msg.listen_gone"));
				}
				else
				{
					if (!BingBongBrain.Busy && (Object)(object)bingBongPlace.Instance != (Object)null && bingBongPlace.Spot == BingBongSpot.Hand)
					{
						AskPatch.Squish(bingBongPlace.Instance);
					}
					BingBongBrain.Ask(bingBongPlace, text);
				}
			}
			catch (ChatException ex)
			{
				Plugin.Log.LogWarning((object)$"Speech recognition failed ({ex.Kind}): {ex.Message}");
				if ((Object)(object)speech != (Object)null)
				{
					speech.StopThinking();
				}
				Messages.Show(BingBongBrain.ErrorText(ex, ListenService.Endpoint));
			}
			catch (Exception ex2)
			{
				Plugin.Log.LogError((object)$"Spoken question failed: {ex2}");
				if ((Object)(object)speech != (Object)null)
				{
					speech.StopThinking();
				}
				Messages.Show(Lang.Get("msg.error.other", ("detail", ex2.GetType().Name)));
			}
			finally
			{
				recorder.Dispose();
			}
		}

		private static bool HandsScroll()
		{
			Character localCharacter = Character.localCharacter;
			Item val = (((Object)(object)localCharacter != (Object)null && (Object)(object)localCharacter.data != (Object)null) ? localCharacter.data.currentItem : null);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			if (!((Object)(object)((Component)val).GetComponentInChildren<Action_GuidebookScroll>(true) != (Object)null) && !((Object)(object)((Component)val).GetComponentInChildren<Actions_Binoculars>(true) != (Object)null) && !((Object)(object)((Component)val).GetComponentInChildren<Action_ConstructableScoutCannonScroll>(true) != (Object)null))
			{
				return (Object)(object)((Component)val).GetComponentInChildren<RopeSpool>(true) != (Object)null;
			}
			return true;
		}

		private static BingBongPlace? LyingNearby()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter == (Object)null || (Object)(object)localCharacter.data == (Object)null || localCharacter.data.dead)
			{
				return null;
			}
			Vector3 me = localCharacter.Center;
			return (from p in BingBongPlace.All()
				where (Object)(object)p.Carrier == (Object)null && Vector3.Distance(p.Position, me) < 25f
				orderby Vector3.Distance(p.Position, me)
				select p).FirstOrDefault();
		}

		public static Action_AskBingBong? HeldBingBong()
		{
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter == (Object)null || (Object)(object)localCharacter.data == (Object)null || localCharacter.data.dead)
			{
				return null;
			}
			Item currentItem = localCharacter.data.currentItem;
			Action_AskBingBong result = default(Action_AskBingBong);
			if (!((Object)(object)currentItem != (Object)null) || !((Component)currentItem).TryGetComponent<Action_AskBingBong>(ref result))
			{
				return null;
			}
			return result;
		}

		private static bool AnyOtherWindowBlocks()
		{
			if (!AskWindow.IsOpen)
			{
				if ((Object)(object)GUIManager.instance != (Object)null)
				{
					return GUIManager.instance.windowBlockingInput;
				}
				return false;
			}
			return true;
		}
	}
	internal static class Lang
	{
		public const string Auto = "auto";

		private const string Fallback = "en";

		private static Dictionary<string, Dictionary<string, string>>? s_tables;

		public static IReadOnlyList<string> Available
		{
			get
			{
				List<string> list = Tables.Keys.ToList();
				list.Sort((string a, string b) => (!(a == "en")) ? ((b == "en") ? 1 : string.CompareOrdinal(a, b)) : (-1));
				return list;
			}
		}

		public static string Current
		{
			get
			{
				string text = Plugin.Language.Value.Trim().ToLowerInvariant();
				if (text != "auto" && Tables.ContainsKey(text))
				{
					return text;
				}
				string text2 = FromGame();
				if (!Tables.ContainsKey(text2))
				{
					return "en";
				}
				return text2;
			}
		}

		public static bool IsAuto => Plugin.Language.Value.Trim().ToLowerInvariant() == "auto";

		private static Dictionary<string, Dictionary<string, string>> Tables => s_tables ?? (s_tables = LoadTables());

		public static string NativeName(string code)
		{
			if (!Tables.TryGetValue(code, out Dictionary<string, string> value) || !value.TryGetValue("_language", out var value2))
			{
				return code;
			}
			return value2;
		}

		public static string Get(string key, params (string name, object value)[] args)
		{
			return Format(Lookup(key), args);
		}

		public static string Count(long n, string key)
		{
			string[] array = Get(key).Split('|');
			int num;
			if (n >= 1000)
			{
				num = 2;
			}
			else
			{
				int num2;
				if (array.Length < 3)
				{
					num2 = ((n != 1) ? 1 : 0);
				}
				else
				{
					int num3;
					if (n % 10 == 1 && n % 100 != 11)
					{
						num3 = 0;
					}
					else
					{
						long num4 = n % 10;
						bool flag = num4 >= 2 && num4 <= 4;
						bool flag2 = flag;
						if (flag2)
						{
							num4 = n % 100;
							bool flag3 = ((num4 < 12 || num4 > 14) ? true : false);
							flag2 = flag3;
						}
						num3 = (flag2 ? 1 : 2);
					}
					num2 = num3;
				}
				num = num2;
			}
			int val = num;
			return Short(n) + " " + array[Math.Min(val, array.Length - 1)];
		}

		public static string Short(long n)
		{
			if (n < 1000)
			{
				return n.ToString(CultureInfo.InvariantCulture);
			}
			bool flag = n >= 1000000;
			string item = ((double)n / (flag ? 1000000.0 : 1000.0)).ToString((n >= 100000 && !flag) ? "0" : "0.#", CultureInfo.InvariantCulture).Replace(".", Get("number.decimal_point"));
			return Get(flag ? "number.millions" : "number.thousands", ("n", item));
		}

		public static string? Find(string key)
		{
			if (!TryLookup(Current, key, out string text) && !TryLookup("en", key, out text))
			{
				return null;
			}
			return text;
		}

		private static string Lookup(string key)
		{
			return Find(key) ?? key;
		}

		private static bool TryLookup(string language, string key, out string text)
		{
			text = "";
			if (Tables.TryGetValue(language, out Dictionary<string, string> value) && value.TryGetValue(key, out text))
			{
				return !string.IsNullOrEmpty(text);
			}
			return false;
		}

		private static string Format(string text, (string name, object value)[] args)
		{
			for (int i = 0; i < args.Length; i++)
			{
				(string name, object value) tuple = args[i];
				string item = tuple.name;
				object item2 = tuple.value;
				text = text.Replace("{" + item + "}", item2?.ToString() ?? "");
			}
			return text;
		}

		private static string FromGame()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return CodeFor(LocalizedText.CURRENT_LANGUAGE);
		}

		internal static string CodeFor(Language language)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected I4, but got Unknown
			return (int)language switch
			{
				0 => "en", 
				1 => "fr", 
				2 => "it", 
				3 => "de", 
				4 => "es", 
				5 => "es-419", 
				6 => "pt-br", 
				7 => "ru", 
				8 => "uk", 
				9 => "zh-hans", 
				10 => "zh-hant", 
				11 => "ja", 
				12 => "ko", 
				13 => "pl", 
				14 => "tr", 
				_ => "en", 
			};
		}

		private static Dictionary<string, Dictionary<string, string>> LoadTables()
		{
			Dictionary<string, Dictionary<string, string>> dictionary = new Dictionary<string, Dictionary<string, string>>(StringComparer.OrdinalIgnoreCase);
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string[] manifestResourceNames = executingAssembly.GetManifestResourceNames();
			foreach (string text in manifestResourceNames)
			{
				if (!text.StartsWith("Lang.", StringComparison.Ordinal) || !text.EndsWith(".json", StringComparison.Ordinal))
				{
					continue;
				}
				string code = text.Substring(5, text.Length - 10).ToLowerInvariant();
				using Stream stream = executingAssembly.GetManifestResourceStream(text);
				using StreamReader streamReader = new StreamReader(stream);
				Merge(dictionary, code, streamReader.ReadToEnd(), text);
			}
			string path = Path.Combine(Path.GetDirectoryName(executingAssembly.Location) ?? "", "Lang");
			if (Directory.Exists(path))
			{
				string[] files = Directory.GetFiles(path, "*.json");
				foreach (string text2 in files)
				{
					Merge(dictionary, Path.GetFileNameWithoutExtension(text2).ToLowerInvariant(), File.ReadAllText(text2), text2);
				}
			}
			Plugin.Log.LogInfo((object)("Languages: " + string.Join(", ", dictionary.Keys)));
			return dictionary;
		}

		private static void Merge(Dictionary<string, Dictionary<string, string>> tables, string code, string json, string source)
		{
			try
			{
				Dictionary<string, string> dictionary = JsonConvert.DeserializeObject<Dictionary<string, string>>(json) ?? new Dictionary<string, string>();
				if (!tables.TryGetValue(code, out Dictionary<string, string> value))
				{
					value = (tables[code] = new Dictionary<string, string>());
				}
				foreach (KeyValuePair<string, string> item in dictionary)
				{
					value[item.Key] = item.Value;
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Could not read translation " + source + ": " + ex.Message));
			}
		}

		public static void CycleOverride()
		{
			List<string> list = new List<string> { "auto" };
			list.AddRange(Available);
			string item = Plugin.Language.Value.Trim().ToLowerInvariant();
			int num = list.IndexOf(item);
			Plugin.Language.Value = list[(num + 1) % list.Count];
		}

		public static string MenuLanguageLabel()
		{
			string text = NativeName(Current);
			return Get("settings.language", ("lang", IsAuto ? Get("settings.language_auto", ("lang", text)) : text));
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("CavyCrew.BingBongAI", "Bing Bong AI", "0.9.1")]
	public class Plugin : BaseUnityPlugin
	{
		public const string Id = "CavyCrew.BingBongAI";

		internal static ManualLogSource Log { get; private set; }

		internal static ConfigEntry<bool> AiEnabled { get; private set; }

		internal static ConfigEntry<string> Provider { get; private set; }

		internal static ConfigEntry<string> BaseUrl { get; private set; }

		internal static ConfigEntry<string> Model { get; private set; }

		internal static ConfigEntry<float> Temperature { get; private set; }

		internal static ConfigEntry<int> MaxReplyTokens { get; private set; }

		internal static ConfigEntry<string> Personality { get; private set; }

		internal static ConfigEntry<string> PersonalityCustom { get; private set; }

		internal static ConfigEntry<string> ReplyLength { get; private set; }

		internal static ConfigEntry<int> TimeoutSeconds { get; private set; }

		internal static ConfigEntry<bool> NoThinking { get; private set; }

		internal static ConfigEntry<bool> SendNicknames { get; private set; }

		internal static ConfigEntry<int> MemoryPairs { get; private set; }

		internal static ConfigEntry<bool> RunSummary { get; private set; }

		internal static ConfigEntry<int> PastRuns { get; private set; }

		internal static ConfigEntry<bool> Reactions { get; private set; }

		internal static ConfigEntry<int> ReactionCooldownSeconds { get; private set; }

		internal static ConfigEntry<bool> GuineaPigs { get; private set; }

		internal static ConfigEntry<bool> GameEvents { get; private set; }

		internal static ConfigEntry<int> GameEventMinutes { get; private set; }

		internal static ConfigEntry<bool> Basketball { get; private set; }

		internal static ConfigEntry<bool> ShowScoreboard { get; private set; }

		internal static ConfigEntry<bool> RealDate { get; private set; }

		internal static ConfigEntry<int> CommentatorMinutes { get; private set; }

		internal static ConfigEntry<int> CommentatorRestMinutes { get; private set; }

		internal static ConfigEntry<int> PigRemarkMinutes { get; private set; }

		internal static ConfigEntry<string> VoiceProvider { get; private set; }

		internal static ConfigEntry<string> WindowsVoiceId { get; private set; }

		internal static ConfigEntry<string> OnlineVoice { get; private set; }

		internal static ConfigEntry<float> VoicePitch { get; private set; }

		internal static ConfigEntry<float> VoiceVolume { get; private set; }

		internal static ConfigEntry<float> VoiceSpeed { get; private set; }

		internal static ConfigEntry<string> OpenAiSpeechModel { get; private set; }

		internal static ConfigEntry<string> OpenAiVoice { get; private set; }

		internal static ConfigEntry<string> SpeechInstructions { get; private set; }

		internal static ConfigEntry<string> ElevenModel { get; private set; }

		internal static ConfigEntry<string> ElevenVoiceId { get; private set; }

		internal static ConfigEntry<string> ElevenVoiceName { get; private set; }

		internal static ConfigEntry<string> KieSpeechModel { get; private set; }

		internal static ConfigEntry<string> KieVoiceId { get; private set; }

		internal static ConfigEntry<string> KieGeminiVoice { get; private set; }

		internal static ConfigEntry<string> GoogleSpeechModel { get; private set; }

		internal static ConfigEntry<string> GoogleVoice { get; private set; }

		internal static ConfigEntry<string> FalSpeechModel { get; private set; }

		internal static ConfigEntry<string> FalGeminiVoice { get; private set; }

		internal static ConfigEntry<string> FalElevenVoice { get; private set; }

		internal static ConfigEntry<bool> ElevenShowPaid { get; private set; }

		internal static ConfigEntry<string> SpeechServerUrl { get; private set; }

		internal static ConfigEntry<string> SpeechServerModel { get; private set; }

		internal static ConfigEntry<string> SpeechServerVoice { get; private set; }

		internal static ConfigEntry<string> SpeechLocalUrl { get; private set; }

		internal static ConfigEntry<string> SpeechLocalModel { get; private set; }

		internal static ConfigEntry<string> SpeechLocalVoice { get; private set; }

		internal static ConfigEntry<string> ListenProvider { get; private set; }

		internal static ConfigEntry<string> ListenGroqModel { get; private set; }

		internal static ConfigEntry<string> ListenOpenAiModel { get; private set; }

		internal static ConfigEntry<string> ListenServerUrl { get; private set; }

		internal static ConfigEntry<string> ListenServerModel { get; private set; }

		internal static ConfigEntry<string> ListenLocalUrl { get; private set; }

		internal static ConfigEntry<string> ListenLocalModel { get; private set; }

		internal static ConfigEntry<string> SettingsKey { get; private set; }

		internal static ConfigEntry<string> AskKey { get; private set; }

		internal static ConfigEntry<string> TalkKey { get; private set; }

		internal static ConfigEntry<string> Language { get; private set; }

		internal static ConfigEntry<string> BingBongLanguage { get; private set; }

		internal static ConfigEntry<bool> ShareAi { get; private set; }

		internal static ConfigEntry<string> AddressMeAs { get; private set; }

		internal static ConfigEntry<string> CallMeBy { get; private set; }

		internal static ConfigEntry<string> MyName { get; private set; }

		internal static ConfigEntry<int> GuestMinSeconds { get; private set; }

		internal static ConfigEntry<int> GuestPerMinute { get; private set; }

		internal static ConfigEntry<bool> VerboseLogging { get; private set; }

		internal static ConfigEntry<bool> LogPrompts { get; private set; }

		public static string Name => "Bing Bong AI";

		public static string Version => "0.9.1";

		private void Awake()
		{
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Expected O, but got Unknown
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Expected O, but got Unknown
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Expected O, but got Unknown
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Expected O, but got Unknown
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Expected O, but got Unknown
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: Expected O, but got Unknown
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_036c: Expected O, but got Unknown
			//IL_03f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fe: Expected O, but got Unknown
			//IL_0426: Unknown result type (might be due to invalid IL or missing references)
			//IL_0430: Expected O, but got Unknown
			//IL_04cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d9: Expected O, but got Unknown
			//IL_050c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0516: Expected O, but got Unknown
			//IL_0549: Unknown result type (might be due to invalid IL or missing references)
			//IL_0553: Expected O, but got Unknown
			//IL_0aa7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ab1: Expected O, but got Unknown
			//IL_0ad9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ae3: Expected O, but got Unknown
			//IL_0b51: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b5b: Expected O, but got Unknown
			//IL_0bcf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bd5: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			AiEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("AI", "Enabled", true, "Bing Bong answers through the AI. Off = the normal random voice lines.");
			Provider = ((BaseUnityPlugin)this).Config.Bind<string>("AI", "Provider", "deepseek", "Which service the settings window shows: deepseek, claude, gemini, gemma, glm, xai (Grok), openai, openrouter, groq (not Grok: open models), mistral, kie, fal, server (another online service), lmstudio, ollama or custom (another program on this PC).");
			BaseUrl = ((BaseUnityPlugin)this).Config.Bind<string>("AI", "BaseUrl", "https://api.deepseek.com", "Address of the AI's API (usually ends in /v1). Used only for server (own server), custom and openrouter; the ready-made services always use their own address.");
			Model = ((BaseUnityPlugin)this).Config.Bind<string>("AI", "Model", "deepseek-flash", "Model name as the service calls it.");
			Temperature = ((BaseUnityPlugin)this).Config.Bind<float>("AI", "Temperature", 0.9f, new ConfigDescription("How playful and unpredictable the answers are.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1.5f), Array.Empty<object>()));
			MaxReplyTokens = ((BaseUnityPlugin)this).Config.Bind<int>("AI", "MaxReplyTokens", 1000, new ConfigDescription("Upper limit of tokens per answer. Bing Bong is told to be brief; models that 'think' first need room for the thinking.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(100, 8000), Array.Empty<object>()));
			Personality = ((BaseUnityPlugin)this).Config.Bind<string>("AI", "Personality", "smart", "Bing Bong's character: smart (a clever, witty companion), naive (a cheerful little simpleton), snarky (teasing but kind), coward (scared of everything), grumpy (grumbles but cares), storyteller (legends and parables), seadog (an old sailor), teacher (speaks simply and explains words, for learning the speech language), expert (knows the game, with notes from its data) or custom (your own text below).");
			PersonalityCustom = ((BaseUnityPlugin)this).Config.Bind<string>("AI", "PersonalityCustom", "", "Your own description of Bing Bong's character, used when Personality = custom.");
			ReplyLength = ((BaseUnityPlugin)this).Config.Bind<string>("AI", "ReplyLength", "normal", "How long his answers are: short (1-2 sentences), normal (1-3) or long (up to 5).");
			TimeoutSeconds = ((BaseUnityPlugin)this).Config.Bind<int>("AI", "TimeoutSeconds", 60, new ConfigDescription("How long to wait for an answer.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(5, 300), Array.Empty<object>()));
			NoThinking = ((BaseUnityPlugin)this).Config.Bind<bool>("AI", "NoThinking", true, "Ask models that 'think' before answering to skip it or keep it short (each service has its own switch): answers come several times faster. Services that do not understand it are asked again without it.");
			MemoryPairs = ((BaseUnityPlugin)this).Config.Bind<int>("AI", "MemoryPairs", 12, new ConfigDescription("How many recent question/answer pairs Bing Bong remembers word for word. Older ones are folded into a short memory of the whole run. More = longer word-for-word memory, but longer requests.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100), Array.Empty<object>()));
			RunSummary = ((BaseUnityPlugin)this).Config.Bind<bool>("AI", "RunSummary", true, "Fold the older conversation into a short memory of the whole run (one small extra request every few answers). Off = older pairs are simply forgotten.");
			PastRuns = ((BaseUnityPlugin)this).Config.Bind<int>("AI", "PastRuns", 1, new ConfigDescription("How many earlier runs Bing Bong remembers (their short memories, kept in %APPDATA%\\BingBongAI). 0 = none.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 20), Array.Empty<object>()));
			SendNicknames = ((BaseUnityPlugin)this).Config.Bind<bool>("AI", "SendNicknames", false, "Also send the scouts' nicknames to the AI service. Off = Bing Bong tells scouts apart by colour only.");
			Reactions = ((BaseUnityPlugin)this).Config.Bind<bool>("AI", "Reactions", true, "Bing Bong speaks up on his own when he is held over a fire, cooked, thrown hard, falls far or lands in water. Only the game of the scout who did it reacts.");
			ReactionCooldownSeconds = ((BaseUnityPlugin)this).Config.Bind<int>("AI", "ReactionCooldownSeconds", 60, new ConfigDescription("Pause between two reactions of the same kind (fire, throws and falls, water); any two reactions are at least 20 s apart.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(15, 900), Array.Empty<object>()));
			GuineaPigs = ((BaseUnityPlugin)this).Config.Bind<bool>("AI", "GuineaPigs", true, "With our mod 'Guinea Pigs and Their Treats' installed: Bing Bong knows the pigs near him and now and then speaks about them (in hands, a pocket or a backpack). Without that mod this does nothing.");
			PigRemarkMinutes = ((BaseUnityPlugin)this).Config.Bind<int>("AI", "PigRemarkMinutes", 10, new ConfigDescription("At most one remark about the guinea pigs per this many minutes.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(2, 60), Array.Empty<object>()));
			GameEvents = ((BaseUnityPlugin)this).Config.Bind<bool>("AI", "GameEvents", true, "Bing Bong now and then speaks up about the game: a scout passes out, comes to, dies or is brought back, a campfire is lit, the scouts reach a new stage.");
			GameEventMinutes = ((BaseUnityPlugin)this).Config.Bind<int>("AI", "GameEventMinutes", 4, new ConfigDescription("At most one remark about the game's events per this many minutes.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 30), Array.Empty<object>()));
			Basketball = ((BaseUnityPlugin)this).Config.Bind<bool>("AI", "BasketballCommentator", true, "When the scouts throw the basketball at a hoop, Bing Bong comments like a sports broadcast.");
			RealDate = ((BaseUnityPlugin)this).Config.Bind<bool>("AI", "RealDate", true, "Tell the AI today's real date and time (the brain's clock), so it knows what year it is.");
			ShowScoreboard = ((BaseUnityPlugin)this).Config.Bind<bool>("AI", "Scoreboard", true, "Show Bing Bong's holographic scoreboard next to the hoop during a basketball game (each player's own setting).");
			CommentatorMinutes = ((BaseUnityPlugin)this).Config.Bind<int>("AI", "CommentatorMinutes", 4, new ConfigDescription("After this many minutes of commenting Bing Bong takes a break.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 15), Array.Empty<object>()));
			CommentatorRestMinutes = ((BaseUnityPlugin)this).Config.Bind<int>("AI", "CommentatorRestMinutes", 3, new ConfigDescription("How long the commentator's break lasts, in minutes.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 30), Array.Empty<object>()));
			VoiceProvider = ((BaseUnityPlugin)this).Config.Bind<string>("Voice", "Provider", "windows", "Bing Bong's voice: windows (the voices built into Windows, no setup), openai (needs the OpenAI key), elevenlabs (needs an ElevenLabs key), kie (ElevenLabs and Gemini voices through kie.ai, needs a kie.ai key), fal (Gemini and ElevenLabs voices through fal.ai, needs a fal.ai key), google (Gemini voices from Google directly, needs the Gemini key), server (another online speech service with OpenAI's /audio/speech API), local (a speech server on this PC) or off (subtitles only).");
			OnlineVoice = ((BaseUnityPlugin)this).Config.Bind<string>("Voice", "LastOnlineProvider", "openai", "The online voice service the settings window comes back to (openai, elevenlabs, kie, fal, google or server).");
			WindowsVoiceId = ((BaseUnityPlugin)this).Config.Bind<string>("Voice", "WindowsVoice", "", "Windows voice per language, as language=registry path separated by ';' (picked in the settings window). A language without a choice gets the best installed voice for it, a male one if there is one.");
			VoicePitch = ((BaseUnityPlugin)this).Config.Bind<float>("Voice", "Pitch", 1.25f, new ConfigDescription("How high (and fast) he sounds: 1 = the voice as it is, 1.25 = a squeaky toy.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 2f), Array.Empty<object>()));
			VoiceVolume = ((BaseUnityPlugin)this).Config.Bind<float>("Voice", "Volume", 1f, new ConfigDescription("Bing Bong's voice volume on top of the game's sound volume: 1 = 100%.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 2f), Array.Empty<object>()));
			VoiceSpeed = ((BaseUnityPlugin)this).Config.Bind<float>("Voice", "Speed", 1f, new ConfigDescription("How fast Bing Bong speaks, 1 = normal. Every voice service applies what it can (ElevenLabs 0.7-1.2; Gemini gets it as a hint). The pitch already speeds him up a little.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 2f), Array.Empty<object>()));
			OpenAiSpeechModel = ((BaseUnityPlugin)this).Config.Bind<string>("Voice", "OpenAiModel", "gpt-4o-mini-tts", "OpenAI speech model.");
			OpenAiVoice = ((BaseUnityPlugin)this).Config.Bind<string>("Voice", "OpenAiVoice", "ash", "OpenAI voice name.");
			SpeechInstructions = ((BaseUnityPlugin)this).Config.Bind<string>("Voice", "OpenAiInstructions", "", "How OpenAI's voice should speak. Empty = a cheerful, slightly squeaky plush toy (in the mod's language).");
			ElevenModel = ((BaseUnityPlugin)this).Config.Bind<string>("Voice", "ElevenLabsModel", "eleven_flash_v2_5", "ElevenLabs model: eleven_flash_v2_5 is the fastest, eleven_multilingual_v2 and eleven_v3 sound richer.");
			ElevenVoiceId = ((BaseUnityPlugin)this).Config.Bind<string>("Voice", "ElevenLabsVoice", "", "ElevenLabs voice id (picked in the settings window).");
			ElevenVoiceName = ((BaseUnityPlugin)this).Config.Bind<string>("Voice", "ElevenLabsVoiceName", "", "Name of that voice, for the settings window.");
			KieSpeechModel = ((BaseUnityPlugin)this).Config.Bind<string>("Voice", "KieModel", "google/gemini-3-8-flash-tts", "kie.ai speech model: google/gemini-3-8-flash-tts, google/gemini-3-8-flash-lite-tts, google/gemini-3-1-flash-tts, elevenlabs/text-to-speech-turbo-2-5 or elevenlabs/text-to-speech-multilingual-v2.");
			KieVoiceId = ((BaseUnityPlugin)this).Config.Bind<string>("Voice", "KieVoice", "9yzdeviXkFddZ4Oz8Mok", "kie.ai ElevenLabs voice id (picked in the settings window).");
			ElevenShowPaid = ((BaseUnityPlugin)this).Config.Bind<bool>("Voice", "ElevenShowLibraryVoices", false, "Also list ElevenLabs Voice Library voices, which only paid plans can use through the API.");
			KieGeminiVoice = ((BaseUnityPlugin)this).Config.Bind<string>("Voice", "KieGeminiVoice", "Puck", "kie.ai Gemini voice name (Puck, Fenrir, Zephyr...; picked in the settings window).");
			GoogleSpeechModel = ((BaseUnityPlugin)this).Config.Bind<string>("Voice", "GoogleModel", "gemini-3.8-flash-lite-tts", "Google's Gemini speech model (Provider = google): gemini-3.8-flash-lite-tts (faster, cheaper) or gemini-3.8-flash-tts (more expressive).");
			GoogleVoice = ((BaseUnityPlugin)this).Config.Bind<string>("Voice", "GoogleVoice", "Puck", "Google's Gemini voice name (Provider = google): Puck, Kore, Charon...; picked in the settings window.");
			FalSpeechModel = ((BaseUnityPlugin)this).Config.Bind<string>("Voice", "FalModel", "fal-ai/gemini-3.1-flash-tts", "fal.ai speech model (Provider = fal): fal-ai/gemini-3.8-flash-lite-tts, fal-ai/gemini-3.8-flash-tts, fal-ai/gemini-3.1-flash-tts, fal-ai/elevenlabs/tts/turbo-v2.5, fal-ai/elevenlabs/tts/multilingual-v2 or fal-ai/elevenlabs/tts/eleven-v3.");
			FalGeminiVoice = ((BaseUnityPlugin)this).Config.Bind<string>("Voice", "FalGeminiVoice", "Puck", "fal.ai Gemini voice name (Puck, Kore, Charon...; picked in the settings window).");
			FalElevenVoice = ((BaseUnityPlugin)this).Config.Bind<string>("Voice", "FalElevenVoice", "Rachel", "fal.ai ElevenLabs voice name (Rachel, Aria, Roger...; picked in the settings window).");
			SpeechServerUrl = ((BaseUnityPlugin)this).Config.Bind<string>("Voice", "OwnServerUrl", "", "Address of another online speech service with OpenAI's /audio/speech API (usually ends in /v1).");
			SpeechServerModel = ((BaseUnityPlugin)this).Config.Bind<string>("Voice", "OwnServerModel", "tts-1", "Model name that service expects.");
			SpeechServerVoice = ((BaseUnityPlugin)this).Config.Bind<string>("Voice", "OwnServerVoice", "", "Voice name that service expects.");
			SpeechLocalUrl = ((BaseUnityPlugin)this).Config.Bind<string>("Voice", "LocalUrl", "http://localhost:8000/v1", "Address of a speech server on this PC with OpenAI's API: Piper through tools/PiperServer/piper_server.py (port 8000, Russian voices), speaches (port 8000), AllTalk (port 7851, XTTS speaks Russian)...");
			SpeechLocalModel = ((BaseUnityPlugin)this).Config.Bind<string>("Voice", "LocalModel", "tts-1", "Model name the local speech server expects.");
			SpeechLocalVoice = ((BaseUnityPlugin)this).Config.Bind<string>("Voice", "LocalVoice", "", "Voice name the local speech server expects.");
			ListenProvider = ((BaseUnityPlugin)this).Config.Bind<string>("Listen", "Provider", "groq", "Speech recognition for spoken questions (hold the talk key while holding Bing Bong): groq, openai, server (another online service with OpenAI's /audio/transcriptions API), local (a Whisper server on this PC) or off (questions by text only).");
			ListenGroqModel = ((BaseUnityPlugin)this).Config.Bind<string>("Listen", "GroqModel", "whisper-large-v3-turbo", "Groq's recognition model.");
			ListenOpenAiModel = ((BaseUnityPlugin)this).Config.Bind<string>("Listen", "OpenAiModel", "gpt-transcribe", "OpenAI's recognition model.");
			ListenServerUrl = ((BaseUnityPlugin)this).Config.Bind<string>("Listen", "OwnServerUrl", "", "Address of another online recognition service with OpenAI's /audio/transcriptions API (usually ends in /v1).");
			ListenServerModel = ((BaseUnityPlugin)this).Config.Bind<string>("Listen", "OwnServerModel", "", "Model that service expects.");
			ListenLocalUrl = ((BaseUnityPlugin)this).Config.Bind<string>("Listen", "LocalUrl", "http://localhost:8080/v1", "Address of a Whisper server on this PC: whisper.cpp's whisper-server started with --inference-path /v1/audio/transcriptions (port 8080), or speaches (port 8000).");
			ListenLocalModel = ((BaseUnityPlugin)this).Config.Bind<string>("Listen", "LocalModel", "", "Model the local server expects (whisper.cpp ignores it).");
			SettingsKey = ((BaseUnityPlugin)this).Config.Bind<string>("Controls", "SettingsKey", "F6", "Opens the Bing Bong AI settings. Unity Input System key names, e.g. F6, F7, Numpad5.");
			AskKey = ((BaseUnityPlugin)this).Config.Bind<string>("Controls", "AskKey", "T", "While holding Bing Bong: opens the box to type a question.");
			TalkKey = ((BaseUnityPlugin)this).Config.Bind<string>("Controls", "TalkKey", "Y", "While holding Bing Bong: hold it and speak, let go to ask out loud (recognition is set up on the Microphone tab). Y is free in the game's default controls.");
			Language = ((BaseUnityPlugin)this).Config.Bind<string>("General", "Language", "auto", "Language of the mod's texts and settings window: 'auto' follows the game; or a code such as ru, en.");
			BingBongLanguage = ((BaseUnityPlugin)this).Config.Bind<string>("General", "BingBongLanguage", "auto", "The language Bing Bong speaks: 'auto' follows the game; or any of the game's languages (en, fr, it, de, es, es-419, pt-br, ru, uk, zh-hans, zh-hant, ja, ko, pl, tr), e.g. to practise one.");
			AddressMeAs = ((BaseUnityPlugin)this).Config.Bind<string>("General", "AddressMeAs", "any", "How Bing Bong speaks to and about you: he, she, or any (no gender). Teammates' games with the mod see it too, so the lobby's brain knows; it goes to the AI service with your nickname.");
			CallMeBy = ((BaseUnityPlugin)this).Config.Bind<string>("General", "CallMeBy", "nick", "How Bing Bong calls you, any of: name, nick, colour (comma-separated). More than one: mostly by name, sometimes by nickname, by colour only now and then as a joke. Empty: as the lobby's brain decides (its SendNicknames).");
			MyName = ((BaseUnityPlugin)this).Config.Bind<string>("General", "MyName", "", "Your name for Bing Bong when CallMeBy has 'name' (up to 20 letters). Goes to the AI service and to teammates' games.");
			ShareAi = ((BaseUnityPlugin)this).Config.Bind<bool>("Coop", "ShareAi", true, "Teammates with this mod ask Bing Bong through your AI and everyone hears the answers (you are the lobby's 'brain'). Your keys never leave your computer. Off: only you use your AI.");
			GuestMinSeconds = ((BaseUnityPlugin)this).Config.Bind<int>("Coop", "GuestMinSeconds", 4, new ConfigDescription("A teammate's next question is taken no sooner than this many seconds after their last.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 60), Array.Empty<object>()));
			GuestPerMinute = ((BaseUnityPlugin)this).Config.Bind<int>("Coop", "GuestPerMinute", 8, new ConfigDescription("At most this many questions a minute from each teammate.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 30), Array.Empty<object>()));
			VerboseLogging = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "VerboseLogging", false, "Write extra diagnostic messages to the BepInEx log.");
			LogPrompts = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "LogPrompts", false, "Write every prompt and raw answer to the BepInEx log (never the key). For tuning Bing Bong's character.");
			SecretStore.LogWarning = delegate(string message)
			{
				Log.LogWarning((object)message);
			};
			GameHooks.PatchAll(new Harmony("CavyCrew.BingBongAI"));
			GameHooks.Start("Reactions", BingBongAI.Brain.Reactions.Init);
			GameHooks.Start("PigsLink", PigsLink.Init);
			GameHooks.Start("BrainNet", BrainNet.Init);
			GameObject val = new GameObject("BingBongAI");
			Object.DontDestroyOnLoad((Object)(object)val);
			((Object)val).hideFlags = (HideFlags)61;
			val.AddComponent<Hotkeys>();
			val.AddComponent<RunTracker>();
			val.AddComponent<BingBongWatcher>();
			val.AddComponent<PigWatcher>();
			val.AddComponent<GameWatcher>();
			val.AddComponent<BrainWatcher>();
			val.AddComponent<MicWatch>();
			val.AddComponent<SupportWatcher>();
			Log.LogInfo((object)("Plugin " + Name + " " + Version + " is loaded! AI: " + (BingBongBrain.IsConfigured ? "configured" : "not configured yet") + "."));
		}

		internal static void Verbose(string message)
		{
			if (VerboseLogging.Value)
			{
				Log.LogInfo((object)message);
			}
		}
	}
}
namespace BingBongAI.Voice
{
	internal static class ElevenLabsClient
	{
		public const string DefaultBaseUrl = "https://api.elevenlabs.io";

		public static readonly string[] KnownModels = new string[3] { "eleven_flash_v2_5", "eleven_multilingual_v2", "eleven_v3" };

		public static ChatEndpoint Endpoint(string? key, string baseUrl = "https://api.elevenlabs.io")
		{
			return new ChatEndpoint(baseUrl, "", key, ChatProtocol.ElevenLabs);
		}

		public static async Task<VoiceAudio> SynthesizeAsync(ChatEndpoint endpoint, string voiceId, string modelId, string text, string? languageCode, TimeSpan timeout, CancellationToken cancel = default(CancellationToken), float speed = 1f)
		{
			if (string.IsNullOrWhiteSpace(voiceId))
			{
				throw new ChatException(ChatErrorKind.BadRequest, "No ElevenLabs voice chosen.");
			}
			JObject val = new JObject
			{
				["text"] = JToken.op_Implicit(text),
				["model_id"] = JToken.op_Implicit(modelId)
			};
			if (Math.Abs(speed - 1f) > 0.01f)
			{
				val["voice_settings"] = (JToken)new JObject { ["speed"] = JToken.op_Implicit(Math.Round(Math.Min(1.2f, Math.Max(0.7f, speed)), 2)) };
			}
			if (!string.IsNullOrWhiteSpace(languageCode))
			{
				val["language_code"] = JToken.op_Implicit(languageCode);
			}
			byte[] data = await ChatClient.PostForBytesAsync(endpoint, "v1/text-to-speech/" + Uri.EscapeDataString(voiceId.Trim()) + "?output_format=wav_22050", ((JToken)val).ToString((Formatting)0, Array.Empty<JsonConverter>()), timeout, cancel).ConfigureAwait(continueOnCapturedContext: false);
			try
			{
				return Wav.Parse(data);
			}
			catch (FormatException ex)
			{
				throw new ChatException(ChatErrorKind.BadResponse, "ElevenLabs did not send a WAV file: " + ex.Message, ex);
			}
		}

		public static async Task<List<VoiceInfo>> ListVoicesAsync(ChatEndpoint endpoint, CancellationToken cancel = default(CancellationToken))
		{
			List<VoiceInfo> voices = new List<VoiceInfo>();
			string text = null;
			for (int i = 0; i < 3; i++)
			{
				string path = "v2/voices?page_size=100" + ((text != null) ? ("&next_page_token=" + Uri.EscapeDataString(text)) : "");
				JObject val = Parse(await ChatClient.GetStringAsync(endpoint, path, TimeSpan.FromSeconds(15.0), cancel).ConfigureAwait(continueOnCapturedContext: false));
				JToken obj = val["voices"];
				foreach (JToken item in (JArray)(((object)((obj is JArray) ? obj : null)) ?? ((object)new JArray())))
				{
					string text2 = (string)item[(object)"voice_id"];
					if (string.IsNullOrWhiteSpace(text2))
					{
						continue;
					}
					JToken obj2 = item[(object)"labels"];
					JObject val2 = (JObject)(object)((obj2 is JObject) ? obj2 : null);
					object obj3 = (string)((val2 != null) ? val2["language"] : null);
					if (obj3 == null)
					{
						JToken obj4 = item[(object)"verified_languages"];
						JToken obj5 = ((obj4 is JArray) ? obj4 : null);
						object obj6;
						if (obj5 == null)
						{
							obj6 = null;
						}
						else
						{
							JToken? obj7 = ((IEnumerable<JToken>)obj5).FirstOrDefault();
							obj6 = ((obj7 != null) ? obj7[(object)"language"] : null);
						}
						obj3 = ((string)(JToken)obj6) ?? "";
					}
					string language = (string)obj3;
					voices.Add(new VoiceInfo(text2, ((string)item[(object)"name"]) ?? text2, language, ((string)((val2 != null) ? val2["gender"] : null)) ?? "", IsLibraryVoice(item)));
				}
				text = (((bool?)val["has_more"] == true) ? ((string)val["next_page_token"]) : null);
				if (text == null)
				{
					break;
				}
			}
			return voices.OrderBy((VoiceInfo v) => v.Library).ToList();
		}

		private static bool IsLibraryVoice(JToken voice)
		{
			JToken obj = voice[(object)"sharing"];
			JToken obj2 = ((obj is JObject) ? obj : null);
			string text = ((string)((obj2 != null) ? ((JObject)obj2)["status"] : null)) ?? "";
			if (text.StartsWith("copied", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			bool flag;
			switch (((string)voice[(object)"category"]) ?? "")
			{
			case "professional":
			case "famous":
			case "high_quality":
				flag = true;
				break;
			default:
				flag = false;
				break;
			}
			if (flag)
			{
				return (bool?)voice[(object)"is_owner"] != true;
			}
			return false;
		}

		public static async Task<List<string>> ListModelsAsync(ChatEndpoint endpoint, CancellationToken cancel = default(CancellationToken))
		{
			string text = await ChatClient.GetStringAsync(endpoint, "v1/models", TimeSpan.FromSeconds(15.0), cancel).ConfigureAwait(continueOnCapturedContext: false);
			try
			{
				return (from m in (IEnumerable<JToken>)JArray.Parse(text)
					where (bool?)m[(object)"can_do_text_to_speech"] != false
					select (string)m[(object)"model_id"] into id
					where !string.IsNullOrWhiteSpace(id)
					select (id)).ToList();
			}
			catch (JsonException ex)
			{
				JsonException inner = ex;
				throw new ChatException(ChatErrorKind.BadResponse, "The ElevenLabs model list is not JSON.", (Exception?)(object)inner);
			}
		}

		private static JObject Parse(string json)
		{
			//IL_000a: Expected O, but got Unknown
			try
			{
				return JObject.Parse(json);
			}
			catch (JsonException ex)
			{
				JsonException inner = ex;
				throw new ChatException(ChatErrorKind.BadResponse, "The ElevenLabs voice list is not JSON.", (Exception?)(object)inner);
			}
		}
	}
	internal static class FalSpeechClient
	{
		public const string DefaultBaseUrl = "https://fal.run";

		public static readonly string[] Models = new string[6] { "fal-ai/gemini-3.8-flash-lite-tts", "fal-ai/gemini-3.8-flash-tts", "fal-ai/gemini-3.1-flash-tts", "fal-ai/elevenlabs/tts/turbo-v2.5", "fal-ai/elevenlabs/tts/multilingual-v2", "fal-ai/elevenlabs/tts/eleven-v3" };

		public const string DefaultGeminiVoice = "Puck";

		public const string DefaultElevenVoice = "Rachel";

		public static readonly IReadOnlyList<(string Id, string Name, string Description)> ElevenVoices = new <>z__ReadOnlyArray<(string, string, string)>(new(string, string, string)[21]
		{
			("Rachel", "Rachel", "Calm, female"),
			("Aria", "Aria", "Expressive, female"),
			("Sarah", "Sarah", "Soft, female"),
			("Laura", "Laura", "Upbeat, female"),
			("Alice", "Alice", "Confident, British female"),
			("Matilda", "Matilda", "Friendly, female"),
			("Jessica", "Jessica", "Expressive, young female"),
			("Lily", "Lily", "Warm, British female"),
			("Charlotte", "Charlotte", "Seductive, female"),
			("River", "River", "Confident, neutral"),
			("Roger", "Roger", "Confident, male"),
			("Charlie", "Charlie", "Natural, Australian male"),
			("George", "George", "Warm, British male"),
			("Callum", "Callum", "Intense, male"),
			("Liam", "Liam", "Articulate, young male"),
			("Will", "Will", "Friendly, young male"),
			("Eric", "Eric", "Friendly, male"),
			("Chris", "Chris", "Casual, male"),
			("Brian", "Brian", "Deep, male"),
			("Daniel", "Daniel", "Authoritative, British male"),
			("Bill", "Bill", "Trustworthy, older male")
		});

		public static bool IsGemini(string model)
		{
			return model.IndexOf("gemini", StringComparison.OrdinalIgnoreCase) >= 0;
		}

		public static IReadOnlyList<(string Id, string Name, string Description)> VoicesFor(string model)
		{
			if (!IsGemini(model))
			{
				return ElevenVoices;
			}
			return KieSpeechClient.GeminiVoices.Take(30).ToList();
		}

		public static ChatEndpoint Endpoint(string? key, string baseUrl = "https://fal.run")
		{
			return new ChatEndpoint(baseUrl, "", key, ChatProtocol.OpenAiCompatible, Kie: false, Fal: true);
		}

		public static async Task<string> SpeakToUrlAsync(ChatEndpoint endpoint, string model, string voice, string text, TimeSpan timeout, CancellationToken cancel = default(CancellationToken), string? style = null, float speed = 1f)
		{
			model = model.Trim();
			JObject val;
			if (IsGemini(model))
			{
				val = new JObject
				{
					["prompt"] = JToken.op_Implicit(text),
					["voice"] = JToken.op_Implicit(string.IsNullOrWhiteSpace(voice) ? "Puck" : voice.Trim())
				};
				if (model.IndexOf("gemini-3.1", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					val["output_format"] = JToken.op_Implicit("wav");
				}
				if (!string.IsNullOrWhiteSpace(style))
				{
					val["style_instructions"] = JToken.op_Implicit(style);
				}
			}
			else
			{
				val = new JObject
				{
					["text"] = JToken.op_Implicit(text),
					["voice"] = JToken.op_Implicit(string.IsNullOrWhiteSpace(voice) ? "Rachel" : voice.Trim())
				};
				if (model.IndexOf("eleven-v3", StringComparison.OrdinalIgnoreCase) < 0)
				{
					val["speed"] = JToken.op_Implicit(Math.Round(Math.Min(1.2f, Math.Max(0.7f, speed)), 2));
				}
			}
			byte[] bytes = await ChatClient.PostForBytesAsync(endpoint, model, ((JToken)val).ToString((Formatting)0, Array.Empty<JsonConverter>()), timeout, cancel).ConfigureAwait(continueOnCapturedContext: false);
			JObject val2;
			try
			{
				val2 = JObject.Parse(Encoding.UTF8.GetString(bytes));
			}
			catch (JsonException ex)
			{
				JsonException inner = ex;
				throw new ChatException(ChatErrorKind.BadResponse, "fal.ai: the answer is not JSON.", (Exception?)(object)inner);
			}
			JToken obj = val2["audio"];
			string text2 = (string)((obj != null) ? obj[(object)"url"] : null);
			if (string.IsNullOrWhiteSpace(text2))
			{
				throw new ChatException(ChatErrorKind.BadResponse, "fal.ai: no audio in the answer.");
			}
			return text2;
		}
	}
	internal static class GoogleSpeechClient
	{
		public const string DefaultBaseUrl = "https://generativelanguage.googleapis.com/v1beta";

		public static readonly string[] Models = new string[3] { "gemini-3.8-flash-lite-tts", "gemini-3.8-flash-tts", "gemini-3.1-flash-tts-preview" };

		private const int PcmRate = 24000;

		public static IReadOnlyList<(string Id, string Name, string Description)> Voices => KieSpeechClient.GeminiVoices;

		public static IReadOnlyList<(string Id, string Name, string Description)> VoicesFor(string model)
		{
			if (model.IndexOf("gemini-3.1", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return Voices;
			}
			return Voices.Take(30).ToList();
		}

		public static ChatEndpoint Endpoint(string? key, string baseUrl = "https://generativelanguage.googleapis.com/v1beta")
		{
			return new ChatEndpoint(baseUrl, "", key, ChatProtocol.Google);
		}

		public static async Task<VoiceAudio> SynthesizeAsync(ChatEndpoint endpoint, string model, string voice, string text, string? style, TimeSpan timeout, CancellationToken cancel = default(CancellationToken))
		{
			JObject val = new JObject
			{
				["type"] = JToken.op_Implicit("text"),
				["text"] = JToken.op_Implicit(text)
			};
			if (!string.IsNullOrWhiteSpace(style))
			{
				JArray val2 = new JArray();
				val2.Add((JToken)new JObject
				{
					["type"] = JToken.op_Implicit("speech_metadata"),
					["style"] = JToken.op_Implicit(style.Trim())
				});
				val["annotations"] = (JToken)val2;
			}
			JObject val3 = new JObject { ["model"] = JToken.op_Implicit(model) };
			JArray val4 = new JArray();
			JObject val5 = new JObject { ["type"] = JToken.op_Implicit("user_input") };
			JArray val6 = new JArray();
			val6.Add((JToken)(object)val);
			val5["content"] = (JToken)val6;
			val4.Add((JToken)val5);
			val3["input"] = (JToken)val4;
			val3["response_format"] = (JToken)new JObject
			{
				["type"] = JToken.op_Implicit("audio"),
				["mime_type"] = JToken.op_Implicit("audio/wav")
			};
			JObject val7 = new JObject();
			JArray val8 = new JArray();
			val8.Add((JToken)new JObject { ["voice"] = JToken.op_Implicit(string.IsNullOrWhiteSpace(voice) ? "Puck" : voice.Trim()) });
			val7["speech_config"] = (JToken)val8;
			val3["generation_config"] = (JToken)val7;
			JObject val9 = val3;
			byte[] answer;
			try
			{
				answer = await ChatClient.PostForBytesAsync(endpoint, "interactions", ((JToken)val9).ToString((Formatting)0, Array.Empty<JsonConverter>()), timeout, cancel).ConfigureAwait(continueOnCapturedContext: false);
			}
			catch (ChatException ex) when (ex.Kind == ChatErrorKind.BadRequest && (ex.Message.IndexOf("API key not valid", StringComparison.OrdinalIgnoreCase) >= 0 || ex.Message.IndexOf("API_KEY_INVALID", StringComparison.OrdinalIgnoreCase) >= 0))
			{
				throw new ChatException(ChatErrorKind.Unauthorized, ex.Message, ex);
			}
			byte[] array = Convert.FromBase64String(AudioData(answer));
			try
			{
				return (array.Length >= 12 && Encoding.ASCII.GetString(array, 0, 4) == "RIFF") ? Wav.Parse(array) : FromPcm(array);
			}
			catch (FormatException ex2)
			{
				throw new ChatException(ChatErrorKind.BadResponse, "Google did not send a WAV file: " + ex2.Message, ex2);
			}
		}

		private static string AudioData(byte[] answer)
		{
			//IL_0014: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			JObject val;
			try
			{
				val = JObject.Parse(Encoding.UTF8.GetString(answer));
			}
			catch (JsonException ex)
			{
				JsonException inner = ex;
				throw new ChatException(ChatErrorKind.BadResponse, "Google's answer is not JSON.", (Exception?)(object)inner);
			}
			JToken obj = val["steps"];
			string text = (from content in ((IEnumerable<JToken>)(((object)((obj is JArray) ? obj : null)) ?? ((object)new JArray()))).Where((JToken step) => (string)step[(object)"type"] == "model_output").SelectMany(delegate(JToken step)
				{
					//IL_0014: Unknown result type (might be due to invalid IL or missing references)
					JToken obj2 = step[(object)"content"];
					return (IEnumerable<JToken>)(((object)((obj2 is JArray) ? obj2 : null)) ?? ((object)new JArray()));
				})
				where (string)content[(object)"type"] == "audio"
				select (string)content[(object)"data"]).LastOrDefault((string value) => !string.IsNullOrEmpty(value));
			return text ?? throw new ChatException(ChatErrorKind.BadResponse, "Google's answer has no audio.");
		}

		private static VoiceAudio FromPcm(byte[] pcm)
		{
			float[] array = new float[pcm.Length / 2];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = (float)BitConverter.ToInt16(pcm, i * 2) / 32768f;
			}
			return new VoiceAudio(array, 1, 24000);
		}
	}
	internal static class KieSpeechClient
	{
		public const string DefaultBaseUrl = "https://api.kie.ai";

		public static readonly string[] Models = new string[5] { "elevenlabs/text-to-speech-turbo-2-5", "elevenlabs/text-to-speech-multilingual-v2", "google/gemini-3-8-flash-tts", "google/gemini-3-8-flash-lite-tts", "google/gemini-3-1-flash-tts" };

		public const string DefaultGeminiVoice = "Puck";

		public static readonly IReadOnlyList<(string Id, string Name, string Description)> GeminiVoices = new <>z__ReadOnlyArray<(string, string, string)>(new(string, string, string)[70]
		{
			("Puck", "Puck", "Upbeat"),
			("Fenrir", "Fenrir", "Excitable"),
			("Zephyr", "Zephyr", "Bright"),
			("Leda", "Leda", "Youthful"),
			("Charon", "Charon", "Informative"),
			("Kore", "Kore", "Firm"),
			("Orus", "Orus", "Firm"),
			("Aoede", "Aoede", "Breezy"),
			("Callirrhoe", "Callirrhoe", "Easy-going"),
			("Autonoe", "Autonoe", "Bright"),
			("Enceladus", "Enceladus", "Breathy"),
			("Iapetus", "Iapetus", "Clear"),
			("Umbriel", "Umbriel", "Easy-going"),
			("Algieba", "Algieba", "Smooth"),
			("Despina", "Despina", "Smooth"),
			("Erinome", "Erinome", "Clear"),
			("Algenib", "Algenib", "Gravelly"),
			("Rasalgethi", "Rasalgethi", "Informative"),
			("Laomedeia", "Laomedeia", "Upbeat"),
			("Achernar", "Achernar", "Soft"),
			("Alnilam", "Alnilam", "Firm"),
			("Schedar", "Schedar", "Even"),
			("Gacrux", "Gacrux", "Mature"),
			("Pulcherrima", "Pulcherrima", "Forward"),
			("Achird", "Achird", "Friendly"),
			("Zubenelgenubi", "Zubenelgenubi", "Casual"),
			("Vindemiatrix", "Vindemiatrix", "Gentle"),
			("Sadachbia", "Sadachbia", "Lively"),
			("Sadaltager", "Sadaltager", "Knowledgeable"),
			("Sulafat", "Sulafat", "Warm"),
			("Bodi", "Bodi", "Tutor, 3.8"),
			("Lumi", "Lumi", "Tutor, 3.8"),
			("Sola", "Sola", "Tutor, 3.8"),
			("Varo", "Varo", "Tutor, 3.8"),
			("Koda", "Koda", "Commercial voiceover, 3.8"),
			("Nika", "Nika", "Commercial voiceover, 3.8"),
			("Tavi", "Tavi", "Commercial voiceover, 3.8"),
			("Zeno", "Zeno", "Commercial voiceover, 3.8"),
			("Kira", "Kira", "Instructional, 3.8"),
			("Ludo", "Ludo", "Instructional, 3.8"),
			("Mako", "Mako", "Instructional, 3.8"),
			("Rina", "Rina", "Instructional, 3.8"),
			("Brio", "Brio", "Podcast, 3.8"),
			("Jori", "Jori", "Podcast, 3.8"),
			("Rami", "Rami", "Podcast, 3.8"),
			("Veda", "Veda", "Podcast, 3.8"),
			("Enzo", "Enzo", "Storyteller, 3.8"),
			("Riko", "Riko", "Storyteller, 3.8"),
			("Sami", "Sami", "Storyteller, 3.8"),
			("Zali", "Zali", "Storyteller, 3.8"),
			("Gero", "Gero", "Digital assistant, 3.8"),
			("Neno", "Neno", "Digital assistant, 3.8"),
			("Olin", "Olin", "Digital assistant, 3.8"),
			("Tari", "Tari", "Digital assistant, 3.8"),
			("Daro", "Daro", "Call center, 3.8"),
			("Fola", "Fola", "Call center, 3.8"),
			("Hali", "Hali", "Call center, 3.8"),
			("Milo", "Milo", "Call center, 3.8"),
			("Arlo", "Arlo", "Concierge, 3.8"),
			("Cleo", "Cleo", "Concierge, 3.8"),
			("Finn", "Finn", "Concierge, 3.8"),
			("Lora", "Lora", "Concierge, 3.8"),
			("Enya", "Enya", "Tech support, 3.8"),
			("Jett", "Jett", "Tech support, 3.8"),
			("Knox", "Knox", "Tech support, 3.8"),
			("Nyla", "Nyla", "Tech support, 3.8"),
			("Cruz", "Cruz", "Professional, 3.8"),
			("Elio", "Elio", "Professional, 3.8"),
			("Tova", "Tova", "Professional, 3.8"),
			("Zuri", "Zuri", "Professional, 3.8")
		});

		private static bool s_skipLanguageCode;

		public static readonly IReadOnlyList<(string Id, string Name, string Description)> Voices = new <>z__ReadOnlyArray<(string, string, string)>(new(string, string, string)[64]
		{
			("EkK5I93UQWFDigLMpZcX", "James", "Husky, Engaging and Bold"),
			("Z3R5wn05IrDiVCyEkUrK", "Arabella", "Mysterious and Emotive"),
			("NNl6r8mD7vthiJatiJt1", "Bradford", "Expressive"),
			("YOq2y2Up4RgXP2HyXjE5", "Xavier", "Dominating, Metallic"),
			("B8gJV1IhpuegLxdpXFOE", "Kuon", "Cheerful, Clear and Steady"),
			("2zRM7PkgwBPiau2jvVXc", "Monika Sogam", "Deep and Natural"),
			("1SM7GgM6IMuvQlz2BwM3", "Mark", "Casual, Relaxed and Light"),
			("5l5f8iK3YPeGga21rQIX", "Adeline", "Feminine"),
			("scOwDtmlUjD3prqpp97I", "Sam", "Support Agent"),
			("NOpBlnGInO9m6vDvFkFC", "Spuds Oxley", "Wise"),
			("BZgkqPqms7Kj9ulSkVzn", "Eve", "Authentic, Energetic"),
			("DGzg6RaUqxGRTHSBjfgF", "Brock", "Commanding and Loud"),
			("x70vRnQBMBu4FAYhjJbO", "Nathan", "Virtual Radio Host"),
			("Sm1seazb4gs7RSlUVw7c", "Anika", "Animated, Friendly"),
			("P1bg08DkjqiVEzOn76yG", "Viraj", "Rich and Soft"),
			("qDuRKMlYmrm8trt5QyBn", "Taksh", "Calm, Serious and Smooth"),
			("qXpMhyvQqiRxWQs4qSSB", "Horatius", "Energetic Character"),
			("TX3LPaxmHKxFdv7VOQHJ", "Liam", "Energetic, Social Media"),
			("N2lVS1w4EtoT3dr4eOWO", "Callum", "Husky Trickster"),
			("FGY2WhTYpPnrIDTdsKH5", "Laura", "Enthusiast, Quirky"),
			("kPzsL2i3teMYv0FxEYQ6", "Brittney", "Social Media Voice -"),
			("UgBBYS2sOqTuMpoF3BR0", "Mark", "Natural Conversations"),
			("hpp4J3VqNfWAUOO0d1Us", "Bella", "Professional, Bright"),
			("nPczCjzI2devNBz1zQrb", "Brian", "Deep, Resonant"),
			("uYXf8XasLslADfZ2MB4u", "Hope", "Bubbly, Gossipy and Girly"),
			("gs0tAILXbY5DNrJrsM6F", "Jeff", "Classy, Resonating"),
			("DTKMou8ccj1ZaWGBiotd", "Jamahal", "Young, Vibrant"),
			("vBKc2FfBKJfcZNyEt1n6", "Finn", "Youthful, Eager"),
			("DYkrAHD8iwork3YSUBbs", "Tom", "Conversations & Books"),
			("56AoDkrOh6qfVPDXZ7Pt", "Cassidy", "Crisp, Direct and Clear"),
			("eR40ATw9ArzDf9h3v7t7", "Addison 2.0", "Australian"),
			("g6xIsTj2HwM6VR4iXFCw", "Jessica Anne Bogart", "Chatty"),
			("lcMyyd2HUfFzxdCaC4Ta", "Lucy", "Fresh & Casual"),
			("6aDn1KB0hjpdcocrUkmq", "Tiffany", "Natural and Welcoming"),
			("Sq93GQT4X1lKDXsQcixO", "Felix", "Warm, Positive"),
			("flHkNRp1BlvT73UL6gyz", "Jessica Anne Bogart", "Eloquent"),
			("9yzdeviXkFddZ4Oz8Mok", "Lutz", "Chuckling, Giggly"),
			("pPdl9cQBQq4p6mRkZy2Z", "Emma", "Adorable and Upbeat"),
			("zYcjlYFOd3taleS0gkk3", "Edward", "Loud, Confident"),
			("nzeAacJi50IvxcyDnMXa", "Marshal", "Friendly, Funny"),
			("ruirxsoakN0GWmGNIo04", "John Morgan", "Gritty, Rugged"),
			("TC0Zp7WVFzhA8zpTlRqV", "Aria", "Sultry Villain"),
			("ljo9gAlSqKOvF6D8sOsX", "Viking Bjorn", "Epic Medieval"),
			("8JVbfL6oEdmuxKn5DK2C", "Johnny Kid", "Serious and Calm"),
			("iCrDUkL56s3C8sCRl7wb", "Hope", "Poetic, Romantic"),
			("wJqPPQ618aTW29mptyoc", "Ana Rita", "Smooth, Expressive"),
			("EiNlNiXeDU1pqqOPrYMO", "John Doe", "Deep"),
			("4YYIPFl9wE5c4L2eu2Gb", "Burt Reynolds™", "Deep, Smooth"),
			("6F5Zhi321D3Oq7v1oNT4", "Hank", "Deep and Engaging Narrator"),
			("YXpFCvM1S3JbWEJhoskW", "Wyatt", "Wise Rustic Cowboy"),
			("LG95yZDEHg6fCZdQjLqj", "Phil", "Explosive, Passionate"),
			("CeNX9CMwmxDxUF5Q2Inm", "Johnny Dynamite", "Vintage Radio"),
			("aD6riP1btT197c6dACmy", "Rachel M", "Pro British Radio"),
			("mtrellq69YZsNwzUSyXh", "Rex Thunder", "Deep N Tough"),
			("dHd5gvgSOzSfduK4CvEg", "Ed", "Late Night Announcer"),
			("eVItLK1UvXctxuaRV2Oq", "Jean", "Alluring and Playful Femme"),
			("esy0r39YPLQjOczyOib8", "Britney", "Calm and Calculative"),
			("Tsns2HvNFKfGiNjllgqo", "Sven", "Emotional and Nice"),
			("1U02n4nD6AdIZ9CjF053", "Viraj", "Smooth and Gentle"),
			("AeRdCCKzvd23BpJoofzx", "Nathaniel", "Engaging, British"),
			("LruHrtVF6PSyGItzMNHS", "Benjamin", "Deep, Warm, Calming"),
			("1wGbFxmAM3Fgw63G1zZJ", "Allison", "Calm, Soothing"),
			("hqfrgApggtO1785R4Fsn", "Theodore HQ", "Serene and Grounded"),
			("MJ0RnG71ty4LH3dvNfSd", "Leon", "Soothing and Grounded")
		});

		public static bool IsGemini(string model)
		{
			return model.Trim().StartsWith("google/", StringComparison.OrdinalIgnoreCase);
		}

		public static string GeminiSibling(string model)
		{
			if (model.IndexOf("gemini-3-8-flash-lite", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return "google/gemini-3-8-flash-lite-tts";
			}
			return "google/gemini-3-8-flash-tts";
		}

		public static IReadOnlyList<(string Id, string Name, string Description)> VoicesFor(string model)
		{
			if (IsGemini(model))
			{
				if (model.IndexOf("gemini-3-1", StringComparison.OrdinalIgnoreCase) < 0)
				{
					return GeminiVoices;
				}
				return GeminiVoices.Take(30).ToList();
			}
			return Voices;
		}

		public static ChatEndpoint Endpoint(string? key, string baseUrl = "https://api.kie.ai")
		{
			return new ChatEndpoint(baseUrl, "", key, ChatProtocol.OpenAiCompatible, Kie: true);
		}

		public static async Task<string> SpeakToUrlAsync(ChatEndpoint endpoint, string model, string voice, string text, string? languageCode, TimeSpan timeout, CancellationToken cancel = default(CancellationToken), string? style = null, float speed = 1f, Action<string>? retrying = null)
		{
			model = model.Trim();
			if (IsGemini(model))
			{
				string[] models = new string[3]
				{
					model,
					model,
					GeminiSibling(model)
				};
				DateTime started = DateTime.UtcNow;
				int attempt = 0;
				while (true)
				{
					try
					{
						return await RunTaskAsync(endpoint, GeminiBody(models[attempt], voice, text, style), timeout - (DateTime.UtcNow - started), cancel).ConfigureAwait(continueOnCapturedContext: false);
					}
					catch (ChatException ex) when (attempt + 1 < models.Length && ex.Kind == ChatErrorKind.BadResponse && ex.Message.StartsWith("kie.ai:", StringComparison.Ordinal) && timeout - (DateTime.UtcNow - started) > TimeSpan.FromSeconds(15.0))
					{
						retrying?.Invoke(models[attempt + 1]);
					}
					attempt++;
				}
			}
			bool withLanguage = !s_skipLanguageCode && !string.IsNullOrWhiteSpace(languageCode) && model.IndexOf("turbo", StringComparison.OrdinalIgnoreCase) >= 0;
			try
			{
				return await RunTaskAsync(endpoint, ElevenLabsBody(model, voice, text, withLanguage ? languageCode : null, speed), timeout, cancel).ConfigureAwait(continueOnCapturedContext: false);
			}
			catch (ChatException ex2) when (withLanguage && ex2.Kind == ChatErrorKind.BadResponse && ex2.Message.StartsWith("kie.ai:", StringComparison.Ordinal))
			{
				string result = await RunTaskAsync(endpoint, ElevenLabsBody(model, voice, text, null, speed), timeout, cancel).ConfigureAwait(continueOnCapturedContext: false);
				s_skipLanguageCode = true;
				return result;
			}
		}

		private static JObject ElevenLabsBody(string model, string voice, string text, string? languageCode, float speed = 1f)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			JObject val = new JObject
			{
				["text"] = JToken.op_Implicit(text),
				["voice"] = JToken.op_Implicit(voice),
				["stability"] = JToken.op_Implicit(0.5),
				["similarity_boost"] = JToken.op_Implicit(0.75),
				["style"] = JToken.op_Implicit(0),
				["speed"] = JToken.op_Implicit(Math.Round(Math.Min(1.2f, Math.Max(0.7f, speed)), 2))
			};
			if (languageCode != null)
			{
				val["language_code"] = JToken.op_Implicit(languageCode);
			}
			return new JObject
			{
				["model"] = JToken.op_Implicit(model),
				["input"] = (JToken)(object)val
			};
		}

		private static JObject GeminiBody(string model, string voice, string text, string? style)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: 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_007f: Expected O, but got Unknown
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected O, but got Unknown
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Expected O, but got Unknown
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Expected O, but got Unknown
			bool flag = model.IndexOf("gemini-3-1", StringComparison.OrdinalIgnoreCase) >= 0;
			JObject val = new JObject
			{
				["speaker_id"] = JToken.op_Implicit("Speaker 1"),
				["voice_name"] = JToken.op_Implicit(string.IsNullOrWhiteSpace(voice) ? "Puck" : voice.Trim())
			};
			JObject val2 = new JObject
			{
				["speaker_id"] = JToken.op_Implicit("Speaker 1"),
				["text"] = JToken.op_Implicit(text)
			};
			JObject val3 = new JObject { ["temperature"] = JToken.op_Implicit(1) };
			if (flag)
			{
				val["accent"] = JToken.op_Implicit("Neutral");
			}
			if (!string.IsNullOrWhiteSpace(style))
			{
				if (flag)
				{
					val3["sample_context"] = JToken.op_Implicit(style);
				}
				else
				{
					val2["style"] = JToken.op_Implicit(style);
				}
			}
			val3["speakers"] = (JToken)new JArray((object)val);
			val3["dialogue_turns"] = (JToken)new JArray((object)val2);
			return new JObject
			{
				["model"] = JToken.op_Implicit(model),
				["input"] = (JToken)(object)val3
			};
		}

		private static async Task<string> RunTaskAsync(ChatEndpoint endpoint, JObject body, TimeSpan timeout, CancellationToken cancel)
		{
			DateTime started = DateTime.UtcNow;
			JObject val = Parse(await ChatClient.PostForBytesAsync(endpoint, "api/v1/jobs/createTask", ((JToken)body).ToString((Formatting)0, Array.Empty<JsonConverter>()), timeout, cancel).ConfigureAwait(continueOnCapturedContext: false));
			JToken obj = val["data"];
			string taskId = (string)((obj != null) ? obj[(object)"taskId"] : null);
			if (string.IsNullOrWhiteSpace(taskId))
			{
				throw new ChatException(ChatErrorKind.BadResponse, "kie.ai did not return a task id.");
			}
			TimeSpan delay = TimeSpan.FromMilliseconds(400.0);
			JToken val2;
			while (true)
			{
				await Task.Delay(delay, cancel).ConfigureAwait(continueOnCapturedContext: false);
				if (DateTime.UtcNow - started > timeout)
				{
					throw new ChatException(ChatErrorKind.Timeout, $"The kie.ai speech task took longer than {timeout.TotalSeconds:0} s.");
				}
				string s = await ChatClient.GetStringAsync(endpoint, "api/v1/jobs/recordInfo?taskId=" + Uri.EscapeDataString(taskId), TimeSpan.FromSeconds(15.0), cancel).ConfigureAwait(continueOnCapturedContext: false);
				val2 = Parse(Encoding.UTF8.GetBytes(s))["data"];
				string text = (string)((val2 != null) ? val2[(object)"state"] : null);
				if (text == "success")
				{
					string text2 = ResultUrl((string)((val2 != null) ? val2[(object)"resultJson"] : null));
					return text2 ?? throw new ChatException(ChatErrorKind.BadResponse, "The kie.ai speech task finished without a file.");
				}
				if (text == "fail")
				{
					break;
				}
				if (delay < TimeSpan.FromSeconds(1.5))
				{
					delay += TimeSpan.FromMilliseconds(200.0);
				}
			}
			string text3 = ((string)((val2 != null) ? val2[(object)"failCode"] : null)) ?? "";
			throw new ChatException(ChatErrorKind.BadResponse, "kie.ai: " + (((string)((val2 != null) ? val2[(object)"failMsg"] : null)) ?? "the speech task failed") + ((text3.Length > 0) ? (" (code " + text3 + ")") : ""));
		}

		private static string? ResultUrl(string? resultJson)
		{
			if (string.IsNullOrWhiteSpace(resultJson))
			{
				return null;
			}
			try
			{
				JToken obj = JObject.Parse(resultJson)["resultUrls"];
				return (string)((IEnumerable<JToken>)((obj is JArray) ? obj : null))?.FirstOrDefault();
			}
			catch (JsonException)
			{
				return null;
			}
		}

		private static JObject Parse(byte[] body)
		{
			//IL_0014: Expected O, but got Unknown
			JObject val;
			try
			{
				val = JObject.Parse(Encoding.UTF8.GetString(body));
			}
			catch (JsonException ex)
			{
				JsonException inner = ex;
				throw new ChatException(ChatErrorKind.BadResponse, "kie.ai's answer is not JSON.", (Exception?)(object)inner);
			}
			ChatClient.ThrowIfServiceError(val);
			return val;
		}
	}
	internal static class ListenService
	{
		public const string Groq = "groq";

		public const string OpenAi = "openai";

		public const string Server = "server";

		public const string Local = "local";

		public const string Off = "off";

		public static readonly string[] Providers = new string[5] { "groq", "openai", "server", "local", "off" };

		public static readonly string[] OnlineProviders = new string[3] { "groq", "openai", "server" };

		public const string GroqUrl = "https://api.groq.com/openai/v1";

		public const string OpenAiUrl = "https://api.openai.com/v1";

		public const string ServerKey = "listen-server";

		public const int MaxSeconds = 30;

		public static readonly string[] GroqModels = new string[2] { "whisper-large-v3-turbo", "whisper-large-v3" };

		public static readonly string[] OpenAiModels = new string[2] { "gpt-transcribe", "gpt-4o-mini-transcribe" };

		public static string Provider
		{
			get
			{
				string text = Plugin.ListenProvider.Value.Trim().ToLowerInvariant();
				if (Array.IndexOf(Providers, text) < 0)
				{
					return "groq";
				}
				return text;
			}
		}

		public static bool Enabled => Provider != "off";

		public static ChatEndpoint Endpoint => Provider switch
		{
			"openai" => new ChatEndpoint("https://api.openai.com/v1", OrDefault(Plugin.ListenOpenAiModel.Value, OpenAiModels[0]), SecretStore.Get(KeyName("openai"))), 
			"server" => new ChatEndpoint(Plugin.ListenServerUrl.Value.Trim(), Plugin.ListenServerModel.Value.Trim(), SecretStore.Get("listen-server")), 
			"local" => new ChatEndpoint(Plugin.ListenLocalUrl.Value.Trim(), Plugin.ListenLocalModel.Value.Trim(), null), 
			_ => new ChatEndpoint("https://api.groq.com/openai/v1", OrDefault(Plugin.ListenGroqModel.Value, GroqModels[0]), SecretStore.Get(KeyName("groq"))), 
		};

		public static bool IsConfigured
		{
			get
			{
				string provider = Provider;
				return provider switch
				{
					"off" => false, 
					"server" => !string.IsNullOrWhiteSpace(Plugin.ListenServerUrl.Value), 
					"local" => !string.IsNullOrWhiteSpace(Plugin.ListenLocalUrl.Value), 
					_ => SecretStore.Has(KeyName(provider)), 
				};
			}
		}

		public static string? GameMicrophone
		{
			get
			{
				try
				{
					GameHandler instance = GameHandler.Instance;
					object obj;
					if (instance == null)
					{
						obj = null;
					}
					else
					{
						SettingsHandler settingsHandler = instance.SettingsHandler;
						obj = ((settingsHandler == null) ? null : settingsHandler.GetSetting<MicrophoneSetting>()?.Value.id);
					}
					string text = (string)obj;
					return string.IsNullOrWhiteSpace(text) ? null : text;
				}
				catch (Exception ex)
				{
					Plugin.Verbose("Could not read the game's microphone setting: " + ex.Message);
					return null;
				}
			}
		}

		public static bool IsOnline(string provider)
		{
			return Array.IndexOf(OnlineProviders, provider) >= 0;
		}

		public static string KeyName(string provider)
		{
			if (!(provider == "groq"))
			{
				if (provider == "openai")
				{
					return "openai";
				}
				return "listen-server";
			}
			return "groq";
		}

		private static string OrDefault(string model, string fallback)
		{
			if (!string.IsNullOrWhiteSpace(model))
			{
				return model.Trim();
			}
			return fallback;
		}

		public static MicRecorder StartRecording()
		{
			return MicRecorder.Start(GameMicrophone, 30);
		}

		public static bool IsSilence(short[] samples)
		{
			float num = (float)samples.Length / 16000f;
			var (num2, num3) = MicRecorder.Loudness(samples);
			Plugin.Verbose($"Spoken question: {num:0.0} s, peak {num2:0.000}, level {num3:0.0000}.");
			if (!(num < 0.4f))
			{
				return num2 < 0.01f;
			}
			return true;
		}

		public static async Task<string?> RecognizeAsync(short[] samples, CancellationToken cancel = default(CancellationToken))
		{
			if (IsSilence(samples))
			{
				return null;
			}
			ChatEndpoint endpoint = Endpoint;
			bool flag = SpeechLanguage.Current == Lang.Current;
			string text = await TranscriptionClient.TranscribeAsync(endpoint, Wav.Encode(samples, 16000), flag ? SpeechLanguage.Iso : null, flag ? Lang.Get("listen.prompt") : null, TimeSpan.FromSeconds(Math.Max(15, Plugin.TimeoutSeconds.Value)), cancel);
			Usage.Add(Usage.Listen(Provider), 0L, 0L, (double)samples.Length / 16000.0);
			Plugin.Verbose("Heard (" + endpoint.Model + "): " + text);
			return TranscriptionClient.IsPhantom(text) ? null : text;
		}
	}
	internal sealed class MicRecorder : IDisposable
	{
		private struct WaveHeader
		{
			public IntPtr lpData;

			public uint dwBufferLength;

			public uint dwBytesRecorded;

			public IntPtr dwUser;

			public uint dwFlags;

			public uint dwLoops;

			public IntPtr lpNext;

			public IntPtr reserved;
		}

		[StructLayout(LayoutKind.Sequential, Pack = 2)]
		private struct WaveFormat
		{
			public ushort wFormatTag;

			public ushort nChannels;

			public uint nSamplesPerSec;

			public uint nAvgBytesPerSec;

			public ushort nBlockAlign;

			public ushort wBitsPerSample;

			public ushort cbSize;
		}

		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
		private struct WaveInCaps
		{
			public ushort wMid;

			public ushort wPid;

			public uint vDriverVersion;

			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
			public string szPname;

			public uint dwFormats;

			public ushort wChannels;

			public ushort wReserved1;
		}

		public const int SampleRate = 16000;

		private const uint WaveMapper = uint.MaxValue;

		private const uint WaveMapped = 4u;

		private const uint HeaderDone = 1u;

		private static readonly uint s_headerSize = (uint)Marshal.SizeOf<WaveHeader>();

		private static readonly int s_flagsOffset = Marshal.OffsetOf<WaveHeader>("dwFlags").ToInt32();

		private IntPtr _handle;

		private IntPtr _header;

		private IntPtr _data;

		private bool _prepared;

		private readonly int _bytes;

		private readonly DateTime _started;

		public string DeviceName { get; }

		public TimeSpan Elapsed => DateTime.UtcNow - _started;

		public bool IsFull
		{
			get
			{
				if (_header != IntPtr.Zero)
				{
					return (Marshal.ReadInt32(_header, s_flagsOffset) & 1) != 0;
				}
				return false;
			}
		}

		public static MicRecorder Start(string? preferredDevice, int maxSeconds)
		{
			if (waveInGetNumDevs() == 0)
			{
				throw new InvalidOperationException("Windows sees no microphone.");
			}
			string name;
			uint num = FindDevice(preferredDevice, out name);
			WaveFormat format = new WaveFormat
			{
				wFormatTag = 1,
				nChannels = 1,
				nSamplesPerSec = 16000u,
				nAvgBytesPerSec = 32000u,
				nBlockAlign = 2,
				wBitsPerSample = 16
			};
			Check(waveInOpen(out var handle, num, ref format, IntPtr.Zero, IntPtr.Zero, (num != uint.MaxValue) ? 4u : 0u), "open");
			return new MicRecorder(handle, maxSeconds, name);
		}

		public static List<string> Devices()
		{
			List<string> list = new List<string>();
			uint num = waveInGetNumDevs();
			for (uint num2 = 0u; num2 < num; num2++)
			{
				if (waveInGetDevCaps((UIntPtr)num2, out var caps, (uint)Marshal.SizeOf<WaveInCaps>()) == 0)
				{
					list.Add(caps.szPname ?? "");
				}
			}
			return list;
		}

		public static (float Peak, float Rms) Loudness(short[] samples)
		{
			if (samples.Length == 0)
			{
				return (Peak: 0f, Rms: 0f);
			}
			int num = 0;
			double num2 = 0.0;
			foreach (short num3 in samples)
			{
				int num4 = Math.Abs((int)num3);
				if (num4 > num)
				{
					num = num4;
				}
				num2 += (double)num3 * (double)num3;
			}
			return (Peak: (float)num / 32768f, Rms: (float)(Math.Sqrt(num2 / (double)samples.Length) / 32768.0));
		}

		private MicRecorder(IntPtr handle, int maxSeconds, string deviceName)
		{
			_handle = handle;
			DeviceName = deviceName;
			_bytes = 32000 * Math.Max(1, maxSeconds);
			try
			{
				_data = Marshal.AllocHGlobal(_bytes);
				_header = Marshal.AllocHGlobal((int)s_headerSize);
				Marshal.StructureToPtr(new WaveHeader
				{
					lpData = _data,
					dwBufferLength = (uint)_bytes
				}, _header, fDeleteOld: false);
				Check(waveInPrepareHeader(_handle, _header, s_headerSize), "prepare");
				_prepared = true;
				Check(waveInAddBuffer(_handle, _header, s_headerSize), "add buffer");
				Check(waveInStart(_handle), "start");
				_started = DateTime.UtcNow;
			}
			catch
			{
				Release();
				throw;
			}
		}

		public short[] Stop()
		{
			if (_handle == IntPtr.Zero)
			{
				return Array.Empty<short>();
			}
			waveInReset(_handle);
			int num = (int)Math.Min(Marshal.PtrToStructure<WaveHeader>(_header).dwBytesRecorded, (uint)_bytes);
			short[] array = new short[num / 2];
			Marshal.Copy(_data, array, 0, array.Length);
			Release();
			return array;
		}

		public void Dispose()
		{
			Release();
		}

		private void Release()
		{
			if (_handle != IntPtr.Zero)
			{
				waveInReset(_handle);
				if (_prepared)
				{
					waveInUnprepareHeader(_handle, _header, s_headerSize);
				}
				waveInClose(_handle);
				_handle = IntPtr.Zero;
			}
			_prepared = false;
			if (_header != IntPtr.Zero)
			{
				Marshal.FreeHGlobal(_header);
			}
			if (_data != IntPtr.Zero)
			{
				Marshal.FreeHGlobal(_data);
			}
			_header = (_data = IntPtr.Zero);
		}

		private static uint FindDevice(string? preferred, out string name)
		{
			name = "";
			if (string.IsNullOrWhiteSpace(preferred))
			{
				return uint.MaxValue;
			}
			List<string> list = Devices();
			for (int i = 0; i < list.Count; i++)
			{
				string text = list[i].Trim();
				if (text.Length > 0 && (preferred.StartsWith(text, StringComparison.OrdinalIgnoreCase) || text.StartsWith(preferred.Trim(), StringComparison.OrdinalIgnoreCase)))
				{
					name = text;
					return (uint)i;
				}
			}
			return uint.MaxValue;
		}

		private static void Check(uint result, string step)
		{
			string text;
			switch (result)
			{
			case 0u:
				return;
			case 2u:
				text = "no such microphone";
				break;
			case 4u:
				text = "the microphone is busy";
				break;
			case 6u:
				text = "no driver for the microphone";
				break;
			case 7u:
				text = "out of memory";
				break;
			case 32u:
				text = "the microphone cannot record in 16 kHz mono";
				break;
			default:
				text = "error " + result;
				break;
			}
			string text2 = text;
			throw new InvalidOperationException("Microphone " + step + ": " + text2 + ".");
		}

		[DllImport("winmm.dll")]
		private static extern uint waveInGetNumDevs();

		[DllImport("winmm.dll", CharSet = CharSet.Unicode, EntryPoint = "waveInGetDevCapsW")]
		private static extern uint waveInGetDevCaps(UIntPtr deviceId, out WaveInCaps caps, uint size);

		[DllImport("winmm.dll")]
		private static extern uint waveInOpen(out IntPtr handle, uint deviceId, ref WaveFormat format, IntPtr callback, IntPtr instance, uint flags);

		[DllImport("winmm.dll")]
		private static extern uint waveInPrepareHeader(IntPtr handle, IntPtr header, uint size);

		[DllImport("winmm.dll")]
		private static extern uint waveInUnprepareHeader(IntPtr handle, IntPtr header, uint size);

		[DllImport("winmm.dll")]
		private static extern uint waveInAddBuffer(IntPtr handle, IntPtr header, uint size);

		[DllImport("winmm.dll")]
		private static extern uint waveInStart(IntPtr handle);

		[DllImport("winmm.dll")]
		private static extern uint waveInReset(IntPtr handle);

		[DllImport("winmm.dll")]
		private static extern uint waveInClose(IntPtr handle);
	}
	internal sealed class MicWatch : MonoBehaviour
	{
		private const float CheckSeconds = 5f;

		private float _next;

		private string _last = "";

		private void Update()
		{
			if (Time.time < _next)
			{
				return;
			}
			_next = Time.time + 5f;
			try
			{
				string text = string.Join(" | ", Microphone.devices);
				string text2 = "game sees [" + text + "], uses '" + (ListenService.GameMicrophone ?? "(default)") + "'";
				if (!(text2 == _last))
				{
					_last = text2;
					Plugin.Log.LogInfo((object)("Microphones: " + text2 + "; Windows has [" + string.Join(" | ", MicRecorder.Devices()) + "]."));
				}
			}
			catch (Exception ex)
			{
				Plugin.Verbose("Could not list the microphones: " + ex.Message);
			}
		}
	}
	internal static class SpeechClient
	{
		public static async Task<VoiceAudio> SynthesizeAsync(ChatEndpoint endpoint, string voice, string text, string? instructions, TimeSpan timeout, CancellationToken cancel = default(CancellationToken), float speed = 1f)
		{
			JObject val = new JObject
			{
				["model"] = JToken.op_Implicit(endpoint.Model),
				["input"] = JToken.op_Implicit(text),
				["voice"] = JToken.op_Implicit(voice),
				["response_format"] = JToken.op_Implicit("wav")
			};
			if (!string.IsNullOrWhiteSpace(instructions))
			{
				val["instructions"] = JToken.op_Implicit(instructions);
			}
			if (Math.Abs(speed - 1f) > 0.01f)
			{
				val["speed"] = JToken.op_Implicit(Math.Round(speed, 2));
			}
			byte[] data = await ChatClient.PostForBytesAsync(endpoint, "audio/speech", ((JToken)val).ToString((Formatting)0, Array.Empty<JsonConverter>()), timeout, cancel).ConfigureAwait(continueOnCapturedContext: false);
			try
			{
				return Wav.Parse(data);
			}
			catch (FormatException ex)
			{
				throw new ChatException(ChatErrorKind.BadResponse, "The speech server did not send a WAV file: " + ex.Message, ex);
			}
		}

		public static async Task<List<VoiceInfo>> ListVoicesAsync(ChatEndpoint endpoint, CancellationToken cancel = default(CancellationToken))
		{
			string text = await ChatClient.GetStringAsync(endpoint, "audio/voices", TimeSpan.FromSeconds(10.0), cancel).ConfigureAwait(continueOnCapturedContext: false);
			JToken val;
			try
			{
				val = JToken.Parse(text);
			}
			catch (JsonException ex)
			{
				JsonException inner = ex;
				throw new ChatException(ChatErrorKind.BadResponse, "The voice list is not JSON.", (Exception?)(object)inner);
			}
			object obj = ((val is JArray) ? val : null);
			if (obj == null)
			{
				JToken obj2 = ((val is JObject) ? val : null);
				JToken obj3 = ((obj2 != null) ? ((JObject)obj2)["voices"] : null);
				obj = ((obj3 is JArray) ? obj3 : null);
				if (obj == null)
				{
					JToken obj4 = ((val is JObject) ? val : null);
					JToken obj5 = ((obj4 != null) ? ((JObject)obj4)["data"] : null);
					obj = ((object)((obj5 is JArray) ? obj5 : null)) ?? ((object)new JArray());
				}
			}
			JArray val2 = (JArray)obj;
			List<VoiceInfo> list = new List<VoiceInfo>();
			foreach (JToken item in val2)
			{
				string text2 = ((item is JValue) ? ((string)item) : (((string)item[(object)"id"]) ?? ((string)item[(object)"voice_id"]) ?? ((string)item[(object)"name"])));
				if (!string.IsNullOrWhiteSpace(text2))
				{
					JObject val3 = (JObject)(object)((item is JObject) ? item : null);
					string name = ((val3 != null) ? (((string)val3["name"]) ?? text2) : text2);
					JObject val4 = (JObject)(object)((item is JObject) ? item : null);
					string language = ((val4 != null) ? (((string)val4["language"]) ?? "") : "");
					list.Add(new VoiceInfo(text2, name, language, ""));
				}
			}
			return list;
		}
	}
	internal static class TranscriptionClient
	{
		private static readonly HashSet<string> s_refused = new HashSet<string>();

		private static readonly string[] s_phantoms = new string[10] { "субтитр", "dimatorzok", "продолжение следует", "подписывайтесь на канал", "спасибо за просмотр", "amara.org", "thanks for watching", "thank you for watching", "subtitles by", "please subscribe" };

		public static async Task<string> TranscribeAsync(ChatEndpoint endpoint, byte[] wav, string? language, string? prompt, TimeSpan timeout, CancellationToken cancel = default(CancellationToken))
		{
			if (endpoint.Model.StartsWith("gpt-transcribe", StringComparison.OrdinalIgnoreCase))
			{
				language = null;
			}
			int attempt = 0;
			while (true)
			{
				bool sendLanguage = !string.IsNullOrWhiteSpace(language) && !Refused(endpoint, "language");
				bool sendPrompt = !string.IsNullOrWhiteSpace(prompt) && !Refused(endpoint, "prompt");
				MultipartFormDataContent form = new MultipartFormDataContent();
				ByteArrayContent byteArrayContent = new ByteArrayContent(wav);
				byteArrayContent.Headers.ContentType = new MediaTypeHeaderValue("audio/wav");
				Add(form, byteArrayContent, "file", "question.wav");
				if (!string.IsNullOrWhiteSpace(endpoint.Model))
				{
					Add(form, new StringContent(endpoint.Model), "model");
				}
				Add(form, new StringContent("json"), "response_format");
				if (sendLanguage)
				{
					Add(form, new StringContent(language), "language");
				}
				if (sendPrompt)
				{
					Add(form, new StringContent(prompt), "prompt");
				}
				try
				{
					return ReadText(await ChatClient.PostFormAsync(endpoint, "audio/transcriptio