using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using HarmonyLib;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("CustomizerT2DOnly")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("CustomizerT2DOnly")]
[assembly: AssemblyTitle("CustomizerT2DOnly")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace CustomizerT2DOnly;

[BepInPlugin("com.yourname.customizer.t2donly", "CustomizerT2DOnly", "2.0.0")]
public class CustomizerT2DOnly : BaseUnityPlugin
{
	[HarmonyPatch(typeof(Material), "set_mainTexture")]
	internal static class H_Material_Setters
	{
		private static void Postfix(Material __instance, Texture value)
		{
			Texture2D val = (Texture2D)(object)((value is Texture2D) ? value : null);
			if (val != null)
			{
				Instance?.TrySwap(val);
			}
		}

		[HarmonyPatch(typeof(Material), "SetTexture", new Type[]
		{
			typeof(string),
			typeof(Texture)
		})]
		[HarmonyPostfix]
		private static void SetTexture_Postfix(Material __instance, string name, Texture value)
		{
			Texture2D val = (Texture2D)(object)((value is Texture2D) ? value : null);
			if (val != null)
			{
				Instance?.TrySwap(val);
			}
		}
	}

	[HarmonyPatch(typeof(SpriteRenderer), "set_sprite")]
	internal static class H_SpriteRenderer_SetSprite
	{
		private static void Postfix(Sprite value)
		{
			Texture2D val = (Object.op_Implicit((Object)(object)value) ? value.texture : null);
			if (Object.op_Implicit((Object)(object)val))
			{
				Instance?.TrySwap(val);
			}
		}
	}

	internal static class H_UI_Image_SetSprite
	{
		public static void Postfix(object __instance, Sprite value)
		{
			if (Object.op_Implicit((Object)(object)value))
			{
				Texture2D texture = value.texture;
				if (Object.op_Implicit((Object)(object)texture))
				{
					Instance?.TrySwap(texture);
				}
			}
		}
	}

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

		private object <>2__current;

		public CustomizerT2DOnly <>4__this;

		private Stopwatch <sw>5__2;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Expected O, but got Unknown
			int num = <>1__state;
			CustomizerT2DOnly customizerT2DOnly = <>4__this;
			if (num != 0)
			{
				if (num != 1)
				{
					return false;
				}
				<>1__state = -1;
			}
			else
			{
				<>1__state = -1;
				<sw>5__2 = new Stopwatch();
			}
			if (customizerT2DOnly._keys != null && customizerT2DOnly._satisfiedKeys.Count < customizerT2DOnly._keys.Count)
			{
				if (customizerT2DOnly._scanSnapshot == null || customizerT2DOnly._scanIndex >= customizerT2DOnly._scanSnapshot.Length)
				{
					customizerT2DOnly._scanSnapshot = Resources.FindObjectsOfTypeAll<Texture2D>();
					customizerT2DOnly._scanIndex = 0;
				}
				<sw>5__2.Restart();
				while (customizerT2DOnly._scanIndex < customizerT2DOnly._scanSnapshot.Length && <sw>5__2.Elapsed.TotalMilliseconds < 3.0)
				{
					Texture2D val = customizerT2DOnly._scanSnapshot[customizerT2DOnly._scanIndex++];
					if (Object.op_Implicit((Object)(object)val))
					{
						customizerT2DOnly.TrySwap(val);
					}
				}
				<sw>5__2.Stop();
			}
			else
			{
				customizerT2DOnly._scanSnapshot = null;
				customizerT2DOnly._scanIndex = 0;
			}
			<>2__current = (object)new WaitForSeconds(0.1f);
			<>1__state = 1;
			return true;
		}

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

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

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

		private object <>2__current;

		public CustomizerT2DOnly <>4__this;

		private float <elapsed>5__2;

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

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

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

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

		private bool MoveNext()
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			int num = <>1__state;
			CustomizerT2DOnly customizerT2DOnly = <>4__this;
			switch (num)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<elapsed>5__2 = 0f;
				break;
			case 1:
				<>1__state = -1;
				<elapsed>5__2 += 0.5f;
				break;
			}
			if (<elapsed>5__2 < 4f)
			{
				customizerT2DOnly.ApplyOverridesPass();
				if (customizerT2DOnly._satisfiedKeys.Count < customizerT2DOnly._keys.Count)
				{
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 1;
					return true;
				}
			}
			customizerT2DOnly._watchRoutine = null;
			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 const float MENU_DELAY = 0.6f;

	private const float GAMEPLAY_DELAY = 0.5f;

	private const float WATCH_WINDOW_SECONDS = 4f;

	private const float WATCH_TICK_SECONDS = 0.5f;

	private const float ADAPTIVE_TICK = 0.1f;

	private const double ADAPTIVE_BUDGET_MS = 3.0;

	private static readonly string[] MENU_SCENE_PATTERNS = new string[3] { "menu", "mainmenu", "title" };

	private static MethodInfo _miLoadImageBool;

	private static MethodInfo _miLoadImage;

	private static MethodInfo _miTexLoadImage;

	private Dictionary<string, (byte[] bytes, int w, int h)> _map;

	private HashSet<string> _keys;

	private readonly HashSet<int> _replacedIds = new HashSet<int>();

	private readonly HashSet<int> _notOurTex = new HashSet<int>();

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

	private bool _armedForGameplayOnce;

	private Coroutine _watchRoutine;

	private Coroutine _adaptiveRoutine;

	private Type _typeSpriteAtlas;

	private Type _typeSpriteAtlasManager;

	private EventInfo _evAtlasRegistered;

	private MethodInfo _miGetSprites_Array;

	private Delegate _atlasCallbackDelegate;

	private Texture2D[] _scanSnapshot;

	private int _scanIndex;

	private Harmony _harmony;

	private static CustomizerT2DOnly Instance
	{
		get
		{
			GameObject managerObject = Chainloader.ManagerObject;
			if (managerObject == null)
			{
				return null;
			}
			return managerObject.GetComponent<CustomizerT2DOnly>();
		}
	}

	private void OnEnable()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Expected O, but got Unknown
		_harmony = new Harmony("com.yourname.customizer.t2donly.setters");
		try
		{
			_harmony.PatchAll(typeof(H_Material_Setters));
			_harmony.PatchAll(typeof(H_SpriteRenderer_SetSprite));
			TryPatchUIImageSetter(_harmony);
		}
		catch (Exception arg)
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)$"[T2D] Harmony setters failed: {arg}");
		}
		TryHookSpriteAtlasRegistered();
		SceneManager.sceneLoaded += OnSceneLoaded;
	}

	private void OnDisable()
	{
		SceneManager.sceneLoaded -= OnSceneLoaded;
		if (_watchRoutine != null)
		{
			((MonoBehaviour)this).StopCoroutine(_watchRoutine);
		}
		if (_adaptiveRoutine != null)
		{
			((MonoBehaviour)this).StopCoroutine(_adaptiveRoutine);
		}
		TryUnhookSpriteAtlasRegistered();
		try
		{
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
		catch
		{
		}
	}

	private void Awake()
	{
		CacheLoadImageMethods();
	}

	private void Start()
	{
		//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)
		BuildOverrideMap();
		if (_keys != null && _keys.Count > 0 && _adaptiveRoutine == null)
		{
			_adaptiveRoutine = ((MonoBehaviour)this).StartCoroutine(AdaptiveWatcher());
		}
		Scene activeScene = SceneManager.GetActiveScene();
		if (IsMenu(activeScene))
		{
			_armedForGameplayOnce = true;
			((MonoBehaviour)this).Invoke("ApplyOnMenu", 0.6f);
		}
	}

	private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		if (IsMenu(scene))
		{
			_armedForGameplayOnce = true;
			((MonoBehaviour)this).Invoke("ApplyOnMenu", 0.6f);
		}
		else if (_armedForGameplayOnce)
		{
			_armedForGameplayOnce = false;
			((MonoBehaviour)this).Invoke("StartGameplayWatch", 0.5f);
		}
	}

	private static bool IsMenu(Scene scene)
	{
		string text = ((Scene)(ref scene)).name ?? string.Empty;
		string[] mENU_SCENE_PATTERNS = MENU_SCENE_PATTERNS;
		foreach (string value in mENU_SCENE_PATTERNS)
		{
			if (text.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return true;
			}
		}
		return false;
	}

	private void ApplyOnMenu()
	{
		_satisfiedKeys.Clear();
		ApplyOverridesPass();
	}

	private void StartGameplayWatch()
	{
		if (_watchRoutine != null)
		{
			((MonoBehaviour)this).StopCoroutine(_watchRoutine);
		}
		_watchRoutine = ((MonoBehaviour)this).StartCoroutine(WatchRoutine());
	}

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

	private void CacheLoadImageMethods()
	{
		try
		{
			Type type = Type.GetType("UnityEngine.ImageConversion, UnityEngine.ImageConversionModule", throwOnError: false);
			if (type != null)
			{
				_miLoadImageBool = type.GetMethod("LoadImage", BindingFlags.Static | BindingFlags.Public, null, new Type[3]
				{
					typeof(Texture2D),
					typeof(byte[]),
					typeof(bool)
				}, null);
				if (_miLoadImageBool == null)
				{
					_miLoadImage = type.GetMethod("LoadImage", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
					{
						typeof(Texture2D),
						typeof(byte[])
					}, null);
				}
			}
			_miTexLoadImage = typeof(Texture2D).GetMethod("LoadImage", BindingFlags.Instance | BindingFlags.Public, null, new Type[1] { typeof(byte[]) }, null);
		}
		catch
		{
		}
	}

	private bool LoadImageCompat(Texture2D tex, byte[] data, bool makeNoLongerReadable)
	{
		try
		{
			if ((Object)(object)tex == (Object)null || data == null)
			{
				return false;
			}
			if (_miLoadImageBool != null)
			{
				return (bool)_miLoadImageBool.Invoke(null, new object[3] { tex, data, makeNoLongerReadable });
			}
			if (_miLoadImage != null)
			{
				return (bool)_miLoadImage.Invoke(null, new object[2] { tex, data });
			}
			if (_miTexLoadImage != null)
			{
				return (bool)_miTexLoadImage.Invoke(tex, new object[1] { data });
			}
			return false;
		}
		catch
		{
			return false;
		}
	}

	private static string NormalizeName(string name)
	{
		if (string.IsNullOrEmpty(name))
		{
			return name;
		}
		if (name.StartsWith("sactx-", StringComparison.OrdinalIgnoreCase))
		{
			int num = name.LastIndexOf('-');
			if (num > 0 && num < name.Length - 1)
			{
				int num2 = name.Length - (num + 1);
				if (num2 >= 6 && num2 <= 10)
				{
					bool flag = true;
					for (int i = num + 1; i < name.Length; i++)
					{
						char c = name[i];
						if ((c < '0' || c > '9') && (c < 'a' || c > 'f') && (c < 'A' || c > 'F'))
						{
							flag = false;
							break;
						}
					}
					if (flag)
					{
						return name.Substring(0, num);
					}
				}
			}
		}
		return name;
	}

	private void BuildOverrideMap()
	{
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a2: Expected O, but got Unknown
		_map = new Dictionary<string, (byte[], int, int)>(StringComparer.OrdinalIgnoreCase);
		try
		{
			string path = Path.Combine(Application.dataPath, "Mods", "Customizer");
			if (!Directory.Exists(path))
			{
				return;
			}
			string[] directories = Directory.GetDirectories(path);
			foreach (string path2 in directories)
			{
				string path3 = Path.Combine(path2, "Texture2D");
				if (!Directory.Exists(path3))
				{
					continue;
				}
				foreach (string item in Directory.EnumerateFiles(path3, "*.png", SearchOption.TopDirectoryOnly))
				{
					string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(item);
					string key = NormalizeName(fileNameWithoutExtension);
					try
					{
						byte[] array = File.ReadAllBytes(item);
						Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
						if (LoadImageCompat(val, array, makeNoLongerReadable: false))
						{
							_map[key] = (array, ((Texture)val).width, ((Texture)val).height);
						}
						Object.Destroy((Object)(object)val);
					}
					catch
					{
					}
				}
			}
			_keys = new HashSet<string>(_map.Keys, StringComparer.OrdinalIgnoreCase);
		}
		catch
		{
		}
	}

	private void ApplyOverridesPass()
	{
		if (_map != null && _map.Count != 0)
		{
			Texture2D[] array = Resources.FindObjectsOfTypeAll<Texture2D>();
			for (int i = 0; i < array.Length; i++)
			{
				TrySwap(array[i]);
			}
		}
	}

	private bool TrySwap(Texture2D tex)
	{
		if (!Object.op_Implicit((Object)(object)tex))
		{
			return false;
		}
		int instanceID = ((Object)tex).GetInstanceID();
		if (_replacedIds.Contains(instanceID) || _notOurTex.Contains(instanceID))
		{
			return false;
		}
		string text = NormalizeName(((Object)tex).name);
		if (!_keys.Contains(text))
		{
			_notOurTex.Add(instanceID);
			return false;
		}
		(byte[], int, int) tuple = _map[text];
		if (((Texture)tex).width != tuple.Item2 || ((Texture)tex).height != tuple.Item3)
		{
			_notOurTex.Add(instanceID);
			return false;
		}
		if (LoadImageCompat(tex, tuple.Item1, makeNoLongerReadable: false))
		{
			_replacedIds.Add(instanceID);
			_satisfiedKeys.Add(text);
			if (_replacedIds.Count > 16384 || _notOurTex.Count > 16384)
			{
				_replacedIds.Clear();
				_notOurTex.Clear();
			}
			return true;
		}
		_notOurTex.Add(instanceID);
		return false;
	}

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

	private void TryHookSpriteAtlasRegistered()
	{
		try
		{
			_typeSpriteAtlas = Type.GetType("UnityEngine.U2D.SpriteAtlas, UnityEngine.U2DModule", throwOnError: false);
			_typeSpriteAtlasManager = Type.GetType("UnityEngine.U2D.SpriteAtlasManager, UnityEngine.U2DModule", throwOnError: false);
			if (!(_typeSpriteAtlas == null) && !(_typeSpriteAtlasManager == null))
			{
				_evAtlasRegistered = _typeSpriteAtlasManager.GetEvent("atlasRegistered", BindingFlags.Static | BindingFlags.Public);
				_miGetSprites_Array = _typeSpriteAtlas.GetMethod("GetSprites", BindingFlags.Instance | BindingFlags.Public, null, new Type[1] { typeof(Sprite[]) }, null);
				if (!(_evAtlasRegistered == null) && !(_miGetSprites_Array == null))
				{
					MethodInfo method = typeof(CustomizerT2DOnly).GetMethod("OnAtlasRegisteredHandler", BindingFlags.Instance | BindingFlags.NonPublic);
					Type type = typeof(Action<>).MakeGenericType(_typeSpriteAtlas);
					_atlasCallbackDelegate = Delegate.CreateDelegate(type, this, method);
					_evAtlasRegistered.GetAddMethod().Invoke(null, new object[1] { _atlasCallbackDelegate });
				}
			}
		}
		catch
		{
		}
	}

	private void TryUnhookSpriteAtlasRegistered()
	{
		try
		{
			if (_evAtlasRegistered != null && (object)_atlasCallbackDelegate != null)
			{
				_evAtlasRegistered.GetRemoveMethod().Invoke(null, new object[1] { _atlasCallbackDelegate });
			}
		}
		catch
		{
		}
		finally
		{
			_atlasCallbackDelegate = null;
			_evAtlasRegistered = null;
			_miGetSprites_Array = null;
			_typeSpriteAtlas = null;
			_typeSpriteAtlasManager = null;
		}
	}

	private void OnAtlasRegisteredHandler(object atlasObj)
	{
		try
		{
			if (atlasObj == null || _miGetSprites_Array == null || _map == null || _map.Count == 0)
			{
				return;
			}
			Sprite[] array = (Sprite[])(object)new Sprite[1024];
			int num = (int)_miGetSprites_Array.Invoke(atlasObj, new object[1] { array });
			if (num <= 0)
			{
				return;
			}
			for (int i = 0; i < num && i < array.Length; i++)
			{
				Sprite val = array[i];
				if (Object.op_Implicit((Object)(object)val))
				{
					Texture2D texture = val.texture;
					if (Object.op_Implicit((Object)(object)texture))
					{
						TrySwap(texture);
					}
				}
			}
		}
		catch
		{
		}
	}

	private void TryPatchUIImageSetter(Harmony h)
	{
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Expected O, but got Unknown
		try
		{
			Type type = Type.GetType("UnityEngine.UI.Image, UnityEngine.UI", throwOnError: false) ?? Type.GetType("UnityEngine.UI.Image, UnityEngine.UIModule", throwOnError: false);
			if (!(type == null))
			{
				MethodInfo methodInfo = AccessTools.Property(type, "sprite")?.GetSetMethod();
				if (!(methodInfo == null))
				{
					HarmonyMethod val = new HarmonyMethod(typeof(H_UI_Image_SetSprite).GetMethod("Postfix", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic));
					h.Patch((MethodBase)methodInfo, (HarmonyMethod)null, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					((BaseUnityPlugin)this).Logger.LogInfo((object)"[T2D] Patched UI.Image.set_sprite");
				}
			}
		}
		catch
		{
		}
	}
}