using System;
using System.ClientModel;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Net.WebSockets;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Text.Json.Serialization.Metadata;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;
using Microsoft.Extensions.AI;
using Microsoft.Extensions.Logging;
using NAudio.CoreAudioApi;
using NAudio.MediaFoundation;
using NAudio.Wave;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using OllamaSharp;
using OpenAI;
using TimShaw.VoiceBox.Components;
using TimShaw.VoiceBox.Core;
using TimShaw.VoiceBox.Data;
using TimShaw.VoiceBox.GUI;
using TimShaw.VoiceBox.Generics;
using TimShaw.VoiceBox.Modding;
using UnityEngine;
using UnityEngine.Networking;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("VoiceBoxModLib.Core")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.3.4.0")]
[assembly: AssemblyInformationalVersion("0.3.4+8df47c835b89e3c9278a4984060ef6efbdf76fe6")]
[assembly: AssemblyProduct("VoiceBoxModLib.Core")]
[assembly: AssemblyTitle("VoiceBoxModLib.Core")]
[assembly: AssemblyVersion("0.3.4.0")]
public class APITester : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <>c__DisplayClass15_0
	{
		public bool waitingForTTS;

		public float clipLength;

		public APITester <>4__this;

		internal void <TestTextToSpeech>b__0(string path)
		{
			Debug.Log((object)("[Test: Text To Speech 1] Generated audio file at " + path));
			waitingForTTS = false;
		}

		internal void <TestTextToSpeech>b__2(AudioClip audioClip)
		{
			Debug.Log((object)"[Test: Text To Speech 2] Generated audioclip and playing...");
			clipLength = audioClip.length;
			waitingForTTS = false;
			<>4__this.audioSource.PlayOneShot(audioClip);
		}

		internal void <TestTextToSpeech>b__3(string err)
		{
			Debug.LogError((object)err);
			waitingForTTS = false;
		}
	}

	[CompilerGenerated]
	private sealed class <>c__DisplayClass16_0
	{
		public bool waitingForResponse;

		public string combinedResponse;

		internal void <TestChat>b__0(ChatUtils.VoiceBoxChatMessage chatMessage)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			ChatRole role = ((ChatMessage)chatMessage).Role;
			Debug.Log((object)(((object)(ChatRole)(ref role)).ToString() + ": " + chatMessage.Text));
			waitingForResponse = false;
		}

		internal void <TestChat>b__1(string error)
		{
			Debug.LogError((object)error);
			waitingForResponse = false;
		}

		internal void <TestChat>b__2(ChatResponseUpdate chunk)
		{
			Debug.Log((object)(chunk.Role.ToString() + ": " + chunk.Text));
			combinedResponse += (object)chunk;
		}

		internal void <TestChat>b__3()
		{
			Debug.Log((object)("Combined response: " + combinedResponse));
			waitingForResponse = false;
		}

		internal void <TestChat>b__4(string error)
		{
			Debug.LogError((object)error);
			waitingForResponse = false;
		}

		internal void <TestChat>b__5(ChatUtils.VoiceBoxChatMessage chatMessage)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			ChatRole role = ((ChatMessage)chatMessage).Role;
			Debug.Log((object)(((object)(ChatRole)(ref role)).ToString() + ": " + chatMessage.Text));
			waitingForResponse = false;
		}

		internal void <TestChat>b__6(string error)
		{
			Debug.LogError((object)error);
			waitingForResponse = false;
		}

		internal void <TestChat>b__7(ChatUtils.VoiceBoxChatMessage chatMessage)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			ChatRole role = ((ChatMessage)chatMessage).Role;
			Debug.Log((object)(((object)(ChatRole)(ref role)).ToString() + ": " + chatMessage.Text));
			waitingForResponse = false;
		}

		internal void <TestChat>b__8(string error)
		{
			Debug.LogError((object)error);
			waitingForResponse = false;
		}
	}

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

		private object <>2__current;

		public APITester <>4__this;

		private <>c__DisplayClass16_0 <>8__1;

		private List<ChatUtils.VoiceBoxChatMessage> <chats>5__2;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Expected O, but got Unknown
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Expected O, but got Unknown
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Expected O, but got Unknown
			int num = <>1__state;
			APITester aPITester = <>4__this;
			ChatUtils.VoiceBoxChatMessage item;
			ChatUtils.VoiceBoxChatMessage item2;
			ChatUtils.VoiceBoxChatTool item3;
			ChatUtils.VoiceBoxChatCompletionOptions options;
			ChatUtils.VoiceBoxChatTool item4;
			ChatUtils.VoiceBoxChatCompletionOptions voiceBoxChatCompletionOptions;
			ChatUtils.VoiceBoxChatMessage item5;
			switch (num)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>8__1 = new <>c__DisplayClass16_0();
				goto IL_0062;
			case 1:
				<>1__state = -1;
				goto IL_0062;
			case 2:
				<>1__state = -1;
				goto IL_0123;
			case 3:
				<>1__state = -1;
				goto IL_01c6;
			case 4:
				<>1__state = -1;
				goto IL_02ad;
			case 5:
				{
					<>1__state = -1;
					return false;
				}
				IL_0062:
				if (aPITester.testIsRunning)
				{
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 1;
					return true;
				}
				aPITester.testIsRunning = true;
				<>8__1.waitingForResponse = false;
				Debug.Log((object)"VoiceBox: Testing Chat");
				Debug.Log((object)"[Test: Chat 1] Simple chat request");
				<chats>5__2 = new List<ChatUtils.VoiceBoxChatMessage>();
				item = new ChatUtils.VoiceBoxChatMessage(ChatUtils.VoiceBoxChatRole.User, "Write a 1 paragraph essay about huskies. ");
				<chats>5__2.Add(item);
				<>8__1.waitingForResponse = true;
				AIManager.Instance.SendChatMessage(<chats>5__2, delegate(ChatUtils.VoiceBoxChatMessage chatMessage)
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					ChatRole role3 = ((ChatMessage)chatMessage).Role;
					Debug.Log((object)(((object)(ChatRole)(ref role3)).ToString() + ": " + chatMessage.Text));
					<>8__1.waitingForResponse = false;
				}, delegate(string error)
				{
					Debug.LogError((object)error);
					<>8__1.waitingForResponse = false;
				});
				goto IL_0123;
				IL_0123:
				if (<>8__1.waitingForResponse)
				{
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 2;
					return true;
				}
				<>8__1.combinedResponse = "";
				Debug.Log((object)"[Test: Chat 2] Simple streaming chat request");
				<>8__1.waitingForResponse = true;
				AIManager.Instance.StreamChatMessage(<chats>5__2, delegate(ChatResponseUpdate chunk)
				{
					Debug.Log((object)(chunk.Role.ToString() + ": " + chunk.Text));
					<>8__1.combinedResponse += (object)chunk;
				}, delegate
				{
					Debug.Log((object)("Combined response: " + <>8__1.combinedResponse));
					<>8__1.waitingForResponse = false;
				}, delegate(string error)
				{
					Debug.LogError((object)error);
					<>8__1.waitingForResponse = false;
				});
				goto IL_01c6;
				IL_02ad:
				if (<>8__1.waitingForResponse)
				{
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 4;
					return true;
				}
				Debug.Log((object)"[Test: Chat 4] Simple chat request with complex tool");
				item2 = new ChatUtils.VoiceBoxChatMessage(ChatUtils.VoiceBoxChatRole.User, "Display a Vector2 (1.00, 2.00) and a Quaterion (4.00, 4.00, 4.00) to the console");
				<chats>5__2.Clear();
				<chats>5__2.Add(item2);
				item3 = new ChatUtils.VoiceBoxChatTool(aPITester, "SampleTool3", "Displays a provided vector2 and quaternion to the console.", new List<JsonConverter>
				{
					new ChatUtils.ColorJsonConverter()
				});
				options = new ChatUtils.VoiceBoxChatCompletionOptions
				{
					VoiceBoxTools = { item3 }
				};
				<>8__1.waitingForResponse = true;
				AIManager.Instance.SendChatMessage(<chats>5__2, delegate(ChatUtils.VoiceBoxChatMessage chatMessage)
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					ChatRole role2 = ((ChatMessage)chatMessage).Role;
					Debug.Log((object)(((object)(ChatRole)(ref role2)).ToString() + ": " + chatMessage.Text));
					<>8__1.waitingForResponse = false;
				}, delegate(string error)
				{
					Debug.LogError((object)error);
					<>8__1.waitingForResponse = false;
				}, options);
				Debug.Log((object)"VoiceBox: Finished Testing Chat");
				<>2__current = null;
				<>1__state = 5;
				return true;
				IL_01c6:
				if (<>8__1.waitingForResponse)
				{
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 3;
					return true;
				}
				Debug.Log((object)"[Test: Chat 3] Simple chat request with tool");
				item4 = new ChatUtils.VoiceBoxChatTool(aPITester, "SampleTool1", "Displays provided text in the console");
				voiceBoxChatCompletionOptions = new ChatUtils.VoiceBoxChatCompletionOptions
				{
					VoiceBoxTools = { item4 }
				};
				Debug.Log((object)((ChatOptions)voiceBoxChatCompletionOptions).Tools.Count);
				item5 = new ChatUtils.VoiceBoxChatMessage(ChatUtils.VoiceBoxChatRole.User, "Write a 1 paragraph essay about huskies. Then, display the first sentence to the console. Only display one sentence to the console.");
				<chats>5__2.Clear();
				<chats>5__2.Add(item5);
				<>8__1.waitingForResponse = true;
				AIManager.Instance.SendChatMessage(<chats>5__2, delegate(ChatUtils.VoiceBoxChatMessage chatMessage)
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					ChatRole role = ((ChatMessage)chatMessage).Role;
					Debug.Log((object)(((object)(ChatRole)(ref role)).ToString() + ": " + chatMessage.Text));
					<>8__1.waitingForResponse = false;
				}, delegate(string error)
				{
					Debug.LogError((object)error);
					<>8__1.waitingForResponse = false;
				}, voiceBoxChatCompletionOptions);
				goto IL_02ad;
			}
		}

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

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

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

		private object <>2__current;

		public APITester <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			int num = <>1__state;
			APITester aPITester = <>4__this;
			switch (num)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				goto IL_004b;
			case 1:
				<>1__state = -1;
				goto IL_004b;
			case 2:
				{
					<>1__state = -1;
					return false;
				}
				IL_004b:
				if (aPITester.testIsRunning)
				{
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 1;
					return true;
				}
				aPITester.testIsRunning = true;
				Debug.Log((object)"VoiceBox: Testing Modding Tools");
				Debug.Log((object)"[Test: ModdingTools] Create AIManager using ModdingTools");
				ModdingTools.CreateAIManagerObject<GeminiServiceConfig, AzureSTTServiceConfig, ElevenlabsTTSServiceConfig>();
				Debug.Log((object)"VoiceBox: Finished Testing Modding Tools");
				aPITester.testIsRunning = false;
				<>2__current = null;
				<>1__state = 2;
				return true;
			}
		}

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

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

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

		private object <>2__current;

		public APITester <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Expected O, but got Unknown
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Expected O, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Expected O, but got Unknown
			int num = <>1__state;
			APITester aPITester = <>4__this;
			switch (num)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				goto IL_0057;
			case 1:
				<>1__state = -1;
				goto IL_0057;
			case 2:
				<>1__state = -1;
				Debug.Log((object)"[Test: Speech To Text 1] Stop Speech Transcription after 10s...");
				AIManager.Instance.StopSpeechTranscription();
				Debug.Log((object)"[Test: Speech To Text 2] Wait 2s then Start Speech Transcription for 10s after previous stop...");
				<>2__current = (object)new WaitForSeconds(2f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				AIManager.Instance.StartSpeechTranscription();
				<>2__current = (object)new WaitForSeconds(10f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				Debug.Log((object)"[Test: Speech To Text 2] Stop Speech Transcription again after 10s...");
				AIManager.Instance.StopSpeechTranscription();
				Debug.Log((object)"VoiceBox: Finished Testing Speech To Text");
				aPITester.testIsRunning = false;
				<>2__current = null;
				<>1__state = 5;
				return true;
			case 5:
				{
					<>1__state = -1;
					return false;
				}
				IL_0057:
				if (aPITester.testIsRunning)
				{
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 1;
					return true;
				}
				aPITester.testIsRunning = true;
				Debug.Log((object)"VoiceBox: Testing Speech To Text");
				Debug.Log((object)"[Test: Speech To Text 1] Start Speech Transcription for 10s...");
				AIManager.Instance.SpeechToTextService.OnRecognized += aPITester.LogRecognizedSpeech;
				AIManager.Instance.StartSpeechTranscription(aPITester.internalCancellationTokenSource.Token);
				<>2__current = (object)new WaitForSeconds(10f);
				<>1__state = 2;
				return true;
			}
		}

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

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

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

		private object <>2__current;

		public APITester <>4__this;

		private <>c__DisplayClass15_0 <>8__1;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Expected O, but got Unknown
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Expected O, but got Unknown
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Expected O, but got Unknown
			int num = <>1__state;
			APITester aPITester = <>4__this;
			switch (num)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>8__1 = new <>c__DisplayClass15_0();
				<>8__1.<>4__this = <>4__this;
				goto IL_0073;
			case 1:
				<>1__state = -1;
				goto IL_0073;
			case 2:
				<>1__state = -1;
				goto IL_0116;
			case 3:
				<>1__state = -1;
				goto IL_019c;
			case 4:
				<>1__state = -1;
				Debug.Log((object)"[Test: Text To Speech 3] Stream audio");
				AIManager.Instance.RequestAudioAndStream("This audio is streaming instead of waiting for the full response. This approach reduces first-word latency tremendously.", ((Component)aPITester.audioSource).GetComponent<AudioStreamer>());
				Debug.Log((object)"VoiceBox: Finished Testing Text To Speech");
				aPITester.testIsRunning = false;
				<>2__current = null;
				<>1__state = 5;
				return true;
			case 5:
				{
					<>1__state = -1;
					return false;
				}
				IL_0073:
				if (aPITester.testIsRunning)
				{
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 1;
					return true;
				}
				aPITester.testIsRunning = true;
				<>8__1.waitingForTTS = true;
				Debug.Log((object)"VoiceBox: Testing Text To Speech");
				Debug.Log((object)"[Test: Text To Speech 1] Generate audio file");
				AIManager.Instance.GenerateSpeechFileFromText("Hello World", "helloworld.wav", Application.dataPath, delegate(string path)
				{
					Debug.Log((object)("[Test: Text To Speech 1] Generated audio file at " + path));
					<>8__1.waitingForTTS = false;
				}, delegate(string err)
				{
					Debug.LogError((object)err);
				});
				goto IL_0116;
				IL_0116:
				if (<>8__1.waitingForTTS)
				{
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 2;
					return true;
				}
				Debug.Log((object)"[Test: Text To Speech 2] Generating audioclip");
				<>8__1.waitingForTTS = true;
				<>8__1.clipLength = 0f;
				AIManager.Instance.GenerateSpeechAudioClipFromText("Hello World 2!", delegate(AudioClip audioClip)
				{
					Debug.Log((object)"[Test: Text To Speech 2] Generated audioclip and playing...");
					<>8__1.clipLength = audioClip.length;
					<>8__1.waitingForTTS = false;
					<>8__1.<>4__this.audioSource.PlayOneShot(audioClip);
				}, delegate(string err)
				{
					Debug.LogError((object)err);
					<>8__1.waitingForTTS = false;
				});
				goto IL_019c;
				IL_019c:
				if (<>8__1.waitingForTTS)
				{
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 3;
					return true;
				}
				<>2__current = (object)new WaitForSeconds(<>8__1.clipLength);
				<>1__state = 4;
				return true;
			}
		}

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

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

	[SerializeField]
	public bool testSpawnManager;

	[SerializeField]
	public bool testGUI;

	[SerializeField]
	public bool testSTT;

	[SerializeField]
	public bool testTTS;

	[SerializeField]
	public bool testChat;

	[SerializeField]
	public AudioSource audioSource;

	private CancellationTokenSource internalCancellationTokenSource = new CancellationTokenSource();

	private bool testIsRunning;

	private void LogRecognizedSpeech(object s, STTUtils.VoiceBoxSpeechRecognitionEventArgs e)
	{
		if (e.Result.Reason == STTUtils.VoiceBoxResultReason.RecognizedSpeech)
		{
			if (e.Result.Text.Length > 0)
			{
				Debug.Log((object)("API Tester: Recognized: " + e.Result.Text));
			}
		}
		else if (e.Result.Reason == STTUtils.VoiceBoxResultReason.RecognizedSpeechWithTimestamps && e.Result.Text.Length > 0)
		{
			Debug.Log((object)("API Tester: Recognized with timestamps: " + e.Result.Text));
		}
	}

	public void SampleTool1(string textToDisplay)
	{
		Debug.Log((object)("AI is displaying text! --> " + textToDisplay));
	}

	public void SampleTool2(Color color)
	{
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		Color val = color;
		Debug.Log((object)("AI is displaying a color! --> " + ((object)(Color)(ref val)).ToString()));
	}

	public void SampleTool3(Vector2 dir, Quaternion rot)
	{
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		Vector2 val = dir;
		string? text = ((object)(Vector2)(ref val)).ToString();
		Quaternion val2 = rot;
		Debug.Log((object)("AI is displaying a Vector2 and a Quaternion! --> " + text + " -- " + ((object)(Quaternion)(ref val2)).ToString()));
	}

	private void Start()
	{
		if (testSpawnManager)
		{
			((MonoBehaviour)this).StartCoroutine(TestModdingTools());
		}
		if (testGUI && (Object)(object)GUIManager.Instance != (Object)null)
		{
			GUIManager.Instance.visible = true;
			GUIManager instance = GUIManager.Instance;
			instance.onApiKeysLoaded = (EventHandler)Delegate.Combine(instance.onApiKeysLoaded, (EventHandler)delegate
			{
				Debug.Log((object)"Api keys loaded!");
			});
			GUIManager instance2 = GUIManager.Instance;
			instance2.onMicrophoneSelected = (EventHandler<string>)Delegate.Combine(instance2.onMicrophoneSelected, (EventHandler<string>)delegate(object obj, string mic)
			{
				Debug.Log((object)("Mic selected: " + mic));
			});
			GUIManager instance3 = GUIManager.Instance;
			instance3.onRecordingStopped = (EventHandler<AudioClip>)Delegate.Combine(instance3.onRecordingStopped, (EventHandler<AudioClip>)delegate
			{
				Debug.Log((object)"Clip recorded!");
			});
		}
		if (testSTT)
		{
			((MonoBehaviour)this).StartCoroutine(TestSpeechToText());
		}
		if (testTTS)
		{
			((MonoBehaviour)this).StartCoroutine(TestTextToSpeech());
		}
		if (testChat)
		{
			((MonoBehaviour)this).StartCoroutine(TestChat());
		}
	}

	[IteratorStateMachine(typeof(<TestModdingTools>d__13))]
	private IEnumerator TestModdingTools()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <TestModdingTools>d__13(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<TestSpeechToText>d__14))]
	private IEnumerator TestSpeechToText()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <TestSpeechToText>d__14(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<TestTextToSpeech>d__15))]
	private IEnumerator TestTextToSpeech()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <TestTextToSpeech>d__15(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<TestChat>d__16))]
	private IEnumerator TestChat()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <TestChat>d__16(0)
		{
			<>4__this = this
		};
	}

	private void OnDestroy()
	{
		internalCancellationTokenSource.Cancel();
	}
}
namespace TimShaw.VoiceBox.Modding
{
	public static class ModdingTools
	{
		public static T CreateChatServiceConfig<T>() where T : GenericChatServiceConfig
		{
			return ScriptableObject.CreateInstance<T>();
		}

		public static T CreateSTTServiceConfig<T>() where T : GenericSTTServiceConfig
		{
			return ScriptableObject.CreateInstance<T>();
		}

		public static T CreateTTSServiceConfig<T>() where T : GenericTTSServiceConfig
		{
			return ScriptableObject.CreateInstance<T>();
		}

		public static GameObject CreateAIManagerObject<ChatConfigType, STTConfigType, TTSConfigType>(string keysFile = "", string chatKey = null, string sttKey = null, string ttsKey = null) where ChatConfigType : GenericChatServiceConfig where STTConfigType : GenericSTTServiceConfig where TTSConfigType : GenericTTSServiceConfig
		{
			return CreateAIManagerObject(CreateChatServiceConfig<ChatConfigType>(), CreateSTTServiceConfig<STTConfigType>(), CreateTTSServiceConfig<TTSConfigType>(), keysFile, chatKey, sttKey, ttsKey);
		}

		public static GameObject CreateAIManagerObject(GenericChatServiceConfig genericChatServiceConfig, GenericSTTServiceConfig genericSTTServiceConfig, GenericTTSServiceConfig genericTTSServiceConfig, string keysFile = "", string chatKey = null, string sttKey = null, string ttsKey = null)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			if ((Object)(object)AIManager.Instance == (Object)null)
			{
				GameObject val = new GameObject("_AIManager");
				AIManager aIManager = val.AddComponent<AIManager>();
				aIManager.chatServiceConfig = genericChatServiceConfig;
				aIManager.speechToTextConfig = genericSTTServiceConfig;
				aIManager.textToSpeechConfig = genericTTSServiceConfig;
				AIManager.Instance.LoadAPIKeys(keysFile, chatKey, sttKey, ttsKey);
				aIManager.ChatService = ServiceFactory.CreateChatService(aIManager.chatServiceConfig);
				aIManager.SpeechToTextService = ServiceFactory.CreateSttService(aIManager.speechToTextConfig);
				aIManager.TextToSpeechService = ServiceFactory.CreateTtsService(aIManager.textToSpeechConfig);
				return val;
			}
			Debug.LogWarning((object)"AI Manager already exists, no new object will be created.");
			return ((Component)AIManager.Instance).gameObject;
		}

		public static void InitChatManagerObject(ChatManager manager, GenericChatServiceConfig config, string apiKeysJsonPath = "", string chatKey = null)
		{
			manager.chatServiceConfig = config;
			if (apiKeysJsonPath.Length > 0)
			{
				manager.LoadAPIKey(apiKeysJsonPath);
			}
			else if (chatKey != null)
			{
				manager.LoadAPIKey(null, chatKey);
			}
			else
			{
				manager.LoadAPIKey();
			}
			manager.ChatService = ServiceFactory.CreateChatService(manager.chatServiceConfig);
		}

		public static void InitTTSManagerObject(TTSManager manager, GenericTTSServiceConfig config, string apiKeysJsonPath = "", string ttsKey = null)
		{
			manager.textToSpeechConfig = config;
			if (apiKeysJsonPath.Length > 0)
			{
				manager.LoadAPIKey(apiKeysJsonPath);
			}
			else if (ttsKey != null)
			{
				manager.LoadAPIKey(null, ttsKey);
			}
			else
			{
				manager.LoadAPIKey();
			}
			manager.TextToSpeechService = ServiceFactory.CreateTtsService(manager.textToSpeechConfig);
		}
	}
}
namespace TimShaw.VoiceBox.GUI
{
	public class GUIManager : MonoBehaviour
	{
		[Header("GUI Settings")]
		[Tooltip("The global scale for all GUI elements.")]
		public float guiScale = 1.5f;

		[Tooltip("Pixel padding from the screen edges (before scaling).")]
		public float padding = 10f;

		[Tooltip("The color for our background.")]
		public Color backgroundColor = new Color(0.2f, 0.2f, 0.2f, 0.75f);

		[Header("API Keys")]
		private string chatApiKey = "";

		private string sttApiKey = "";

		private string ttsApiKey = "";

		[Header("Microphone")]
		[Tooltip("How sensitive the audio indicator is. Increase this if the bar is too low.")]
		public float audioSensitivity = 8.5f;

		[Tooltip("The height of the audio level bar in scaled pixels.")]
		public float audioBarHeight = 20f;

		[Tooltip("The max height of the microphone selection box in scaled pixels.")]
		public float micListMaxHeight = 100f;

		private float sliderValue = 60f;

		private DateTime recordingStartTime = DateTime.Now;

		private static string[] micDevices;

		private static int selectedMicIndex;

		private static bool isRecording;

		private static AudioClip recordingClip;

		private float currentAudioLevel;

		private float[] audioSampleData;

		private int sampleWindow = 256;

		public bool enableKeyboardShortcut = true;

		public bool visible;

		private Vector2 windowScrollPosition;

		private Vector2 micScrollPosition;

		private GUIStyle indicatorBoxStyle;

		private GUIStyle titleStyle;

		private GUIStyle subtitleStyle;

		private GenericChatServiceConfig chatServiceConfig;

		private GenericSTTServiceConfig sttServiceConfig;

		private GenericTTSServiceConfig ttsServiceConfig;

		private ChatManager[] chatManagers;

		private TTSManager[] tTSManagers;

		private HashSet<KeyCode> currentlyPressedKeys = new HashSet<KeyCode>();

		public EventHandler<AudioClip> onRecordingStopped;

		public EventHandler onApiKeysLoaded;

		public EventHandler<string> onMicrophoneSelected;

		public static GUIManager Instance { get; private set; }

		public static GameObject CreateGUIManagerObject()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			if ((Object)(object)Instance != (Object)null)
			{
				return ((Component)Instance).gameObject;
			}
			GameObject val = new GameObject("_VoiceBoxGUIManager");
			val.AddComponent<GUIManager>();
			return val;
		}

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
			else
			{
				Instance = this;
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}

		private void Start()
		{
			micDevices = Microphone.devices;
			audioSampleData = new float[sampleWindow];
			if (micDevices.Length == 0)
			{
				Debug.LogWarning((object)"No microphone devices found!");
				micDevices = new string[1] { "No microphones available" };
			}
			Debug.Log((object)"[GUIManager] GUI Manager created!");
		}

		private void Update()
		{
			if (isRecording && (Object)(object)recordingClip != (Object)null)
			{
				currentAudioLevel = GetAudioLevel();
			}
			else
			{
				currentAudioLevel = 0f;
			}
		}

		private void OnGUI()
		{
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Expected O, but got Unknown
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Invalid comparison between Unknown and I4
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_069c: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_09af: Unknown result type (might be due to invalid IL or missing references)
			//IL_08b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_08b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_08bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0913: Unknown result type (might be due to invalid IL or missing references)
			//IL_0918: Unknown result type (might be due to invalid IL or missing references)
			//IL_091d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0924: Unknown result type (might be due to invalid IL or missing references)
			if (enableKeyboardShortcut)
			{
				if (Event.current.isKey && (int)Event.current.keyCode != 0)
				{
					if ((int)Event.current.type == 4)
					{
						currentlyPressedKeys.Add(Event.current.keyCode);
					}
					else if ((int)Event.current.type == 5)
					{
						currentlyPressedKeys.Remove(Event.current.keyCode);
					}
				}
				if (Event.current.shift && currentlyPressedKeys.Contains((KeyCode)118) && currentlyPressedKeys.Contains((KeyCode)98))
				{
					visible = true;
				}
			}
			if (!visible)
			{
				return;
			}
			Matrix4x4 matrix = GUI.matrix;
			GUI.matrix = Matrix4x4.Scale(new Vector3(guiScale, guiScale, 1f));
			float num = padding / guiScale;
			float num2 = (float)Screen.width / guiScale;
			float num3 = (float)Screen.height / guiScale;
			Rect val = new Rect(num, num, num2 - num * 2f, num3 - num * 2f);
			Color val2 = GUI.backgroundColor;
			GUI.backgroundColor = backgroundColor;
			GUI.Box(val, GUIContent.none);
			GUI.backgroundColor = val2;
			if (indicatorBoxStyle == null)
			{
				indicatorBoxStyle = new GUIStyle(GUI.skin.box);
				indicatorBoxStyle.alignment = (TextAnchor)3;
			}
			if (titleStyle == null)
			{
				titleStyle = new GUIStyle(GUI.skin.label);
				titleStyle.fontStyle = (FontStyle)1;
				int num4 = GUI.skin.label.fontSize;
				if (num4 <= 0)
				{
					num4 = 12;
				}
				titleStyle.fontSize = num4 * 2;
			}
			if (subtitleStyle == null)
			{
				subtitleStyle = new GUIStyle(GUI.skin.label);
				subtitleStyle.fontStyle = (FontStyle)1;
				int num5 = GUI.skin.label.fontSize;
				if (num5 <= 0)
				{
					num5 = 12;
				}
				subtitleStyle.fontSize = Mathf.FloorToInt((float)num5 * 1.2f);
			}
			GUILayout.BeginArea(val);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.FlexibleSpace();
			if (GUILayout.Button("Hide", (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(60f),
				GUILayout.Height(25f)
			}))
			{
				visible = false;
			}
			GUILayout.EndHorizontal();
			windowScrollPosition = GUILayout.BeginScrollView(windowScrollPosition, false, true, Array.Empty<GUILayoutOption>());
			GUILayout.Label("VoiceBox Utilities GUI", titleStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("", Array.Empty<GUILayoutOption>());
			GUILayout.Label("API Keys", subtitleStyle, Array.Empty<GUILayoutOption>());
			if (GUILayout.Button("Load API Keys", Array.Empty<GUILayoutOption>()))
			{
				if ((Object)(object)Object.FindFirstObjectByType<ChatManager>() != (Object)null)
				{
					chatManagers = Object.FindObjectsByType<ChatManager>((FindObjectsSortMode)0);
					chatServiceConfig = chatManagers[0].chatServiceConfig;
					chatApiKey = chatManagers[0].chatServiceConfig?.apiKey;
				}
				if ((Object)(object)AIManager.Instance != (Object)null && AIManager.Instance.ChatService != null)
				{
					chatServiceConfig = AIManager.Instance.chatServiceConfig;
					chatApiKey = AIManager.Instance.chatServiceConfig.apiKey;
				}
				if ((Object)(object)AIManager.Instance != (Object)null && AIManager.Instance.SpeechToTextService != null)
				{
					sttServiceConfig = AIManager.Instance.speechToTextConfig;
					sttApiKey = AIManager.Instance.speechToTextConfig.apiKey;
				}
				if ((Object)(object)Object.FindFirstObjectByType<TTSManager>() != (Object)null)
				{
					tTSManagers = Object.FindObjectsByType<TTSManager>((FindObjectsSortMode)0);
					ttsServiceConfig = tTSManagers[0].textToSpeechConfig;
					ttsApiKey = tTSManagers[0].textToSpeechConfig?.apiKey;
				}
				if ((Object)(object)AIManager.Instance != (Object)null && AIManager.Instance.TextToSpeechService != null)
				{
					ttsServiceConfig = AIManager.Instance.textToSpeechConfig;
					ttsApiKey = AIManager.Instance.textToSpeechConfig.apiKey;
				}
				onApiKeysLoaded?.Invoke(this, null);
			}
			if ((Object)(object)chatServiceConfig != (Object)null)
			{
				GUILayout.Label("Chat (Type: " + chatServiceConfig.serviceManagerType?.ToString() + ") (Manager Count: " + chatManagers?.Length + ") (" + (((Object)(object)AIManager.Instance != (Object)null && AIManager.Instance.ChatService != null) ? "AIManager)" : ")"), Array.Empty<GUILayoutOption>());
			}
			else
			{
				GUILayout.Label("Chat (Not Initialized)", Array.Empty<GUILayoutOption>());
			}
			chatApiKey = GUILayout.PasswordField((chatApiKey == null) ? "" : chatApiKey, '*', Array.Empty<GUILayoutOption>());
			if ((Object)(object)sttServiceConfig != (Object)null)
			{
				GUILayout.Label("Speech to Text (Type: " + sttServiceConfig.serviceManagerType?.ToString() + ") (AIManager)", Array.Empty<GUILayoutOption>());
			}
			else
			{
				GUILayout.Label("Speech to Text (Not Initialized)", Array.Empty<GUILayoutOption>());
			}
			sttApiKey = GUILayout.PasswordField((sttApiKey == null) ? "" : sttApiKey, '*', Array.Empty<GUILayoutOption>());
			if ((Object)(object)ttsServiceConfig != (Object)null)
			{
				GUILayout.Label("Text to Speech (Type: " + ttsServiceConfig.serviceManagerType?.ToString() + ") (Manager Count: " + tTSManagers?.Length + ") (" + (((Object)(object)AIManager.Instance != (Object)null && AIManager.Instance.TextToSpeechService != null) ? "AIManager)" : ")"), Array.Empty<GUILayoutOption>());
			}
			else
			{
				GUILayout.Label("Text to Speech (Not Initialized)", Array.Empty<GUILayoutOption>());
			}
			ttsApiKey = GUILayout.PasswordField((ttsApiKey == null) ? "" : ttsApiKey, '*', Array.Empty<GUILayoutOption>());
			GUILayout.Space(20f);
			GUILayout.Label("Microphone Utilities", subtitleStyle, Array.Empty<GUILayoutOption>());
			if (micDevices.Length != 0)
			{
				GUILayout.Label("Select a microphone (does not affect services):", Array.Empty<GUILayoutOption>());
				micScrollPosition = GUILayout.BeginScrollView(micScrollPosition, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(micListMaxHeight) });
				int num6 = selectedMicIndex;
				selectedMicIndex = GUILayout.SelectionGrid(selectedMicIndex, micDevices, 1, Array.Empty<GUILayoutOption>());
				if (num6 != selectedMicIndex)
				{
					onMicrophoneSelected?.Invoke(this, micDevices[selectedMicIndex]);
				}
				GUILayout.EndScrollView();
				GUILayout.Space(10f);
				GUILayout.Label("Record an AudioClip", subtitleStyle, Array.Empty<GUILayoutOption>());
				GUILayout.Label("Clip length: " + sliderValue + " seconds", Array.Empty<GUILayoutOption>());
				sliderValue = (int)Math.Round(GUILayout.HorizontalSlider(sliderValue, 1f, 600f, Array.Empty<GUILayoutOption>()), 0);
				if (GUILayout.Button(isRecording ? "Stop Recording" : "Start Recording", Array.Empty<GUILayoutOption>()))
				{
					if (isRecording)
					{
						AudioClip e = StopRecording();
						onRecordingStopped?.Invoke(this, e);
					}
					else
					{
						recordingStartTime = DateTime.Now;
						StartRecording();
					}
				}
				GUILayout.Space(5f);
				if (isRecording && (float)(DateTime.Now - recordingStartTime).Seconds >= sliderValue)
				{
					AudioClip e2 = StopRecording();
					onRecordingStopped?.Invoke(this, e2);
					Debug.Log((object)$"[GUIManager] Clip size maximum of {sliderValue} reached. Stopped recording.");
				}
				if (isRecording)
				{
					float num7 = Mathf.Clamp01(currentAudioLevel * audioSensitivity);
					if (num7 < 0.02f)
					{
						num7 = 0f;
					}
					GUILayout.Label("Listening... Level: " + (num7 * 100f).ToString("F0") + "%", Array.Empty<GUILayoutOption>());
					Rect rect = GUILayoutUtility.GetRect(GUIContent.none, indicatorBoxStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Height(audioBarHeight),
						GUILayout.ExpandWidth(true)
					});
					Color val3 = GUI.backgroundColor;
					Color color = GUI.color;
					GUI.backgroundColor = new Color(0.1f, 0.1f, 0.1f, 0.8f);
					GUI.Box(rect, GUIContent.none, indicatorBoxStyle);
					Rect val4 = new Rect(((Rect)(ref rect)).x, ((Rect)(ref rect)).y, ((Rect)(ref rect)).width * num7, ((Rect)(ref rect)).height);
					GUI.color = Color.Lerp(Color.green, Color.red, num7);
					GUI.DrawTexture(val4, (Texture)(object)Texture2D.whiteTexture);
					GUI.color = color;
					GUI.backgroundColor = val3;
					GUILayout.Label("Recording length: " + (DateTime.Now - recordingStartTime).Seconds + " seconds", Array.Empty<GUILayoutOption>());
				}
				else
				{
					GUILayout.Box("Not Recording", indicatorBoxStyle, Array.Empty<GUILayoutOption>());
				}
			}
			else
			{
				GUILayout.Label("No microphone devices found.", Array.Empty<GUILayoutOption>());
			}
			GUILayout.EndScrollView();
			GUILayout.EndArea();
			GUI.matrix = matrix;
		}

		public static void StartRecording()
		{
			if (micDevices.Length != 0)
			{
				string text = micDevices[selectedMicIndex];
				recordingClip = Microphone.Start(text, false, 60, 44100);
				isRecording = true;
				Debug.Log((object)("Started recording from: " + text));
			}
		}

		public static AudioClip StopRecording()
		{
			if (micDevices.Length == 0)
			{
				return null;
			}
			string text = micDevices[selectedMicIndex];
			Microphone.End(text);
			isRecording = false;
			AudioClip result = recordingClip;
			recordingClip = null;
			Debug.Log((object)("Stopped recording from: " + text));
			return result;
		}

		private float GetAudioLevel()
		{
			if ((Object)(object)recordingClip == (Object)null)
			{
				return 0f;
			}
			int num = Microphone.GetPosition(micDevices[selectedMicIndex]) - sampleWindow;
			if (num < 0)
			{
				num = 0;
			}
			recordingClip.GetData(audioSampleData, num);
			float num2 = 0f;
			for (int i = 0; i < sampleWindow; i++)
			{
				num2 += audioSampleData[i] * audioSampleData[i];
			}
			return Mathf.Sqrt(num2 / (float)sampleWindow);
		}

		private void OnDisable()
		{
			if (isRecording)
			{
				StopRecording();
			}
		}
	}
}
namespace TimShaw.VoiceBox.Generics
{
	public class GenericChatServiceConfig : ScriptableObject
	{
		public Type serviceManagerType;

		public string apiKey;

		public string apiKeyJSONString;

		public string modelName;

		public bool useFunctionInvokation = true;
	}
	public class GenericSTTServiceConfig : ScriptableObject
	{
		public Type serviceManagerType;

		public string apiKey;

		public string apiKeyJSONString;
	}
	public class GenericTTSServiceConfig : ScriptableObject
	{
		public Type serviceManagerType;

		public string apiKey;

		public string apiKeyJSONString;
	}
}
namespace TimShaw.VoiceBox.Data
{
	[CreateAssetMenu(fileName = "AzureSTTServiceConfig", menuName = "VoiceBox/STT/AzureSTTService Configuration")]
	public class AzureSTTServiceConfig : GenericSTTServiceConfig
	{
		public string region = "canadacentral";

		public string language = "en-CA";

		public string audioInputDeviceName = "Default";

		public string[] audioInputEndpointNames = new string[1] { "Default" };

		public bool requestWordLevelTimestamps;

		public AzureSTTServiceConfig()
		{
			serviceManagerType = typeof(AzureSTTServiceManager);
			apiKeyJSONString = "AZURE_SPEECH_API_KEY";
		}

		public void OnValidate()
		{
			audioInputEndpointNames = STTUtils.GetAudioInputEndpoints().Keys.ToArray();
		}
	}
	[CreateAssetMenu(fileName = "ChatGPTServiceConfig", menuName = "VoiceBox/Chat/ChatGPTService Configuration")]
	public class ChatGPTServiceConfig : GenericChatServiceConfig
	{
		public string serviceEndpoint = "https://api.openai.com/v1";

		public ChatGPTServiceConfig()
		{
			serviceManagerType = typeof(ChatGPTServiceManager);
			apiKeyJSONString = "OPENAI_API_KEY";
			modelName = "gpt-5-nano";
		}
	}
	[CreateAssetMenu(fileName = "ClaudeServiceConfig", menuName = "VoiceBox/Chat/ClaudeService Configuration")]
	public class ClaudeServiceConfig : GenericChatServiceConfig
	{
		public string serviceEndpoint = "https://api.anthropic.com/v1";

		public ClaudeServiceConfig()
		{
			serviceManagerType = typeof(ClaudeServiceManager);
			apiKeyJSONString = "ANTHROPIC_API_KEY";
			modelName = "claude-haiku-4-5";
		}
	}
	[Serializable]
	public enum ElevenlabsSTTCommitStrategy
	{
		Manual,
		Vad
	}
	[CreateAssetMenu(fileName = "ElevenlabsSTTServiceConfig", menuName = "VoiceBox/STT/ElevenlabsSTTService Configuration")]
	public class ElevenlabsSTTServiceConfig : GenericSTTServiceConfig
	{
		public string language_code = "eng";

		public string audioInputDeviceName = "Default";

		public string[] audioInputEndpointNames = new string[1] { "Default" };

		public bool include_timestamps = true;

		public bool include_language_detection;

		public ElevenlabsSTTCommitStrategy commit_strategy = ElevenlabsSTTCommitStrategy.Vad;

		public double vad_silence_threshold_secs = 0.65;

		public double vad_threshold = 0.4;

		public int min_speech_duration_ms = 250;

		public int min_silence_duration_ms = 550;

		public ElevenlabsSTTServiceConfig()
		{
			serviceManagerType = typeof(ElevenlabsSTTServiceManager);
			apiKeyJSONString = "ELEVENLABS_API_KEY";
		}

		public void OnValidate()
		{
			audioInputEndpointNames = STTUtils.GetAudioInputEndpoints().Keys.ToArray();
		}
	}
	[Serializable]
	public class VoiceSettings
	{
		[Tooltip("A float between 0 and 1. Higher values result in more stable speech, but may sound monotonous. Lower values are more expressive, but may be unstable.")]
		[Range(0f, 1f)]
		public float stability = 0.5f;

		[Tooltip("A float between 0 and 1. Higher values boost the similarity to the original voice, but may introduce artifacts. Lower values are more generic, but cleaner.")]
		[Range(0f, 1f)]
		public float similarity_boost = 0.75f;

		[Tooltip("A float between 0 and 1. A higher value will exaggerate the style of the voice.")]
		[Range(0f, 1f)]
		public float style;

		[Tooltip("Whether to use the speaker boost feature, which can enhance voice clarity.")]
		public bool use_speaker_boost = true;

		[Tooltip("A float between 0.7 and 1.2. A higher value will exaggerate the speed of the voice.")]
		[Range(0.7f, 1.2f)]
		public float speed = 1f;
	}
	[Serializable]
	public class PronunciationDictionaryLocator
	{
		[Tooltip("The ID of the pronunciation dictionary.")]
		public string pronunciation_dictionary_id;

		[Tooltip("The version ID of the pronunciation dictionary.")]
		public string version_id;
	}
	[CreateAssetMenu(fileName = "ElevenlabsServiceConfig", menuName = "VoiceBox/TTS/ElevenlabsService Configuration")]
	public class ElevenlabsTTSServiceConfig : GenericTTSServiceConfig
	{
		[Tooltip("The API endpoint for the text-to-speech service.")]
		public string serviceEndpoint = "https://api.elevenlabs.io/v1/text-to-speech/";

		[Tooltip("The ID of the voice you want to use.")]
		public string voiceId = "JBFqnCBsd6RMkjVDRZzb";

		[Tooltip("The ID of the model to be used. Defaults to eleven_flash_v2_5.")]
		public string modelID = "eleven_flash_v2_5";

		[Tooltip("Voice settings that override the stored settings for the given voice.")]
		public VoiceSettings voiceSettings;

		[Tooltip("Output format for the generated audio. Currently only mp3 is supported. e.g., mp3_44100_128")]
		public string output_format = "mp3_44100_128";

		public ElevenlabsTTSServiceConfig()
		{
			serviceManagerType = typeof(ElevenLabsTTSServiceManager);
			apiKeyJSONString = "ELEVENLABS_API_KEY";
		}
	}
	[CreateAssetMenu(fileName = "GeminiServiceConfig", menuName = "VoiceBox/Chat/GeminiService Configuration")]
	public class GeminiServiceConfig : GenericChatServiceConfig
	{
		public string serviceEndpoint = "https://generativelanguage.googleapis.com/v1beta/openai/";

		public GeminiServiceConfig()
		{
			serviceManagerType = typeof(GeminiServiceManager);
			apiKeyJSONString = "GEMINI_API_KEY";
			modelName = "gemini-2.5-flash";
		}
	}
	[CreateAssetMenu(fileName = "OllamaServiceConfig", menuName = "VoiceBox/Chat/OllamaService Configuration")]
	public class OllamaChatServiceConfig : GenericChatServiceConfig
	{
		public string serviceEndpoint = "http://localhost:11434/";

		public OllamaChatServiceConfig()
		{
			serviceManagerType = typeof(OllamaChatServiceManager);
			apiKeyJSONString = "OLLAMA_API_KEY";
		}
	}
	[CreateAssetMenu(fileName = "WhisperLiveSTTServiceConfig", menuName = "VoiceBox/STT/WhisperLiveSTTService Configuration")]
	public class WhisperLiveServiceConfig : GenericSTTServiceConfig
	{
		public string audioInputDeviceName = "Default";

		public string[] audioInputEndpointNames = new string[1] { "Default" };

		public WhisperLiveServiceConfig()
		{
			serviceManagerType = typeof(WhisperLiveServiceManager);
			apiKeyJSONString = "";
		}

		public void OnValidate()
		{
			audioInputEndpointNames = STTUtils.GetAudioInputEndpoints().Keys.ToArray();
		}
	}
}
namespace TimShaw.VoiceBox.Core
{
	public class AIManager : MonoBehaviour
	{
		private CancellationTokenSource internalChatCancellationTokenSource = new CancellationTokenSource();

		private CancellationTokenSource internalSttCancellationTokenSource = new CancellationTokenSource();

		private CancellationTokenSource internalTtsCancellationTokenSource = new CancellationTokenSource();

		[Tooltip("Path to an api keys json file.")]
		[SerializeField]
		public string apiKeysJsonPath = "";

		[Header("Service Configurations")]
		[Tooltip("Configuration asset for the chat service (e.g., GeminiConfig, ChatGPTConfig).")]
		[SerializeField]
		public GenericChatServiceConfig chatServiceConfig;

		[Tooltip("Configuration asset for the STT service (e.g., AzureConfig).")]
		[SerializeField]
		public GenericSTTServiceConfig speechToTextConfig;

		[Tooltip("Configuration asset for the TTS service (e.g., ElevenlabsConfig).")]
		[SerializeField]
		public GenericTTSServiceConfig textToSpeechConfig;

		private IChatService _chatService;

		private ISpeechToTextService _sttService;

		private ITextToSpeechService _ttsService;

		public static AIManager Instance { get; private set; }

		public IChatService ChatService
		{
			get
			{
				return _chatService;
			}
			set
			{
				_chatService = value;
			}
		}

		public ISpeechToTextService SpeechToTextService
		{
			get
			{
				return _sttService;
			}
			set
			{
				_sttService = value;
			}
		}

		public ITextToSpeechService TextToSpeechService
		{
			get
			{
				return _ttsService;
			}
			set
			{
				_ttsService = value;
			}
		}

		private static void CreateAIManagerObj()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)Object.FindFirstObjectByType<AIManager>()))
			{
				Debug.LogError((object)"Error creating AI Manager: only 1 AI manager can exist in a scene at a time.");
			}
			else
			{
				new GameObject("_AIManager").AddComponent<AIManager>();
			}
		}

		public void LoadAPIKeys(string keysFile = null, string chatKey = null, string sttKey = null, string ttsKey = null)
		{
			Dictionary<string, string> keysFromFile = null;
			if (!string.IsNullOrEmpty(keysFile))
			{
				keysFromFile = LoadKeysFromFile(keysFile);
			}
			if ((Object)(object)chatServiceConfig != (Object)null)
			{
				chatServiceConfig.apiKey = GetApiKey(chatKey, chatServiceConfig.apiKeyJSONString, chatServiceConfig.apiKeyJSONString, keysFromFile);
				if (string.IsNullOrEmpty(chatServiceConfig.apiKey))
				{
					Debug.LogWarning((object)"Chat service API key not found.");
				}
			}
			if ((Object)(object)speechToTextConfig != (Object)null)
			{
				speechToTextConfig.apiKey = GetApiKey(sttKey, speechToTextConfig.apiKeyJSONString, speechToTextConfig.apiKeyJSONString, keysFromFile);
				if (string.IsNullOrEmpty(speechToTextConfig.apiKey))
				{
					Debug.LogWarning((object)"STT service API key not found.");
				}
			}
			if ((Object)(object)textToSpeechConfig != (Object)null)
			{
				textToSpeechConfig.apiKey = GetApiKey(ttsKey, textToSpeechConfig.apiKeyJSONString, textToSpeechConfig.apiKeyJSONString, keysFromFile);
				if (string.IsNullOrEmpty(textToSpeechConfig.apiKey))
				{
					Debug.LogWarning((object)"TTS service API key not found.");
				}
			}
		}

		private string GetApiKey(string directKey, string envVar, string jsonKey, Dictionary<string, string> keysFromFile)
		{
			if (!string.IsNullOrEmpty(directKey))
			{
				return directKey;
			}
			if (!string.IsNullOrEmpty(envVar))
			{
				string environmentVariable = Environment.GetEnvironmentVariable(envVar, EnvironmentVariableTarget.User);
				if (!string.IsNullOrEmpty(environmentVariable))
				{
					return environmentVariable;
				}
			}
			if (keysFromFile != null && !string.IsNullOrEmpty(jsonKey) && keysFromFile.ContainsKey(jsonKey))
			{
				return keysFromFile[jsonKey];
			}
			return null;
		}

		private Dictionary<string, string> LoadKeysFromFile(string keysFile)
		{
			try
			{
				return JsonSerializer.Deserialize<Dictionary<string, string>>(File.ReadAllText(keysFile));
			}
			catch (FileNotFoundException)
			{
				Debug.LogWarning((object)("[AI Manager] API keys json file not found at: " + keysFile));
				return null;
			}
			catch (Exception ex2)
			{
				Debug.LogError((object)("[AI Manager] Error reading API keys file: " + ex2.Message));
				return null;
			}
		}

		private void UnloadAPIKeys()
		{
			if (Object.op_Implicit((Object)(object)chatServiceConfig))
			{
				chatServiceConfig.apiKey = "";
			}
			if (Object.op_Implicit((Object)(object)speechToTextConfig))
			{
				speechToTextConfig.apiKey = "";
			}
			if (Object.op_Implicit((Object)(object)textToSpeechConfig))
			{
				textToSpeechConfig.apiKey = "";
			}
		}

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			Instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			if (apiKeysJsonPath.Length > 0)
			{
				LoadAPIKeys(apiKeysJsonPath);
			}
			else
			{
				LoadAPIKeys();
			}
			ChatService = ServiceFactory.CreateChatService(chatServiceConfig);
			SpeechToTextService = ServiceFactory.CreateSttService(speechToTextConfig);
			TextToSpeechService = ServiceFactory.CreateTtsService(textToSpeechConfig);
		}

		private void OnDestroy()
		{
			internalChatCancellationTokenSource.Cancel();
			internalSttCancellationTokenSource.Cancel();
			internalTtsCancellationTokenSource.Cancel();
			UnloadAPIKeys();
			Instance = null;
		}

		public void SendChatMessage(List<ChatUtils.VoiceBoxChatMessage> messageHistory, Action<ChatUtils.VoiceBoxChatMessage> onSuccess, Action<string> onError, ChatUtils.VoiceBoxChatCompletionOptions options = null, CancellationToken token = default(CancellationToken))
		{
			if (internalChatCancellationTokenSource.IsCancellationRequested)
			{
				internalChatCancellationTokenSource = new CancellationTokenSource();
			}
			if (ChatService == null)
			{
				onError?.Invoke("Chat service is not initialized. Check AIManager configuration.");
				return;
			}
			token = CancellationTokenSource.CreateLinkedTokenSource(token, internalChatCancellationTokenSource.Token).Token;
			Task.Run(() => ChatService.SendMessage(messageHistory, onSuccess, onError, options, token));
		}

		public async void StreamChatMessage(List<ChatUtils.VoiceBoxChatMessage> messageHistory, Action<ChatResponseUpdate> onChunkReceived, Action onComplete, Action<string> onError, ChatUtils.VoiceBoxChatCompletionOptions options = null, CancellationToken token = default(CancellationToken))
		{
			if (internalChatCancellationTokenSource.IsCancellationRequested)
			{
				internalChatCancellationTokenSource = new CancellationTokenSource();
			}
			if (ChatService == null)
			{
				onError?.Invoke("Chat service is not initialized. Check AIManager configuration.");
				return;
			}
			token = CancellationTokenSource.CreateLinkedTokenSource(token, internalChatCancellationTokenSource.Token).Token;
			try
			{
				await Task.Run(() => ChatService.SendMessageStream(messageHistory, onChunkReceived, onComplete, onError, options, token));
			}
			catch (Exception ex)
			{
				Debug.LogException(ex);
			}
		}

		public void StartSpeechTranscription(CancellationToken token = default(CancellationToken))
		{
			if (internalSttCancellationTokenSource.IsCancellationRequested)
			{
				internalSttCancellationTokenSource = new CancellationTokenSource();
			}
			if (SpeechToTextService == null)
			{
				Debug.Log((object)"STT Service not initialized. Check AIManager configuration.");
				return;
			}
			token = CancellationTokenSource.CreateLinkedTokenSource(token, internalSttCancellationTokenSource.Token).Token;
			Debug.Log((object)"[AI Manager] Starting speech recognition.");
			Task.Run(() => SpeechToTextService.TranscribeAudioFromMic(token));
		}

		public void StopSpeechTranscription()
		{
			internalSttCancellationTokenSource.Cancel();
		}

		public void GenerateSpeechFileFromText(string prompt, string fileName, string dir, Action<string> onSuccess, Action<string> onError, CancellationToken token = default(CancellationToken))
		{
			Task.Run(() => TextToSpeechService.RequestAudioFile(prompt, fileName, dir, onSuccess, onError, token));
		}

		public async void GenerateSpeechAudioClipFromText(string prompt, Action<AudioClip> onSuccess, Action<string> onError)
		{
			try
			{
				AudioClip obj = await TextToSpeechService.RequestAudioClip(prompt);
				onSuccess?.Invoke(obj);
			}
			catch (Exception ex)
			{
				onError?.Invoke("Failed to generate speech: " + ex.Message);
			}
		}

		public void RequestAudioAndStream(string prompt, AudioStreamer audioStreamer, CancellationToken token = default(CancellationToken))
		{
			if (Object.op_Implicit((Object)(object)audioStreamer))
			{
				audioStreamer.InitStreaming(TextToSpeechService);
				if (internalTtsCancellationTokenSource.IsCancellationRequested)
				{
					internalTtsCancellationTokenSource = new CancellationTokenSource();
				}
				audioStreamer.ConnectAndStream(prompt, TextToSpeechService, isFinalSegment: true, internalTtsCancellationTokenSource.Token);
			}
			else
			{
				Debug.LogError((object)"[AI Manager] Audio Streamer is null.");
			}
		}

		public void RequestAudioAndStream(string promptChunk, bool isFinalSegment, AudioStreamer audioStreamer, CancellationToken token = default(CancellationToken))
		{
			if (Object.op_Implicit((Object)(object)audioStreamer))
			{
				audioStreamer.InitStreaming(TextToSpeechService);
				if (internalTtsCancellationTokenSource.IsCancellationRequested)
				{
					internalTtsCancellationTokenSource = new CancellationTokenSource();
				}
				audioStreamer.ConnectAndStream(promptChunk, TextToSpeechService, isFinalSegment, internalTtsCancellationTokenSource.Token);
			}
			else
			{
				Debug.LogError((object)"[AI Manager] Audio Streamer is null.");
			}
		}

		public async Task<string> CloneVoiceAndGetVoiceIDAsync(AudioFileSource filePaths, string voiceName, string description = "", bool removeBackgroundNoise = false)
		{
			return await TextToSpeechService.CloneVoiceAndGetVoiceIDAsync(filePaths.Paths, voiceName, description, removeBackgroundNoise);
		}

		public async Task<string> CloneVoiceAndGetVoiceIDAsync(AudioDataSource audioDataList, string voiceName, string description = "", bool removeBackgroundNoise = false, string mediaType = "mpeg")
		{
			return await TextToSpeechService.CloneVoiceAndGetVoiceIDAsync(audioDataList.Data, voiceName, description, removeBackgroundNoise, mediaType);
		}
	}
	public static class ChatUtils
	{
		public readonly struct VoiceBoxChatRole
		{
			public static VoiceBoxChatRole System { get; } = new VoiceBoxChatRole("system");


			public static VoiceBoxChatRole Assistant { get; } = new VoiceBoxChatRole("assistant");


			public static VoiceBoxChatRole User { get; } = new VoiceBoxChatRole("user");


			public static VoiceBoxChatRole Tool { get; } = new VoiceBoxChatRole("tool");


			public string Value { get; }

			public VoiceBoxChatRole(string value)
			{
				Value = value;
			}
		}

		public class VoiceBoxChatMessage : ChatMessage
		{
			public string Text => ConcatText(((ChatMessage)this).Contents);

			public VoiceBoxChatMessage(VoiceBoxChatRole role, string content)
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Expected O, but got Unknown
				((ChatMessage)this).Role = new ChatRole(role.Value);
				((ChatMessage)this).Contents = ((content == null) ? new List<AIContent>() : new List<AIContent> { (AIContent)new TextContent(content) });
			}

			public VoiceBoxChatMessage(ChatMessage chatMessage)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				((ChatMessage)this).Role = chatMessage.Role;
				((ChatMessage)this).Contents = chatMessage.Contents;
				((ChatMessage)this).AdditionalProperties = chatMessage.AdditionalProperties;
				((ChatMessage)this).CreatedAt = chatMessage.CreatedAt;
				((ChatMessage)this).RawRepresentation = chatMessage.RawRepresentation;
				((ChatMessage)this).MessageId = chatMessage.MessageId;
				((ChatMessage)this).AuthorName = chatMessage.AuthorName;
			}

			private static string ConcatText(IEnumerable<AIContent> contents)
			{
				if (contents is IList<AIContent> list)
				{
					int count = list.Count;
					switch (count)
					{
					case 0:
						return string.Empty;
					case 1:
					{
						AIContent obj2 = list[0];
						AIContent obj3 = ((obj2 is TextContent) ? obj2 : null);
						return ((obj3 != null) ? ((TextContent)obj3).Text : null) ?? string.Empty;
					}
					default:
					{
						StringBuilder stringBuilder = new StringBuilder();
						for (int i = 0; i < count; i++)
						{
							AIContent obj = list[i];
							TextContent val = (TextContent)(object)((obj is TextContent) ? obj : null);
							if (val != null)
							{
								stringBuilder.Append(val.Text);
							}
						}
						return stringBuilder.ToString();
					}
					}
				}
				return string.Concat(contents.OfType<TextContent>());
			}
		}

		public class VoiceBoxList<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable
		{
			public Action<T> AddCallback;

			private readonly List<T> _internalList = new List<T>();

			public T this[int index]
			{
				get
				{
					return _internalList[index];
				}
				set
				{
					_internalList[index] = value;
				}
			}

			public int Count => _internalList.Count;

			public bool IsReadOnly => false;

			public VoiceBoxList()
			{
			}

			public VoiceBoxList(Action<T> addCallback)
			{
				AddCallback = addCallback;
			}

			public void Add(T item)
			{
				_internalList.Add(item);
				AddCallback?.Invoke(item);
			}

			public void Clear()
			{
				_internalList.Clear();
			}

			public bool Contains(T item)
			{
				return _internalList.Contains(item);
			}

			public void CopyTo(T[] array, int arrayIndex)
			{
				_internalList.CopyTo(array, arrayIndex);
			}

			public IEnumerator<T> GetEnumerator()
			{
				return _internalList.GetEnumerator();
			}

			public int IndexOf(T item)
			{
				return _internalList.IndexOf(item);
			}

			public void Insert(int index, T item)
			{
				_internalList.Insert(index, item);
			}

			public bool Remove(T item)
			{
				return _internalList.Remove(item);
			}

			public void RemoveAt(int index)
			{
				_internalList.RemoveAt(index);
			}

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

		public class VoiceBoxChatCompletionOptions : ChatOptions
		{
			public VoiceBoxList<VoiceBoxChatTool> VoiceBoxTools = new VoiceBoxList<VoiceBoxChatTool>();

			public VoiceBoxChatCompletionOptions()
			{
				if (((ChatOptions)this).Tools == null)
				{
					((ChatOptions)this).Tools = new List<AITool>();
				}
				VoiceBoxTools.AddCallback = delegate(VoiceBoxChatTool tool)
				{
					((ChatOptions)this).Tools.Add((AITool)(object)tool.InternalChatTool);
				};
			}
		}

		public class VoiceBoxChatTool
		{
			public AIFunction InternalChatTool;

			public object Caller;

			public MethodInfo Method;

			public VoiceBoxChatTool(object caller, string functionName, string functionDescription, IList<JsonConverter> customConverters = null)
			{
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Expected O, but got Unknown
				Caller = caller;
				Method = caller.GetType().GetMethod(functionName);
				JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions
				{
					Converters = 
					{
						(JsonConverter)new Vector2JsonConverter(),
						(JsonConverter)new Vector3JsonConverter(),
						(JsonConverter)new Vector4JsonConverter(),
						(JsonConverter)new QuaternionJsonConverter()
					},
					TypeInfoResolver = (IJsonTypeInfoResolver)new DefaultJsonTypeInfoResolver()
				};
				if (customConverters != null)
				{
					foreach (JsonConverter customConverter in customConverters)
					{
						jsonSerializerOptions.Converters.Add(customConverter);
					}
				}
				InternalChatTool = AIFunctionFactory.Create(Method, Caller, functionName, functionDescription, jsonSerializerOptions);
			}

			private BinaryData GetBinaryDataFromParameters(ParameterInfo[] parameters)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Expected O, but got Unknown
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected O, but got Unknown
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Expected O, but got Unknown
				JObject val = new JObject();
				JArray val2 = new JArray();
				foreach (ParameterInfo parameterInfo in parameters)
				{
					val.Add(parameterInfo.Name, (JToken)(object)GetJsonSchemaForType(parameterInfo.ParameterType));
					if (!parameterInfo.IsOptional)
					{
						val2.Add(JToken.op_Implicit(parameterInfo.Name));
					}
				}
				return BinaryData.FromString(((object)new JObject
				{
					["type"] = JToken.op_Implicit("object"),
					["properties"] = (JToken)(object)val,
					["required"] = (JToken)(object)val2
				}).ToString());
			}

			private JObject GetJsonSchemaForType(Type type)
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Expected O, but got Unknown
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Expected O, but got Unknown
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Expected O, but got Unknown
				//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: Expected O, but got Unknown
				//IL_010e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0113: Unknown result type (might be due to invalid IL or missing references)
				//IL_0128: Unknown result type (might be due to invalid IL or missing references)
				//IL_013e: Expected O, but got Unknown
				//IL_0241: Unknown result type (might be due to invalid IL or missing references)
				//IL_0246: Unknown result type (might be due to invalid IL or missing references)
				//IL_025c: Expected O, but got Unknown
				//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bb: Expected O, but got Unknown
				//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c1: Expected O, but got Unknown
				//IL_017d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0182: Unknown result type (might be due to invalid IL or missing references)
				//IL_0197: Unknown result type (might be due to invalid IL or missing references)
				//IL_01aa: Expected O, but got Unknown
				//IL_020e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0213: Unknown result type (might be due to invalid IL or missing references)
				//IL_0228: Unknown result type (might be due to invalid IL or missing references)
				//IL_0234: Unknown result type (might be due to invalid IL or missing references)
				//IL_0241: Expected O, but got Unknown
				if (!(type == typeof(string)))
				{
					if (!(type == typeof(int)) && !(type == typeof(long)) && !(type == typeof(short)))
					{
						if (!(type == typeof(double)) && !(type == typeof(float)) && !(type == typeof(decimal)))
						{
							if (!(type == typeof(bool)))
							{
								if (!(type == typeof(Guid)))
								{
									if (type.IsGenericType && (type.GetGenericTypeDefinition() == typeof(List<>) || type.GetGenericTypeDefinition() == typeof(IEnumerable<>)))
									{
										Type type2 = type.GetGenericArguments()[0];
										return new JObject
										{
											["type"] = JToken.op_Implicit("array"),
											["items"] = (JToken)(object)GetJsonSchemaForType(type2)
										};
									}
									if (type.IsClass)
									{
										JObject val = new JObject();
										JArray val2 = new JArray();
										PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
										foreach (PropertyInfo propertyInfo in properties)
										{
											val.Add(propertyInfo.Name, (JToken)(object)GetJsonSchemaForType(propertyInfo.PropertyType));
											val2.Add(JToken.op_Implicit(propertyInfo.Name));
										}
										return new JObject
										{
											["type"] = JToken.op_Implicit("object"),
											["properties"] = (JToken)(object)val,
											["required"] = (JToken)(object)val2
										};
									}
									return new JObject { ["type"] = JToken.op_Implicit("string") };
								}
								return new JObject
								{
									["type"] = JToken.op_Implicit("string"),
									["format"] = JToken.op_Implicit("uuid")
								};
							}
							return new JObject { ["type"] = JToken.op_Implicit("boolean") };
						}
						return new JObject { ["type"] = JToken.op_Implicit("number") };
					}
					return new JObject { ["type"] = JToken.op_Implicit("integer") };
				}
				return new JObject { ["type"] = JToken.op_Implicit("string") };
			}
		}

		public class Vector2JsonConverter : JsonConverter<Vector2>
		{
			public override bool CanConvert(Type typeToConvert)
			{
				return typeToConvert == typeof(Vector2);
			}

			public override Vector2 Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
			{
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				if (reader.TokenType == JsonTokenType.String)
				{
					string[] array = reader.GetString().Trim('(', ')', ' ').Split(',');
					if (array.Length == 2 && float.TryParse(array[0], out var result) && float.TryParse(array[1], out var result2))
					{
						return new Vector2(result, result2);
					}
				}
				else if (reader.TokenType == JsonTokenType.StartObject)
				{
					float num = 0f;
					float num2 = 0f;
					while (reader.Read())
					{
						if (reader.TokenType == JsonTokenType.EndObject)
						{
							return new Vector2(num, num2);
						}
						if (reader.TokenType != JsonTokenType.PropertyName)
						{
							continue;
						}
						string? @string = reader.GetString();
						reader.Read();
						string text = @string.ToLower();
						if (!(text == "x"))
						{
							if (text == "y")
							{
								num2 = reader.GetSingle();
							}
						}
						else
						{
							num = reader.GetSingle();
						}
					}
				}
				throw new JsonException("Unexpected token or format when parsing Vector2. Value: " + reader.GetString());
			}

			public override void Write(Utf8JsonWriter writer, Vector2 value, JsonSerializerOptions options)
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				writer.WriteStartObject();
				writer.WriteNumber("x", value.x);
				writer.WriteNumber("y", value.y);
				writer.WriteEndObject();
			}
		}

		public class Vector3JsonConverter : JsonConverter<Vector3>
		{
			public override bool CanConvert(Type typeToConvert)
			{
				return typeToConvert == typeof(Vector3);
			}

			public override Vector3 Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
			{
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				if (reader.TokenType == JsonTokenType.String)
				{
					string[] array = reader.GetString().Trim('(', ')', ' ').Split(',');
					if (array.Length == 3 && float.TryParse(array[0], out var result) && float.TryParse(array[1], out var result2) && float.TryParse(array[2], out var result3))
					{
						return new Vector3(result, result2, result3);
					}
				}
				else if (reader.TokenType == JsonTokenType.StartObject)
				{
					float num = 0f;
					float num2 = 0f;
					float num3 = 0f;
					while (reader.Read())
					{
						if (reader.TokenType == JsonTokenType.EndObject)
						{
							return new Vector3(num, num2, num3);
						}
						if (reader.TokenType == JsonTokenType.PropertyName)
						{
							string? @string = reader.GetString();
							reader.Read();
							switch (@string.ToLower())
							{
							case "x":
								num = reader.GetSingle();
								break;
							case "y":
								num2 = reader.GetSingle();
								break;
							case "z":
								num3 = reader.GetSingle();
								break;
							}
						}
					}
				}
				throw new JsonException("Unexpected token or format when parsing Vector3. Value: " + reader.GetString());
			}

			public override void Write(Utf8JsonWriter writer, Vector3 value, JsonSerializerOptions options)
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				writer.WriteStartObject();
				writer.WriteNumber("x", value.x);
				writer.WriteNumber("y", value.y);
				writer.WriteNumber("z", value.z);
				writer.WriteEndObject();
			}
		}

		public class Vector4JsonConverter : JsonConverter<Vector4>
		{
			public override bool CanConvert(Type typeToConvert)
			{
				return typeToConvert == typeof(Vector4);
			}

			public override Vector4 Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
			{
				//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				if (reader.TokenType == JsonTokenType.String)
				{
					string[] array = reader.GetString().Trim('(', ')', ' ').Split(',');
					if (array.Length == 4 && float.TryParse(array[0], out var result) && float.TryParse(array[1], out var result2) && float.TryParse(array[2], out var result3) && float.TryParse(array[3], out var result4))
					{
						return new Vector4(result, result2, result3, result4);
					}
				}
				else if (reader.TokenType == JsonTokenType.StartObject)
				{
					float num = 0f;
					float num2 = 0f;
					float num3 = 0f;
					float num4 = 0f;
					while (reader.Read())
					{
						if (reader.TokenType == JsonTokenType.EndObject)
						{
							return new Vector4(num, num2, num3, num4);
						}
						if (reader.TokenType == JsonTokenType.PropertyName)
						{
							string? @string = reader.GetString();
							reader.Read();
							switch (@string.ToLower())
							{
							case "x":
								num = reader.GetSingle();
								break;
							case "y":
								num2 = reader.GetSingle();
								break;
							case "z":
								num3 = reader.GetSingle();
								break;
							case "w":
								num4 = reader.GetSingle();
								break;
							}
						}
					}
				}
				throw new JsonException("Unexpected token or format when parsing Vector4. Value: " + reader.GetString());
			}

			public override void Write(Utf8JsonWriter writer, Vector4 value, JsonSerializerOptions options)
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: 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)
				writer.WriteStartObject();
				writer.WriteNumber("x", value.x);
				writer.WriteNumber("y", value.y);
				writer.WriteNumber("z", value.z);
				writer.WriteNumber("w", value.w);
				writer.WriteEndObject();
			}
		}

		public class QuaternionJsonConverter : JsonConverter<Quaternion>
		{
			public override bool CanConvert(Type typeToConvert)
			{
				return typeToConvert == typeof(Quaternion);
			}

			public override Quaternion Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
			{
				//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				if (reader.TokenType == JsonTokenType.String)
				{
					string[] array = reader.GetString().Trim('(', ')', ' ').Split(',');
					if (array.Length == 4 && float.TryParse(array[0], out var result) && float.TryParse(array[1], out var result2) && float.TryParse(array[2], out var result3) && float.TryParse(array[3], out var result4))
					{
						return new Quaternion(result, result2, result3, result4);
					}
				}
				else if (reader.TokenType == JsonTokenType.StartObject)
				{
					float num = 0f;
					float num2 = 0f;
					float num3 = 0f;
					float num4 = 0f;
					while (reader.Read())
					{
						if (reader.TokenType == JsonTokenType.EndObject)
						{
							return new Quaternion(num, num2, num3, num4);
						}
						if (reader.TokenType == JsonTokenType.PropertyName)
						{
							string? @string = reader.GetString();
							reader.Read();
							switch (@string.ToLower())
							{
							case "x":
								num = reader.GetSingle();
								break;
							case "y":
								num2 = reader.GetSingle();
								break;
							case "z":
								num3 = reader.GetSingle();
								break;
							case "w":
								num4 = reader.GetSingle();
								break;
							}
						}
					}
				}
				throw new JsonException("Unexpected token or format when parsing Quaternion. Value: " + reader.GetString());
			}

			public override void Write(Utf8JsonWriter writer, Quaternion value, JsonSerializerOptions options)
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: 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)
				writer.WriteStartObject();
				writer.WriteNumber("x", value.x);
				writer.WriteNumber("y", value.y);
				writer.WriteNumber("z", value.z);
				writer.WriteNumber("w", value.w);
				writer.WriteEndObject();
			}
		}

		public class ColorJsonConverter : JsonConverter<Color>
		{
			public override bool CanConvert(Type typeToConvert)
			{
				return typeToConvert == typeof(Color);
			}

			public override Color Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				if (reader.TokenType == JsonTokenType.String)
				{
					string @string = reader.GetString();
					if (string.IsNullOrEmpty(@string))
					{
						return default(Color);
					}
					@string = @string.Trim('(', ')', ' ');
					string[] array = @string.Split(',');
					if (array.Length == 4 && float.TryParse(array[0], out var result) && float.TryParse(array[1], out var result2) && float.TryParse(array[2], out var result3) && float.TryParse(array[3], out var result4))
					{
						return new Color(result, result2, result3, result4);
					}
				}
				else if (reader.TokenType == JsonTokenType.StartObject)
				{
					float num = 0f;
					float num2 = 0f;
					float num3 = 0f;
					float num4 = 1f;
					while (reader.Read())
					{
						if (reader.TokenType == JsonTokenType.EndObject)
						{
							return new Color(num, num2, num3, num4);
						}
						if (reader.TokenType == JsonTokenType.PropertyName)
						{
							string? string2 = reader.GetString();
							reader.Read();
							switch (string2.ToLower())
							{
							case "r":
								num = reader.GetSingle();
								break;
							case "g":
								num2 = reader.GetSingle();
								break;
							case "b":
								num3 = reader.GetSingle();
								break;
							case "a":
								num4 = reader.GetSingle();
								break;
							}
						}
					}
				}
				throw new JsonException($"Unexpected token or format when parsing Color. Token: {reader.TokenType}");
			}

			public override void Write(Utf8JsonWriter writer, Color value, JsonSerializerOptions options)
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: 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)
				writer.WriteStartObject();
				writer.WriteNumber("r", value.r);
				writer.WriteNumber("g", value.g);
				writer.WriteNumber("b", value.b);
				writer.WriteNumber("a", value.a);
				writer.WriteEndObject();
			}
		}
	}
	public interface IChatService
	{
		void Initialize(GenericChatServiceConfig config);

		Task SendMessage(List<ChatUtils.VoiceBoxChatMessage> messageHistory, Action<ChatUtils.VoiceBoxChatMessage> onSuccess, Action<string> onError, ChatUtils.VoiceBoxChatCompletionOptions options, CancellationToken token);

		Task SendMessageStream(List<ChatUtils.VoiceBoxChatMessage> messageHistory, Action<ChatResponseUpdate> onChunkReceived, Action onComplete, Action<string> onError, ChatUtils.VoiceBoxChatCompletionOptions options, CancellationToken token);
	}
	public interface ISpeechToTextService
	{
		event EventHandler<STTUtils.VoiceBoxSpeechRecognitionEventArgs> OnRecognizing;

		event EventHandler<STTUtils.VoiceBoxSpeechRecognitionEventArgs> OnRecognized;

		event EventHandler<STTUtils.VoiceBoxSpeechRecognitionCanceledEventArgs> OnCanceled;

		event EventHandler<SessionEventArgs> OnSessionStarted;

		event EventHandler<SessionEventArgs> OnSessionStopped;

		event EventHandler<RecognitionEventArgs> OnSpeechStartDetected;

		event EventHandler<RecognitionEventArgs> OnSpeechEndDetected;

		void Initialize(GenericSTTServiceConfig config);

		Task TranscribeAudioFromMic(CancellationToken token);
	}
	public interface ITextToSpeechService
	{
		event EventHandler<byte[]> OnAudioDataReceived;

		void Initialize(GenericTTSServiceConfig config);

		Task RequestAudioFile(string prompt, string fileName, string dir, Action<string> onSuccess, Action<string> onError, CancellationToken token);

		Task<AudioClip> RequestAudioClip(string prompt);

		void InitWebsocket(ClientWebSocket webSocket, StreamingAudioDecoder audioDecoder, CancellationToken token);

		Task ConnectAndStream(string text, ClientWebSocket _webSocket, bool isFinalSegment, CancellationToken token);

		void StopStreamingAndDisconnect(ClientWebSocket websocket, CancellationToken token = default(CancellationToken));

		Task<string> CloneVoiceAndGetVoiceIDAsync(IEnumerable<byte[]> audioDataList, string voiceName, string description = "", bool removeBackgroundNoise = false, string mediaType = "mpeg");

		Task<string> CloneVoiceAndGetVoiceIDAsync(IEnumerable<string> filePaths, string voiceName, string description = "", bool removeBackgroundNoise = false);
	}
	public static class ServiceFactory
	{
		public static IChatService CreateChatService(GenericChatServiceConfig config)
		{
			try
			{
				IChatService obj = Activator.CreateInstance(config.serviceManagerType) as IChatService;
				obj.Initialize(config);
				return obj;
			}
			catch (Exception ex)
			{
				if ((Object)(object)config != (Object)null)
				{
					string modelName = config.modelName;
					if (modelName != null && modelName.Length == 0)
					{
						Debug.LogError((object)"[ServiceFactory] No model name specified for chat model.");
					}
					if (config.serviceManagerType != null && ex.GetType() == typeof(NullReferenceException))
					{
						Debug.LogError((object)("[ServiceFactory] Unknown chat config type: " + ((object)config).GetType().Name + ". Does it implement IChatService?"));
					}
				}
				else
				{
					Debug.LogWarning((object)"[ServiceFactory] Chat service config is null. No chat service will be created.");
				}
				return null;
			}
		}

		public static ISpeechToTextService CreateSttService(GenericSTTServiceConfig config)
		{
			try
			{
				ISpeechToTextService obj = Activator.CreateInstance(config.serviceManagerType) as ISpeechToTextService;
				obj.Initialize(config);
				return obj;
			}
			catch
			{
				if ((Object)(object)config != (Object)null)
				{
					if (config.serviceManagerType != null)
					{
						Debug.LogError((object)("[ServiceFactory] Unknown STT config type: " + ((object)config).GetType().Name));
					}
				}
				else
				{
					Debug.LogWarning((object)"[ServiceFactory] STT service config is null. No STT service will be created.");
				}
				return null;
			}
		}

		public static ITextToSpeechService CreateTtsService(GenericTTSServiceConfig config)
		{
			try
			{
				ITextToSpeechService obj = Activator.CreateInstance(config.serviceManagerType) as ITextToSpeechService;
				obj.Initialize(config);
				return obj;
			}
			catch
			{
				if ((Object)(object)config != (Object)null)
				{
					if (config.serviceManagerType != null)
					{
						Debug.LogError((object)("[ServiceFactory] Unknown TTS config type: " + ((object)config).GetType().Name));
					}
				}
				else
				{
					Debug.LogWarning((object)"[ServiceFactory] TTS service config is null. No TTS service will be created.");
				}
				return null;
			}
		}
	}
	public class STTUtils
	{
		public enum VoiceBoxResultReason
		{
			NoMatch,
			Canceled,
			RecognizingSpeech,
			RecognizedSpeech,
			RecognizingIntent,
			RecognizedIntent,
			TranslatingSpeech,
			TranslatedSpeech,
			SynthesizingAudio,
			SynthesizingAudioCompleted,
			RecognizingKeyword,
			RecognizedKeyword,
			SynthesizingAudioStarted,
			TranslatingParticipantSpeech,
			TranslatedParticipantSpeech,
			TranslatedInstantMessage,
			TranslatedParticipantInstantMessage,
			EnrollingVoiceProfile,
			EnrolledVoiceProfile,
			RecognizedSpeakers,
			RecognizedSpeaker,
			ResetVoiceProfile,
			DeletedVoiceProfile,
			VoicesListRetrieved,
			RecognizedSpeechWithTimestamps
		}

		public class RecognitionResult
		{
			public VoiceBoxResultReason Reason { get; set; }

			public string Text { get; set; }

			public TimeSpan Duration { get; set; }

			public long OffsetInTicks { get; set; }
		}

		public class VoiceBoxSpeechRecognitionEventArgs
		{
			public RecognitionResult Result { get; set; }

			public string Text => Result.Text;

			public VoiceBoxSpeechRecognitionEventArgs()
			{
				Result = new RecognitionResult();
			}

			public VoiceBoxSpeechRecognitionEventArgs(VoiceBoxResultReason reason, string text, TimeSpan duration, long offsetInTicks)
			{
				Result = new RecognitionResult();
				Result.Reason = reason;
				Result.Text = text;
				Result.Duration = duration;
				Result.OffsetInTicks = offsetInTicks;
			}

			public static explicit operator VoiceBoxSpeechRecognitionEventArgs(SpeechRecognitionEventArgs args)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Expected I4, but got Unknown
				return new VoiceBoxSpeechRecognitionEventArgs((VoiceBoxResultReason)((RecognitionResult)args.Result).Reason, ((RecognitionResult)args.Result).Text, ((RecognitionResult)args.Result).Duration, ((RecognitionResult)args.Result).OffsetInTicks);
			}
		}

		public class VoiceBoxSpeechRecognitionCanceledEventArgs : EventArgs
		{
			public CancellationReason Reason { get; private set; }

			public string ErrorCode { get; private set; }

			public string ErrorDetails { get; private set; }

			public VoiceBoxSpeechRecognitionCanceledEventArgs(CancellationReason reason, string errorCode, string errorDetails)
			{
				Reason = reason;
				ErrorCode = errorCode;
				ErrorDetails = errorDetails;
			}

			public static explicit operator VoiceBoxSpeechRecognitionCanceledEventArgs(SpeechRecognitionCanceledEventArgs args)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected I4, but got Unknown
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				if (args == null)
				{
					return null;
				}
				CancellationReason reason = CancellationReason.Error;
				CancellationReason reason2 = args.Reason;
				switch (reason2 - 1)
				{
				case 0:
					reason = CancellationReason.Error;
					break;
				case 1:
					reason = CancellationReason.EndOfStream;
					break;
				case 2:
					reason = CancellationReason.User;
					break;
				}
				CancellationErrorCode errorCode = args.ErrorCode;
				string errorCode2 = ((object)(CancellationErrorCode)(ref errorCode)).ToString();
				return new VoiceBoxSpeechRecognitionCanceledEventArgs(reason, errorCode2, args.ErrorDetails);
			}
		}

		public enum CancellationReason
		{
			Error,
			EndOfStream,
			User
		}

		public static Dictionary<string, string> GetAudioInputEndpoints()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			List<MMDevice> list = ((IEnumerable<MMDevice>)new MMDeviceEnumerator().EnumerateAudioEndPoints((DataFlow)1, (DeviceState)1)).ToList();
			dictionary.Add("Default", "");
			foreach (MMDevice item in list)
			{
				dictionary.Add(item.FriendlyName, item.ID);
			}
			return dictionary;
		}

		public static int GetAudioInputDeviceNum(string deviceName, Dictionary<string, string> audioInputEndpoints)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (deviceName == "Default")
			{
				return 0;
			}
			int deviceCount = WaveIn.DeviceCount;
			for (int i = 0; i < deviceCount; i++)
			{
				WaveInCapabilities capabilities = WaveIn.GetCapabilities(i);
				foreach (string key in audioInputEndpoints.Keys)
				{
					if (key.StartsWith(((WaveInCapabilities)(ref capabilities)).ProductName) && key == deviceName)
					{
						return i;
					}
				}
			}
			Debug.LogWarning((object)("Device " + deviceName + " not found."));
			return -1;
		}
	}
	public readonly struct AudioFileSource
	{
		public IEnumerable<string> Paths { get; }

		public AudioFileSource(string path)
		{
			Paths = new string[1] { path };
		}

		public AudioFileSource(IEnumerable<string> paths)
		{
			Paths = paths;
		}

		public static implicit operator AudioFileSource(string path)
		{
			return new AudioFileSource(path);
		}

		public static implicit operator AudioFileSource(List<string> paths)
		{
			return new AudioFileSource(paths);
		}

		public static implicit operator AudioFileSource(string[] paths)
		{
			return new AudioFileSource(paths);
		}
	}
	public readonly struct AudioDataSource
	{
		public IEnumerable<byte[]> Data { get; }

		public AudioDataSource(byte[] singleItem)
		{
			Data = new byte[1][] { singleItem };
		}

		public AudioDataSource(IEnumerable<byte[]> collection)
		{
			Data = collection;
		}

		public static implicit operator AudioDataSource(byte[] data)
		{
			return new AudioDataSource(data);
		}

		public static implicit operator AudioDataSource(List<byte[]> data)
		{
			return new AudioDataSource(data);
		}

		public static implicit operator AudioDataSource(byte[][] data)
		{
			return new AudioDataSource(data);
		}
	}
	public class AzureSTTServiceManager : ISpeechToTextService
	{
		public SpeechRecognizer speechRecognizer;

		private Dictionary<string, string> audioEndpoints;

		private AzureSTTServiceConfig _config;

		public event EventHandler<STTUtils.VoiceBoxSpeechRecognitionEventArgs> OnRecognizing;

		public event EventHandler<STTUtils.VoiceBoxSpeechRecognitionEventArgs> OnRecognized;

		public event EventHandler<STTUtils.VoiceBoxSpeechRecognitionCanceledEventArgs> OnCanceled;

		public event EventHandler<SessionEventArgs> OnSessionStarted;

		public event EventHandler<SessionEventArgs> OnSessionStopped;

		public event EventHandler<RecognitionEventArgs> OnSpeechStartDetected;

		public event EventHandler<RecognitionEventArgs> OnSpeechEndDetected;

		public async Task TranscribeAudioFromMic(CancellationToken token)
		{
			_ = 2;
			try
			{
				TaskCompletionSource<int> stopRecognition = new TaskCompletionSource<int>();
				token.Register(delegate
				{
					stopRecognition.TrySetResult(0);
				});
				await speechRecognizer.StartContinuousRecognitionAsync();
				await stopRecognition.Task;
				await speechRecognizer.StopContinuousRecognitionAsync();
				Debug.Log((object)"Azure Service Manager: Transcription stopped.");
			}
			catch (Exception ex)
			{
				Debug.Log((object)"Azure Service Manager: Speech to Text error");
				Debug.Log((object)ex.ToString());
			}
		}

		public void Initialize(GenericSTTServiceConfig config)
		{
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			_config = config as AzureSTTServiceConfig;
			if (_config.apiKey.Length == 0)
			{
				Debug.Log((object)"No API key. STT disabled.");
				return;
			}
			audioEndpoints = STTUtils.GetAudioInputEndpoints();
			AudioConfig val;
			try
			{
				val = ((_config.audioInputDeviceName == "Default") ? AudioConfig.FromDefaultMicrophoneInput() : AudioConfig.FromMicrophoneInput(audioEndpoints[_config.audioInputDeviceName]));
			}
			catch (Exception ex)
			{
				Debug.LogWarning((object)("Azure Service Manager: AudioConfig error: " + ex.Message + " -- Using default microphone."));
				val = AudioConfig.FromDefaultMicrophoneInput();
			}
			SpeechConfig val2 = SpeechConfig.FromSubscription(_config.apiKey, _config.region);
			val2.SpeechRecognitionLanguage = _config.language;
			if (_config.requestWordLevelTimestamps)
			{
				val2.RequestWordLevelTimestamps();
			}
			speechRecognizer = new SpeechRecognizer(val2, val);
			InitSpeechRecognizer();
		}

		private void InitSpeechRecognizer()
		{
			speechRecognizer.Recognizing += delegate(object s, SpeechRecognitionEventArgs e)
			{
				Debug.Log((object)("Azure Service Manager: Recognizing: " + ((RecognitionResult)e.Result).Text));
				this.OnRecognizing?.Invoke(this, (STTUtils.VoiceBoxSpeechRecognitionEventArgs)e);
			};
			speechRecognizer.Recognized += delegate(object s, SpeechRecognitionEventArgs e)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Invalid comparison between Unknown and I4
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				if ((int)((RecognitionResult)e.Result).Reason == 3)
				{
					Debug.Log((object)("Azure Service Manager: Recognized: " + ((RecognitionResult)e.Result).Text));
				}
				else if ((int)((RecognitionResult)e.Result).Reason == 0)
				{
					Debug.Log((object)"Azure Service Manager: No match.");
				}
				STTUtils.VoiceBoxSpeechRecognitionEventArgs voiceBoxSpeechRecognitionEventArgs = (STTUtils.VoiceBoxSpeechRecognitionEventArgs)e;
				if (_config.requestWordLevelTimestamps && voiceBoxSpeechRecognitionEventArgs.Result.Reason == STTUtils.VoiceBoxResultReason.RecognizedSpeech)
				{
					voiceBoxSpeechRecognitionEventArgs.Result.Reason = STTUtils.VoiceBoxResultReason.RecognizedSpeechWithTimestamps;
				}
				this.OnRecognized?.Invoke(this, voiceBoxSpeechRecognitionEventArgs);
			};
			speechRecognizer.Canceled += delegate(object s, SpeechRecognitionCanceledEventArgs e)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				Debug.Log((object)$"Azure Service Manager: CANCELED: Reason={e.Reason} Details={e.ErrorDetails}");
				this.OnCanceled?.Invoke(this, (STTUtils.VoiceBoxSpeechRecognitionCanceledEventArgs)e);
			};
			((Recognizer)speechRecognizer).SessionStarted += delegate(object s, SessionEventArgs e)
			{
				Debug.Log((object)"Azure Service Manager: Session Started.");
				this.OnSessionStarted?.Invoke(this, e);
			};
			((Recognizer)speechRecognizer).SessionStopped += delegate(object s, SessionEventArgs e)
			{
				Debug.Log((object)"Azure Service Manager: Session Stopped.");
				this.OnSessionStopped?.Invoke(this, e);
			};
			((Recognizer)speechRecognizer).SpeechStartDetected += delegate(object s, RecognitionEventArgs e)
			{
				this.OnSpeechStartDetected?.Invoke(this, e);
			};
			((Recognizer)speechRecognizer).SpeechEndDetected += delegate(object s, RecognitionEventArgs e)
			{
				this.OnSpeechEndDetected?.Invoke(this, e);
			};
		}
	}
	internal class ChatGPTServiceManager : IChatService
	{
		private IChatClient _client;

		private ChatGPTServiceConfig _config;

		public void Initialize(GenericChatServiceConfig config)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid