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.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using ExitGames.Client.Photon;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using Photon.Realtime;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("CustomPaintings")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+f1989f898e2eafb0a46ef0fdffeea9e6ae271875")]
[assembly: AssemblyProduct("CustomPaintings")]
[assembly: AssemblyTitle("CustomPaintings")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace CustomPaintings
{
	[BepInPlugin("UnderratedJunk.CustomPaintings", "CustomPaintings", "1.1.4")]
	public class CustomPaintings : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(LoadingUI), "LevelAnimationComplete")]
		public class PaintingSwapPatch
		{
			private static void Postfix()
			{
				Task.Run(async delegate
				{
					int waited = 0;
					int interval = 50;
					while (!receivedSeed.HasValue && waited < maxWaitTimeMs)
					{
						await Task.Delay(interval);
						waited += interval;
					}
					if (receivedSeed.HasValue)
					{
						logger.LogInfo($"[Postfix] Client using received seed: {receivedSeed.Value}");
						CustomPaintingsSwap.ReceivedSeed = receivedSeed.Value;
						receivedSeed = null;
					}
					swapper.ReplacePaintings();
				});
			}

			private static void Prefix()
			{
				if (swapper.GetModState() == CustomPaintingsSwap.ModState.Client)
				{
					PhotonNetwork.AddCallbackTarget((object)sync);
				}
				if (swapper.GetModState() == CustomPaintingsSwap.ModState.Host)
				{
					CustomPaintingsSwap.HostSeed = Random.Range(0, int.MaxValue);
					logger.LogInfo($"Generated Hostseed: {CustomPaintingsSwap.HostSeed}");
					PhotonNetwork.AddCallbackTarget((object)sync);
					sync.SendSeed(CustomPaintingsSwap.HostSeed);
					if (CustomPaintingsConfig.SeperateImages.Value)
					{
						sync.SendSeperateState("on");
					}
					else if (!CustomPaintingsConfig.SeperateImages.Value)
					{
						sync.SendSeperateState("off");
					}
				}
				loader.UpdateGrungeMaterialParameters();
			}
		}

		[HarmonyPatch(typeof(NetworkConnect), "TryJoiningRoom")]
		public class JoinLobbyPatch
		{
			private static void Prefix()
			{
				if (swapper.GetModState() != 0)
				{
					swapper.SetState(CustomPaintingsSwap.ModState.Client);
				}
			}
		}

		[HarmonyPatch(typeof(SteamManager), "HostLobby")]
		public class HostLobbyPatch
		{
			private static bool Prefix()
			{
				swapper.SetState(CustomPaintingsSwap.ModState.Host);
				return true;
			}
		}

		[HarmonyPatch(typeof(SteamManager), "LeaveLobby")]
		public class LeaveLobbyPatch
		{
			private static void Postfix()
			{
				PhotonNetwork.RemoveCallbackTarget((object)sync);
				swapper.SetState(CustomPaintingsSwap.ModState.SinglePlayer);
				CustomPaintingsSwap.SeperateState = "Singleplayer";
			}
		}

		private static Logger logger;

		private static CustomPaintingsLoader loader;

		private static CustomPaintingsSwap swapper;

		private static CustomPaintingsSync sync;

		private static CustomPaintingsGroupList grouper;

		private static CustomPaintingsConfig configfile;

		public static int? receivedSeed = null;

		public static readonly int maxWaitTimeMs = 1000;

		private readonly Harmony harmony = new Harmony("UnderratedJunk.CustomPaintings");

		private void Awake()
		{
			logger = new Logger("CustomPaintings");
			logger.LogInfo("CustomPaintings mod initialized.");
			CustomPaintingsConfig.Init(((BaseUnityPlugin)this).Config);
			loader = new CustomPaintingsLoader(logger);
			loader.LoadImagesFromAllPlugins();
			configfile = new CustomPaintingsConfig();
			grouper = new CustomPaintingsGroupList(logger);
			swapper = new CustomPaintingsSwap(logger, loader, grouper);
			sync = new CustomPaintingsSync(logger);
			harmony.PatchAll();
		}
	}
	public class CustomPaintingsConfig
	{
		internal static class Grunge
		{
			internal static ConfigEntry<bool> State;

			internal static ConfigEntry<float> Intensity;

			internal static ConfigEntry<Color> _BaseColor;

			internal static ConfigEntry<Color> _MainColor;

			internal static ConfigEntry<Color> _CracksColor;

			internal static ConfigEntry<Color> _OutlineColor;
		}

		internal static class Graphics
		{
			internal static ConfigEntry<bool> PointFiltering;
		}

		public static ConfigEntry<bool> HostControl;

		public static ConfigEntry<bool> SeperateImages;

		public static ConfigEntry<bool> ChaosMode;

		internal static void Init(ConfigFile config)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected O, but got Unknown
			//IL_00ef: 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_0109: Expected O, but got Unknown
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Expected O, but got Unknown
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Expected O, but got Unknown
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Expected O, but got Unknown
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Expected O, but got Unknown
			HostControl = config.Bind<bool>("Image Settings", "Host Control", true, new ConfigDescription("choose if host controls seperate state", (AcceptableValueBase)null, Array.Empty<object>()));
			SeperateImages = config.Bind<bool>("Image Settings", "Seperate paintings", false, new ConfigDescription("seperate square, landscape and portrait images on swap", (AcceptableValueBase)null, Array.Empty<object>()));
			ChaosMode = config.Bind<bool>("Image Settings", "Chaos Mode", false, new ConfigDescription("adds a bunch of materials that shouldn't be changed to the pool", (AcceptableValueBase)null, Array.Empty<object>()));
			Grunge.State = config.Bind<bool>("Grunge", "Grunge state", true, new ConfigDescription("Whether the grunge effect is enabled", (AcceptableValueBase)null, Array.Empty<object>()));
			Grunge.Intensity = config.Bind<float>("Grunge", "Grunge intensity", 0.5f, new ConfigDescription("change how intense the grunge is applied", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.01f, 2f), Array.Empty<object>()));
			Grunge._BaseColor = config.Bind<Color>("Grunge", "_GrungeBaseColor", new Color(0f, 0f, 0f, 1f), new ConfigDescription("The base color of the grunge", (AcceptableValueBase)null, Array.Empty<object>()));
			Grunge._MainColor = config.Bind<Color>("Grunge", "_GrungeMainColor", new Color(0f, 0f, 0f, 0.5f), new ConfigDescription("The color of the main overlay of grunge", (AcceptableValueBase)null, Array.Empty<object>()));
			Grunge._CracksColor = config.Bind<Color>("Grunge", "_GrungeCracksColor", new Color(0.25f, 0.25f, 0.25f, 1f), new ConfigDescription("The color of the cracks in the grunge", (AcceptableValueBase)null, Array.Empty<object>()));
			Grunge._OutlineColor = config.Bind<Color>("Grunge", "_GrungeOutlineColor", new Color(0f, 0f, 0f, 1f), new ConfigDescription("The color of the grunge outlining the painting", (AcceptableValueBase)null, Array.Empty<object>()));
			Graphics.PointFiltering = config.Bind<bool>("Graphics", "PointFiltering", true, new ConfigDescription("Point filtering will match the pixelated effect the game has", (AcceptableValueBase)null, Array.Empty<object>()));
		}
	}
	public class CustomPaintingsGroupList
	{
		private readonly Logger logger;

		public static readonly Dictionary<string, List<string>> MaterialNameToGroup = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase)
		{
			{
				"Painting_H_Landscape",
				new List<string> { "Landscape", "Normal", "Chaos" }
			},
			{
				"Painting_H_crow",
				new List<string> { "Landscape", "Normal", "Chaos" }
			},
			{
				"Painting_H_crow_0",
				new List<string> { "Landscape", "Normal", "Chaos" }
			},
			{
				"PaintingMedium",
				new List<string> { "Landscape", "Normal", "Chaos" }
			},
			{
				"Painting_Danish_Flag",
				new List<string> { "Landscape", "Normal", "Chaos" }
			},
			{
				"Painting_Board",
				new List<string> { "Landscape", "Normal", "Chaos" }
			},
			{
				"Painting Danish Flag",
				new List<string> { "Landscape", "Normal", "Chaos" }
			},
			{
				"Painting Board",
				new List<string> { "Landscape", "Normal", "Chaos" }
			},
			{
				"Shop Outside Billboard Ad",
				new List<string> { "Landscape", "Normal", "Chaos" }
			},
			{
				"Painting_S_Creep",
				new List<string> { "Square", "Normal", "Chaos" }
			},
			{
				"Painting_S_Creep 2_0",
				new List<string> { "Square", "Normal", "Chaos" }
			},
			{
				"Painting_S_Creep 2",
				new List<string> { "Square", "Normal", "Chaos" }
			},
			{
				"Painting Wizard Class",
				new List<string> { "Square", "Normal", "Chaos" }
			},
			{
				"Picture Frame - Picture 01",
				new List<string> { "Square", "Normal", "Chaos" }
			},
			{
				"Painting_Aurora",
				new List<string> { "Square", "Normal", "Chaos" }
			},
			{
				"Painting_McJannek",
				new List<string> { "Square", "Normal", "Chaos" }
			},
			{
				"Painting Aurora",
				new List<string> { "Square", "Normal", "Chaos" }
			},
			{
				"Painting McJannek",
				new List<string> { "Square", "Normal", "Chaos" }
			},
			{
				"Painting_V_jannk",
				new List<string> { "Portrait", "Normal", "Chaos" }
			},
			{
				"Painting_V_Furman",
				new List<string> { "Portrait", "Normal", "Chaos" }
			},
			{
				"Painting_V_surrealistic",
				new List<string> { "Portrait", "Normal", "Chaos" }
			},
			{
				"Painting_V_surrealistic_0",
				new List<string> { "Portrait", "Normal", "Chaos" }
			},
			{
				"painting teacher01",
				new List<string> { "Portrait", "Normal", "Chaos" }
			},
			{
				"painting teacher02",
				new List<string> { "Portrait", "Normal", "Chaos" }
			},
			{
				"painting teacher03",
				new List<string> { "Portrait", "Normal", "Chaos" }
			},
			{
				"painting teacher04",
				new List<string> { "Portrait", "Normal", "Chaos" }
			},
			{
				"Painting_S_Tree",
				new List<string> { "Portrait", "Normal", "Chaos" }
			},
			{
				"Painting Calendar",
				new List<string> { "Portrait", "Normal", "Chaos" }
			},
			{
				"Magazine01",
				new List<string> { "Portrait", "Normal", "Chaos" }
			},
			{
				"Magazine02",
				new List<string> { "Portrait", "Normal", "Chaos" }
			},
			{
				"Magazine03",
				new List<string> { "Portrait", "Normal", "Chaos" }
			},
			{
				"Magazine04",
				new List<string> { "Portrait", "Normal", "Chaos" }
			},
			{
				"Magazine05",
				new List<string> { "Portrait", "Normal", "Chaos" }
			},
			{
				"Valuable_Painting",
				new List<string> { "Portrait", "Normal", "Chaos" }
			},
			{
				"regular material 01",
				new List<string> { "Chaos", "Square" }
			},
			{
				"Arctic Sign Accounting",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Arctic Sign Bathroom",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Arctic Sign Botanical Research",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Arctic Sign Brige 4B",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Arctic Sign Brige 8N",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Arctic Sign Cafeteria",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Arctic Sign Cargo processing",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Arctic Sign Catwalk L5",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Arctic Sign Cooling Center",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Arctic Sign Epsilon Station",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Arctic Sign Exotic Materials Division",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Arctic Sign Infirmary",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Arctic Sign Kitchen",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Arctic Sign Living Quarters",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Arctic Sign Loading Dock",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Arctic Sign Maintenance2",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Arctic Sign Observation Platform",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Arctic Sign Recreation",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Arctic Sign Research Lab",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Arctic Sign Storage Yard",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Arctic Sign Testing Lab",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Arctic Sign Vehicle Maintenance",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Arctic Sign Ventilation Chamber",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Arctic Sign Warehouse",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Arctic Sign",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Lobby Sign - Closed Road",
				new List<string> { "Chaos", "Square" }
			},
			{
				"Lobby Sign - No stopping",
				new List<string> { "Chaos", "Square" }
			},
			{
				"Robot Company Sign 2",
				new List<string> { "Chaos", "Square" }
			},
			{
				"Robot Company Sign 3",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Robot Company Sign 4",
				new List<string> { "Chaos", "Portrait" }
			},
			{
				"Robot Company Sign 5",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Robot Company Sign 6",
				new List<string> { "Chaos", "Portrait" }
			},
			{
				"Robot Company Sign 7",
				new List<string> { "Chaos", "Square" }
			},
			{
				"Robot Company Sign",
				new List<string> { "Chaos", "Square" }
			},
			{
				"Wizard Sign Cauldron Storage",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Wizard Sign Common Room",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Wizard Sign Courtyard",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Wizard Sign Dark Arts",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Wizard Sign Deathpit Corridor",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Wizard Sign Dining Hall",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Wizard Sign Dormatory",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Wizard Sign Dungeon",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Wizard Sign East Wing Lobby",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Wizard Sign Enchanted Lava Room",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Wizard Sign Gnome Alley",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Wizard Sign Headmasters Study",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Wizard Sign Lecture Hall",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Wizard Sign Magic Plant School",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Wizard Sign Potions And Spells",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Wizard Sign Relaxation Room",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Wizard Sign Sludge Pits of Joy",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Wizard Sign Sludge Pits",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Wizard Sign Sorcery Class",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Wizard Sign Storage Room",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Wizard Sign The Great Library",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Wizard Sign Thinking Chamber",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Wizard Sign West Wing Garden",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Rug",
				new List<string> { "Chaos", "Square" }
			},
			{
				"Rug Plain Red",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"shop rug",
				new List<string> { "Chaos", "Square" }
			},
			{
				"Bathroom Rug",
				new List<string> { "Chaos", "Square" }
			},
			{
				"Wizard Wall Flag",
				new List<string> { "Chaos", "Portrait" }
			},
			{
				"upgrade_throw",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"upgrade_strength",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"upgrade_speed",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"upgrade_health",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"upgrade_grab range",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"upgrade_energy",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"upgrade_tumble_launch",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"upgrade_map_player_count",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"upgrade_extra_jump",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Welcome_Flag_Front",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Welcome_Flag_Back",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Wizard Door Double",
				new List<string> { "Chaos", "Portrait" }
			},
			{
				"Wizard Door Double Blocked",
				new List<string> { "Chaos", "Portrait" }
			},
			{
				"Wizard Door Double Blocked Lock",
				new List<string> { "Chaos", "Portrait" }
			},
			{
				"Door Wizard",
				new List<string> { "Chaos", "Portrait" }
			},
			{
				"Shop Door",
				new List<string> { "Chaos", "Portrait" }
			},
			{
				"Door Shop WC",
				new List<string> { "Chaos", "Portrait" }
			},
			{
				"Garage Door",
				new List<string> { "Chaos", "Landscape" }
			},
			{
				"Arctic Door",
				new List<string> { "Chaos", "Portrait" }
			},
			{
				"Arctic Door Blocked",
				new List<string> { "Chaos", "Portrait" }
			},
			{
				"Museum Door",
				new List<string> { "Chaos", "Portrait" }
			},
			{
				"door base",
				new List<string> { "Chaos", "Portrait" }
			}
		};

		public CustomPaintingsGroupList(Logger logger)
		{
			this.logger = logger;
		}
	}
	public class CustomPaintingsLoader
	{
		private const string IMAGE_FOLDER_NAME = "CustomPaintings";

		private readonly Logger logger;

		public Dictionary<string, List<Material>> MaterialGroups = new Dictionary<string, List<Material>>();

		private const string GRUNGE_ASSET_BUNDLE = "GrungeAssets";

		private const string MATERIAL_LANDSCAPE_ASSET_NAME = "GrungeHorizontalMaterial";

		private const string MATERIAL_PORTRAIT_ASSET_NAME = "GrungeVerticalMaterial";

		private static Material _LandscapeMaterial;

		private static Material _PortraitMaterial;

		public List<Material> LoadedMaterials { get; } = new List<Material>();


		public CustomPaintingsLoader(Logger logger)
		{
			this.logger = logger;
		}

		public void LoadImagesFromAllPlugins()
		{
			string text = Path.Combine(Paths.PluginPath);
			if (!Directory.Exists(text))
			{
				logger.LogWarning("Plugins directory not found: " + text);
				return;
			}
			string[] directories = Directory.GetDirectories(text, "CustomPaintings", SearchOption.AllDirectories);
			LoadGrungeMaterials();
			BindConfigUpdates();
			if (directories.Length == 0)
			{
				logger.LogWarning("No 'CustomPaintings' folders found in plugins.");
				return;
			}
			string[] array = directories;
			foreach (string text2 in array)
			{
				logger.LogInfo("Loading images from: " + text2);
				LoadImagesFromDirectory(text2);
			}
		}

		private void LoadImagesFromDirectory(string directoryPath)
		{
			if (!Directory.Exists(directoryPath))
			{
				logger.LogWarning("Directory does not exist: " + directoryPath);
				return;
			}
			string[] validExtensions = new string[4] { ".png", ".jpg", ".jpeg", ".bmp" };
			string[] array = (from file in Directory.EnumerateFiles(directoryPath, "*.*", SearchOption.AllDirectories)
				where validExtensions.Contains(Path.GetExtension(file).ToLower())
				select file).ToArray();
			if (array.Length == 0)
			{
				logger.LogWarning("No images found in " + directoryPath);
				return;
			}
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i];
				Texture2D val = LoadTextureFromFile(text);
				if ((Object)(object)val == (Object)null)
				{
					logger.LogWarning($"Failed to load image #{i + 1}: {text}");
					continue;
				}
				float num = (float)((Texture)val).width / (float)((Texture)val).height;
				if (num > 1.3f)
				{
					AddGrungeMaterial("Landscape", _LandscapeMaterial, val);
				}
				else if (num < 0.769f)
				{
					AddGrungeMaterial("Portrait", _PortraitMaterial, val);
				}
				else
				{
					AddGrungeMaterial("Square", _LandscapeMaterial, val);
				}
				logger.LogInfo($"Loaded image #{i + 1}: {Path.GetFileName(text)}");
			}
			foreach (KeyValuePair<string, List<Material>> materialGroup in MaterialGroups)
			{
				LoadedMaterials.AddRange(materialGroup.Value);
			}
			logger.LogInfo($"Total images loaded: {LoadedMaterials.Count}");
		}

		private Material AddGrungeMaterial(Material grungeMaterial, Texture2D texture)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			if ((Object)(object)grungeMaterial == (Object)null)
			{
				logger.LogWarning("Falling back to default shader");
				return new Material(Shader.Find("Standard"));
			}
			return new Material(grungeMaterial)
			{
				mainTexture = (Texture)(object)texture
			};
		}

		private void AddGrungeMaterial(string paintingType, Material grungeMaterial, Texture2D texture)
		{
			if (!MaterialGroups.ContainsKey(paintingType))
			{
				MaterialGroups[paintingType] = new List<Material>();
			}
			Material item = AddGrungeMaterial(grungeMaterial, texture);
			MaterialGroups[paintingType].Add(item);
		}

		private Texture2D LoadTextureFromFile(string filePath)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			byte[] array = File.ReadAllBytes(filePath);
			Texture2D val = new Texture2D(2, 2);
			if (ImageConversion.LoadImage(val, array))
			{
				SetFilterMode((Texture)(object)val);
				val.Apply();
				return val;
			}
			return null;
		}

		private void LoadGrungeMaterials()
		{
			string? directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			string text = "GrungeAssets";
			string text2 = Path.Combine(directoryName, text);
			logger.LogInfo("Loading [" + text2 + "]");
			if (File.Exists(text2))
			{
				logger.LogInfo("Grunge Asset Bundle exists.");
			}
			else
			{
				logger.LogWarning("Grunge Asset Bundle doesn't exist!");
			}
			AssetBundle val = AssetBundle.LoadFromFile(text2);
			if ((Object)(object)val == (Object)null)
			{
				logger.LogError("Failed to load [" + text + "]!");
			}
			else
			{
				_LandscapeMaterial = val.LoadAsset<Material>("GrungeHorizontalMaterial");
				if ((Object)(object)_LandscapeMaterial == (Object)null)
				{
					logger.LogError("Could not load landscape painting material [GrungeHorizontalMaterial]!");
				}
				_PortraitMaterial = val.LoadAsset<Material>("GrungeVerticalMaterial");
				if ((Object)(object)_PortraitMaterial == (Object)null)
				{
					logger.LogError("Could not load portrait painting material [GrungeVerticalMaterial]!");
				}
			}
			if ((Object)(object)_LandscapeMaterial != (Object)null && (Object)(object)_PortraitMaterial != (Object)null)
			{
				logger.LogInfo("Grunge materials successfully loaded!");
			}
		}

		internal void BindConfigUpdates()
		{
			CustomPaintingsConfig.Grunge.State.SettingChanged += OnGrungeConfigOptionChanged;
			CustomPaintingsConfig.Grunge.Intensity.SettingChanged += OnGrungeConfigOptionChanged;
			CustomPaintingsConfig.Grunge._BaseColor.SettingChanged += OnGrungeConfigOptionChanged;
			CustomPaintingsConfig.Grunge._BaseColor.SettingChanged += OnGrungeConfigOptionChanged;
			CustomPaintingsConfig.Grunge._MainColor.SettingChanged += OnGrungeConfigOptionChanged;
			CustomPaintingsConfig.Grunge._CracksColor.SettingChanged += OnGrungeConfigOptionChanged;
			CustomPaintingsConfig.Grunge._OutlineColor.SettingChanged += OnGrungeConfigOptionChanged;
			CustomPaintingsConfig.Graphics.PointFiltering.SettingChanged += OnPointFilteringConfigOptionChange;
		}

		internal void OnPointFilteringConfigOptionChange(object sender, EventArgs e)
		{
			foreach (Material loadedMaterial in LoadedMaterials)
			{
				SetFilterMode(loadedMaterial.mainTexture);
			}
		}

		internal void SetFilterMode(Texture texture)
		{
			if (CustomPaintingsConfig.Graphics.PointFiltering.Value)
			{
				texture.filterMode = (FilterMode)0;
			}
			else
			{
				texture.filterMode = (FilterMode)2;
			}
		}

		internal void OnGrungeConfigOptionChanged(object sender, EventArgs e)
		{
			UpdateGrungeMaterialParameters();
		}

		internal void UpdateGrungeMaterialParameters()
		{
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: 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_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			logger.LogDebug("Updating Grunge Material Parameters...");
			bool value = CustomPaintingsConfig.Grunge.State.Value;
			float value2 = CustomPaintingsConfig.Grunge.Intensity.Value;
			Color val = default(Color);
			((Color)(ref val))..ctor(1f, 1f, 1f, value2);
			logger.LogDebug($"Grunge state is [{value}]!");
			logger.LogDebug($"Grunge intensity is [{value2}]!");
			logger.LogDebug($"Number of loaded painting materials = [{LoadedMaterials.Count}]");
			foreach (Material loadedMaterial in LoadedMaterials)
			{
				if ((Object)(object)loadedMaterial == (Object)null)
				{
					logger.LogWarning("No material found!");
				}
				else if (value)
				{
					loadedMaterial.SetColor(((ConfigEntryBase)CustomPaintingsConfig.Grunge._BaseColor).Definition.Key, CustomPaintingsConfig.Grunge._BaseColor.Value);
					loadedMaterial.SetColor(((ConfigEntryBase)CustomPaintingsConfig.Grunge._MainColor).Definition.Key, CustomPaintingsConfig.Grunge._MainColor.Value * val);
					loadedMaterial.SetColor(((ConfigEntryBase)CustomPaintingsConfig.Grunge._CracksColor).Definition.Key, CustomPaintingsConfig.Grunge._CracksColor.Value * val);
					loadedMaterial.SetColor(((ConfigEntryBase)CustomPaintingsConfig.Grunge._OutlineColor).Definition.Key, CustomPaintingsConfig.Grunge._OutlineColor.Value * val);
				}
				else
				{
					loadedMaterial.SetColor(((ConfigEntryBase)CustomPaintingsConfig.Grunge._BaseColor).Definition.Key, Color.clear);
					loadedMaterial.SetColor(((ConfigEntryBase)CustomPaintingsConfig.Grunge._MainColor).Definition.Key, Color.clear);
					loadedMaterial.SetColor(((ConfigEntryBase)CustomPaintingsConfig.Grunge._CracksColor).Definition.Key, Color.clear);
					loadedMaterial.SetColor(((ConfigEntryBase)CustomPaintingsConfig.Grunge._OutlineColor).Definition.Key, Color.clear);
				}
			}
		}
	}
	public class CustomPaintingsSwap
	{
		public enum ModState
		{
			Host,
			Client,
			SinglePlayer
		}

		private readonly Logger logger;

		private readonly CustomPaintingsLoader loader;

		private readonly CustomPaintingsGroupList grouper;

		private static CustomPaintingsConfig configfile;

		private static int randomSeed = 0;

		public static int HostSeed = 0;

		public static int ReceivedSeed = 0;

		public static int Seed = 0;

		public static string SeperateState = "Singleplayer";

		public static string ImageMode = "Normal";

		private int paintingsChangedCount;

		private int LandscapeChangedCount;

		private int SquareChangedCount;

		private int PortraitChangedCount;

		private static ModState currentState = ModState.SinglePlayer;

		public ModState GetModState()
		{
			return currentState;
		}

		public CustomPaintingsSwap(Logger logger, CustomPaintingsLoader loader, CustomPaintingsGroupList grouper)
		{
			this.logger = logger;
			this.loader = loader;
			this.grouper = grouper;
			logger.LogInfo($"Initial ModState: {currentState}");
			if (randomSeed == 0)
			{
				randomSeed = Random.Range(0, int.MaxValue);
				logger.LogInfo($"Generated initial random seed: {randomSeed}");
			}
		}

		public void ReplacePaintings()
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			if (currentState == ModState.SinglePlayer)
			{
				Seed = randomSeed;
			}
			if (currentState == ModState.Host)
			{
				Seed = HostSeed;
			}
			if (currentState == ModState.Client)
			{
				Seed = ReceivedSeed;
			}
			if (CustomPaintingsConfig.ChaosMode.Value)
			{
				ImageMode = "Chaos";
			}
			else if (!CustomPaintingsConfig.ChaosMode.Value)
			{
				ImageMode = "Normal";
			}
			Scene activeScene = SceneManager.GetActiveScene();
			logger.LogInfo($"Applying seed {Seed} for painting swaps in scene: {((Scene)(ref activeScene)).name}");
			logger.LogInfo("Replacing all paintings with custom images...");
			paintingsChangedCount = 0;
			int num = 0;
			Scene activeScene2;
			if ((!CustomPaintingsConfig.SeperateImages.Value && SeperateState == "Singleplayer") || (SeperateState == "off" && CustomPaintingsConfig.HostControl.Value) || (!CustomPaintingsConfig.HostControl.Value && !CustomPaintingsConfig.SeperateImages.Value))
			{
				activeScene2 = SceneManager.GetActiveScene();
				GameObject[] rootGameObjects = ((Scene)(ref activeScene2)).GetRootGameObjects();
				for (int i = 0; i < rootGameObjects.Length; i++)
				{
					MeshRenderer[] componentsInChildren = rootGameObjects[i].GetComponentsInChildren<MeshRenderer>();
					foreach (MeshRenderer val in componentsInChildren)
					{
						Material[] sharedMaterials = ((Renderer)val).sharedMaterials;
						for (int k = 0; k < sharedMaterials.Length; k++)
						{
							num++;
							string key = ((Object)sharedMaterials[k]).name.Trim();
							if (CustomPaintingsGroupList.MaterialNameToGroup.TryGetValue(key, out var value) && (Object)(object)sharedMaterials[k] != (Object)null && value.Contains(ImageMode) && !((Object)sharedMaterials[k]).name.Contains("Painting Frame Vertical Gold") && !((Object)sharedMaterials[k]).name.Contains("Painting Frame Horizontal Gold") && loader.LoadedMaterials.Count > 0)
							{
								int index = Mathf.Abs((Seed + paintingsChangedCount) % loader.LoadedMaterials.Count);
								sharedMaterials[k] = loader.LoadedMaterials[index];
								paintingsChangedCount++;
							}
						}
						((Renderer)val).sharedMaterials = sharedMaterials;
					}
				}
			}
			else
			{
				if ((!CustomPaintingsConfig.SeperateImages.Value || !(SeperateState == "Singleplayer")) && (!(SeperateState == "on") || !CustomPaintingsConfig.HostControl.Value) && (CustomPaintingsConfig.HostControl.Value || !CustomPaintingsConfig.SeperateImages.Value))
				{
					return;
				}
				activeScene2 = SceneManager.GetActiveScene();
				GameObject[] rootGameObjects = ((Scene)(ref activeScene2)).GetRootGameObjects();
				for (int i = 0; i < rootGameObjects.Length; i++)
				{
					MeshRenderer[] componentsInChildren = rootGameObjects[i].GetComponentsInChildren<MeshRenderer>();
					foreach (MeshRenderer val2 in componentsInChildren)
					{
						Material[] sharedMaterials2 = ((Renderer)val2).sharedMaterials;
						for (int l = 0; l < sharedMaterials2.Length; l++)
						{
							num++;
							string key2 = ((Object)sharedMaterials2[l]).name.Trim();
							if (CustomPaintingsGroupList.MaterialNameToGroup.TryGetValue(key2, out var value2) && (Object)(object)sharedMaterials2[l] != (Object)null && value2.Contains(ImageMode))
							{
								if (((Object)sharedMaterials2[l]).name.Contains("Painting Frame Vertical Gold") || ((Object)sharedMaterials2[l]).name.Contains("Painting Frame Horizontal Gold"))
								{
									continue;
								}
								if (value2.Contains("Landscape"))
								{
									int index2 = Mathf.Abs((Seed + LandscapeChangedCount) % loader.MaterialGroups["Landscape"].Count);
									sharedMaterials2[l] = loader.MaterialGroups["Landscape"][index2];
									LandscapeChangedCount++;
								}
								else if (value2.Contains("Square"))
								{
									int index3 = Mathf.Abs((Seed + SquareChangedCount) % loader.MaterialGroups["Square"].Count);
									sharedMaterials2[l] = loader.MaterialGroups["Square"][index3];
									SquareChangedCount++;
								}
								else if (value2.Contains("Portrait"))
								{
									int index4 = Mathf.Abs((Seed + PortraitChangedCount) % loader.MaterialGroups["Portrait"].Count);
									sharedMaterials2[l] = loader.MaterialGroups["Portrait"][index4];
									PortraitChangedCount++;
								}
							}
							((Renderer)val2).sharedMaterials = sharedMaterials2;
						}
					}
				}
				logger.LogInfo($"Total materials checked: {num}");
				logger.LogInfo($"Total paintings changed in this scene: {LandscapeChangedCount + SquareChangedCount + PortraitChangedCount}");
			}
		}

		public void SetState(ModState newState)
		{
			currentState = newState;
			logger.LogInfo($"Mod state set to: {currentState}");
		}
	}
	public class CustomPaintingsSync : MonoBehaviourPunCallbacks, IOnEventCallback
	{
		private readonly Logger logger;

		public const byte SeedEventCode = 1;

		public const byte SeperateStateCode = 2;

		public CustomPaintingsSync(Logger logger)
		{
			this.logger = logger;
		}

		public void SendSeed(int seed)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			object[] array = new object[1] { seed };
			logger.LogInfo("sharing seed with other clients");
			RaiseEventOptions val = new RaiseEventOptions
			{
				Receivers = (ReceiverGroup)1,
				CachingOption = (EventCaching)4
			};
			PhotonNetwork.RaiseEvent((byte)1, (object)array, val, SendOptions.SendReliable);
		}

		public void SendSeperateState(string toggle)
		{
			//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_0022: 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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			object[] array = new object[1] { toggle };
			logger.LogInfo("sharing seperation setting");
			RaiseEventOptions val = new RaiseEventOptions
			{
				Receivers = (ReceiverGroup)1,
				CachingOption = (EventCaching)4
			};
			PhotonNetwork.RaiseEvent((byte)2, (object)array, val, SendOptions.SendReliable);
		}

		public void OnEvent(EventData photonEvent)
		{
			if (photonEvent.Code == 1)
			{
				int num = (int)((object[])photonEvent.CustomData)[0];
				logger.LogInfo($"Received seed: {num}");
				CustomPaintingsSwap.ReceivedSeed = num;
			}
			if (photonEvent.Code == 2)
			{
				string text = (string)((object[])photonEvent.CustomData)[0];
				logger.LogInfo("Received seperate state: " + text);
				CustomPaintingsSwap.SeperateState = text;
			}
		}
	}
	public class Logger
	{
		private readonly string logFilePath;

		private readonly ManualLogSource logSource;

		public Logger(string modName)
		{
			string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			logFilePath = Path.Combine(directoryName, modName + "_log.txt");
			if (File.Exists(logFilePath))
			{
				File.Delete(logFilePath);
			}
			logSource = Logger.CreateLogSource(modName);
		}

		public void LogDebug(string message)
		{
			WriteLog("DEBUG", message);
			logSource.LogDebug((object)message);
		}

		public void LogInfo(string message)
		{
			WriteLog("INFO", message);
			logSource.LogInfo((object)message);
		}

		public void LogWarning(string message)
		{
			WriteLog("WARNING", message);
			logSource.LogWarning((object)message);
		}

		public void LogError(string message)
		{
			WriteLog("ERROR", message);
			logSource.LogError((object)message);
		}

		private void WriteLog(string level, string message)
		{
			string text = $"{DateTime.Now:yyyy-MM-dd HH:mm:ss} [{level}] {message}";
			File.AppendAllText(logFilePath, text + Environment.NewLine);
		}

		public void LogMaterial(Material material)
		{
			if ((Object)(object)material != (Object)null && ((Object)material).name.ToLower().Contains("painting"))
			{
				LogInfo("Material containing 'painting': " + ((Object)material).name);
			}
		}

		public void ClearLog()
		{
			if (File.Exists(logFilePath))
			{
				File.Delete(logFilePath);
			}
		}
	}
}