using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Strobotnik.Klattersynth;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("Omniscye")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("OmniSimsTTS")]
[assembly: AssemblyTitle("OmniSimsTTS")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace OmniSimsTTS
{
	[BepInPlugin("Omniscye.OmniSimsTTS", "OmniSimsTTS", "1.0")]
	public class OmniSimsTTS : BaseUnityPlugin
	{
		internal static OmniSimsTTS Instance { get; private set; }

		internal static ManualLogSource Logger => Instance._logger;

		private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;

		internal Harmony? Harmony { get; set; }

		private void Awake()
		{
			Instance = this;
			((Component)this).gameObject.transform.parent = null;
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			Patch();
			Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} has loaded!");
		}

		internal void Patch()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0026: Expected O, but got Unknown
			if (Harmony == null)
			{
				Harmony val = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
				Harmony val2 = val;
				Harmony = val;
			}
			Harmony.PatchAll();
		}

		internal void Unpatch()
		{
			Harmony? harmony = Harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		private void Update()
		{
		}
	}
}
namespace SimlishTTS
{
	[HarmonyPatch(typeof(Speech))]
	internal static class SimlishSpeechPatch
	{
		private static readonly Dictionary<string, string> simlishDict = new Dictionary<string, string>
		{
			{ "hello", "sul sul" },
			{ "hi", "zoola" },
			{ "hey", "heya" },
			{ "goodbye", "dag dag" },
			{ "bye", "froda" },
			{ "yes", "yibs" },
			{ "no", "neib" },
			{ "okay", "oka" },
			{ "ok", "yabo" },
			{ "alright", "alri" },
			{ "thanks", "tankyu" },
			{ "thank", "bando" },
			{ "please", "pleese" },
			{ "sorry", "sorri" },
			{ "wow", "woohoo" },
			{ "cool", "koolo" },
			{ "morning", "morno" },
			{ "evening", "evino" },
			{ "happy", "freng" },
			{ "sad", "groble" },
			{ "angry", "grawl" },
			{ "excited", "woohooz" },
			{ "tired", "sneyb" },
			{ "hungry", "hungrig" },
			{ "love", "luvva" },
			{ "hate", "blorf" },
			{ "scared", "fribbi" },
			{ "surprised", "majah" },
			{ "calm", "planka" },
			{ "confused", "nogg" },
			{ "nervous", "shibly" },
			{ "bored", "drowzy" },
			{ "go", "gonk" },
			{ "come", "kome" },
			{ "eat", "nom" },
			{ "sleep", "zzub" },
			{ "work", "werkz" },
			{ "play", "pley" },
			{ "dance", "dansi" },
			{ "sing", "singz" },
			{ "run", "skrrt" },
			{ "walk", "plak" },
			{ "talk", "chatz" },
			{ "see", "blicka" },
			{ "look", "blik" },
			{ "hear", "zib" },
			{ "listen", "zibba" },
			{ "think", "noggla" },
			{ "know", "knarb" },
			{ "want", "wanna" },
			{ "need", "needa" },
			{ "like", "likka" },
			{ "give", "giva" },
			{ "take", "taka" },
			{ "ask", "aska" },
			{ "help", "helpa" },
			{ "buy", "buyee" },
			{ "find", "finda" },
			{ "make", "makka" },
			{ "use", "uzo" },
			{ "open", "oppa" },
			{ "close", "closa" },
			{ "wait", "weita" },
			{ "stop", "stopp" },
			{ "start", "starta" },
			{ "call", "kal" },
			{ "watch", "wach" },
			{ "move", "mova" },
			{ "turn", "turna" },
			{ "fall", "faloo" },
			{ "sit", "sita" },
			{ "stand", "stando" },
			{ "drive", "vrooom" },
			{ "read", "reado" },
			{ "write", "writo" },
			{ "smile", "smilo" },
			{ "cry", "criyo" },
			{ "laugh", "lafa" },
			{ "break", "braka" },
			{ "house", "homeez" },
			{ "car", "vroom" },
			{ "money", "simoleons" },
			{ "food", "nooboo" },
			{ "water", "glippa" },
			{ "friend", "palsie" },
			{ "family", "famza" },
			{ "child", "kiddi" },
			{ "dog", "woofy" },
			{ "cat", "meewa" },
			{ "phone", "blingo" },
			{ "computer", "diggo" },
			{ "game", "playz" },
			{ "music", "tuno" },
			{ "song", "singzo" },
			{ "movie", "flika" },
			{ "school", "eduka" },
			{ "job", "jobba" },
			{ "city", "citka" },
			{ "country", "landoo" },
			{ "road", "radda" },
			{ "day", "dai" },
			{ "time", "tima" },
			{ "weather", "weatha" },
			{ "rain", "plipa" },
			{ "sun", "sola" },
			{ "moon", "luno" },
			{ "star", "stara" },
			{ "sky", "skyy" },
			{ "tree", "treelo" },
			{ "flower", "floora" },
			{ "bird", "chirpa" },
			{ "fish", "swima" },
			{ "mountain", "montee" },
			{ "river", "rivo" },
			{ "sea", "seeya" },
			{ "wind", "blowa" },
			{ "fire", "fira" },
			{ "earth", "erthee" },
			{ "air", "aira" },
			{ "light", "luma" },
			{ "dark", "duska" },
			{ "big", "gurb" },
			{ "small", "litzee" },
			{ "hot", "firby" },
			{ "cold", "freezy" },
			{ "fast", "skrrt" },
			{ "slow", "drow" },
			{ "new", "novu" },
			{ "old", "antik" },
			{ "good", "gud" },
			{ "bad", "blarfy" },
			{ "easy", "ezza" },
			{ "hard", "harz" },
			{ "beautiful", "bluma" },
			{ "ugly", "uggo" },
			{ "strong", "stronka" },
			{ "weak", "weaka" },
			{ "clean", "clena" },
			{ "dirty", "dirta" },
			{ "bright", "brila" },
			{ "soft", "soffa" },
			{ "loud", "luda" },
			{ "quiet", "queta" },
			{ "quickly", "skrrtly" },
			{ "slowly", "drowly" },
			{ "very", "veroo" },
			{ "really", "reelo" },
			{ "just", "jusso" },
			{ "never", "nope" },
			{ "always", "alwaza" },
			{ "sometimes", "sumbra" },
			{ "here", "hirro" },
			{ "there", "therro" },
			{ "everywhere", "evrywheree" },
			{ "soon", "soonoo" },
			{ "late", "lata" },
			{ "early", "erly" },
			{ "i", "meh" },
			{ "you", "yu" },
			{ "he", "heh" },
			{ "she", "sheh" },
			{ "we", "wee" },
			{ "they", "dey" },
			{ "me", "meh" },
			{ "my", "mai" },
			{ "your", "yur" },
			{ "his", "hiz" },
			{ "her", "hir" },
			{ "our", "owr" },
			{ "their", "deyr" },
			{ "who", "hoo" },
			{ "what", "wha" },
			{ "when", "wen" },
			{ "where", "wher" },
			{ "why", "whai" },
			{ "how", "hau" },
			{ "in", "inno" },
			{ "on", "onno" },
			{ "at", "atta" },
			{ "by", "bai" },
			{ "with", "wif" },
			{ "about", "aboo" },
			{ "under", "undro" },
			{ "over", "ovro" },
			{ "between", "bwetin" },
			{ "through", "throo" },
			{ "around", "arouda" },
			{ "before", "befora" },
			{ "after", "aftera" },
			{ "and", "en" },
			{ "or", "ohr" },
			{ "but", "boh" },
			{ "so", "soso" },
			{ "because", "becuz" },
			{ "although", "altho" },
			{ "while", "wila" },
			{ "if", "iffa" },
			{ "unless", "unlesa" },
			{ "fuck", "fraka" },
			{ "fucking", "frakoo" },
			{ "shit", "shizz" },
			{ "bitch", "bircha" },
			{ "asshole", "asoola" },
			{ "damn", "damba" },
			{ "crap", "krappa" },
			{ "dick", "dikzo" },
			{ "piss", "pisso" },
			{ "bollocks", "bolka" },
			{ "bugger", "buggo" },
			{ "bloody", "bluda" },
			{ "arse", "arso" },
			{ "twat", "twata" },
			{ "wanker", "wanko" }
		};

		private static readonly string[] simlishSyllables = new string[22]
		{
			"blar", "flor", "grib", "plerg", "wab", "zib", "freng", "gleb", "narf", "blicka",
			"meshka", "zurb", "firby", "nooboo", "pleerg", "wabadeb", "majah", "degoba", "ooboo", "firby",
			"blarf", "neib"
		};

		private static readonly string[] simlishExclamations = new string[10] { "wabadebadoo", "plerg majah", "nooboo", "meshaloob", "firby nurbs", "degoba", "woobox", "sul sul", "yibs yibs", "blarfy grawl" };

		private static readonly Random random = new Random();

		private static readonly HashSet<string> alreadyConverted = new HashSet<string>();

		private static string ConvertToSimlish(string englishText)
		{
			if (string.IsNullOrEmpty(englishText))
			{
				return englishText;
			}
			if (alreadyConverted.Contains(englishText.ToLower()) || IsAlreadySimlish(englishText))
			{
				return englishText;
			}
			StringBuilder stringBuilder = new StringBuilder();
			string[] array = englishText.ToLower().Split(new char[4] { ' ', '\t', '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string input = array[i];
				string punctuation = "";
				string text = Regex.Replace(input, "[^\\w]", delegate(Match match)
				{
					punctuation += match.Value;
					return "";
				});
				string text2 = ((!simlishDict.ContainsKey(text)) ? GenerateSimlishWord(text) : simlishDict[text]);
				if (random.NextDouble() < 0.1)
				{
					text2 = AddVoiceEffect(text2);
				}
				stringBuilder.Append(text2 + punctuation);
				if (i < array.Length - 1)
				{
					stringBuilder.Append(" ");
				}
				if (random.NextDouble() < 0.05 && i < array.Length - 1)
				{
					stringBuilder.Append(" " + simlishExclamations[random.Next(simlishExclamations.Length)] + " ");
				}
			}
			string text3 = stringBuilder.ToString();
			alreadyConverted.Add(text3.ToLower());
			return text3;
		}

		private static bool IsAlreadySimlish(string text)
		{
			string text2 = text.ToLower();
			string[] array = new string[12]
			{
				"sul sul", "dag dag", "yibs", "neib", "blarf", "freng", "plerg", "nooboo", "meshka", "degoba",
				"wabadeb", "firby"
			};
			string[] array2 = array;
			foreach (string value in array2)
			{
				if (text2.Contains(value))
				{
					return true;
				}
			}
			return false;
		}

		private static string GenerateSimlishWord(string englishWord)
		{
			if (englishWord.Length <= 2)
			{
				return simlishSyllables[random.Next(simlishSyllables.Length / 2)];
			}
			if (englishWord.Length <= 5)
			{
				return simlishSyllables[random.Next(simlishSyllables.Length)];
			}
			int num = Math.Min(3, (englishWord.Length + 2) / 3);
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < num; i++)
			{
				stringBuilder.Append(simlishSyllables[random.Next(simlishSyllables.Length)]);
			}
			return stringBuilder.ToString();
		}

		private static string AddVoiceEffect(string word)
		{
			return random.Next(4) switch
			{
				0 => word.Replace("a", "aaa").Replace("e", "eee").Replace("i", "iii")
					.Replace("o", "ooo")
					.Replace("u", "uuu"), 
				1 => word[0] + "-" + word, 
				2 => word.ToUpper() + "!", 
				3 => word + "?", 
				_ => word, 
			};
		}

		[HarmonyPrefix]
		[HarmonyPatch("speak", new Type[]
		{
			typeof(int),
			typeof(VoicingSource),
			typeof(StringBuilder),
			typeof(bool)
		})]
		private static void Speak_StringBuilder_ONLY_Prefix(int voiceBaseFrequency, VoicingSource voicingSource, StringBuilder text, bool bracketsAsPhonemes)
		{
			if (text == null || text.Length <= 0)
			{
				return;
			}
			string text2 = text.ToString();
			if (!IsAlreadySimlish(text2))
			{
				string text3 = ConvertToSimlish(text2);
				if (text2 != text3)
				{
					text.Clear();
					text.Append(text3);
					Debug.Log((object)("[SimlishTTS] FINAL CONVERSION: '" + text2 + "' -> '" + text3 + "'"));
				}
			}
		}
	}
	[HarmonyPatch(typeof(Speech))]
	internal static class HumanVoicePatch
	{
		private static readonly Random voiceRandom = new Random();

		[HarmonyPostfix]
		[HarmonyPatch("Awake")]
		private static void Awake_Postfix(Speech __instance)
		{
			__instance.voiceBaseFrequency = 160;
			__instance.flutter = 1;
			__instance.flutterSpeed = 0.3f;
			__instance.msPerSpeechFrame = 20;
			Debug.Log((object)"[SimlishTTS] Voice HEAVILY humanized! Should sound much more natural now!");
		}

		[HarmonyPrefix]
		[HarmonyPatch("speak", new Type[]
		{
			typeof(int),
			typeof(VoicingSource),
			typeof(StringBuilder),
			typeof(bool)
		})]
		private static void Speak_StringBuilder_Humanize_Prefix(ref int voiceBaseFrequency, VoicingSource voicingSource, StringBuilder text, bool bracketsAsPhonemes)
		{
			string text2 = text.ToString().ToLower();
			if (text2.Contains("?"))
			{
				voiceBaseFrequency += voiceRandom.Next(20, 40);
			}
			else if (text2.Contains("!"))
			{
				voiceBaseFrequency += voiceRandom.Next(-15, 30);
			}
			else
			{
				voiceBaseFrequency += voiceRandom.Next(-10, 15);
			}
			voiceBaseFrequency = Mathf.Clamp(voiceBaseFrequency, 120, 280);
		}

		[HarmonyPrefix]
		[HarmonyPatch("schedule", new Type[]
		{
			typeof(int),
			typeof(VoicingSource),
			typeof(string),
			typeof(bool)
		})]
		private static void Schedule_AddNaturalPauses_Prefix(ref string text)
		{
			if (!string.IsNullOrEmpty(text))
			{
				text = text.Replace(", ", ", ... ");
				text = text.Replace(". ", ". ... ... ");
				text = text.Replace("! ", "! ... ");
				text = text.Replace("? ", "? ... ");
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("getCurrentLoudness")]
		private static void GetCurrentLoudness_Humanize_Postfix(ref float __result)
		{
			float num = 0.8f + (float)voiceRandom.NextDouble() * 0.4f;
			__result *= num;
			if (voiceRandom.NextDouble() < 0.05)
			{
				__result *= 1.3f;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("Update")]
		private static void Update_HumanTiming_Postfix(Speech __instance)
		{
			if (voiceRandom.NextDouble() < 0.02)
			{
				__instance.flutter = Mathf.Clamp(__instance.flutter + voiceRandom.Next(-2, 3), 1, 8);
				__instance.flutterSpeed = Mathf.Clamp(__instance.flutterSpeed + ((float)voiceRandom.NextDouble() - 0.5f) * 0.2f, 0.3f, 1.2f);
			}
		}
	}
	[HarmonyPatch(typeof(Speech))]
	internal static class AdvancedHumanizationPatch
	{
		private static readonly Dictionary<string, float> emotionalPitchModifiers = new Dictionary<string, float>
		{
			{ "happy", 1.15f },
			{ "excited", 1.25f },
			{ "surprised", 1.3f },
			{ "sad", 0.85f },
			{ "tired", 0.8f },
			{ "angry", 0.9f },
			{ "calm", 1f },
			{ "confused", 1.1f }
		};

		[HarmonyPrefix]
		[HarmonyPatch("speak", new Type[]
		{
			typeof(string),
			typeof(bool)
		})]
		private static void Speak_EmotionalIntelligence_Prefix(Speech __instance, string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return;
			}
			string text2 = text.ToLower();
			foreach (KeyValuePair<string, float> emotionalPitchModifier in emotionalPitchModifiers)
			{
				if (text2.Contains(emotionalPitchModifier.Key))
				{
					__instance.voiceBaseFrequency = Mathf.RoundToInt((float)__instance.voiceBaseFrequency * emotionalPitchModifier.Value);
					if (emotionalPitchModifier.Key == "excited" || emotionalPitchModifier.Key == "happy")
					{
						__instance.flutterSpeed *= 1.2f;
					}
					else if (emotionalPitchModifier.Key == "sad" || emotionalPitchModifier.Key == "tired")
					{
						__instance.flutterSpeed *= 0.7f;
						__instance.msPerSpeechFrame += 3;
					}
					break;
				}
			}
		}
	}
}