using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Microsoft.Extensions.Logging;
using Photon.Pun;
using Photon.Realtime;
using TwitchLib.Client;
using TwitchLib.Client.Enums;
using TwitchLib.Client.Events;
using TwitchLib.Client.Models;
using TwitchLib.Communication.Interfaces;
using UnityEngine;
using UnityEngine.Networking;
using Zorro.Core;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("TwitchBingBong")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.1.3.0")]
[assembly: AssemblyInformationalVersion("1.1.3")]
[assembly: AssemblyProduct("TwitchBingBong")]
[assembly: AssemblyTitle("TwitchBingBong")]
[assembly: AssemblyVersion("1.1.3.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
public class BingBongTTS : MonoBehaviourPunCallbacks
{
	[CompilerGenerated]
	private sealed class <>c__DisplayClass52_0
	{
		public bool ok;

		internal void <ClientPrepareClip>b__0(bool r)
		{
			ok = r;
		}
	}

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

		private object <>2__current;

		public string text;

		public string utteranceId;

		public BingBongTTS <>4__this;

		private <>c__DisplayClass52_0 <>8__1;

		private string <temp>5__2;

		private UnityWebRequest <uwr>5__3;

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

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

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

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			int num = <>1__state;
			if (num == -3 || num == 2)
			{
				try
				{
				}
				finally
				{
					<>m__Finally1();
				}
			}
			<>8__1 = null;
			<temp>5__2 = null;
			<uwr>5__3 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Invalid comparison between Unknown and I4
			try
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass52_0();
					<>4__this._preparedClip = null;
					<temp>5__2 = Path.Combine(Application.temporaryCachePath, $"tts_{utteranceId}_{DateTime.Now.Ticks}.wav");
					<>8__1.ok = false;
					<>2__current = <>4__this.RunPiperToFile(text, <temp>5__2, delegate(bool r)
					{
						<>8__1.ok = r;
					});
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!<>8__1.ok || !File.Exists(<temp>5__2))
					{
						<>4__this.TryAckReady(utteranceId, ok: false);
						return false;
					}
					<uwr>5__3 = UnityWebRequestMultimedia.GetAudioClip("file://" + <temp>5__2, (AudioType)20);
					<>1__state = -3;
					<>2__current = <uwr>5__3.SendWebRequest();
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -3;
					if ((int)<uwr>5__3.result == 1)
					{
						<>4__this._preparedClip = DownloadHandlerAudioClip.GetContent(<uwr>5__3);
					}
					<>m__Finally1();
					<uwr>5__3 = null;
					try
					{
						File.Delete(<temp>5__2);
					}
					catch
					{
					}
					if ((Object)(object)<>4__this._preparedClip != (Object)null)
					{
						<>4__this._clips[utteranceId] = <>4__this._preparedClip;
					}
					<>4__this.TryAckReady(utteranceId, (Object)(object)<>4__this._preparedClip != (Object)null);
					<>4__this.TryStart(utteranceId);
					return false;
				}
			}
			catch
			{
				//try-fault
				((IDisposable)this).Dispose();
				throw;
			}
		}

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

		private void <>m__Finally1()
		{
			<>1__state = -1;
			if (<uwr>5__3 != null)
			{
				((IDisposable)<uwr>5__3).Dispose();
			}
		}

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

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

		private object <>2__current;

		public string text;

		public BingBongTTS <>4__this;

		private float <started>5__1;

		private double <goAtNetworkTime>5__2;

		private bool <hostPrepared>5__3;

		private bool <everyoneAnswered>5__4;

		private bool <someoneAnswered>5__5;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0379: Unknown result type (might be due to invalid IL or missing references)
			//IL_0383: Expected O, but got Unknown
			//IL_0357: Unknown result type (might be due to invalid IL or missing references)
			//IL_0361: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				if (!<>4__this._piperReady)
				{
					Log.LogWarning((object)"[TTS] Piper not initialized; skipping.");
					return false;
				}
				<>4__this._currentUtteranceId = Guid.NewGuid().ToString();
				<>4__this._readyOK.Clear();
				<>4__this._readyAll.Clear();
				<>4__this._preparedClip = null;
				<>4__this._pendingGo.Clear();
				<>4__this._clips.Clear();
				Log.LogInfo((object)("[TTS] PREPARE “" + text + "” (" + <>4__this._currentUtteranceId + ")"));
				<>4__this._pv.RPC("RPC_PrepareTTS", (RpcTarget)0, new object[2] { text, <>4__this._currentUtteranceId });
				<>4__this.RebuildExpectedSnapshot();
				<started>5__1 = Time.time;
				goto IL_0254;
			case 1:
				<>1__state = -1;
				goto IL_0254;
			case 2:
				<>1__state = -1;
				break;
			case 3:
				{
					<>1__state = -1;
					break;
				}
				IL_0254:
				<hostPrepared>5__3 = (Object)(object)<>4__this._preparedClip != (Object)null;
				<everyoneAnswered>5__4 = <>4__this._readyAll.IsSupersetOf(<>4__this._expected);
				<someoneAnswered>5__5 = <>4__this._readyAll.Overlaps(<>4__this._expected) || <>4__this._readyAll.Count > 0;
				if (!(<hostPrepared>5__3 & <everyoneAnswered>5__4))
				{
					if (!(Time.time - <started>5__1 >= 15f))
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					if (!(<hostPrepared>5__3 & <someoneAnswered>5__5))
					{
						Log.LogWarning((object)"[TTS] Timeout: nobody answered; skipping line.");
						return false;
					}
					Log.LogWarning((object)"[TTS] Timeout: proceeding with answered clients only.");
				}
				<goAtNetworkTime>5__2 = PhotonNetwork.Time + 0.95;
				Log.LogInfo((object)$"[TTS] GO {<>4__this._currentUtteranceId} at net={<goAtNetworkTime>5__2:F3} (answered {<>4__this._readyAll.Count}/{<>4__this._expected.Count}, ok {<>4__this._readyOK.Count})");
				<>4__this._pv.RPC("RPC_StartPreparedTTS", (RpcTarget)0, new object[2] { <>4__this._currentUtteranceId, <goAtNetworkTime>5__2 });
				if ((Object)(object)<>4__this._preparedClip != (Object)null)
				{
					<>2__current = (object)new WaitForSeconds(<>4__this._preparedClip.length + 0.25f);
					<>1__state = 2;
					return true;
				}
				<>2__current = (object)new WaitForSeconds(0.2f);
				<>1__state = 3;
				return true;
			}
			return false;
		}

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

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

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

		private object <>2__current;

		public BingBongTTS <>4__this;

		private string <next>5__1;

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

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

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

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

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this._isSpeaking = true;
				goto IL_00a5;
			case 1:
				<>1__state = -1;
				goto IL_0086;
			case 2:
				{
					<>1__state = -1;
					<next>5__1 = null;
					goto IL_00a5;
				}
				IL_00a5:
				if (<>4__this._queue.Count > 0)
				{
					<next>5__1 = <>4__this._queue.Dequeue();
					if (<>4__this.ActAsHost())
					{
						<>2__current = <>4__this.HostPrepareBarrierThenStart(<next>5__1);
						<>1__state = 1;
						return true;
					}
					goto IL_0086;
				}
				<>4__this._isSpeaking = false;
				return false;
				IL_0086:
				<>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 <RegisterWhenInRoom>d__45 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public BingBongTTS <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (!PhotonNetwork.InRoom)
			{
				<>2__current = null;
				<>1__state = 1;
				return true;
			}
			if (PhotonNetwork.IsMasterClient)
			{
				<>4__this._modClients.Add(<>4__this._userId);
			}
			if (PhotonNetwork.IsMasterClient)
			{
				<>4__this._actorToUserId[PhotonNetwork.LocalPlayer.ActorNumber] = <>4__this._userId;
			}
			<>4__this._pv.RPC("RPC_RegisterMod", (RpcTarget)2, new object[1] { <>4__this._userId });
			return false;
		}

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

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

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

		private object <>2__current;

		public string text;

		public string outPath;

		public Action<bool> done;

		public BingBongTTS <>4__this;

		private string <len>5__1;

		private string <args>5__2;

		private ProcessStartInfo <psi>5__3;

		private Process <proc>5__4;

		private Exception <ex>5__5;

		private FileInfo <fi>5__6;

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

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

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

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<len>5__1 = null;
			<args>5__2 = null;
			<psi>5__3 = null;
			<proc>5__4 = null;
			<ex>5__5 = null;
			<fi>5__6 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				done(obj: false);
				if (!<>4__this._piperReady)
				{
					Log.LogError((object)"[TTS] Piper files missing.");
					return false;
				}
				try
				{
					Directory.CreateDirectory(Path.GetDirectoryName(outPath) ?? Application.temporaryCachePath);
				}
				catch
				{
				}
				<len>5__1 = <>4__this.PiperSpeed.ToString(CultureInfo.InvariantCulture);
				<args>5__2 = "-m \"" + <>4__this._piperModelPath + "\" -c \"" + <>4__this._piperConfigPath + "\" -f \"" + outPath + "\" -q --length_scale " + <len>5__1;
				if (<>4__this.PiperSentencePauseMs > 0f)
				{
					<args>5__2 += $" --sentence_silence {Mathf.RoundToInt(<>4__this.PiperSentencePauseMs)}";
				}
				<psi>5__3 = new ProcessStartInfo
				{
					FileName = <>4__this._piperExePath,
					Arguments = <args>5__2,
					UseShellExecute = false,
					RedirectStandardInput = true,
					RedirectStandardError = true,
					CreateNoWindow = true
				};
				<proc>5__4 = null;
				try
				{
					<proc>5__4 = Process.Start(<psi>5__3);
				}
				catch (Exception ex)
				{
					<ex>5__5 = ex;
					Log.LogError((object)("[TTS] Failed to start piper: " + <ex>5__5.Message));
					return false;
				}
				try
				{
					<proc>5__4.StandardInput.WriteLine(text);
					<proc>5__4.StandardInput.Close();
				}
				catch
				{
				}
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (!<proc>5__4.HasExited)
			{
				<>2__current = null;
				<>1__state = 1;
				return true;
			}
			if (<proc>5__4.ExitCode != 0)
			{
				try
				{
					Log.LogError((object)("[TTS] Piper stderr: " + <proc>5__4.StandardError.ReadToEnd()));
				}
				catch
				{
				}
				return false;
			}
			if (!File.Exists(outPath))
			{
				return false;
			}
			try
			{
				<fi>5__6 = new FileInfo(outPath);
				if (<fi>5__6.Length < 128)
				{
					return false;
				}
				<fi>5__6 = null;
			}
			catch
			{
			}
			done(obj: true);
			return false;
		}

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

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

	private static readonly ManualLogSource Log = Logger.CreateLogSource("BingBongTTS");

	private static BingBongTTS _instance;

	private string _piperExePath = "";

	private string _piperModelPath = "";

	private string _piperConfigPath = "";

	private bool _piperReady = false;

	public float PiperSpeed = 1f;

	public float PiperSentencePauseMs = 0f;

	public string VoiceName = "Ryan-High";

	private AudioSource _src;

	[Range(0f, 1f)]
	public float BaseVolume = 1f;

	private Transform _target;

	private float _nextTargetSearchAt;

	private const float TargetSearchPeriod = 0.5f;

	private float _mouthOpen;

	public float MouthUpdateHz = 13f;

	public float MouthSampleWindowMs = 64f;

	public float MouthAttackHz = 25f;

	public float MouthReleaseHz = 15f;

	public float MouthGain = 25f;

	public float MouthFloor = 0.021f;

	public float MouthKnee = 0.07f;

	public float MouthMaxDeltaPerSec = 6f;

	private float[] _outSamples;

	private float _mouthNextAt;

	private float _mouthPeak = 0.05f;

	private const int PV_ID = 71539131;

	private PhotonView _pv;

	private readonly string _userId = Guid.NewGuid().ToString();

	private readonly HashSet<string> _modClients = new HashSet<string>();

	private readonly HashSet<string> _readyOK = new HashSet<string>();

	private readonly HashSet<string> _readyAll = new HashSet<string>();

	private readonly HashSet<string> _expected = new HashSet<string>();

	private readonly Dictionary<int, string> _actorToUserId = new Dictionary<int, string>();

	private string _currentUtteranceId = "";

	private Coroutine _prepareCo;

	private AudioClip _preparedClip;

	private readonly Dictionary<string, double> _pendingGo = new Dictionary<string, double>();

	private readonly Dictionary<string, AudioClip> _clips = new Dictionary<string, AudioClip>();

	private readonly Queue<string> _queue = new Queue<string>();

	private bool _isSpeaking;

	private Animator _anim;

	private int _animMouthHash = -1;

	private void Awake()
	{
		if ((Object)(object)_instance != (Object)null)
		{
			Object.Destroy((Object)(object)((Component)this).gameObject);
			return;
		}
		_instance = this;
		Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
		_src = ((Component)this).gameObject.AddComponent<AudioSource>();
		_src.spatialBlend = 1f;
		_src.rolloffMode = (AudioRolloffMode)0;
		_src.minDistance = 3f;
		_src.maxDistance = 40f;
		_src.priority = 128;
		_src.loop = false;
		_pv = ((Component)this).gameObject.AddComponent<PhotonView>();
		_pv.ViewID = 71539131;
		TryInitPiper();
		((MonoBehaviour)this).StartCoroutine(RegisterWhenInRoom());
	}

	private void TryBindAnimator()
	{
		if ((Object)(object)_anim != (Object)null)
		{
			return;
		}
		Transform val = (Object.op_Implicit((Object)(object)_target) ? _target.root : null);
		if (Object.op_Implicit((Object)(object)val))
		{
			_anim = ((Component)val).GetComponentInChildren<Animator>(true);
			if ((Object)(object)_anim != (Object)null)
			{
				_animMouthHash = Animator.StringToHash("Mouth Blend");
				Log.LogInfo((object)("[Mouth] Driving Animator float 'Mouth Blend' on " + ((Object)((Component)_anim).gameObject).name));
			}
		}
	}

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

	public bool TryInitPiper()
	{
		string path = Path.GetDirectoryName(((object)this).GetType().Assembly.Location) ?? Environment.CurrentDirectory;
		_piperExePath = Path.Combine(path, "piper.exe");
		_piperModelPath = Path.Combine(path, "en_US-ryan-high.onnx");
		_piperConfigPath = _piperModelPath + ".json";
		_piperReady = File.Exists(_piperExePath) && File.Exists(_piperModelPath) && File.Exists(_piperConfigPath);
		if (_piperReady)
		{
			Log.LogInfo((object)$"[TTS] Piper ready. exe={_piperExePath}, model={_piperModelPath}, length_scale={PiperSpeed.ToString(CultureInfo.InvariantCulture)}, sentence_silence={PiperSentencePauseMs}ms");
		}
		else
		{
			if (!File.Exists(_piperExePath))
			{
				Log.LogError((object)("[TTS] Missing piper.exe at: " + _piperExePath));
			}
			if (!File.Exists(_piperModelPath))
			{
				Log.LogError((object)("[TTS] Missing voice model at: " + _piperModelPath));
			}
			if (!File.Exists(_piperConfigPath))
			{
				Log.LogError((object)("[TTS] Missing model config at: " + _piperConfigPath));
			}
		}
		return _piperReady;
	}

	private bool ActAsHost()
	{
		return PhotonNetwork.IsMasterClient;
	}

	public void Enqueue(string text)
	{
		if (!string.IsNullOrWhiteSpace(text))
		{
			text = new string((from c in text.Trim()
				where !char.IsControl(c) || c == ' '
				select c).ToArray());
			_queue.Enqueue(text);
			if (!_isSpeaking)
			{
				((MonoBehaviour)this).StartCoroutine(ProcessQueue());
			}
		}
	}

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

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

	[PunRPC]
	private void RPC_PrepareTTS(string text, string utteranceId)
	{
		_currentUtteranceId = utteranceId;
		if (_prepareCo != null)
		{
			((MonoBehaviour)this).StopCoroutine(_prepareCo);
			_prepareCo = null;
		}
		_pendingGo.Clear();
		_clips.Clear();
		_prepareCo = ((MonoBehaviour)this).StartCoroutine(ClientPrepareClip(text, utteranceId));
	}

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

	private void TryAckReady(string utteranceId, bool ok)
	{
		try
		{
			_pv.RPC("RPC_ReadyAck", (RpcTarget)2, new object[3] { utteranceId, _userId, ok });
		}
		catch
		{
		}
	}

	[PunRPC]
	private void RPC_ReadyAck(string utteranceId, string userId, bool ok)
	{
		if (PhotonNetwork.IsMasterClient && !(utteranceId != _currentUtteranceId))
		{
			_modClients.Add(userId);
			_readyAll.Add(userId);
			if (ok)
			{
				_readyOK.Add(userId);
			}
			Log.LogInfo((object)$"[TTS] READY {userId} ok={ok} ({_readyOK.Count}/{_expected.Count})");
		}
	}

	[PunRPC]
	private void RPC_StartPreparedTTS(string utteranceId, double goAtNetworkTime)
	{
		_currentUtteranceId = utteranceId;
		_pendingGo[utteranceId] = goAtNetworkTime;
		TryStart(utteranceId);
	}

	private void TryStart(string utteranceId)
	{
		if (_pendingGo.TryGetValue(utteranceId, out var value) && _clips.TryGetValue(utteranceId, out var value2) && !((Object)(object)value2 == (Object)null))
		{
			if (_src.isPlaying)
			{
				_src.Stop();
			}
			_src.clip = null;
			_src.clip = value2;
			double time = PhotonNetwork.Time;
			double num = value - time;
			if (num > 0.02)
			{
				_src.PlayScheduled(AudioSettings.dspTime + num);
				Log.LogInfo((object)$"[TTS] schedule in {num:F3}s (net now={time:F3})");
			}
			else
			{
				_src.Play();
				Log.LogInfo((object)$"[TTS] late by {0.0 - num:F3}s -> playing immediately");
			}
			_pendingGo.Remove(utteranceId);
			_clips.Remove(utteranceId);
		}
	}

	[PunRPC]
	private void RPC_RegisterMod(string userId, PhotonMessageInfo info)
	{
		//IL_000f: 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)
		if (PhotonNetwork.IsMasterClient)
		{
			int num = ((info.Sender != null) ? info.Sender.ActorNumber : PhotonNetwork.LocalPlayer.ActorNumber);
			_actorToUserId[num] = userId;
			_modClients.Add(userId);
			Log.LogInfo((object)$"[TTS] Registered mod client: {userId} (actor {num}) (total {_modClients.Count})");
		}
	}

	public static void NotifyRoomRosterPossiblyChanged()
	{
		_instance?._PruneGhostsAndRebuildExpected();
	}

	private void _PruneGhostsAndRebuildExpected()
	{
		if (!PhotonNetwork.IsMasterClient)
		{
			return;
		}
		HashSet<int> presentActors = new HashSet<int>(PhotonNetwork.PlayerList.Select((Player p) => p.ActorNumber));
		List<int> list = _actorToUserId.Keys.Where((int a) => !presentActors.Contains(a)).ToList();
		foreach (int item in list)
		{
			string text = _actorToUserId[item];
			_actorToUserId.Remove(item);
			_modClients.Remove(text);
			_readyAll.Remove(text);
			_readyOK.Remove(text);
			_expected.Remove(text);
			Log.LogInfo((object)$"[TTS] Pruned ghost: {text} (actor {item})");
		}
		RebuildExpectedSnapshot();
	}

	private void RebuildExpectedSnapshot()
	{
		_expected.Clear();
		Player[] playerList = PhotonNetwork.PlayerList;
		foreach (Player val in playerList)
		{
			if (_actorToUserId.TryGetValue(val.ActorNumber, out var value) && _modClients.Contains(value))
			{
				_expected.Add(value);
			}
		}
		if (PhotonNetwork.IsMasterClient && _actorToUserId.TryGetValue(PhotonNetwork.LocalPlayer.ActorNumber, out var value2))
		{
			_expected.Add(value2);
		}
		Log.LogInfo((object)$"[TTS] Expected snapshot = {_expected.Count} clients.");
	}

	[IteratorStateMachine(typeof(<RunPiperToFile>d__61))]
	private IEnumerator RunPiperToFile(string text, string outPath, Action<bool> done)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <RunPiperToFile>d__61(0)
		{
			<>4__this = this,
			text = text,
			outPath = outPath,
			done = done
		};
	}

	private void LateUpdate()
	{
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		if (!Object.op_Implicit((Object)(object)_target) && Time.time >= _nextTargetSearchAt)
		{
			_nextTargetSearchAt = Time.time + 0.5f;
			GameObject val = GameObject.Find("Bing Bong Plush") ?? GameObject.Find("BingBong(Clone)");
			if (Object.op_Implicit((Object)(object)val))
			{
				_target = val.transform;
			}
		}
		if (Object.op_Implicit((Object)(object)_target))
		{
			((Component)this).transform.position = _target.position;
		}
		bool flag = Singleton<PeakHandler>.Instance?.isPlayingCinematic ?? false;
		_src.spatialBlend = (flag ? 0f : 1f);
		_src.volume = (((Object)(object)_target != (Object)null) ? BaseVolume : 0f);
		if ((Object)(object)_src != (Object)null && _src.isPlaying && Time.time >= _mouthNextAt)
		{
			_mouthNextAt = Time.time + 1f / Mathf.Max(10f, MouthUpdateHz);
			int outputSampleRate = AudioSettings.outputSampleRate;
			int num = Mathf.Clamp(Mathf.RoundToInt((float)outputSampleRate * (MouthSampleWindowMs / 1000f)), 256, 4096);
			if (_outSamples == null || _outSamples.Length != num)
			{
				_outSamples = new float[num];
			}
			_src.GetOutputData(_outSamples, 0);
			float num2 = 0f;
			for (int i = 0; i < num; i++)
			{
				float num3 = _outSamples[i];
				num2 += num3 * num3;
			}
			float num4 = Mathf.Sqrt(num2 / (float)Mathf.Max(1, num));
			if (num4 < MouthFloor)
			{
				num4 = 0f;
			}
			float num5 = 1f / Mathf.Max(10f, MouthUpdateHz);
			float num6 = Mathf.Exp((0f - num5) / 1.8f);
			if (num4 > _mouthPeak)
			{
				_mouthPeak = num4;
			}
			else
			{
				_mouthPeak *= num6;
			}
			float num7 = ((_mouthPeak > 1E-06f) ? (num4 / _mouthPeak) : 0f);
			float num8 = Mathf.InverseLerp(MouthKnee, 1f, num7);
			float num9 = Mathf.Pow(num8, 0.75f);
			float num10 = Mathf.Clamp01(num9 * MouthGain);
			float deltaTime = Time.deltaTime;
			float num11 = ((num10 > _mouthOpen) ? MouthAttackHz : MouthReleaseHz);
			float num12 = 1f - Mathf.Exp((0f - num11) * deltaTime);
			float num13 = _mouthOpen + (num10 - _mouthOpen) * num12;
			if (MouthMaxDeltaPerSec > 0f)
			{
				num13 = Mathf.MoveTowards(_mouthOpen, num13, MouthMaxDeltaPerSec * deltaTime);
			}
			_mouthOpen = num13;
			float num14 = Mathf.Clamp01(Mathf.Pow(_mouthOpen, 0.7f) * 2.2f);
			TryBindAnimator();
			if ((Object)(object)_anim != (Object)null && _animMouthHash != -1)
			{
				_anim.SetFloat(_animMouthHash, num14);
			}
		}
		else
		{
			float deltaTime2 = Time.deltaTime;
			float num15 = 1f - Mathf.Exp((0f - MouthReleaseHz) * deltaTime2);
			_mouthOpen = Mathf.Lerp(_mouthOpen, 0f, num15);
			float num16 = Mathf.Clamp01(Mathf.Pow(_mouthOpen, 0.7f) * 2.2f);
			TryBindAnimator();
			if ((Object)(object)_anim != (Object)null && _animMouthHash != -1)
			{
				_anim.SetFloat(_animMouthHash, num16);
			}
		}
	}

	private void OnDestroy()
	{
		((MonoBehaviour)this).StopAllCoroutines();
		if (Object.op_Implicit((Object)(object)_src))
		{
			_src.Stop();
		}
		try
		{
			if (Object.op_Implicit((Object)(object)_pv))
			{
				PhotonNetwork.RemoveRPCs(_pv);
			}
		}
		catch
		{
		}
		if (Object.op_Implicit((Object)(object)_pv))
		{
			_pv.ViewID = 0;
		}
		_pendingGo.Clear();
		_clips.Clear();
	}
}
[BepInPlugin("com.TeddyBRB.twitchbingbongtts", "Twitch→BingBong TTS", "1.1.7")]
public class YourPlugin : BaseUnityPlugin
{
	private ConfigEntry<string> _channelsCsv;

	private ConfigEntry<int> _minBits;

	private ConfigEntry<bool> _readEveryChat;

	private ConfigEntry<float> _volume;

	private ConfigEntry<bool> _sayBingBongPrefix;

	private string[] _channels = Array.Empty<string>();

	private TwitchConnector _chat;

	private BingBongTTS _tts;

	private void Awake()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Expected O, but got Unknown
		Harmony val = new Harmony("com.TeddyBRB.twitchbingbongtts");
		val.PatchAll();
		List<MethodBase> list = val.GetPatchedMethods().ToList();
		((BaseUnityPlugin)this).Logger.LogInfo((object)$"[Harmony] Patched {list.Count} method(s) for {val.Id}:");
		foreach (MethodBase item in list)
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)("[Harmony]  • " + item.DeclaringType?.FullName + "." + item.Name));
			Patches patchInfo = Harmony.GetPatchInfo(item);
			if (patchInfo != null)
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)$"[Harmony]     prefixes={patchInfo.Prefixes.Count}, postfixes={patchInfo.Postfixes.Count}, transpilers={patchInfo.Transpilers.Count}");
			}
		}
		_channelsCsv = ((BaseUnityPlugin)this).Config.Bind<string>("Twitch", "Channels", "", "Comma/space-separated list of channels (Example:TeddyBRB, Greppian).");
		_minBits = ((BaseUnityPlugin)this).Config.Bind<int>("Twitch", "MinimumBits", 100, "Cheer threshold (ignored when ReadEveryChat is true).");
		_readEveryChat = ((BaseUnityPlugin)this).Config.Bind<bool>("Twitch", "ReadEveryChat", false, "If true, speak every chat message; otherwise only cheers with ≥ MinimumBits.");
		_volume = ((BaseUnityPlugin)this).Config.Bind<float>("Audio", "Volume", 0.7f, "TTS playback volume (0.0 min – 1.0 max).");
		_sayBingBongPrefix = ((BaseUnityPlugin)this).Config.Bind<bool>("Twitch", "SayBingBongPrefix", true, "If true, prepend \"Bing bong\" before spoken Twitch messages.");
		_channels = (from s in _channelsCsv.Value.Split(new char[3] { ',', ';', ' ' }, StringSplitOptions.RemoveEmptyEntries)
			select s.Trim().TrimStart(new char[1] { '#' }).ToLowerInvariant()).Distinct<string>(StringComparer.OrdinalIgnoreCase).ToArray();
		_tts = ((Component)this).gameObject.AddComponent<BingBongTTS>();
		_tts.BaseVolume = Mathf.Clamp01(_volume.Value);
		_volume.SettingChanged += delegate
		{
			if (Object.op_Implicit((Object)(object)_tts))
			{
				_tts.BaseVolume = Mathf.Clamp01(_volume.Value);
			}
		};
		EvaluateTwitchListener();
		((BaseUnityPlugin)this).Logger.LogInfo((object)("[TTS] Temp path: " + Application.temporaryCachePath));
	}

	private void OnDisable()
	{
		StopTwitchListener();
	}

	private void EvaluateTwitchListener()
	{
		if (_channels.Length == 0)
		{
			StopTwitchListener();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"[Twitch] No channels configured; not listening.");
		}
		else
		{
			MaybeStartTwitchListener();
		}
	}

	private void MaybeStartTwitchListener()
	{
		if (_chat == null)
		{
			_chat = new TwitchConnector(_channels, _minBits.Value, _readEveryChat.Value, _sayBingBongPrefix.Value);
			_chat.OnBitsCheerReceived += delegate(string msg)
			{
				_tts.Enqueue(msg);
			};
			_chat.Connect();
			((BaseUnityPlugin)this).Logger.LogInfo((object)("[Twitch] Listening (" + (_readEveryChat.Value ? "reading all chat" : $"cheers ≥ {_minBits.Value}") + ")."));
		}
	}

	private void StopTwitchListener()
	{
		if (_chat != null)
		{
			try
			{
				_chat.Dispose();
			}
			catch
			{
			}
			_chat = null;
			((BaseUnityPlugin)this).Logger.LogInfo((object)"[Twitch] Stopped listening.");
		}
	}
}
[HarmonyPatch(typeof(PlayerConnectionLog), "OnPlayerLeftRoom")]
internal static class TTS_OnPlayerLeftRoomPatch
{
	[HarmonyPostfix]
	private static void Postfix()
	{
		BingBongTTS.NotifyRoomRosterPossiblyChanged();
	}
}
[HarmonyPatch(typeof(PlayerConnectionLog), "OnPlayerEnteredRoom")]
internal static class TTS_OnPlayerEnteredRoomPatch
{
	[HarmonyPostfix]
	private static void Postfix()
	{
		BingBongTTS.NotifyRoomRosterPossiblyChanged();
	}
}
public class TwitchConnector : IDisposable
{
	private readonly TwitchClient _client = new TwitchClient((IClient)null, (ClientProtocol)1, (ILogger<TwitchClient>)null);

	private readonly string[] _channels;

	private readonly int _minBits;

	private readonly bool _readEveryChat;

	private static readonly ManualLogSource Log = Logger.CreateLogSource("TwitchConnector");

	private readonly bool _addPrefix;

	public event Action<string> OnBitsCheerReceived;

	public TwitchConnector(string[] channels, int minBits, bool readEveryChat, bool addPrefix)
	{
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		//IL_000e: Expected O, but got Unknown
		//IL_00db: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e1: Expected O, but got Unknown
		_readEveryChat = readEveryChat;
		_addPrefix = addPrefix;
		if (channels == null || channels.Length == 0)
		{
			throw new ArgumentException("At least one channel is required.", "channels");
		}
		_channels = (from c in channels
			where !string.IsNullOrWhiteSpace(c)
			select c.Trim().TrimStart(new char[1] { '#' }).ToLowerInvariant()).Distinct<string>(StringComparer.OrdinalIgnoreCase).ToArray();
		_minBits = Math.Max(1, minBits);
		string text = $"justinfan{Random.Range(10000, 99999)}";
		ConnectionCredentials val = new ConnectionCredentials(text, "SCHMUCK", "wss://irc-ws.chat.twitch.tv:443", false, (Capabilities)null);
		_client.Initialize(val, _channels[0], '!', '!', true);
		_client.OnConnected += delegate
		{
			for (int i = 1; i < _channels.Length; i++)
			{
				_client.JoinChannel(_channels[i], false);
			}
		};
		_client.OnLog += delegate(object _, OnLogArgs e)
		{
			Log.LogDebug((object)("[TwitchLib] " + e.Data));
		};
		_client.OnConnectionError += delegate(object _, OnConnectionErrorArgs e)
		{
			Log.LogError((object)$"[Twitch] Conn error: {e.Error}");
		};
		_client.OnJoinedChannel += delegate(object _, OnJoinedChannelArgs e)
		{
			Log.LogInfo((object)("[Twitch] Joined #" + e.Channel));
		};
		_client.OnMessageReceived += HandleMessage;
	}

	public void Connect()
	{
		_client.Connect();
	}

	public void Dispose()
	{
		try
		{
			_client.OnMessageReceived -= HandleMessage;
			if (_client.IsConnected)
			{
				_client.Disconnect();
			}
		}
		catch
		{
		}
	}

	private void Emit(string text)
	{
		string obj = (_addPrefix ? ("Bing bong, " + text) : text);
		this.OnBitsCheerReceived?.Invoke(obj);
	}

	private void HandleMessage(object _, OnMessageReceivedArgs e)
	{
		string text = e.ChatMessage.Message ?? string.Empty;
		if (_readEveryChat)
		{
			string text2 = text.Trim();
			if (!string.IsNullOrWhiteSpace(text2))
			{
				Emit(text2);
			}
		}
		else if (e.ChatMessage.Bits >= _minBits && !Regex.IsMatch(text, "^(?:/cheer\\s*)?\\d+\\s*(?:bits?)?$", RegexOptions.IgnoreCase))
		{
			string text3 = Regex.Replace(text, "(?:(?:/cheer|cheer)\\d+\\b|\\b\\d+\\s*bits?\\b)", "", RegexOptions.IgnoreCase).Trim();
			if (!string.IsNullOrWhiteSpace(text3))
			{
				Emit(text3);
			}
		}
	}
}
namespace TwitchBingBong
{
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "TwitchBingBong";

		public const string PLUGIN_NAME = "TwitchBingBong";

		public const string PLUGIN_VERSION = "1.1.3";
	}
}