using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Threading;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.ML.OnnxRuntime;
using Microsoft.ML.OnnxRuntime.Tensors;
using OpenCvSharp;
using OpenCvSharp.Dnn;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("EmotionalResonance")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("HP")]
[assembly: AssemblyProduct("EmotionalResonance")]
[assembly: AssemblyCopyright("Copyright © HP 2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("96a2423f-4deb-40bd-9b0a-7c0a85c5f472")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace FaceSync
{
	public class NotificationManager : MonoBehaviour
	{
		private class Notification
		{
			public string message;

			public NotificationType type;

			public float lifetime;

			public float createdTime;

			public float alpha = 0f;

			public float slideOffset = 100f;

			public bool IsExpired => Time.time - createdTime > lifetime;

			public float Age => Time.time - createdTime;
		}

		public enum NotificationType
		{
			Info,
			Success,
			Warning,
			Error
		}

		private static NotificationManager instance;

		private List<Notification> activeNotifications = new List<Notification>();

		private const float NOTIFICATION_WIDTH = 320f;

		private const float NOTIFICATION_HEIGHT = 70f;

		private const float NOTIFICATION_MARGIN = 15f;

		private const float NOTIFICATION_PADDING = 12f;

		private const float FADE_IN_DURATION = 0.3f;

		private const float FADE_OUT_DURATION = 0.5f;

		private const float SLIDE_DURATION = 0.4f;

		private const float DEFAULT_LIFETIME = 3f;

		private const int MAX_NOTIFICATIONS = 5;

		private GUIStyle notificationStyle;

		private GUIStyle messageStyle;

		private GUIStyle iconStyle;

		private bool stylesInitialized = false;

		private Texture2D backgroundTexture;

		private static readonly Color InfoColor = new Color(0.2f, 0.6f, 1f, 1f);

		private static readonly Color SuccessColor = new Color(0.3f, 0.8f, 0.3f, 1f);

		private static readonly Color WarningColor = new Color(1f, 0.7f, 0.2f, 1f);

		private static readonly Color ErrorColor = new Color(1f, 0.3f, 0.3f, 1f);

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

		public static void Show(string message, NotificationType type = NotificationType.Info, float lifetime = 3f)
		{
			if ((Object)(object)instance != (Object)null)
			{
				instance.AddNotification(message, type, lifetime);
			}
		}

		private void AddNotification(string message, NotificationType type, float lifetime)
		{
			if (activeNotifications.Count >= 5)
			{
				activeNotifications.RemoveAt(0);
			}
			Notification item = new Notification
			{
				message = message,
				type = type,
				lifetime = lifetime,
				createdTime = Time.time
			};
			activeNotifications.Add(item);
		}

		private void Update()
		{
			activeNotifications.RemoveAll((Notification n) => n.IsExpired);
		}

		private void OnGUI()
		{
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			if (!stylesInitialized)
			{
				InitializeStyles();
			}
			float num = Screen.width;
			float num2 = Screen.height;
			float num3 = num - 320f - 15f;
			float num4 = num2 - 15f;
			for (int num5 = activeNotifications.Count - 1; num5 >= 0; num5--)
			{
				Notification notification = activeNotifications[num5];
				float age = notification.Age;
				float num6 = Mathf.Clamp01(age / 0.3f);
				float num7 = 0f;
				if (age > notification.lifetime - 0.5f)
				{
					num7 = (age - (notification.lifetime - 0.5f)) / 0.5f;
				}
				notification.alpha = Mathf.Lerp(0f, 1f, num6) * (1f - num7);
				float t = Mathf.Clamp01(age / 0.4f);
				float num8 = EaseOutCubic(t);
				notification.slideOffset = Mathf.Lerp(100f, 0f, num8);
				float num9 = num3 + notification.slideOffset;
				float num10 = num4 - 70f;
				DrawNotification(notification, new Rect(num9, num10, 320f, 70f));
				num4 -= 85f;
			}
		}

		private void DrawNotification(Notification notification, Rect rect)
		{
			//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_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: 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_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			Color backgroundColor = GetBackgroundColor(notification.type);
			Color accentColor = GetAccentColor(notification.type);
			Color color = GUI.color;
			GUI.color = new Color(backgroundColor.r, backgroundColor.g, backgroundColor.b, notification.alpha * 0.95f);
			GUI.DrawTexture(rect, (Texture)(object)Texture2D.whiteTexture);
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(((Rect)(ref rect)).x, ((Rect)(ref rect)).y, 5f, ((Rect)(ref rect)).height);
			GUI.color = new Color(accentColor.r, accentColor.g, accentColor.b, notification.alpha);
			GUI.DrawTexture(val, (Texture)(object)Texture2D.whiteTexture);
			Rect val2 = default(Rect);
			((Rect)(ref val2))..ctor(((Rect)(ref rect)).x + 15f, ((Rect)(ref rect)).y + 12f, 32f, 32f);
			GUI.color = new Color(accentColor.r, accentColor.g, accentColor.b, notification.alpha);
			string icon = GetIcon(notification.type);
			iconStyle.normal.textColor = new Color(1f, 1f, 1f, notification.alpha);
			GUI.Label(val2, icon, iconStyle);
			Rect val3 = default(Rect);
			((Rect)(ref val3))..ctor(((Rect)(ref rect)).x + 55f, ((Rect)(ref rect)).y + 12f, ((Rect)(ref rect)).width - 65f, ((Rect)(ref rect)).height - 24f);
			messageStyle.fontSize = 17;
			messageStyle.normal.textColor = new Color(1f, 1f, 1f, notification.alpha);
			GUI.Label(val3, notification.message, messageStyle);
			Rect val4 = default(Rect);
			((Rect)(ref val4))..ctor(((Rect)(ref rect)).x + 2f, ((Rect)(ref rect)).y + 2f, ((Rect)(ref rect)).width, ((Rect)(ref rect)).height);
			GUI.color = new Color(0f, 0f, 0f, notification.alpha * 0.3f);
			GUI.DrawTexture(val4, (Texture)(object)Texture2D.whiteTexture);
			GUI.color = color;
		}

		private void InitializeStyles()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			notificationStyle = new GUIStyle(GUI.skin.box);
			backgroundTexture = MakeTexture(2, 2, new Color(0.1f, 0.1f, 0.1f, 0.95f));
			notificationStyle.normal.background = backgroundTexture;
			notificationStyle.border = new RectOffset(8, 8, 8, 8);
			messageStyle = new GUIStyle(GUI.skin.label);
			messageStyle.fontSize = 14;
			messageStyle.wordWrap = true;
			messageStyle.alignment = (TextAnchor)3;
			messageStyle.normal.textColor = Color.white;
			iconStyle = new GUIStyle(GUI.skin.label);
			iconStyle.fontSize = 28;
			iconStyle.alignment = (TextAnchor)4;
			iconStyle.fontStyle = (FontStyle)1;
			stylesInitialized = true;
		}

		private Color GetBackgroundColor(NotificationType type)
		{
			//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)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			return (Color)(type switch
			{
				NotificationType.Success => new Color(0.15f, 0.25f, 0.15f, 1f), 
				NotificationType.Warning => new Color(0.3f, 0.25f, 0.1f, 1f), 
				NotificationType.Error => new Color(0.3f, 0.15f, 0.15f, 1f), 
				_ => new Color(0.1f, 0.15f, 0.25f, 1f), 
			});
		}

		private Color GetAccentColor(NotificationType type)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			return (Color)(type switch
			{
				NotificationType.Success => SuccessColor, 
				NotificationType.Warning => WarningColor, 
				NotificationType.Error => ErrorColor, 
				_ => InfoColor, 
			});
		}

		private string GetIcon(NotificationType type)
		{
			return type switch
			{
				NotificationType.Success => "✓", 
				NotificationType.Warning => "⚠", 
				NotificationType.Error => "✖", 
				_ => "ℹ", 
			};
		}

		private float EaseOutCubic(float t)
		{
			return 1f - Mathf.Pow(1f - t, 3f);
		}

		private Texture2D MakeTexture(int width, int height, Color col)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			Color[] array = (Color[])(object)new Color[width * height];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = col;
			}
			Texture2D val = new Texture2D(width, height);
			val.SetPixels(array);
			val.Apply();
			return val;
		}

		private void OnDestroy()
		{
			if ((Object)(object)instance == (Object)(object)this)
			{
				instance = null;
			}
			if ((Object)(object)backgroundTexture != (Object)null)
			{
				Object.Destroy((Object)(object)backgroundTexture);
				backgroundTexture = null;
			}
		}
	}
	public class FaceSyncMenu : MonoBehaviour
	{
		private ManualLogSource logger;

		private ThreadSafeEmotionState emotionState;

		private EmotionRecognition recognition;

		private bool showUI = true;

		private Rect windowRect = new Rect(100f, 100f, 1000f, 1050f);

		private bool showCameraPreview = false;

		private Texture2D previewTexture = null;

		private int selectedCameraIndex = 0;

		private int cameraCount = 0;

		private string[] cameraNames;

		private List<int> availableCameras = new List<int>();

		private float previewUpdateTimer = 0f;

		private const float PREVIEW_UPDATE_INTERVAL = 0.1f;

		private GUIStyle windowStyle;

		private GUIStyle labelStyle;

		private GUIStyle emotionLabelStyle;

		private GUIStyle headerStyle;

		private GUIStyle sliderStyle;

		private GUIStyle sliderThumbStyle;

		private bool stylesInitialized = false;

		private bool showGraph = true;

		private Vector2 lastMousePos;

		private bool isResizing = false;

		private Vector2 resizeStart;

		private Rect resizeStartRect;

		private const float RESIZE_HANDLE_SIZE = 20f;

		private const float MIN_WINDOW_WIDTH = 300f;

		private const float MIN_WINDOW_HEIGHT = 250f;

		private Texture2D whiteTexture;

		private readonly string[] emotionLabels = new string[8] { "Neutral", "Happiness", "Surprise", "Sadness", "Anger", "Disgust", "Fear", "Contempt" };

		private readonly Color[] emotionColors = (Color[])(object)new Color[8]
		{
			new Color(0.7f, 0.7f, 0.7f),
			new Color(1f, 0.9f, 0.2f),
			new Color(1f, 0.6f, 0f),
			new Color(0.3f, 0.5f, 1f),
			new Color(1f, 0.2f, 0.2f),
			new Color(0.6f, 0.2f, 0.6f),
			new Color(0.5f, 0.2f, 0.8f),
			new Color(0.8f, 0.6f, 0.3f)
		};

		public void Initialize(ThreadSafeEmotionState state, ManualLogSource logger, EmotionRecognition recognition)
		{
			emotionState = state;
			this.logger = logger;
			this.recognition = recognition;
			Thread thread = new Thread((ThreadStart)delegate
			{
				availableCameras = CameraUtils.GetAvailableCameras();
				cameraNames = new string[availableCameras.Count];
				for (int i = 0; i < availableCameras.Count; i++)
				{
					cameraNames[i] = $"Camera {availableCameras[i]}";
				}
				selectedCameraIndex = availableCameras.IndexOf(FSConfig.CameraIndex);
				if (selectedCameraIndex < 0)
				{
					selectedCameraIndex = 0;
				}
				logger.LogInfo((object)$"✓ Detected {availableCameras.Count} camera(s)");
			});
			thread.IsBackground = true;
			thread.Start();
		}

		private void Update()
		{
			if (Input.GetKeyDown((KeyCode)288))
			{
				showUI = !showUI;
			}
			if (showUI && showCameraPreview && recognition != null)
			{
				previewUpdateTimer += Time.deltaTime;
				if (previewUpdateTimer >= 0.1f)
				{
					previewUpdateTimer = 0f;
					UpdateCameraPreview();
				}
			}
		}

		private void UpdateCameraPreview()
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			int width;
			int height;
			byte[] latestFrame = recognition.GetLatestFrame(out width, out height);
			if (latestFrame == null || latestFrame.Length == 0)
			{
				return;
			}
			try
			{
				if ((Object)(object)previewTexture == (Object)null || ((Texture)previewTexture).width != width || ((Texture)previewTexture).height != height)
				{
					if ((Object)(object)previewTexture != (Object)null)
					{
						Object.Destroy((Object)(object)previewTexture);
					}
					previewTexture = new Texture2D(width, height, (TextureFormat)3, false);
					((Texture)previewTexture).filterMode = (FilterMode)1;
				}
				previewTexture.LoadRawTextureData(latestFrame);
				previewTexture.Apply();
			}
			catch (Exception ex)
			{
				ManualLogSource obj = logger;
				if (obj != null)
				{
					obj.LogError((object)("Preview update failed: " + ex.Message));
				}
			}
		}

		private void OnGUI()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			if (showUI && emotionState != null)
			{
				InitializeStyles();
				windowRect = GUI.Window(12345, windowRect, new WindowFunction(DrawEmotionWindow), "Face Sync", windowStyle);
			}
		}

		private void InitializeStyles()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Expected O, but got Unknown
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Expected O, but got Unknown
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Expected O, but got Unknown
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			if (!stylesInitialized)
			{
				windowStyle = new GUIStyle(GUI.skin.window);
				windowStyle.normal.background = MakeTexture(2, 2, new Color(0f, 0f, 0f, 1f));
				windowStyle.padding = new RectOffset(10, 10, 20, 10);
				whiteTexture = new Texture2D(2, 2);
				whiteTexture.SetPixel(0, 0, Color.white);
				whiteTexture.Apply();
				labelStyle = new GUIStyle(GUI.skin.label);
				labelStyle.fontSize = 19;
				labelStyle.normal.textColor = Color.white;
				labelStyle.wordWrap = false;
				emotionLabelStyle = new GUIStyle(GUI.skin.label);
				emotionLabelStyle.fontSize = 16;
				emotionLabelStyle.fontStyle = (FontStyle)1;
				emotionLabelStyle.normal.textColor = Color.white;
				emotionLabelStyle.alignment = (TextAnchor)4;
				headerStyle = new GUIStyle(GUI.skin.label);
				headerStyle.fontSize = 17;
				headerStyle.fontStyle = (FontStyle)1;
				headerStyle.normal.textColor = new Color(0.8f, 0.9f, 1f);
				sliderStyle = new GUIStyle(GUI.skin.horizontalSlider);
				sliderStyle.fixedHeight = 20f;
				sliderThumbStyle = new GUIStyle(GUI.skin.horizontalSliderThumb);
				sliderThumbStyle.fixedWidth = 20f;
				sliderThumbStyle.fixedHeight = 20f;
				sliderThumbStyle.normal.background = MakeTexture(2, 2, new Color(0.8f, 0.8f, 0.8f));
				sliderThumbStyle.hover.background = MakeTexture(2, 2, new Color(1f, 1f, 1f));
				sliderThumbStyle.active.background = MakeTexture(2, 2, new Color(0.6f, 0.8f, 1f));
				stylesInitialized = true;
			}
		}

		private void DrawEmotionWindow(int windowID)
		{
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: 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_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_041e: Unknown result type (might be due to invalid IL or missing references)
			//IL_048d: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_055e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0874: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d7: 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)
			//IL_0938: Unknown result type (might be due to invalid IL or missing references)
			//IL_0956: Unknown result type (might be due to invalid IL or missing references)
			//IL_095b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0973: Unknown result type (might be due to invalid IL or missing references)
			//IL_0979: Invalid comparison between Unknown and I4
			//IL_0987: Unknown result type (might be due to invalid IL or missing references)
			//IL_098c: Unknown result type (might be due to invalid IL or missing references)
			//IL_098e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0991: Unknown result type (might be due to invalid IL or missing references)
			//IL_0996: Unknown result type (might be due to invalid IL or missing references)
			//IL_099b: Unknown result type (might be due to invalid IL or missing references)
			//IL_09b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_09dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_09f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_09f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a0a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a10: Invalid comparison between Unknown and I4
			//IL_0a36: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a86: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			if (cameraNames != null && cameraNames.Length != 0)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.Label("Camera:", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(60f) });
				int num = GUILayout.SelectionGrid(selectedCameraIndex, cameraNames, Mathf.Min(cameraNames.Length, 4), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(25f) });
				if (num != selectedCameraIndex)
				{
					selectedCameraIndex = num;
					int num2 = availableCameras[selectedCameraIndex];
					recognition?.SwitchCamera(num2);
					Plugin.cameraIndex.Value = num2;
				}
				GUILayout.EndHorizontal();
				GUILayout.Space(5f);
			}
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Preview:", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(60f) });
			bool flag = GUILayout.Toggle(showCameraPreview, showCameraPreview ? "Hide \ud83d\udcf7" : "Show \ud83d\udcf7", GUI.skin.button, Array.Empty<GUILayoutOption>());
			if (flag != showCameraPreview)
			{
				showCameraPreview = flag;
				recognition?.SetPreviewEnabled(showCameraPreview);
			}
			GUILayout.EndHorizontal();
			if (showCameraPreview && (Object)(object)previewTexture != (Object)null)
			{
				GUILayout.Space(5f);
				float num3 = ((Rect)(ref windowRect)).width - 20f;
				float num4 = 180f;
				float num5 = (float)((Texture)previewTexture).width / (float)((Texture)previewTexture).height;
				float num6 = num3;
				float num7 = num6 / num5;
				if (num7 > num4)
				{
					num7 = num4;
					num6 = num7 * num5;
				}
				Rect rect = GUILayoutUtility.GetRect(num6, num7);
				GUI.Box(rect, "");
				Rect val = default(Rect);
				((Rect)(ref val))..ctor(0f, 1f, 1f, -1f);
				GUI.DrawTextureWithTexCoords(rect, (Texture)(object)previewTexture, val);
				GUILayout.Space(5f);
			}
			GUILayout.Space(10f);
			EmotionSnapshot snapshot = emotionState.GetSnapshot();
			if (!string.IsNullOrEmpty(snapshot.error))
			{
				GUI.color = new Color(1f, 0.3f, 0.3f);
				GUILayout.Label("Error: " + snapshot.error, labelStyle, Array.Empty<GUILayoutOption>());
				GUI.color = Color.white;
				GUILayout.EndVertical();
				GUI.DragWindow();
				return;
			}
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Status:", labelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(70f) });
			if (snapshot.active)
			{
				GUI.color = new Color(0.3f, 1f, 0.3f);
				GUILayout.Label("● Active", labelStyle, Array.Empty<GUILayoutOption>());
			}
			else
			{
				GUI.color = new Color(0.7f, 0.7f, 0.7f);
				GUILayout.Label("○ Inactive (Initializing...)", labelStyle, Array.Empty<GUILayoutOption>());
			}
			GUI.color = Color.white;
			GUILayout.EndHorizontal();
			if (snapshot.active)
			{
				float timeSinceUpdate = snapshot.TimeSinceUpdate;
				GUILayout.Label($"Last Update: {timeSinceUpdate:F1}s ago", labelStyle, Array.Empty<GUILayoutOption>());
			}
			GUILayout.Space(10f);
			if (snapshot.active && snapshot.emotion != "No Face")
			{
				GUI.color = GetEmotionColor(snapshot.emotion);
				GUILayout.Label("★ " + snapshot.emotion, emotionLabelStyle, Array.Empty<GUILayoutOption>());
				GUI.color = Color.white;
				if (snapshot.confidence > 0f)
				{
					GUILayout.Label($"Confidence: {snapshot.confidence:P0}", labelStyle, Array.Empty<GUILayoutOption>());
				}
			}
			else if (snapshot.emotion == "No Face")
			{
				GUI.color = new Color(0.7f, 0.7f, 0.7f);
				GUILayout.Label("No Face Detected", emotionLabelStyle, Array.Empty<GUILayoutOption>());
				GUI.color = Color.white;
			}
			GUILayout.Space(10f);
			GUILayout.Label("Emotion Probabilities:", headerStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Space(5f);
			bool flag2 = GUILayout.Toggle(showGraph, showGraph ? "Hide Graph" : "Show Graph", GUI.skin.button, Array.Empty<GUILayoutOption>());
			if (flag2 != showGraph)
			{
				showGraph = flag2;
			}
			if (showGraph)
			{
				for (int i = 0; i < Math.Min(snapshot.probs.Length, emotionLabels.Length); i++)
				{
					DrawEmotionBar(emotionLabels[i], snapshot.probs[i], emotionColors[i]);
				}
			}
			GUILayout.Space(20f);
			GUILayout.Label("Recoginzer Type", headerStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("CASCADE: Lightweight, but lighting and camera should be at the front (like a laptop) ", labelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("DNN: Slightly heavier, but the camera does not need to be positioned at the front", labelStyle, Array.Empty<GUILayoutOption>());
			string[] names = Enum.GetNames(typeof(RecognizerType));
			int num8 = Array.IndexOf(names, FSConfig.RecognizerType.ToString());
			int num9 = GUILayout.SelectionGrid(num8, names, 1, Array.Empty<GUILayoutOption>());
			if (num9 != num8)
			{
				RecognizerType recognizerType2 = (FSConfig.RecognizerType = (RecognizerType)Enum.Parse(typeof(RecognizerType), names[num9]));
				Notification.Info($"Recognizer Type set to: {recognizerType2}");
			}
			GUILayout.Label("Recognition Update Interval", headerStyle, Array.Empty<GUILayoutOption>());
			float num10 = DrawCustomSlider("", (float)FSConfig.UpdateIntervalMs / 1000f, 0.1f, 1f, "s");
			if (Math.Abs(num10 - (float)FSConfig.UpdateIntervalMs / 1000f) > 0.01f)
			{
				FSConfig.UpdateIntervalMs = (int)(num10 * 1000f);
			}
			GUILayout.Space(10f);
			GUILayout.Label("Expression Sync", headerStyle, Array.Empty<GUILayoutOption>());
			bool flag3 = GUILayout.Toggle(FSConfig.EnableExpressionSync, FSConfig.EnableExpressionSync ? "ON" : "OFF", GUI.skin.button, Array.Empty<GUILayoutOption>());
			if (flag3 != FSConfig.EnableExpressionSync)
			{
				FSConfig.EnableExpressionSync = flag3;
				NotificationManager.Show("Expression Sync: " + (FSConfig.EnableExpressionSync ? "ON" : "OFF"), FSConfig.EnableExpressionSync ? NotificationManager.NotificationType.Success : NotificationManager.NotificationType.Warning);
			}
			GUILayout.Space(5f);
			GUILayout.Label("Hide Player Expression Popup", headerStyle, Array.Empty<GUILayoutOption>());
			bool flag4 = GUILayout.Toggle(FSConfig.AlwaysHidePlayerExpressionPopup, FSConfig.AlwaysHidePlayerExpressionPopup ? "ON" : "OFF", GUI.skin.button, Array.Empty<GUILayoutOption>());
			if (flag4 != FSConfig.AlwaysHidePlayerExpressionPopup)
			{
				FSConfig.AlwaysHidePlayerExpressionPopup = flag4;
				NotificationManager.Show("Always Hide Player Expression Popup: " + (FSConfig.AlwaysHidePlayerExpressionPopup ? "ON" : "OFF"), FSConfig.AlwaysHidePlayerExpressionPopup ? NotificationManager.NotificationType.Success : NotificationManager.NotificationType.Warning);
			}
			GUILayout.Space(10f);
			GUILayout.Label($"GPU Acceleration: {FSConfig.GpuAcceleration}", headerStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("This feature can accelerate emotional inference. \nIf any issues arise, please disable it in the Mod Manager Config", labelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Space(10f);
			GUI.color = new Color(0.8f, 0.8f, 0.8f);
			GUILayout.Label("Controls:", headerStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("F7: Toggle Menu", labelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("F8: Toggle Expression Sync", labelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("F9: Toggle Player Expression Popup Invisible", labelStyle, Array.Empty<GUILayoutOption>());
			GUI.color = Color.white;
			GUILayout.EndVertical();
			Rect val2 = default(Rect);
			((Rect)(ref val2))..ctor(((Rect)(ref windowRect)).width - 20f, ((Rect)(ref windowRect)).height - 20f, 20f, 20f);
			Event current = Event.current;
			if ((int)current.type == 0 && current.button == 0 && ((Rect)(ref val2)).Contains(current.mousePosition))
			{
				isResizing = true;
				lastMousePos = current.mousePosition;
				current.Use();
			}
			if (isResizing && (int)current.type == 3)
			{
				Vector2 mousePosition = current.mousePosition;
				Vector2 val3 = mousePosition - lastMousePos;
				((Rect)(ref windowRect)).width = Mathf.Max(300f, ((Rect)(ref windowRect)).width + val3.x);
				((Rect)(ref windowRect)).height = Mathf.Max(250f, ((Rect)(ref windowRect)).height + val3.y);
				lastMousePos = mousePosition;
				current.Use();
			}
			if (isResizing && (int)current.type == 1 && current.button == 0)
			{
				isResizing = false;
				current.Use();
			}
			GUI.Box(val2, "⇲");
			if (!isResizing)
			{
				Rect val4 = default(Rect);
				((Rect)(ref val4))..ctor(0f, 0f, ((Rect)(ref windowRect)).width - 20f, ((Rect)(ref windowRect)).height - 20f);
				GUI.DragWindow(val4);
			}
		}

		private void DrawEmotionBar(string label, float value, Color color)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(label, labelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(90f) });
			Rect rect = GUILayoutUtility.GetRect(180f, 18f);
			Color color2 = GUI.color;
			GUI.color = new Color(0.2f, 0.2f, 0.2f, 1f);
			GUI.DrawTexture(rect, (Texture)(object)whiteTexture);
			if (value > 0f)
			{
				Rect val = default(Rect);
				((Rect)(ref val))..ctor(((Rect)(ref rect)).x, ((Rect)(ref rect)).y, ((Rect)(ref rect)).width * Mathf.Clamp01(value), ((Rect)(ref rect)).height);
				GUI.color = color;
				GUI.DrawTexture(val, (Texture)(object)whiteTexture);
			}
			GUI.color = color2;
			GUILayout.Label($"{value:P0}", labelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(50f) });
			GUILayout.EndHorizontal();
		}

		private float DrawCustomSlider(string label, float value, float min, float max, string unit = "", float labelWidth = 120f)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: 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_013e: 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_0143: 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_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(label, labelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(labelWidth) });
			Rect rect = GUILayoutUtility.GetRect(200f, 30f);
			Color color = GUI.color;
			GUI.color = new Color(0.2f, 0.2f, 0.2f);
			GUI.DrawTexture(rect, (Texture)(object)whiteTexture);
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(((Rect)(ref rect)).x + 10f, ((Rect)(ref rect)).y + 12f, ((Rect)(ref rect)).width - 20f, 6f);
			GUI.color = new Color(0.4f, 0.4f, 0.4f);
			GUI.DrawTexture(val, (Texture)(object)whiteTexture);
			float num = (value - min) / (max - min);
			float num2 = ((Rect)(ref val)).x + ((Rect)(ref val)).width * num;
			Rect val2 = default(Rect);
			((Rect)(ref val2))..ctor(num2 - 10f, ((Rect)(ref rect)).y + 5f, 20f, 20f);
			Color color2 = (((Rect)(ref val2)).Contains(Event.current.mousePosition) ? new Color(1f, 1f, 1f) : new Color(0.8f, 0.8f, 0.8f));
			GUI.color = color2;
			GUI.DrawTexture(val2, (Texture)(object)whiteTexture);
			GUI.color = color;
			if ((int)Event.current.type == 0 && ((Rect)(ref rect)).Contains(Event.current.mousePosition))
			{
				float x = Event.current.mousePosition.x;
				float num3 = Mathf.Clamp01((x - ((Rect)(ref val)).x) / ((Rect)(ref val)).width);
				value = min + (max - min) * num3;
				Event.current.Use();
			}
			GUILayout.Label($"{value:F1}{unit}", labelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(60f) });
			GUILayout.EndHorizontal();
			return value;
		}

		private Color GetEmotionColor(string emotion)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			int num = Array.IndexOf(emotionLabels, emotion);
			if (num >= 0 && num < emotionColors.Length)
			{
				return emotionColors[num];
			}
			return Color.white;
		}

		private Texture2D MakeTexture(int width, int height, Color col)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			Color[] array = (Color[])(object)new Color[width * height];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = col;
			}
			Texture2D val = new Texture2D(width, height);
			val.SetPixels(array);
			val.Apply();
			return val;
		}

		public void SetVisible(bool visible)
		{
			showUI = visible;
		}

		public void ResetWindowPosition()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			windowRect = new Rect(20f, 20f, 400f, 350f);
		}

		private void OnDestroy()
		{
			if ((Object)(object)previewTexture != (Object)null)
			{
				Object.Destroy((Object)(object)previewTexture);
				previewTexture = null;
			}
			if ((Object)(object)whiteTexture != (Object)null)
			{
				Object.Destroy((Object)(object)whiteTexture);
				whiteTexture = null;
			}
		}
	}
	public static class CalcUtils
	{
		public static Rect Grow(Rect r, double ratio, int w, int h)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: 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_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			int num = r.X + r.Width / 2;
			int num2 = r.Y + r.Height / 2;
			int num3 = (int)((double)r.Width * (1.0 + ratio));
			int num4 = (int)((double)r.Height * (1.0 + ratio));
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(num - num3 / 2, num2 - num4 / 2, num3, num4);
			val.X = Math.Max(0, val.X);
			val.Y = Math.Max(0, val.Y);
			val.Width = Math.Min(val.Width, w - val.X);
			val.Height = Math.Min(val.Height, h - val.Y);
			return val;
		}

		public static bool IsProb(float[] v)
		{
			if (v.Length == 0)
			{
				return false;
			}
			float num = 0f;
			foreach (float num2 in v)
			{
				if ((double)num2 < -1E-06 || (double)num2 > 1.000001)
				{
					return false;
				}
				num += num2;
			}
			return Math.Abs(num - 1f) < 0.02f;
		}

		public static float[] ReweightFerPlus(float[] p)
		{
			float[] array = new float[8] { 0.7f, 1.2f, 1.2f, 1.15f, 1.15f, 1.1f, 1.1f, 1f };
			float[] array2 = new float[p.Length];
			float num = 0f;
			for (int i = 0; i < p.Length; i++)
			{
				array2[i] = p[i] * ((i < array.Length) ? array[i] : 1f);
				num += array2[i];
			}
			if (num <= 0f)
			{
				return p;
			}
			for (int j = 0; j < array2.Length; j++)
			{
				array2[j] /= num;
			}
			return array2;
		}

		public static float[] Softmax(float[] x)
		{
			float max = x.Max();
			float[] array = x.Select((float v) => (float)Math.Exp(v - max)).ToArray();
			float num = array.Sum();
			for (int i = 0; i < array.Length; i++)
			{
				array[i] /= num;
			}
			return array;
		}

		public static float[] Average(IEnumerable<float[]> arrs)
		{
			List<float[]> list = arrs.ToList();
			float[] array = new float[list[0].Length];
			foreach (float[] item in list)
			{
				for (int i = 0; i < array.Length; i++)
				{
					array[i] += item[i];
				}
			}
			for (int j = 0; j < array.Length; j++)
			{
				array[j] /= list.Count;
			}
			return array;
		}

		public static int ArgMax(float[] a)
		{
			int num = 0;
			for (int i = 1; i < a.Length; i++)
			{
				if (a[i] > a[num])
				{
					num = i;
				}
			}
			return num;
		}
	}
	public class EmotionRecognition
	{
		private readonly ManualLogSource _logger;

		private RecognizerType _recognizerType;

		private Dictionary<RecognizerType, EmotionRecognizer> _recognizers = new Dictionary<RecognizerType, EmotionRecognizer>();

		private VideoCapture _videoCapture = null;

		private EmotionRecognizer _recognizer;

		private int _currentCameraIndex = 0;

		protected volatile bool _isRunning = false;

		protected readonly object _captureLock = new object();

		protected readonly object _frameLock = new object();

		protected readonly object _recognizerLock = new object();

		private bool _previewEnabled = false;

		protected byte[] _latestFrameData = null;

		protected int _frameWidth = 0;

		protected int _frameHeight = 0;

		private Thread _workerThread = null;

		protected readonly ThreadSafeEmotionState _emotionState = new ThreadSafeEmotionState();

		public ThreadSafeEmotionState EmotionState => _emotionState;

		public EmotionRecognition(ManualLogSource logger, int cameraIndex)
		{
			_logger = logger;
			_currentCameraIndex = cameraIndex;
		}

		private void InitializeCapture(int cameraIndex)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			_videoCapture = new VideoCapture(cameraIndex, (VideoCaptureAPIs)0);
			if (!_videoCapture.IsOpened())
			{
				throw new Exception("Cannot open camera with index " + cameraIndex);
			}
			_videoCapture.Set((VideoCaptureProperties)3, 640.0);
			_videoCapture.Set((VideoCaptureProperties)4, 480.0);
		}

		public bool Start()
		{
			RecognizerType recognizerType = FSConfig.RecognizerType;
			if (!_recognizers.TryGetValue(recognizerType, out var value))
			{
				return false;
			}
			_recognizer = value;
			_recognizerType = recognizerType;
			_isRunning = true;
			_workerThread = new Thread(RecognizeLoop)
			{
				IsBackground = true,
				Priority = ThreadPriority.BelowNormal,
				Name = "EmotionRecognitionThread"
			};
			_workerThread.Start();
			return true;
		}

		public bool Stop()
		{
			if (!_isRunning)
			{
				return true;
			}
			_isRunning = false;
			if (_workerThread == null)
			{
				return true;
			}
			try
			{
				bool flag = _workerThread.Join(3000);
				if (!flag)
				{
					_logger.LogWarning((object)"[-] Emotion recognition thread did not terminate in time.");
				}
				return flag;
			}
			catch (Exception ex)
			{
				_logger.LogError((object)("[-] Error while stopping emotion recognition thread: " + ex.Message));
				return false;
			}
		}

		private void RecognizeLoop()
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Expected O, but got Unknown
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Expected O, but got Unknown
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				InitializeCapture(_currentCameraIndex);
			}
			catch (Exception ex)
			{
				_logger.LogError((object)("Failed to initialize camera: " + ex.Message));
				throw new Exception("Camera initialization failed", ex);
			}
			Mat val = new Mat();
			try
			{
				while (_isRunning)
				{
					bool flag = false;
					lock (_captureLock)
					{
						if (_videoCapture != null && _videoCapture.IsOpened())
						{
							flag = _videoCapture.Read(val) && !val.Empty();
						}
					}
					if (!flag)
					{
						Thread.Sleep(10);
						_emotionState.Update("Waiting for camera ...", 0f, null);
						continue;
					}
					if (_previewEnabled)
					{
						lock (_frameLock)
						{
							Mat val2 = new Mat();
							try
							{
								Cv2.CvtColor(InputArray.op_Implicit(val), OutputArray.op_Implicit(val2), (ColorConversionCodes)4, 0);
								int num = 320;
								int num2 = (int)((float)val.Height * ((float)num / (float)val.Width));
								Mat val3 = new Mat();
								try
								{
									Cv2.Resize(InputArray.op_Implicit(val2), OutputArray.op_Implicit(val3), new Size(num, num2), 0.0, 0.0, (InterpolationFlags)1);
									_frameWidth = num;
									_frameHeight = num2;
									int num3 = val3.Width * val3.Height * 3;
									if (_latestFrameData == null || _latestFrameData.Length != num3)
									{
										_latestFrameData = new byte[num3];
									}
									Marshal.Copy(val3.Data, _latestFrameData, 0, num3);
								}
								finally
								{
									((IDisposable)val3)?.Dispose();
								}
							}
							finally
							{
								((IDisposable)val2)?.Dispose();
							}
						}
					}
					if (!IsInGame())
					{
						_emotionState.Update("Waiting for starting game ...", 0f, null);
						Thread.Sleep(100);
						continue;
					}
					if (_recognizerType != FSConfig.RecognizerType)
					{
						lock (_recognizerLock)
						{
							_recognizerType = FSConfig.RecognizerType;
							_recognizer = _recognizers[_recognizerType];
						}
					}
					if (_recognizer.InferEmotion(val, out var emotion, out var confidence, out var probabilities))
					{
						_emotionState.Update(emotion, confidence, probabilities);
					}
					else
					{
						_emotionState.Update("No Face", 0f, new float[8]);
					}
					Thread.Sleep(FSConfig.UpdateIntervalMs);
				}
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
		}

		public byte[] GetLatestFrame(out int width, out int height)
		{
			lock (_frameLock)
			{
				width = _frameWidth;
				height = _frameHeight;
				if (_latestFrameData == null)
				{
					return null;
				}
				byte[] array = new byte[_latestFrameData.Length];
				Array.Copy(_latestFrameData, array, _latestFrameData.Length);
				return array;
			}
		}

		public void RegisterRecognizer(RecognizerType recognizerType, EmotionRecognizer recognizer)
		{
			_recognizers[recognizerType] = recognizer;
		}

		public void SwitchCamera(int newCameraIndex)
		{
			try
			{
				lock (_captureLock)
				{
					if (_videoCapture != null)
					{
						_videoCapture.Release();
						((DisposableObject)_videoCapture).Dispose();
						_videoCapture = null;
					}
					Thread.Sleep(100);
					_videoCapture = VideoCapture.FromCamera(newCameraIndex, (VideoCaptureAPIs)0);
					if (_videoCapture == null || !_videoCapture.IsOpened())
					{
						_logger.LogError((object)$"Failed to open camera {newCameraIndex}");
						_videoCapture = VideoCapture.FromCamera(_currentCameraIndex, (VideoCaptureAPIs)0);
					}
					else
					{
						_currentCameraIndex = newCameraIndex;
						NotificationManager.Show($"Camera switched to: {newCameraIndex}", NotificationManager.NotificationType.Success);
					}
				}
			}
			catch (Exception ex)
			{
				NotificationManager.Show("Camera switch failed", NotificationManager.NotificationType.Error);
				_logger.LogError((object)("Camera switch error: " + ex.Message));
			}
		}

		public void SetPreviewEnabled(bool enabled)
		{
			_previewEnabled = enabled;
		}

		public void Dispose()
		{
			if (Stop())
			{
				lock (_captureLock)
				{
					if (_videoCapture != null)
					{
						_videoCapture.Release();
						((DisposableObject)_videoCapture).Dispose();
						_videoCapture = null;
					}
				}
			}
			foreach (EmotionRecognizer value in _recognizers.Values)
			{
				value.Dispose();
			}
			_recognizers.Clear();
		}

		private static bool IsInGame()
		{
			return !SemiFunc.IsCurrentLevel(RunManager.instance.levelCurrent, RunManager.instance.levelLobbyMenu) && !SemiFunc.IsCurrentLevel(RunManager.instance.levelCurrent, RunManager.instance.levelMainMenu) && !SemiFunc.IsCurrentLevel(RunManager.instance.levelCurrent, RunManager.instance.levelSplashScreen) && !SemiFunc.IsCurrentLevel(RunManager.instance.levelCurrent, RunManager.instance.levelTutorial);
		}
	}
	public enum RecognizerType
	{
		CASCADE,
		DNN
	}
	public class CameraUtils
	{
		public static List<int> GetAvailableCameras()
		{
			List<int> list = new List<int>();
			for (int i = 0; i < 10; i++)
			{
				try
				{
					VideoCapture val = VideoCapture.FromCamera(i, (VideoCaptureAPIs)0);
					try
					{
						if (val != null && val.IsOpened())
						{
							list.Add(i);
							val.Release();
						}
						else if (list.Count > 0)
						{
							break;
						}
					}
					finally
					{
						((IDisposable)val)?.Dispose();
					}
				}
				catch
				{
					if (list.Count > 0)
					{
						break;
					}
				}
			}
			if (list.Count == 0)
			{
				list.Add(0);
			}
			return list;
		}
	}
	public class FSConfig
	{
		public static int CameraIndex
		{
			get
			{
				return Plugin.cameraIndex.Value;
			}
			set
			{
				Plugin.cameraIndex.Value = value;
			}
		}

		public static int UpdateIntervalMs
		{
			get
			{
				return Plugin.updateIntervalMs.Value;
			}
			set
			{
				Plugin.updateIntervalMs.Value = value;
			}
		}

		public static bool GpuAcceleration
		{
			get
			{
				return Plugin.gpuAcceleration.Value;
			}
			set
			{
				Plugin.gpuAcceleration.Value = value;
			}
		}

		public static bool EnableExpressionSync
		{
			get
			{
				return Plugin.enableExpressionSync.Value;
			}
			set
			{
				Plugin.enableExpressionSync.Value = value;
			}
		}

		public static bool AlwaysHidePlayerExpressionPopup
		{
			get
			{
				return Plugin.alwaysHidePlayerExpressionPopup.Value;
			}
			set
			{
				Plugin.alwaysHidePlayerExpressionPopup.Value = value;
			}
		}

		public static RecognizerType RecognizerType
		{
			get
			{
				return Plugin.recognizerType.Value;
			}
			set
			{
				Plugin.recognizerType.Value = value;
			}
		}
	}
	public class DnnEmotionRecognizer : EmotionRecognizer
	{
		private const float CONFIDENCE_THRESHOLD = 0.6f;

		private Net faceNet;

		public DnnEmotionRecognizer(ManualLogSource logger, string modelPath, string faceProtoPath, string faceCaffeModelPath)
			: base(logger, modelPath)
		{
			faceNet = CvDnn.ReadNetFromCaffe(faceProtoPath, faceCaffeModelPath);
		}

		public override bool InferEmotion(Mat frame, out string emotion, out float confidence, out float[] probabilities)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected O, but got Unknown
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			Rect val = DetectFaceWithDNN(frame);
			if (val.Width > 0 && val.Height > 0)
			{
				flag = true;
			}
			else if (lastDetectedFace.HasValue)
			{
				val = lastDetectedFace.Value;
				flag = true;
			}
			if (!flag)
			{
				emotion = "No Face";
				confidence = 0f;
				probabilities = new float[8];
				return false;
			}
			Rect val2 = CalcUtils.Grow(val, 0.2, frame.Width, frame.Height);
			float[] array = new float[4096];
			Mat val3 = new Mat();
			try
			{
				Mat val4 = new Mat();
				try
				{
					Cv2.CvtColor(InputArray.op_Implicit(frame), OutputArray.op_Implicit(val3), (ColorConversionCodes)6, 0);
					Mat val5 = val3.SubMat(val2);
					try
					{
						Mat val6 = val5.Clone();
						try
						{
							Cv2.Resize(InputArray.op_Implicit(val6), OutputArray.op_Implicit(val4), new Size(64, 64), 0.0, 0.0, (InterpolationFlags)1);
						}
						finally
						{
							((IDisposable)val6)?.Dispose();
						}
					}
					finally
					{
						((IDisposable)val5)?.Dispose();
					}
					for (int i = 0; i < 64; i++)
					{
						for (int j = 0; j < 64; j++)
						{
							byte b = val4.At<byte>(i, j);
							array[i * 64 + j] = (int)b;
						}
					}
				}
				finally
				{
					((IDisposable)val4)?.Dispose();
				}
			}
			finally
			{
				((IDisposable)val3)?.Dispose();
			}
			Memory<float> memory = array;
			object obj = global::<PrivateImplementationDetails>.D4F9C16444BBD6A5FB4F10E9D647D15787CF536E9A2324E584122A50678AA55D_A6;
			if (obj == null)
			{
				obj = new int[4] { 1, 1, 64, 64 };
				global::<PrivateImplementationDetails>.D4F9C16444BBD6A5FB4F10E9D647D15787CF536E9A2324E584122A50678AA55D_A6 = (int[])obj;
			}
			DenseTensor<float> val7 = new DenseTensor<float>(memory, new ReadOnlySpan<int>((int[]?)obj), false);
			List<NamedOnnxValue> list = new List<NamedOnnxValue> { NamedOnnxValue.CreateFromTensor<float>("Input3", (Tensor<float>)(object)val7) };
			IDisposableReadOnlyCollection<DisposableNamedOnnxValue> val8 = session.Run((IReadOnlyCollection<NamedOnnxValue>)list);
			float[] item;
			try
			{
				Tensor<float> source = ((NamedOnnxValue)((IEnumerable<DisposableNamedOnnxValue>)val8).First((DisposableNamedOnnxValue r) => ((NamedOnnxValue)r).Name == "Plus692_Output_0")).AsTensor<float>();
				float[] array2 = ((IEnumerable<float>)source).ToArray();
				item = (CalcUtils.IsProb(array2) ? CalcUtils.ReweightFerPlus(array2) : CalcUtils.ReweightFerPlus(CalcUtils.Softmax(array2)));
			}
			finally
			{
				((IDisposable)val8)?.Dispose();
			}
			scoreHist.Enqueue(item);
			if (scoreHist.Count > smoothN)
			{
				scoreHist.Dequeue();
			}
			float[] array3 = CalcUtils.Average(scoreHist);
			int num = CalcUtils.ArgMax(array3);
			float num2 = array3[num];
			emotion = EmotionRecognizer.Labels[num];
			confidence = num2;
			probabilities = array3;
			return true;
		}

		private Rect DetectFaceWithDNN(Mat frame)
		{
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				int rows = frame.Rows;
				int cols = frame.Cols;
				Mat val = CvDnn.BlobFromImage(frame, 1.0, new Size(300, 300), new Scalar(104.0, 117.0, 123.0), false, false);
				try
				{
					faceNet.SetInput(val, "data");
					Mat val2 = faceNet.Forward("detection_out");
					try
					{
						int num = val2.Size(2);
						Mat val3 = val2.Reshape(1, num);
						try
						{
							float num2 = 0f;
							Rect result = default(Rect);
							for (int i = 0; i < val3.Rows; i++)
							{
								float num3 = val3.At<float>(i, 2);
								if (num3 > 0.6f && num3 > num2)
								{
									int val4 = (int)(val3.At<float>(i, 3) * (float)cols);
									int val5 = (int)(val3.At<float>(i, 4) * (float)rows);
									int val6 = (int)(val3.At<float>(i, 5) * (float)cols);
									int val7 = (int)(val3.At<float>(i, 6) * (float)rows);
									val4 = Math.Max(0, Math.Min(val4, cols - 1));
									val5 = Math.Max(0, Math.Min(val5, rows - 1));
									val6 = Math.Max(0, Math.Min(val6, cols - 1));
									val7 = Math.Max(0, Math.Min(val7, rows - 1));
									int num4 = val6 - val4;
									int num5 = val7 - val5;
									if (num4 >= 30 && num5 >= 30)
									{
										num2 = num3;
										((Rect)(ref result))..ctor(val4, val5, num4, num5);
									}
								}
							}
							return result;
						}
						finally
						{
							((IDisposable)val3)?.Dispose();
						}
					}
					finally
					{
						((IDisposable)val2)?.Dispose();
					}
				}
				finally
				{
					((IDisposable)val)?.Dispose();
				}
			}
			catch (Exception ex)
			{
				logger.LogError((object)("DNN detection error: " + ex.Message));
				return default(Rect);
			}
		}

		protected override string PickOutputName(InferenceSession session)
		{
			foreach (KeyValuePair<string, NodeMetadata> outputMetadatum in session.OutputMetadata)
			{
				int[] dimensions = outputMetadatum.Value.Dimensions;
				int num = 1;
				int[] array = dimensions;
				foreach (int num2 in array)
				{
					if (num2 > 0)
					{
						num *= num2;
					}
				}
				if (dimensions.Length <= 2 && num >= 7 && num <= 10)
				{
					return outputMetadatum.Key;
				}
			}
			string[] array2 = new string[5] { "Prob", "prob", "Plus692_Output_0", "output", "softmaxout" };
			foreach (string text in array2)
			{
				if (session.OutputMetadata.ContainsKey(text))
				{
					return text;
				}
			}
			return session.OutputMetadata.Keys.First();
		}

		public override void Dispose()
		{
			if (isDisposed)
			{
				return;
			}
			try
			{
				isRunning = false;
				Net obj = faceNet;
				if (obj != null)
				{
					((DisposableObject)obj).Dispose();
				}
				faceNet = null;
				InferenceSession obj2 = session;
				if (obj2 != null)
				{
					obj2.Dispose();
				}
				session = null;
				isDisposed = true;
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Error during disposal: " + ex.Message));
			}
		}
	}
	public abstract class EmotionRecognizer
	{
		protected static readonly string[] Labels = new string[8] { "Neutral", "Happiness", "Surprise", "Sadness", "Anger", "Disgust", "Fear", "Contempt" };

		protected readonly ManualLogSource logger;

		protected readonly ThreadSafeEmotionState emotionState;

		protected volatile bool isRunning = false;

		protected InferenceSession session;

		protected string inputName;

		protected string outputName;

		protected int frameCount = 0;

		protected bool isDisposed = false;

		protected int smoothN = 1;

		protected Rect? lastDetectedFace = null;

		protected int framesWithoutDetection = 0;

		protected const int MAX_FRAMES_WITHOUT_DETECTION = 30;

		protected int detectFrameCounter = 0;

		protected int detectEveryNFrames = 9;

		protected Queue<float[]> scoreHist = new Queue<float[]>();

		public ThreadSafeEmotionState EmotionState => emotionState;

		protected EmotionRecognizer(ManualLogSource logger, string modelPath)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			this.logger = logger;
			try
			{
				SessionOptions val = new SessionOptions
				{
					GraphOptimizationLevel = (GraphOptimizationLevel)99
				};
				if (FSConfig.GpuAcceleration)
				{
					val.AppendExecutionProvider_DML(0);
				}
				val.AppendExecutionProvider_CPU(1);
				session = new InferenceSession(modelPath, val);
				inputName = session.InputMetadata.Keys.First();
				outputName = PickOutputName(session);
			}
			catch (Exception ex)
			{
				logger.LogError((object)("[-] Failed to initialize emotion recognizer: " + ex.Message));
				throw;
			}
		}

		public abstract void Dispose();

		protected abstract string PickOutputName(InferenceSession session);

		public abstract bool InferEmotion(Mat frame, out string emotion, out float confidence, out float[] probabilities);
	}
	public class CascadeEmotionRecognizer : EmotionRecognizer
	{
		private CascadeClassifier faceCascade;

		public CascadeEmotionRecognizer(ManualLogSource logger, string modelPath, string cascadePath)
			: base(logger, modelPath)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			faceCascade = new CascadeClassifier(cascadePath);
			detectEveryNFrames = 1;
			smoothN = 3;
		}

		public override bool InferEmotion(Mat frame, out string emotion, out float confidence, out float[] probabilities)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_0076: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Expected O, but got Unknown
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Expected O, but got Unknown
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			Mat val = new Mat();
			try
			{
				Mat val2 = new Mat();
				try
				{
					Cv2.CvtColor(InputArray.op_Implicit(frame), OutputArray.op_Implicit(val), (ColorConversionCodes)6, 0);
					Rect? val3 = null;
					detectFrameCounter++;
					if (detectFrameCounter >= detectEveryNFrames || !lastDetectedFace.HasValue)
					{
						detectFrameCounter = 0;
						Cv2.Resize(InputArray.op_Implicit(val), OutputArray.op_Implicit(val2), new Size(0, 0), 0.5, 0.5, (InterpolationFlags)1);
						Rect[] array = faceCascade.DetectMultiScale(val2, 1.2, 3, (HaarDetectionTypes)0, (Size?)new Size(20, 20), (Size?)new Size(0, 0));
						if (array.Length != 0)
						{
							Rect val4 = array.OrderByDescending((Rect f) => f.Width * f.Height).First();
							val3 = (lastDetectedFace = new Rect(val4.X * 2, val4.Y * 2, val4.Width * 2, val4.Height * 2));
							framesWithoutDetection = 0;
						}
						else
						{
							framesWithoutDetection++;
						}
					}
					else
					{
						val3 = lastDetectedFace;
					}
					if (!val3.HasValue || framesWithoutDetection > 30)
					{
						emotion = "No Face";
						confidence = 0f;
						probabilities = new float[8];
						lastDetectedFace = null;
						return false;
					}
					Rect val5 = CalcUtils.Grow(val3.Value, 0.1, frame.Width, frame.Height);
					Mat val6 = new Mat(frame, val5);
					try
					{
						Mat val7 = new Mat();
						try
						{
							Cv2.CvtColor(InputArray.op_Implicit(val6), OutputArray.op_Implicit(val7), (ColorConversionCodes)6, 0);
							CLAHE val8 = Cv2.CreateCLAHE(2.0, (Size?)new Size(8, 8));
							try
							{
								val8.Apply(InputArray.op_Implicit(val7), OutputArray.op_Implicit(val7));
							}
							finally
							{
								((IDisposable)val8)?.Dispose();
							}
							Cv2.Resize(InputArray.op_Implicit(val7), OutputArray.op_Implicit(val7), new Size(64, 64), 0.0, 0.0, (InterpolationFlags)1);
							val7.ConvertTo(OutputArray.op_Implicit(val7), MatType.CV_32FC1, 1.0, 0.0);
							object obj = global::<PrivateImplementationDetails>.D4F9C16444BBD6A5FB4F10E9D647D15787CF536E9A2324E584122A50678AA55D_A6;
							if (obj == null)
							{
								obj = new int[4] { 1, 1, 64, 64 };
								global::<PrivateImplementationDetails>.D4F9C16444BBD6A5FB4F10E9D647D15787CF536E9A2324E584122A50678AA55D_A6 = (int[])obj;
							}
							DenseTensor<float> val9 = new DenseTensor<float>(new ReadOnlySpan<int>((int[]?)obj), false);
							Indexer<float> genericIndexer = val7.GetGenericIndexer<float>();
							int num = 0;
							for (int i = 0; i < 64; i++)
							{
								for (int j = 0; j < 64; j++)
								{
									val9.Buffer.Span[num++] = ((MatIndexer<float>)(object)genericIndexer)[i, j];
								}
							}
							List<NamedOnnxValue> list = new List<NamedOnnxValue> { NamedOnnxValue.CreateFromTensor<float>(inputName, (Tensor<float>)(object)val9) };
							IDisposableReadOnlyCollection<DisposableNamedOnnxValue> val10 = session.Run((IReadOnlyCollection<NamedOnnxValue>)list);
							try
							{
								float[] array2 = ((NamedOnnxValue)((IEnumerable<DisposableNamedOnnxValue>)val10).First((DisposableNamedOnnxValue r) => ((NamedOnnxValue)r).Name == outputName)).AsEnumerable<float>().ToArray();
								float[] p = (CalcUtils.IsProb(array2) ? array2 : CalcUtils.Softmax(array2));
								p = CalcUtils.ReweightFerPlus(p);
								scoreHist.Enqueue(p);
								if (scoreHist.Count > smoothN)
								{
									scoreHist.Dequeue();
								}
								float[] array3 = CalcUtils.Average(scoreHist);
								int num2 = CalcUtils.ArgMax(array3);
								string text = EmotionRecognizer.Labels[Math.Min(num2, EmotionRecognizer.Labels.Length - 1)];
								float num3 = array3[num2];
								emotion = text;
								confidence = num3;
								probabilities = array3;
								return true;
							}
							finally
							{
								((IDisposable)val10)?.Dispose();
							}
						}
						finally
						{
							((IDisposable)val7)?.Dispose();
						}
					}
					finally
					{
						((IDisposable)val6)?.Dispose();
					}
				}
				finally
				{
					((IDisposable)val2)?.Dispose();
				}
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
		}

		protected override string PickOutputName(InferenceSession session)
		{
			foreach (KeyValuePair<string, NodeMetadata> outputMetadatum in session.OutputMetadata)
			{
				int[] dimensions = outputMetadatum.Value.Dimensions;
				int num = 1;
				int[] array = dimensions;
				foreach (int num2 in array)
				{
					if (num2 > 0)
					{
						num *= num2;
					}
				}
				if (dimensions.Length <= 2 && num >= 7 && num <= 10)
				{
					return outputMetadatum.Key;
				}
			}
			string[] array2 = new string[5] { "Prob", "prob", "Plus692_Output_0", "output", "softmaxout" };
			foreach (string text in array2)
			{
				if (session.OutputMetadata.ContainsKey(text))
				{
					return text;
				}
			}
			return session.OutputMetadata.Keys.First();
		}

		public override void Dispose()
		{
			if (isDisposed)
			{
				return;
			}
			try
			{
				CascadeClassifier obj = faceCascade;
				if (obj != null)
				{
					((DisposableObject)obj).Dispose();
				}
				faceCascade = null;
				InferenceSession obj2 = session;
				if (obj2 != null)
				{
					obj2.Dispose();
				}
				session = null;
				isDisposed = true;
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Error during disposal: " + ex.Message));
			}
		}
	}
	public static class Notification
	{
		public static void Info(string message)
		{
			NotificationManager.Show(message);
		}

		public static void Error(string message)
		{
			NotificationManager.Show(message, NotificationManager.NotificationType.Error);
		}

		public static void Warning(string message)
		{
			NotificationManager.Show(message, NotificationManager.NotificationType.Warning);
		}

		public static void Success(string message)
		{
			NotificationManager.Show(message, NotificationManager.NotificationType.Success);
		}
	}
	public class ExpressionIntegration : MonoBehaviour
	{
		private class EmotionMapping
		{
			public string Emotion;

			public int ExpressionIndex;

			public string ExpressionName;
		}

		private ManualLogSource logger;

		private ThreadSafeEmotionState emotionState;

		private float updateInterval = 0.3f;

		private float confidenceThreshold = 0.35f;

		private bool enableIntegration = true;

		private float updateTimer = 0f;

		private string lastAppliedEmotion = "";

		private float lastEmotionChangeTime = 0f;

		private const float MIN_EMOTION_CHANGE_INTERVAL = 0.7f;

		private string pendingEmotion = "";

		private float pendingEmotionConfidence = 0f;

		private int pendingEmotionCount = 0;

		private const int REQUIRED_STABLE_COUNT = 2;

		private Func<object> getPlayerAvatarInstance;

		private Func<object, object> getPlayerExpression;

		private Func<object, object> getInputToggleList;

		private Func<object, int> getItemIndex;

		private Action<object, bool> setItemActive;

		private bool listItemAccessorsInitialized = false;

		private Type playerAvatarType;

		private Type playerExpressionsUIType;

		private FieldInfo playerExpressionsUIInstanceField;

		private MethodInfo shrinkResetMethod;

		private bool reflectionCacheInitialized = false;

		private static readonly EmotionMapping[] EmotionMappings = new EmotionMapping[8]
		{
			new EmotionMapping
			{
				Emotion = "Neutral",
				ExpressionIndex = 0,
				ExpressionName = "SUSPICIOUS"
			},
			new EmotionMapping
			{
				Emotion = "Happiness",
				ExpressionIndex = 6,
				ExpressionName = "HAPPY"
			},
			new EmotionMapping
			{
				Emotion = "Surprise",
				ExpressionIndex = 5,
				ExpressionName = "EYES CLOSED"
			},
			new EmotionMapping
			{
				Emotion = "Sadness",
				ExpressionIndex = 2,
				ExpressionName = "SAD"
			},
			new EmotionMapping
			{
				Emotion = "Anger",
				ExpressionIndex = 1,
				ExpressionName = "ANGRY"
			},
			new EmotionMapping
			{
				Emotion = "Disgust",
				ExpressionIndex = 3,
				ExpressionName = "CRAZY"
			},
			new EmotionMapping
			{
				Emotion = "Fear",
				ExpressionIndex = 2,
				ExpressionName = "SAD"
			},
			new EmotionMapping
			{
				Emotion = "Contempt",
				ExpressionIndex = 3,
				ExpressionName = "ANGRY"
			}
		};

		public void Initialize(float updateInterval, float confidenceThreshold, float expressionDuration, bool enable)
		{
			this.updateInterval = 0.3f;
			this.confidenceThreshold = Mathf.Max(0.35f, confidenceThreshold - 0.05f);
			enableIntegration = enable;
			InitializeReflectionCache();
		}

		private void InitializeReflectionCache()
		{
			try
			{
				playerAvatarType = Type.GetType("PlayerAvatar, Assembly-CSharp");
				if (playerAvatarType != null)
				{
					FieldInfo field = playerAvatarType.GetField("instance", BindingFlags.Static | BindingFlags.Public);
					if (field != null)
					{
						getPlayerAvatarInstance = CreateStaticGetter(field);
					}
					FieldInfo field2 = playerAvatarType.GetField("playerExpression", BindingFlags.Instance | BindingFlags.Public);
					if (field2 != null)
					{
						getPlayerExpression = CreateFieldGetter(field2);
						Type fieldType = field2.FieldType;
						FieldInfo field3 = fieldType.GetField("inputToggleList", BindingFlags.Instance | BindingFlags.NonPublic);
						if (field3 != null)
						{
							getInputToggleList = CreateFieldGetter(field3);
						}
					}
				}
				playerExpressionsUIType = Type.GetType("PlayerExpressionsUI, Assembly-CSharp");
				if (playerExpressionsUIType != null)
				{
					playerExpressionsUIInstanceField = playerExpressionsUIType.GetField("instance", BindingFlags.Static | BindingFlags.Public);
					shrinkResetMethod = playerExpressionsUIType.GetMethod("ShrinkReset", BindingFlags.Instance | BindingFlags.Public);
				}
				reflectionCacheInitialized = getPlayerAvatarInstance != null && getPlayerExpression != null && getInputToggleList != null && playerExpressionsUIType != null && playerExpressionsUIInstanceField != null && shrinkResetMethod != null;
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Failed to initialize reflection cache: " + ex.Message));
				reflectionCacheInitialized = false;
			}
		}

		private Func<object> CreateStaticGetter(FieldInfo field)
		{
			MemberExpression expression = Expression.Field(null, field);
			UnaryExpression body = Expression.Convert(expression, typeof(object));
			return Expression.Lambda<Func<object>>(body, Array.Empty<ParameterExpression>()).Compile();
		}

		private Func<object, object> CreateFieldGetter(FieldInfo field)
		{
			ParameterExpression parameterExpression = Expression.Parameter(typeof(object), "target");
			UnaryExpression expression = Expression.Convert(parameterExpression, field.DeclaringType);
			MemberExpression expression2 = Expression.Field(expression, field);
			UnaryExpression body = Expression.Convert(expression2, typeof(object));
			return Expression.Lambda<Func<object, object>>(body, new ParameterExpression[1] { parameterExpression }).Compile();
		}

		private Func<object, int> CreateIntFieldGetter(FieldInfo field)
		{
			ParameterExpression parameterExpression = Expression.Parameter(typeof(object), "target");
			UnaryExpression expression = Expression.Convert(parameterExpression, field.DeclaringType);
			MemberExpression body = Expression.Field(expression, field);
			return Expression.Lambda<Func<object, int>>(body, new ParameterExpression[1] { parameterExpression }).Compile();
		}

		private Action<object, bool> CreateBoolFieldSetter(FieldInfo field)
		{
			ParameterExpression parameterExpression = Expression.Parameter(typeof(object), "target");
			ParameterExpression parameterExpression2 = Expression.Parameter(typeof(bool), "value");
			UnaryExpression expression = Expression.Convert(parameterExpression, field.DeclaringType);
			MemberExpression left = Expression.Field(expression, field);
			BinaryExpression body = Expression.Assign(left, parameterExpression2);
			return Expression.Lambda<Action<object, bool>>(body, new ParameterExpression[2] { parameterExpression, parameterExpression2 }).Compile();
		}

		private void Update()
		{
			if (FSConfig.EnableExpressionSync && emotionState != null && reflectionCacheInitialized)
			{
				updateTimer += Time.deltaTime;
				if (updateTimer >= updateInterval)
				{
					updateTimer = 0f;
					UpdatePlayerExpression();
				}
			}
		}

		private void UpdatePlayerExpression()
		{
			try
			{
				object obj = getPlayerAvatarInstance();
				if (obj == null)
				{
					return;
				}
				object obj2 = getPlayerExpression(obj);
				if (obj2 == null)
				{
					return;
				}
				EmotionSnapshot snapshot = emotionState.GetSnapshot();
				if (!snapshot.active || snapshot.emotion == "No Face")
				{
					ResetPendingEmotion();
				}
				else
				{
					if (snapshot.confidence < confidenceThreshold)
					{
						return;
					}
					if (snapshot.emotion == pendingEmotion)
					{
						pendingEmotionCount++;
						pendingEmotionConfidence = Mathf.Max(pendingEmotionConfidence, snapshot.confidence);
					}
					else
					{
						pendingEmotion = snapshot.emotion;
						pendingEmotionConfidence = snapshot.confidence;
						pendingEmotionCount = 1;
					}
					if (pendingEmotion == lastAppliedEmotion || pendingEmotionCount < 2)
					{
						return;
					}
					float num = Time.time - lastEmotionChangeTime;
					if (!(num < 0.7f) || !(lastAppliedEmotion != ""))
					{
						EmotionMapping emotionMapping = GetEmotionMapping(pendingEmotion);
						if (emotionMapping != null)
						{
							SetPlayerExpression(obj2, emotionMapping.ExpressionIndex);
							lastAppliedEmotion = pendingEmotion;
							lastEmotionChangeTime = Time.time;
							ResetPendingEmotion();
						}
					}
				}
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Failed to update expression: " + ex.Message));
			}
		}

		private void ResetPendingEmotion()
		{
			pendingEmotion = "";
			pendingEmotionConfidence = 0f;
			pendingEmotionCount = 0;
		}

		private void SetPlayerExpression(object playerExpression, int expressionIndex)
		{
			try
			{
				if (!(getInputToggleList(playerExpression) is IList list) || list.Count == 0)
				{
					return;
				}
				if (!listItemAccessorsInitialized)
				{
					object obj = list[0];
					Type type = obj.GetType();
					FieldInfo field = type.GetField("index", BindingFlags.Instance | BindingFlags.Public);
					FieldInfo field2 = type.GetField("active", BindingFlags.Instance | BindingFlags.Public);
					if (!(field != null) || !(field2 != null))
					{
						logger.LogError((object)"Failed to find 'index' or 'active' fields on list item");
						return;
					}
					getItemIndex = CreateIntFieldGetter(field);
					setItemActive = CreateBoolFieldSetter(field2);
					listItemAccessorsInitialized = true;
				}
				foreach (object item in list)
				{
					int num = getItemIndex(item);
					bool arg = num == expressionIndex;
					setItemActive(item, arg);
				}
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Failed to set expression: " + ex.Message));
				listItemAccessorsInitialized = false;
			}
		}

		private void ShowPlayerExpressionsUI()
		{
			try
			{
				object value = playerExpressionsUIInstanceField.GetValue(null);
				if (value != null)
				{
					shrinkResetMethod?.Invoke(value, null);
				}
			}
			catch (Exception ex)
			{
				logger.LogError((object)("Failed to show UI: " + ex.Message));
			}
		}

		private EmotionMapping GetEmotionMapping(string emotionName)
		{
			EmotionMapping[] emotionMappings = EmotionMappings;
			foreach (EmotionMapping emotionMapping in emotionMappings)
			{
				if (emotionMapping.Emotion == emotionName)
				{
					return emotionMapping;
				}
			}
			return null;
		}

		public void SetEnabled(bool enabled)
		{
			enableIntegration = enabled;
			if (enabled)
			{
				lastAppliedEmotion = "";
				lastEmotionChangeTime = 0f;
				ResetPendingEmotion();
			}
		}

		public void TestExpression(int expressionIndex)
		{
		}
	}
	public class FaceSyncClient : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <DelayedInitialization>d__10 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public FaceSyncClient <>4__this;

			private float <delay>5__1;

			private string <pluginDir>5__2;

			private string <modelPath>5__3;

			private string <cascadePath>5__4;

			private CascadeEmotionRecognizer <cascadeRecognizer>5__5;

			private string <deployProto>5__6;

			private string <caffemodel>5__7;

			private DnnEmotionRecognizer <dnnRecognizer>5__8;

			private FieldInfo <loggerField>5__9;

			private FieldInfo <emotionStateField>5__10;

			private Exception <ex>5__11;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<pluginDir>5__2 = null;
				<modelPath>5__3 = null;
				<cascadePath>5__4 = null;
				<cascadeRecognizer>5__5 = null;
				<deployProto>5__6 = null;
				<caffemodel>5__7 = null;
				<dnnRecognizer>5__8 = null;
				<loggerField>5__9 = null;
				<emotionStateField>5__10 = null;
				<ex>5__11 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<delay>5__1 = Plugin.startDelaySeconds.Value;
					<>2__current = (object)new WaitForSeconds(<delay>5__1);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					try
					{
						<pluginDir>5__2 = Path.GetDirectoryName(<>4__this.pluginInfo.Location);
						<modelPath>5__3 = Path.Combine(<pluginDir>5__2, "emotion-ferplus-8.onnx");
						<cascadePath>5__4 = Path.Combine(<pluginDir>5__2, "haarcascade_frontalface_default.xml");
						<cascadeRecognizer>5__5 = new CascadeEmotionRecognizer(<>4__this.logger, <modelPath>5__3, <cascadePath>5__4);
						<deployProto>5__6 = Path.Combine(<pluginDir>5__2, "deploy.prototxt");
						<caffemodel>5__7 = Path.Combine(<pluginDir>5__2, "res10_300x300_ssd_iter_140000.caffemodel");
						<dnnRecognizer>5__8 = new DnnEmotionRecognizer(<>4__this.logger, <modelPath>5__3, <deployProto>5__6, <caffemodel>5__7);
						<>4__this.recognition = new EmotionRecognition(<>4__this.logger, FSConfig.CameraIndex);
						<>4__this.recognition.RegisterRecognizer(RecognizerType.CASCADE, <cascadeRecognizer>5__5);
						<>4__this.recognition.RegisterRecognizer(RecognizerType.DNN, <dnnRecognizer>5__8);
						<>4__this.recognition.Start();
						<>4__this.displayUI = ((Component)<>4__this).gameObject.AddComponent<FaceSyncMenu>();
						<>4__this.displayUI.Initialize(<>4__this.recognition.EmotionState, <>4__this.logger, <>4__this.recognition);
						<>4__this.expressionIntegration = ((Component)<>4__this).gameObject.AddComponent<ExpressionIntegration>();
						<loggerField>5__9 = typeof(ExpressionIntegration).GetField("logger", BindingFlags.Instance | BindingFlags.NonPublic);
						<emotionStateField>5__10 = typeof(ExpressionIntegration).GetField("emotionState", BindingFlags.Instance | BindingFlags.NonPublic);
						<>4__this.notificationManager = ((Component)<>4__this).gameObject.AddComponent<NotificationManager>();
						if (<loggerField>5__9 != null)
						{
							<loggerField>5__9.SetValue(<>4__this.expressionIntegration, <>4__this.logger);
						}
						if (<emotionStateField>5__10 != null)
						{
							<emotionStateField>5__10.SetValue(<>4__this.expressionIntegration, <>4__this.recognition.EmotionState);
						}
						<>4__this.expressionIntegration.Initialize(Plugin.expressionUpdateInterval.Value, Plugin.expressionConfidenceThreshold.Value, Plugin.expressionDuration.Value, Plugin.enableExpressionSync.Value);
						<>4__this.isInitialized = true;
						NotificationManager.Show("Face Sync Started", NotificationManager.NotificationType.Success);
						<pluginDir>5__2 = null;
						<modelPath>5__3 = null;
						<cascadePath>5__4 = null;
						<cascadeRecognizer>5__5 = null;
						<deployProto>5__6 = null;
						<caffemodel>5__7 = null;
						<dnnRecognizer>5__8 = null;
						<loggerField>5__9 = null;
						<emotionStateField>5__10 = null;
					}
					catch (Exception ex)
					{
						<ex>5__11 = ex;
						<>4__this.logger.LogError((object)"===========================================");
						<>4__this.logger.LogError((object)"=== Initialization Failed ===");
						<>4__this.logger.LogError((object)"===========================================");
						<>4__this.logger.LogError((object)("Error: " + <ex>5__11.Message));
						<>4__this.logger.LogError((object)("Stack Trace:\n" + <ex>5__11.StackTrace));
						<>4__this.logger.LogError((object)"===========================================");
						NotificationManager.Show("Initialization Failed", NotificationManager.NotificationType.Error);
						<>4__this.CleanUp();
					}
					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 ManualLogSource logger;

		private ConfigFile config;

		private PluginInfo pluginInfo;

		private EmotionRecognition recognition;

		private FaceSyncMenu displayUI;

		private ExpressionIntegration expressionIntegration;

		private NotificationManager notificationManager;

		private bool isInitialized = false;

		public void Initialize(ManualLogSource logger, ConfigFile config, PluginInfo pluginInfo)
		{
			this.logger = logger;
			this.config = config;
			this.pluginInfo = pluginInfo;
		}

		private void Start()
		{
			string directoryName = Path.GetDirectoryName(pluginInfo.Location);
			string text = Path.Combine(directoryName, "emotion-ferplus-8.onnx");
			string text2 = Path.Combine(directoryName, "haarcascade_frontalface_default.xml");
			if (!File.Exists(text))
			{
				Notification.Error("Model file not found: " + text);
			}
			else if (!File.Exists(text2))
			{
				Notification.Error("Cascade file not found: " + text2);
			}
			else
			{
				((MonoBehaviour)this).StartCoroutine(DelayedInitialization());
			}
		}

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

		private void Update()
		{
			if (isInitialized && recognition != null && !((Object)(object)expressionIntegration == (Object)null))
			{
				if (Input.GetKeyDown((KeyCode)289))
				{
					FSConfig.EnableExpressionSync = !FSConfig.EnableExpressionSync;
					NotificationManager.Show("Expression Sync: " + (FSConfig.EnableExpressionSync ? "ON" : "OFF"), FSConfig.EnableExpressionSync ? NotificationManager.NotificationType.Success : NotificationManager.NotificationType.Warning);
				}
				if (Input.GetKeyDown((KeyCode)290))
				{
					FSConfig.AlwaysHidePlayerExpressionPopup = !FSConfig.AlwaysHidePlayerExpressionPopup;
					NotificationManager.Show("Always Hide Player Expression Popup: " + (FSConfig.AlwaysHidePlayerExpressionPopup ? "ON" : "OFF"), FSConfig.AlwaysHidePlayerExpressionPopup ? NotificationManager.NotificationType.Success : NotificationManager.NotificationType.Warning);
				}
			}
		}

		private void OnDestroy()
		{
			ManualLogSource obj = logger;
			if (obj != null)
			{
				obj.LogInfo((object)"FaceSync- Shutting down...");
			}
			CleanUp();
		}

		private void CleanUp()
		{
			try
			{
				if (recognition != null)
				{
					recognition.Dispose();
					recognition = null;
				}
			}
			catch (Exception)
			{
			}
			isInitialized = false;
		}
	}
	public static class PlayerExpressionUIHelper
	{
		private static Type playerExpressionsUIType;

		private static FieldInfo instanceField;

		private static MethodInfo shrinkResetMethod;

		private static FieldInfo shrinkTimerField;

		private static bool cacheInitialized;

		private static bool initializationAttempted;

		private static void InitializeCache()
		{
			if (initializationAttempted)
			{
				return;
			}
			initializationAttempted = true;
			try
			{
				playerExpressionsUIType = Type.GetType("PlayerExpressionsUI, Assembly-CSharp");
				if (!(playerExpressionsUIType == null))
				{
					instanceField = playerExpressionsUIType.GetField("instance", BindingFlags.Static | BindingFlags.Public);
					shrinkResetMethod = playerExpressionsUIType.GetMethod("ShrinkReset", BindingFlags.Instance | BindingFlags.Public);
					shrinkTimerField = playerExpressionsUIType.GetField("shrinkTimer", BindingFlags.Instance | BindingFlags.NonPublic);
					cacheInitialized = playerExpressionsUIType != null && instanceField != null && shrinkResetMethod != null && shrinkTimerField != null;
				}
			}
			catch
			{
				cacheInitialized = false;
			}
		}

		public static object GetPlayerExpressionsUIInstance()
		{
			if (!cacheInitialized)
			{
				InitializeCache();
			}
			try
			{
				return instanceField?.GetValue(null);
			}
			catch
			{
				return null;
			}
		}

		public static bool ShowPlayerExpressionUI(ManualLogSource logger = null)
		{
			if (!cacheInitialized)
			{
				InitializeCache();
			}
			if (!cacheInitialized)
			{
				if (logger != null)
				{
					logger.LogWarning((object)"Reflection cache not initialized");
				}
				return false;
			}
			try
			{
				object value = instanceField.GetValue(null);
				if (value == null)
				{
					if (logger != null)
					{
						logger.LogDebug((object)"PlayerExpressionsUI.instance is null");
					}
					return false;
				}
				shrinkResetMethod.Invoke(value, null);
				if (logger != null)
				{
					logger.LogDebug((object)"PlayerExpressionsUI.ShrinkReset() called");
				}
				return true;
			}
			catch (Exception ex)
			{
				if (logger != null)
				{
					logger.LogError((object)("Failed to show PlayerExpressionsUI: " + ex.Message));
				}
				return false;
			}
		}

		public static bool KeepPlayerExpressionUIVisible(ManualLogSource logger = null)
		{
			if (!cacheInitialized)
			{
				InitializeCache();
			}
			if (!cacheInitialized)
			{
				return false;
			}
			try
			{
				object value = instanceField.GetValue(null);
				if (value == null)
				{
					return false;
				}
				shrinkTimerField.SetValue(value, 999999f);
				return true;
			}
			catch (Exception ex)
			{
				if (logger != null)
				{
					logger.LogError((object)("Failed to keep PlayerExpressionsUI visible: " + ex.Message));
				}
				return false;
			}
		}

		public static bool IsPlayerExpressionsUIAvailable()
		{
			return GetPlayerExpressionsUIInstance() != null;
		}

		public static void ResetCache()
		{
			cacheInitialized = false;
			initializationAttempted = false;
			playerExpressionsUIType = null;
			instanceField = null;
			shrinkResetMethod = null;
			shrinkTimerField = null;
		}
	}
	[BepInPlugin("rec.enuwbt.facesync", "Face Sync", "1.0.3")]
	public class Plugin : BaseUnityPlugin
	{
		public static ConfigEntry<bool> enableMod;

		public static ConfigEntry<bool> gpuAcceleration;

		public static ConfigEntry<bool> showUI;

		public static ConfigEntry<int> cameraIndex;

		public static ConfigEntry<int> updateIntervalMs;

		public static ConfigEntry<float> startDelaySeconds;

		public static ConfigEntry<bool> enableExpressionSync;

		public static ConfigEntry<float> expressionUpdateInterval;

		public static ConfigEntry<float> expressionConfidenceThreshold;

		public static ConfigEntry<float> expressionDuration;

		public static ConfigEntry<bool> alwaysHidePlayerExpressionPopup;

		public static ConfigEntry<RecognizerType> recognizerType;

		private void Awake()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			((BaseUnityPlugin)this).Logger.LogInfo((object)"=== Face Sync v1.0.3 ===");
			InitializeConfig();
			if (!enableMod.Value)
			{
				Notification.Warning("Face Sync mod is disabled in config");
				return;
			}
			GameObject val = new GameObject("FaceSyncMod");
			((Object)val).hideFlags = (HideFlags)61;
			Object.DontDestroyOnLoad((Object)(object)val);
			Harmony val2 = new Harmony("rec.enuwbt.facesync");
			val2.PatchAll();
			FaceSyncClient faceSyncClient = val.AddComponent<FaceSyncClient>();
			faceSyncClient.Initialize(((BaseUnityPlugin)this).Logger, ((BaseUnityPlugin)this).Config, ((BaseUnityPlugin)this).Info);
		}

		private void InitializeConfig()
		{
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Expected O, but got Unknown
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Expected O, but got Unknown
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: 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_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Expected O, but got Unknown
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Expected O, but got Unknown
			enableMod = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableMod", true, "Enable the mod");
			showUI = ((BaseUnityPlugin)this).Config.Bind<bool>("UI", "ShowUI", true, "Show UI on startup");
			gpuAcceleration = ((BaseUnityPlugin)this).Config.Bind<bool>("Performance", "GPUAcceleration", false, "Enable GPU acceleration for emotion recognition (requires compatible GPU)");
			cameraIndex = ((BaseUnityPlugin)this).Config.Bind<int>("Camera", "CameraIndex", 0, new ConfigDescription("Camera index (0=default)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 10), Array.Empty<object>()));
			cameraIndex.SettingChanged += delegate
			{
				((BaseUnityPlugin)this).Config.Save();
			};
			updateIntervalMs = ((BaseUnityPlugin)this).Config.Bind<int>("Performance", "UpdateIntervalMs", 500, new ConfigDescription("Emotion recognition update interval (milliseconds)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(100, 5000), Array.Empty<object>()));
			startDelaySeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Performance", "StartDelaySeconds", 5f, new ConfigDescription("Delay before starting MOD after game launch (seconds)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 30f), Array.Empty<object>()));
			enableExpressionSync = ((BaseUnityPlugin)this).Config.Bind<bool>("Expression", "EnableExpressionSync", true, "Automatically change player expression based on detected emotion");
			expressionUpdateInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Expression", "UpdateInterval", 0.1f, new ConfigDescription("Expression update check interval (seconds)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 5f), Array.Empty<object>()));
			expressionConfidenceThreshold = ((BaseUnityPlugin)this).Config.Bind<float>("Expression", "ConfidenceThreshold", 0.4f, new ConfigDescription("Minimum confidence for expression change (0.0-1.0)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 0.9f), Array.Empty<object>()));
			expressionDuration = ((BaseUnityPlugin)this).Config.Bind<float>("Expression", "ExpressionDuration", 100f, new ConfigDescription("Expression intensity (%)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(10f, 100f), Array.Empty<object>()));
			alwaysHidePlayerExpressionPopup = ((BaseUnityPlugin)this).Config.Bind<bool>("Expression", "AlwaysHidePlayerExpressionUI", true, "Keep in-game expression UI always invisible");
			alwaysHidePlayerExpressionPopup.SettingChanged += delegate
			{
				((BaseUnityPlugin)this).Config.Save();
			};
			recognizerType = ((BaseUnityPlugin)this).Config.Bind<RecognizerType>("Recognizer", "RecognizerType", RecognizerType.CASCADE, new ConfigDescription("Recognizer Selection\n- CASCADE: Lightweight, fast (camera in front)\n- DNN: Heavier, camera angle-agnostic", (AcceptableValueBase)null, Array.Empty<object>()));
		}
	}
	public class ThreadSafeEmotionState
	{
		private readonly object lockObject = new object();

		private string currentEmotion = "Unknown";

		private float confidence = 0f;

		private float[] probabilities = new float[8];

		private DateTime lastUpdate = DateTime.MinValue;

		private bool isActive = false;

		private string errorMessage = null;

		public string CurrentEmotion
		{
			get
			{
				lock (lockObject)
				{
					return currentEmotion;
				}
			}
		}

		public float Confidence
		{
			get
			{
				lock (lockObject)
				{
					return confidence;
				}
			}
		}

		public bool IsActive
		{
			get
			{
				lock (lockObject)
				{
					return isActive;
				}
			}
		}

		public void Update(string emotion, float confidence, float[] probs)
		{
			lock (lockObject)
			{
				currentEmotion = emotion;
				this.confidence = confidence;
				if (probs != null && probs.Length >= 8)
				{
					Array.Copy(probs, probabilities, Math.Min(probs.Length, 8));
				}
				lastUpdate = DateTime.Now;
				isActive = true;
				errorMessage = null;
			}
		}

		public void SetError(string error)
		{
			lock (lockObject)
			{
				errorMessage = error;
				isActive = false;
			}
		}

		public EmotionSnapshot GetSnapshot()
		{
			lock (lockObject)
			{
				EmotionSnapshot result = default(EmotionSnapshot);
				result.emotion = currentEmotion;
				result.confidence = confidence;
				result.probs = (float[])probabilities.Clone();
				result.time = lastUpdate;
				result.active = isActive;
				result.error = errorMessage;
				return result;
			}
		}

		public void Reset()
		{
			lock (lockObject)
			{
				currentEmotion = "Unknown";
				confidence = 0f;
				Array.Clear(probabilities, 0, probabilities.Length);
				lastUpdate = DateTime.MinValue;
				isActive = false;
				errorMessage = null;
			}
		}
	}
	public struct EmotionSnapshot
	{
		public string emotion;

		public float confidence;

		public float[] probs;

		public DateTime time;

		public bool active;

		public string error;

		public bool IsValid => active && string.IsNullOrEmpty(error) && emotion != "No Face";

		public float TimeSinceUpdate => (float)(DateTime.Now - time).TotalSeconds;
	}
}
namespace FaceSync.patch
{
	public class PlayerExpressionsUIPatch
	{
		[HarmonyPatch(typeof(PlayerExpressionsUI))]
		public static class Update
		{
			private static MethodBase TargetMethod()
			{
				return AccessTools.Method(typeof(PlayerExpressionsUI), "Update", (Type[])null, (Type[])null);
			}

			private static void Prefix(PlayerExpressionsUI __instance)
			{
				if (FSConfig.AlwaysHidePlayerExpressionPopup)
				{
					((SemiUI)__instance).isHidden = true;
				}
			}
		}
	}
}