using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using CSVFile;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Pigeon.Movement;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyMetadata("AI_Assisted_Creation", "This assembly was partially or fully created with the assistance of Generative AI.")]
[assembly: AssemblyMetadata("AI_Model_Vendor", "Anthropic")]
[assembly: AssemblyCompany("NoBlasphemy")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+f8a12f66cd84cb9bb5142512e181af7111bc681e")]
[assembly: AssemblyProduct("NoBlasphemy")]
[assembly: AssemblyTitle("NoBlasphemy")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace NoBlasphemy
{
	internal static class Filter
	{
		private static readonly string[] Reverent = new string[2] { "exch_faith_5", "vl_building_2" };

		private static readonly HashSet<TextBlock> blocked = new HashSet<TextBlock>();

		private static readonly HashSet<string> mutedNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, float> durations = new Dictionary<string, float>(StringComparer.OrdinalIgnoreCase);

		private static Dictionary<uint, string> mutedIds;

		public static readonly List<(string group, int index, string variant, string id)> Testable = new List<(string, int, string, string)>();

		private static readonly Dictionary<TextBlock, TextBlock> alternatives = new Dictionary<TextBlock, TextBlock>();

		public static bool IsMuted(TextBlock block)
		{
			if (Plugin.MuteVoice.Value && block != null)
			{
				return blocked.Contains(block);
			}
			return false;
		}

		public static bool IsMuted(string eventName)
		{
			if (Plugin.MuteVoice.Value && eventName != null)
			{
				return mutedNames.Contains(eventName);
			}
			return false;
		}

		public static bool IsMuted(uint eventId, out string name)
		{
			name = null;
			if (!Plugin.MuteVoice.Value || mutedNames.Count == 0)
			{
				return false;
			}
			if (mutedIds == null)
			{
				mutedIds = new Dictionary<uint, string>();
				foreach (string mutedName in mutedNames)
				{
					mutedIds[AkUnitySoundEngine.GetIDFromString(mutedName)] = mutedName;
				}
			}
			return mutedIds.TryGetValue(eventId, out name);
		}

		public static float Duration(string name)
		{
			if (name == null || !durations.TryGetValue(name, out var value))
			{
				return 3f;
			}
			return value;
		}

		public static void Apply()
		{
			blocked.Clear();
			mutedNames.Clear();
			durations.Clear();
			mutedIds = null;
			HashSet<string> keep = Ids(Plugin.KeepLines.Value);
			HashSet<string> extra = Ids(Plugin.ExtraLines.Value);
			keep.UnionWith(Reverent);
			Dictionary<string, string> english = ReadEnglish();
			int language = TextBlocks.LanguageIndex;
			bool cleanText = Plugin.CleanSubtitles.Value;
			Dictionary<string, bool> everyLineBlocked = new Dictionary<string, bool>(StringComparer.OrdinalIgnoreCase);
			int cleaned = 0;
			List<(string group, int index, string variant, string id)> found = new List<(string, int, string, string)>();
			alternatives.Clear();
			foreach (KeyValuePair<string, TextBlockGroup> @string in TextBlocks.strings)
			{
				TextBlockGroup value = @string.Value;
				HashSet<TextBlock[]> hashSet = new HashSet<TextBlock[]>();
				if (value.variations != null)
				{
					foreach (KeyValuePair<string, TextBlock[]> variation in value.variations)
					{
						hashSet.Add(variation.Value);
						for (int i = 0; i < variation.Value.Length; i++)
						{
							if (variation.Value[i] != null)
							{
								Consider(variation.Value[i], variation.Key, @string.Key, i);
							}
						}
						Alternatives(variation.Value);
					}
				}
				if (value.blocks == null || hashSet.Contains(value.blocks))
				{
					continue;
				}
				for (int j = 0; j < value.blocks.Length; j++)
				{
					if (value.blocks[j] != null)
					{
						Consider(value.blocks[j], null, @string.Key, j);
					}
				}
				Alternatives(value.blocks);
			}
			foreach (KeyValuePair<string, bool> item in everyLineBlocked)
			{
				if (item.Value)
				{
					mutedNames.Add(item.Key);
				}
			}
			Testable.Clear();
			Testable.AddRange(from f in found
				where mutedNames.Contains(f.id)
				orderby f.id
				select f);
			Plugin.Log.LogInfo((object)(string.Format("{0} {1}: {2} lines found, {3} subtitles cleaned, ", "Quad's No Blasphemy", "1.0.0", blocked.Count, cleaned) + $"{(Plugin.SwapLines.Value ? alternatives.Count : 0)} swapped for another line when picked at random, " + (Plugin.MuteVoice.Value ? "otherwise silenced" : "voice left on (MuteVoice = false)")));
			static void Alternatives(TextBlock[] lines)
			{
				List<TextBlock> list = lines.Where((TextBlock b) => b != null && !blocked.Contains(b)).ToList();
				if (list.Count != 0)
				{
					for (int num = 0; num < lines.Length; num++)
					{
						if (lines[num] != null && blocked.Contains(lines[num]))
						{
							alternatives[lines[num]] = list[num % list.Count];
						}
					}
				}
			}
			void Consider(TextBlock block, string variant, string groupKey, int index)
			{
				string uniqueID = block.uniqueID;
				if (!english.TryGetValue(Key(uniqueID, variant), out var value2) && !english.TryGetValue(Key(uniqueID, null), out value2))
				{
					value2 = ((language == 0) ? block.text : null);
				}
				bool flag = keep.Contains(uniqueID);
				bool flag2 = extra.Contains(uniqueID) || (!flag && Words.IsBlasphemous(value2));
				bool num = flag2 || (!flag && language != 0 && Words.IsBlasphemous(block.text, language));
				everyLineBlocked[uniqueID] = (!everyLineBlocked.TryGetValue(uniqueID, out var value3) || value3) && flag2;
				if (flag2)
				{
					blocked.Add(block);
					found.Add((groupKey, index, variant, uniqueID));
					durations[uniqueID] = Mathf.Clamp(1f + (float)(value2 ?? block.text).Length * 0.055f, 2f, 12f);
				}
				if (num)
				{
					if (cleanText)
					{
						string text = block.text;
						block.text = Words.Clean(block.text, language);
						block.variations = null;
						if (block.text != text)
						{
							cleaned++;
						}
					}
					if (Plugin.LogLines.Value)
					{
						Plugin.Log.LogInfo((object)("  " + uniqueID + ((variant != null) ? (" [" + variant + "]") : "") + (flag2 ? "" : " (text only)") + ": " + block.text));
					}
				}
			}
		}

		public static TextBlock Swap(TextBlock block)
		{
			if (block == null || !Plugin.SwapLines.Value || !alternatives.TryGetValue(block, out var value))
			{
				return block;
			}
			if (Plugin.LogLines.Value)
			{
				Plugin.Log.LogInfo((object)("No Blasphemy: said another line instead of " + block.uniqueID));
			}
			return value;
		}

		private static Dictionary<string, string> ReadEnglish()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			TextAsset val = Resources.Load<TextAsset>("TextBlocks");
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Log.LogWarning((object)"No Blasphemy: the game's text table wasn't found; only the shown language's text is checked");
				return dictionary;
			}
			try
			{
				CSVReader val2 = CSVReader.FromString(val.text, (CSVSettings)null);
				try
				{
					foreach (string[] item in val2.Lines())
					{
						if (item.Length >= 3 && !string.IsNullOrEmpty(item[0]))
						{
							string text = item[0].Trim();
							string variant = null;
							int num = text.LastIndexOf('[');
							if (text.EndsWith("]") && num > 0)
							{
								variant = text.Substring(num + 1, text.Length - num - 2);
								text = text.Substring(0, num).TrimEnd();
							}
							dictionary[Key(text, variant)] = item[2];
						}
					}
					return dictionary;
				}
				finally
				{
					((IDisposable)val2)?.Dispose();
				}
			}
			finally
			{
				Resources.UnloadAsset((Object)(object)val);
			}
		}

		private static string Key(string id, string variant)
		{
			return id + "\n" + variant;
		}

		private static HashSet<string> Ids(string list)
		{
			return new HashSet<string>(from s in (list ?? "").Split(',')
				select s.Trim() into s
				where s.Length > 0
				select s, StringComparer.OrdinalIgnoreCase);
		}
	}
	[HarmonyPatch(typeof(TextBlocks), "Initialize")]
	internal static class TextLoaded
	{
		private static void Postfix()
		{
			Filter.Apply();
		}
	}
	[HarmonyPatch(typeof(TextBlockGroup), "Get", new Type[] { })]
	internal static class PickAny
	{
		private static void Postfix(ref TextBlock __result)
		{
			__result = Filter.Swap(__result);
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal static class PickSeeded
	{
		private static void Postfix(ref TextBlock __result)
		{
			__result = Filter.Swap(__result);
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal static class PickCharacterLine
	{
		private static void Postfix(string parameter, ref TextBlock block, ref string __result)
		{
			TextBlock val = Filter.Swap(block);
			if (val != block)
			{
				block = val;
				__result = val.GetText(parameter, true);
			}
		}
	}
	[HarmonyPatch(typeof(Highlighter), "PlayVoicelineSound", new Type[]
	{
		typeof(TextBlock),
		typeof(GameObject),
		typeof(string),
		typeof(EventCallback),
		typeof(object)
	})]
	internal static class PlayerLine
	{
		private static bool Prefix(TextBlock block, ref bool __result)
		{
			if (!Filter.IsMuted(block))
			{
				return true;
			}
			if (Plugin.LogLines.Value)
			{
				Plugin.Log.LogInfo((object)("No Blasphemy: silenced " + block.uniqueID));
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(AkUnitySoundEngine), "PostEvent", new Type[]
	{
		typeof(uint),
		typeof(GameObject)
	})]
	internal static class EventById
	{
		private static bool Prefix(uint in_eventID, ref uint __result)
		{
			return Sounds.Allow(in_eventID, 0u, null, null, ref __result);
		}
	}
	[HarmonyPatch(typeof(AkUnitySoundEngine), "PostEvent", new Type[]
	{
		typeof(uint),
		typeof(GameObject),
		typeof(uint),
		typeof(EventCallback),
		typeof(object)
	})]
	internal static class EventByIdWithCallback
	{
		private static bool Prefix(uint in_eventID, uint in_uFlags, EventCallback in_pfnCallback, object in_pCookie, ref uint __result)
		{
			return Sounds.Allow(in_eventID, in_uFlags, in_pfnCallback, in_pCookie, ref __result);
		}
	}
	[HarmonyPatch(typeof(AkUnitySoundEngine), "PostEvent", new Type[]
	{
		typeof(string),
		typeof(GameObject)
	})]
	internal static class EventByName
	{
		private static bool Prefix(string in_pszEventName, ref uint __result)
		{
			return Sounds.Allow(in_pszEventName, 0u, null, null, ref __result);
		}
	}
	[HarmonyPatch(typeof(AkUnitySoundEngine), "PostEvent", new Type[]
	{
		typeof(string),
		typeof(GameObject),
		typeof(uint),
		typeof(EventCallback),
		typeof(object)
	})]
	internal static class EventByNameWithCallback
	{
		private static bool Prefix(string in_pszEventName, uint in_uFlags, EventCallback in_pfnCallback, object in_pCookie, ref uint __result)
		{
			return Sounds.Allow(in_pszEventName, in_uFlags, in_pfnCallback, in_pCookie, ref __result);
		}
	}
	internal static class Sounds
	{
		public static bool Allow(uint id, uint flags, EventCallback callback, object cookie, ref uint result)
		{
			if (Filter.IsMuted(id, out var name))
			{
				return Silence(name, flags, callback, cookie, ref result);
			}
			return true;
		}

		public static bool Allow(string name, uint flags, EventCallback callback, object cookie, ref uint result)
		{
			if (Filter.IsMuted(name))
			{
				return Silence(name, flags, callback, cookie, ref result);
			}
			return true;
		}

		private static bool Silence(string name, uint flags, EventCallback callback, object cookie, ref uint result)
		{
			if (Plugin.LogLines.Value)
			{
				Plugin.Log.LogInfo((object)("No Blasphemy: silenced " + name));
			}
			if ((flags & 1) != 0)
			{
				Later.Call(Filter.Duration(name), callback, cookie);
			}
			result = 0u;
			return false;
		}
	}
	[BepInPlugin("quadslab.mycopunk.noblasphemy", "Quad's No Blasphemy", "1.0.0")]
	[BepInProcess("Mycopunk.exe")]
	public class Plugin : BaseUnityPlugin
	{
		public const string Guid = "quadslab.mycopunk.noblasphemy";

		public const string Title = "Quad's No Blasphemy";

		public const string Version = "1.0.0";

		internal static ManualLogSource Log;

		internal static ConfigEntry<bool> MuteVoice;

		internal static ConfigEntry<bool> CleanSubtitles;

		internal static ConfigEntry<bool> SwapLines;

		internal static ConfigEntry<string> KeepLines;

		internal static ConfigEntry<string> ExtraLines;

		internal static ConfigEntry<bool> LogLines;

		internal static ConfigEntry<bool> TestKey;

		private GameObject runner;

		private Harmony harmony;

		private void Awake()
		{
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Expected O, but got Unknown
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			MuteVoice = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "MuteVoice", true, "Silence the spoken lines that use God's name in vain. A recording can't lose just one word, so the whole line is quiet; its subtitle still shows, cleaned.");
			CleanSubtitles = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "CleanSubtitles", true, "Take God's name out of the subtitles, in every language the game has. Takes effect at the next start.");
			SwapLines = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "SwapLines", true, "When a character has other lines for the same moment (a call for help), say one of those instead of going quiet.");
			KeepLines = ((BaseUnityPlugin)this).Config.Bind<string>("Lines", "Keep", "", "More line IDs to leave alone, comma-separated (the lines that speak of God sincerely are always kept). Takes effect at the next start.");
			ExtraLines = ((BaseUnityPlugin)this).Config.Bind<string>("Lines", "Extra", "", "More line IDs to clean and silence, comma-separated, for any line the word list misses. Takes effect at the next start.");
			LogLines = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "LogLines", false, "Write every line changed (at start) and every line silenced (as it plays) to the BepInEx log, with its ID.");
			TestKey = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "TestKey", false, "F8 in a game plays the next line this mod changes, as mission control would say it: you see its cleaned subtitle and hear nothing. (A file BepInEx\\noblasphemy-test.txt does the same, for automated tests.)");
			runner = new GameObject("NoBlasphemy");
			Object.DontDestroyOnLoad((Object)(object)runner);
			((Object)runner).hideFlags = (HideFlags)61;
			runner.AddComponent<Later>();
			harmony = new Harmony("quadslab.mycopunk.noblasphemy");
			harmony.PatchAll(typeof(Plugin).Assembly);
			if (TextBlocks.strings.Count > 0)
			{
				Filter.Apply();
			}
		}

		private void OnDestroy()
		{
			Harmony obj = harmony;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
			if ((Object)(object)runner != (Object)null)
			{
				Object.Destroy((Object)(object)runner);
			}
		}
	}
	internal sealed class Later : MonoBehaviour
	{
		private static readonly List<(float at, EventCallback callback, object cookie)> pending = new List<(float, EventCallback, object)>();

		private int nextTest;

		private float nextFileCheck;

		public static void Call(float delay, EventCallback callback, object cookie)
		{
			if (callback != null)
			{
				pending.Add((Time.unscaledTime + delay, callback, cookie));
			}
		}

		private void Update()
		{
			if (Plugin.TestKey.Value && Keyboard.current != null && ((ButtonControl)Keyboard.current.f8Key).wasPressedThisFrame)
			{
				PlayTest();
			}
			if (Plugin.TestKey.Value && Time.unscaledTime >= nextFileCheck)
			{
				nextFileCheck = Time.unscaledTime + 0.5f;
				string path = Path.Combine(Paths.BepInExRootPath, "noblasphemy-test.txt");
				if (File.Exists(path))
				{
					try
					{
						File.Delete(path);
					}
					catch (Exception)
					{
					}
					PlayTest();
				}
			}
			for (int num = pending.Count - 1; num >= 0; num--)
			{
				if (!(Time.unscaledTime < pending[num].at))
				{
					(float at, EventCallback callback, object cookie) tuple = pending[num];
					EventCallback item = tuple.callback;
					object item2 = tuple.cookie;
					pending.RemoveAt(num);
					try
					{
						item.Invoke(item2, (AkCallbackType)1, (AkCallbackInfo)null);
					}
					catch (Exception ex2)
					{
						Plugin.Log.LogWarning((object)("No Blasphemy: a line's finish callback failed: " + ex2.Message));
					}
				}
			}
		}

		private void PlayTest()
		{
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			if (Filter.Testable.Count == 0 || (Object)(object)PlayerLook.Instance == (Object)null || (Object)(object)Highlighter.Instance == (Object)null)
			{
				Plugin.Log.LogInfo((object)"No Blasphemy: the test key works once you're in the game");
				return;
			}
			var (text, num, text2, arg) = Filter.Testable[nextTest++ % Filter.Testable.Count];
			Plugin.Log.LogInfo((object)$"No Blasphemy: test {nextTest}/{Filter.Testable.Count}: {arg}");
			try
			{
				Highlighter.Instance.PlayMissionControlVoiceline(new Voiceline(text, 1000), (string)null, 0, text2, (Predicate)null, (Action)null, 0f, num, (Action<DialogueBox>)null, false, (EventCallback)null, (object)null, (Sprite)null, (GameObject)null);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("No Blasphemy: the test line didn't play: " + ex.Message));
			}
		}
	}
	public static class Words
	{
		private const RegexOptions Opts = RegexOptions.IgnoreCase | RegexOptions.CultureInvariant;

		private static readonly (Regex pattern, MatchEvaluator replace)[][] Rules = new(Regex, MatchEvaluator)[10][]
		{
			new(Regex, MatchEvaluator)[10]
			{
				(new Regex("\\bgod[\\s-]*dam(?:n|m)?(it|ed)?\\b", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant), (Match m) => Cased(m.Value, (m.Groups[1].Value.ToLowerInvariant() == "it") ? "dang it" : "dang")),
				R("(?<=\\bmy\\s+)(god|lord|gawd)\\b", "gosh"),
				R("(?<=\\bthank\\s+)(god|gawd|the\\s+lord)\\b", "goodness"),
				R("\\bfor\\s+god'?s\\s+sake\\b", "for goodness' sake"),
				R("(?<=\\bgood\\s+)lord\\b", "grief"),
				R("(?<=\\b(?:oh|dear|sweet)\\s+)lord\\b", "gosh"),
				R("\\blord\\s+almighty\\b", "goodness gracious"),
				R("\\bomg\\b", "oh my gosh"),
				R("\\bgod\\s+help\\s+us\\b", "heaven help us"),
				R("\\b(god|gawd|jesus|christ|lordy)\\b", "gosh")
			},
			new(Regex, MatchEvaluator)[6]
			{
				R("\\bnom\\s+de\\s+dieu\\b", "nom d'une pipe"),
				R("\\bbonté\\s+divine\\b", "bon sang"),
				R("\\b(?:oh\\s+)?mon\\s+dieu\\b", "oh là là"),
				R("\\bseigneur(?=\\s*[!,.…])", "bon sang"),
				R("\\bdieu(?=\\s*[!…])", "bon sang"),
				R("\\bj[ée]sus\\b", "purée")
			},
			new(Regex, MatchEvaluator)[8]
			{
				R("\\bgottverdammt", "verflixt"),
				R("\\bum\\s+gottes\\s+willen\\b", "um Himmels willen"),
				R("\\bgott\\s+sei\\s+dank\\b", "zum Glück"),
				R("\\bmein\\s+gott\\b", "meine Güte"),
				R("\\boh\\s+gott\\b", "oh Mann"),
				R("\\bgrundgütiger\\b", "meine Güte"),
				R("\\bherrgott\\w*", "Mensch"),
				R("\\b(jessas|jesus)\\b", "Mannomann")
			},
			new(Regex, MatchEvaluator)[7]
			{
				R("\\bdios\\s+m[ií]o\\b", "madre mía"),
				R("\\bgracias\\s+a\\s+dios\\b", "menos mal"),
				R("\\bpor\\s+dios\\b", "por favor"),
				R("\\bque\\s+dios\\s+nos\\s+\\w+", "que haya suerte"),
				R("\\bdios(?=\\s*[,!…])", "madre mía"),
				R("\\bhostias?\\b", "ostras"),
				R("\\bjes[uú]s\\b", "caramba")
			},
			new(Regex, MatchEvaluator)[4]
			{
				R("\\bне\\s+слава\\s+богу\\b", "не так"),
				R("\\bслава\\s+богу\\b", "к счастью"),
				R("\\b(?:о\\s+)?боже(?:\\s+мой)?\\b", "ох"),
				R("\\b(?:о\\s+)?господи\\b", "ох")
			},
			new(Regex, MatchEvaluator)[7]
			{
				R("\\bmeu\\s+deus(?:\\s+do\\s+c[ée]u)?\\b", "minha nossa"),
				R("\\bgraças\\s+a\\s+deus(?=\\s+\\p{L})", "ainda bem que"),
				R("\\bgraças\\s+a\\s+deus\\b", "ainda bem"),
				R("\\bpelo\\s+amor\\s+de\\s+deus\\b", "por favor"),
				R("\\bdeus\\s+do\\s+c[ée]u\\b", "caramba"),
				R("^senhor(?=\\s*[,!])", "caramba"),
				R("\\bjesus\\b", "caramba")
			},
			new(Regex, MatchEvaluator)[4]
			{
				R("愿上帝保佑我们", "但愿我们走运"),
				R("我的上帝", "我的天"),
				R("上帝", "老天"),
				R("耶稣", "天哪")
			},
			new(Regex, MatchEvaluator)[5]
			{
				R("願主保佑我們", "但願我們走運"),
				R("我的上帝", "我的天"),
				R("上帝", "老天"),
				R("主啊", "天啊"),
				R("耶穌", "天哪")
			},
			new(Regex, MatchEvaluator)[3]
			{
				R("オーマイゴッド", "なんてこった"),
				R("ジーザス", "なんてこった"),
				R("神よ", "なんてこった")
			},
			new(Regex, MatchEvaluator)[4]
			{
				R("하느님|하나님", "세상에"),
				R("오\\s*마이\\s*갓", "세상에"),
				R("지저스", "세상에"),
				R("주여", "세상에")
			}
		};

		private static (Regex, MatchEvaluator) R(string pattern, string replacement)
		{
			return (new Regex(pattern, RegexOptions.IgnoreCase | RegexOptions.CultureInvariant), (Match m) => Cased(m.Value, replacement));
		}

		private static (Regex pattern, MatchEvaluator replace)[] For(int language)
		{
			if (language < 0 || language >= Rules.Length)
			{
				return Rules[0];
			}
			return Rules[language];
		}

		public static bool IsBlasphemous(string text, int language = 0)
		{
			if (!string.IsNullOrEmpty(text))
			{
				return For(language).Any(((Regex pattern, MatchEvaluator replace) r) => r.pattern.IsMatch(text));
			}
			return false;
		}

		public static string Clean(string text, int language = 0)
		{
			if (string.IsNullOrEmpty(text))
			{
				return text;
			}
			(Regex, MatchEvaluator)[] array = For(language);
			for (int i = 0; i < array.Length; i++)
			{
				(Regex, MatchEvaluator) tuple = array[i];
				Regex item = tuple.Item1;
				MatchEvaluator item2 = tuple.Item2;
				text = item.Replace(text, item2);
			}
			return text;
		}

		private static string Cased(string original, string replacement)
		{
			string text = original.Split(' ', '-', '\t', '\n')[^1];
			if (IsShouted(original) || (text.Length > 1 && IsShouted(text)))
			{
				return replacement.ToUpperInvariant();
			}
			if (char.IsUpper(original[0]))
			{
				return char.ToUpperInvariant(replacement[0]) + replacement.Substring(1);
			}
			return replacement;
		}

		private static bool IsShouted(string s)
		{
			bool flag = false;
			foreach (char c in s)
			{
				if (char.IsLower(c))
				{
					return false;
				}
				if (char.IsLetter(c))
				{
					flag = true;
				}
			}
			if (flag)
			{
				return s.Length > 1;
			}
			return false;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}