using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Mirror;
using QuickBoxRecycle.Configuration;
using QuickBoxRecycle.Features;
using QuickBoxRecycle.Localization;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("QuickBoxRecycle")]
[assembly: AssemblyDescription("Quick Box Recycle mod for Supermarket Together by Ice Box Studio")]
[assembly: AssemblyCompany("Ice Box Studio")]
[assembly: AssemblyProduct("QuickBoxRecycle")]
[assembly: AssemblyCopyright("Copyright © 2026 Ice Box Studio All rights reserved.")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("9ac2c2e4-0d2a-42f8-95ef-f3ebbb7e9cf8")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace QuickBoxRecycle
{
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "IceBoxStudio.SupermarketTogether.QuickBoxRecycle";

		public const string PLUGIN_NAME = "QuickBoxRecycle";

		public const string PLUGIN_VERSION = "1.0.0";
	}
	[BepInPlugin("IceBoxStudio.SupermarketTogether.QuickBoxRecycle", "QuickBoxRecycle", "1.0.0")]
	public class QuickBoxRecycle : BaseUnityPlugin
	{
		public static QuickBoxRecycle _Instance;

		private Harmony _harmony;

		private bool patchesApplied;

		public static QuickBoxRecycle Instance => _Instance;

		internal static ManualLogSource Logger { get; private set; }

		private void Awake()
		{
			_Instance = this;
			Logger = ((BaseUnityPlugin)this).Logger;
			try
			{
				Logger.LogInfo((object)"=============================================");
				Logger.LogInfo((object)("QuickBoxRecycle " + ModLocalizationManager.Instance.GetLocalizedText("plugin.initializing")));
				Logger.LogInfo((object)(ModLocalizationManager.Instance.GetLocalizedText("plugin.author_prefix") + "Ice Box Studio(https://steamcommunity.com/id/ibox666/)"));
				ConfigManager.Initialize(((BaseUnityPlugin)this).Config);
				ApplyPatches();
				Logger.LogInfo((object)("QuickBoxRecycle " + ModLocalizationManager.Instance.GetLocalizedText("plugin.initialized")));
				Logger.LogInfo((object)"=============================================");
			}
			catch (Exception ex)
			{
				Logger.LogError((object)("QuickBoxRecycle 初始化错误: " + ex.Message + "\n" + ex.StackTrace));
			}
		}

		private void Update()
		{
			QuickRecycleController.Tick();
		}

		private void ApplyPatches()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			if (!patchesApplied)
			{
				try
				{
					_harmony = new Harmony("IceBoxStudio.SupermarketTogether.QuickBoxRecycle");
					_harmony.PatchAll();
					patchesApplied = true;
					return;
				}
				catch (Exception ex)
				{
					Logger.LogError((object)("QuickBoxRecycle 应用补丁错误: " + ex.Message + "\n" + ex.StackTrace));
					return;
				}
			}
			Logger.LogInfo((object)ModLocalizationManager.Instance.GetLocalizedText("plugin.patches_skipped"));
		}
	}
}
namespace QuickBoxRecycle.Localization
{
	public static class LocalizationHelper
	{
		public static Dictionary<string, string> GetDefaultTranslations(string language)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			switch (language)
			{
			case "Localization_CH1":
				dictionary.Add("plugin.initializing", "开始初始化...");
				dictionary.Add("plugin.author_prefix", "作者：");
				dictionary.Add("plugin.initialized", "初始化成功！");
				dictionary.Add("plugin.patches_skipped", "补丁已应用，跳过...");
				dictionary.Add("config.recycle_shortcut", "一键回收空箱的快捷键");
				dictionary.Add("config.show_notifications", "显示回收提示");
				dictionary.Add("recycle.success", "已快速回收空箱，获得 {0}");
				dictionary.Add("recycle.no_box", "当前没有抱着可回收的普通箱子。");
				dictionary.Add("recycle.not_empty", "当前箱子不是空箱，无法快速回收。");
				break;
			case "Localization_CH2":
				dictionary.Add("plugin.initializing", "開始初始化...");
				dictionary.Add("plugin.author_prefix", "作者：");
				dictionary.Add("plugin.initialized", "初始化成功！");
				dictionary.Add("plugin.patches_skipped", "補丁已套用，跳過...");
				dictionary.Add("config.recycle_shortcut", "一鍵回收空箱的快捷鍵");
				dictionary.Add("config.show_notifications", "顯示回收提示");
				dictionary.Add("recycle.success", "已快速回收空箱，獲得 {0}");
				dictionary.Add("recycle.no_box", "目前沒有抱著可回收的普通箱子。");
				dictionary.Add("recycle.not_empty", "目前箱子不是空箱，無法快速回收。");
				break;
			default:
				dictionary.Add("plugin.initializing", "Initializing...");
				dictionary.Add("plugin.author_prefix", "Author: ");
				dictionary.Add("plugin.initialized", "Initialized successfully!");
				dictionary.Add("plugin.patches_skipped", "Patches already applied, skipping...");
				dictionary.Add("config.recycle_shortcut", "Hotkey for quick empty box recycling");
				dictionary.Add("config.show_notifications", "Show recycle notifications");
				dictionary.Add("recycle.success", "Empty box recycled, earned {0}");
				dictionary.Add("recycle.no_box", "You are not holding a recyclable regular box.");
				dictionary.Add("recycle.not_empty", "The current box is not empty and cannot be recycled.");
				break;
			case "Localization_JP":
				dictionary.Add("plugin.initializing", "初期化中...");
				dictionary.Add("plugin.author_prefix", "作者：");
				dictionary.Add("plugin.initialized", "初期化に成功しました！");
				dictionary.Add("plugin.patches_skipped", "パッチは既に適用されているため、スキップします...");
				dictionary.Add("config.recycle_shortcut", "空箱を即時回収するホットキー");
				dictionary.Add("config.show_notifications", "回収通知を表示");
				dictionary.Add("recycle.success", "空箱を即時回収し、{0} を獲得しました");
				dictionary.Add("recycle.no_box", "回収可能な通常の箱を持っていません。");
				dictionary.Add("recycle.not_empty", "現在の箱は空ではないため、即時回収できません。");
				break;
			}
			return dictionary;
		}
	}
	public class ModLocalizationManager
	{
		private const string ChineseSimplifiedLocale = "Localization_CH1";

		private const string ChineseTraditionalLocale = "Localization_CH2";

		private const string EnglishLocale = "Localization_EN";

		private const string JapaneseLocale = "Localization_JP";

		private static ModLocalizationManager _instance;

		private readonly Dictionary<string, Dictionary<string, string>> _localizations = new Dictionary<string, Dictionary<string, string>>();

		private string _currentLocale = "Localization_CH1";

		public static readonly string[] SupportedLanguages = new string[4] { "Localization_CH1", "Localization_CH2", "Localization_EN", "Localization_JP" };

		public static ModLocalizationManager Instance => _instance ?? (_instance = new ModLocalizationManager());

		private ModLocalizationManager()
		{
			Initialize();
		}

		public void Initialize()
		{
			string[] supportedLanguages = SupportedLanguages;
			foreach (string text in supportedLanguages)
			{
				Dictionary<string, string> defaultTranslations = LocalizationHelper.GetDefaultTranslations(text);
				if (defaultTranslations != null && defaultTranslations.Count != 0)
				{
					_localizations[text] = defaultTranslations;
				}
			}
			RefreshCurrentLocale();
		}

		public string GetLocalizedText(string key, params object[] args)
		{
			RefreshCurrentLocale();
			string text = ResolveCurrentLocale();
			if (TryGetLocalizedText(text, key, out var text2) || (text != "Localization_EN" && TryGetLocalizedText("Localization_EN", key, out text2)))
			{
				return FormatLocalizedText(text2, args);
			}
			return key;
		}

		private string ResolveCurrentLocale()
		{
			if (string.IsNullOrEmpty(_currentLocale) || !_localizations.ContainsKey(_currentLocale))
			{
				_currentLocale = "Localization_EN";
			}
			return _currentLocale;
		}

		private bool TryGetLocalizedText(string locale, string key, out string text)
		{
			text = null;
			if (!string.IsNullOrEmpty(locale) && _localizations.TryGetValue(locale, out var value))
			{
				return value.TryGetValue(key, out text);
			}
			return false;
		}

		private static string FormatLocalizedText(string text, object[] args)
		{
			if (args == null || args.Length == 0)
			{
				return text;
			}
			return string.Format(text, args);
		}

		private void RefreshCurrentLocale()
		{
			string currentGameLocale = GetCurrentGameLocale();
			if (!string.IsNullOrEmpty(currentGameLocale))
			{
				_currentLocale = MapGameLocaleToModLocale(currentGameLocale);
			}
		}

		private string GetCurrentGameLocale()
		{
			string text = Application.persistentDataPath + "/Settings/GameOptions.es3";
			if (!ES3.KeyExists("GameLanguage", text))
			{
				return null;
			}
			return ES3.Load<string>("GameLanguage", text);
		}

		private static string MapGameLocaleToModLocale(string gameLocale)
		{
			switch (gameLocale)
			{
			case "Localization_CH1":
			case "Localization_CH2":
			case "Localization_JP":
			case "Localization_EN":
				return gameLocale;
			default:
				return "Localization_EN";
			}
		}
	}
}
namespace QuickBoxRecycle.Features
{
	internal static class QuickRecycleController
	{
		private const float BoxReward = 1.5f;

		private const float Cooldown = 0.25f;

		private static float _nextRecycleTime;

		public static void Tick()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (ConfigManager.Instance != null && Input.GetKeyDown(ConfigManager.Instance.RecycleShortcut.Value) && !IsUiBlocked())
			{
				TryRecycle();
			}
		}

		private static void TryRecycle()
		{
			if (Time.unscaledTime < _nextRecycleTime)
			{
				return;
			}
			PlayerNetwork localPlayer = GetLocalPlayer();
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			if (!HasBox(localPlayer))
			{
				Notify("recycle.no_box");
				return;
			}
			if (!IsEmptyBox(localPlayer))
			{
				Notify("recycle.not_empty");
				return;
			}
			GameData instance = GameData.Instance;
			UpgradesManager val = (((Object)(object)instance != (Object)null) ? ((Component)instance).GetComponent<UpgradesManager>() : null);
			if (!((Object)(object)instance == (Object)null) && !((Object)(object)val == (Object)null))
			{
				float num = Mathf.Round(1.5f * (float)val.boxRecycleFactor * 100f) / 100f;
				localPlayer.CmdChangeEquippedItem(0);
				instance.CmdAlterFunds(num);
				if ((Object)(object)AchievementsManager.Instance != (Object)null)
				{
					AchievementsManager.Instance.CmdAddAchievementPoint(2, 1);
				}
				if ((Object)(object)StatisticsManager.Instance != (Object)null && NetworkServer.active)
				{
					StatisticsManager.Instance.AddDataFromFSMOrScript(0, 1);
				}
				_nextRecycleTime = Time.unscaledTime + 0.25f;
				string text = (((Object)(object)ProductListing.Instance != (Object)null) ? ProductListing.Instance.ConvertFloatToTextPrice(num) : ("$" + num.ToString("0.00")));
				Notify("recycle.success", text);
			}
		}

		private static PlayerNetwork GetLocalPlayer()
		{
			PlayerNetwork[] array = Object.FindObjectsByType<PlayerNetwork>((FindObjectsSortMode)0);
			for (int i = 0; i < array.Length; i++)
			{
				if ((Object)(object)array[i] != (Object)null && ((NetworkBehaviour)array[i]).isLocalPlayer)
				{
					return array[i];
				}
			}
			return null;
		}

		private static bool HasBox(PlayerNetwork player)
		{
			if (player.equippedItem == 1)
			{
				return player.extraParameter1 >= 0;
			}
			return false;
		}

		private static bool IsEmptyBox(PlayerNetwork player)
		{
			return player.extraParameter2 <= 0;
		}

		private static bool IsUiBlocked()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			if ((Object)(object)EventSystem.current != (Object)null && (Object)(object)EventSystem.current.currentSelectedGameObject != (Object)null)
			{
				return true;
			}
			if (Cursor.visible || (int)Cursor.lockState != 1)
			{
				return true;
			}
			if ((Object)(object)GameCanvas.Instance == (Object)null)
			{
				return false;
			}
			if (!IsPanelOpen("Builder") && !IsPanelOpen("SurveillanceContainer") && !IsPanelOpen("EndDayStats") && !IsPanelOpen("SavingContainer"))
			{
				return IsPanelOpen("HostDisconnect");
			}
			return true;
		}

		private static bool IsPanelOpen(string path)
		{
			Transform val = ((Component)GameCanvas.Instance).transform.Find(path);
			if ((Object)(object)val != (Object)null)
			{
				return ((Component)val).gameObject.activeInHierarchy;
			}
			return false;
		}

		private static void Notify(string localizationKey, params object[] args)
		{
			if (ConfigManager.Instance != null && ConfigManager.Instance.ShowNotifications.Value)
			{
				ShowNotice(ModLocalizationManager.Instance.GetLocalizedText(localizationKey, args));
			}
		}

		private static void ShowNotice(string message)
		{
			if (!((Object)(object)GameCanvas.Instance == (Object)null) && !((Object)(object)GameCanvas.Instance.notificationPrefab == (Object)null) && !((Object)(object)GameCanvas.Instance.notificationParentTransform == (Object)null))
			{
				GameObject obj = Object.Instantiate<GameObject>(GameCanvas.Instance.notificationPrefab, GameCanvas.Instance.notificationParentTransform);
				TextMeshProUGUI component = obj.GetComponent<TextMeshProUGUI>();
				if ((Object)(object)component != (Object)null)
				{
					((TMP_Text)component).text = message;
				}
				obj.SetActive(true);
			}
		}
	}
}
namespace QuickBoxRecycle.Configuration
{
	public class ConfigManager
	{
		private static ConfigManager _instance;

		private readonly ConfigFile _configFile;

		private readonly Dictionary<string, ConfigEntry<bool>> _boolConfigs = new Dictionary<string, ConfigEntry<bool>>();

		private readonly Dictionary<string, ConfigEntry<string>> _stringConfigs = new Dictionary<string, ConfigEntry<string>>();

		private readonly Dictionary<string, ConfigEntry<int>> _intConfigs = new Dictionary<string, ConfigEntry<int>>();

		private readonly Dictionary<string, ConfigEntry<float>> _floatConfigs = new Dictionary<string, ConfigEntry<float>>();

		private readonly Dictionary<string, ConfigEntry<KeyCode>> _keyCodeConfigs = new Dictionary<string, ConfigEntry<KeyCode>>();

		public static ConfigManager Instance => _instance;

		public ConfigEntry<KeyCode> RecycleShortcut { get; private set; }

		public ConfigEntry<bool> ShowNotifications { get; private set; }

		private ConfigManager(ConfigFile configFile)
		{
			_configFile = configFile;
			InitializeDefaultConfigs();
		}

		public static void Initialize(ConfigFile configFile)
		{
			if (_instance == null)
			{
				_instance = new ConfigManager(configFile);
			}
		}

		private void InitializeDefaultConfigs()
		{
			RecycleShortcut = RegisterKeyCode("QuickRecycle", "RecycleShortcut", GetLocalizedDescription("config.recycle_shortcut"), (KeyCode)120);
			ShowNotifications = RegisterBool("QuickRecycle", "ShowNotifications", GetLocalizedDescription("config.show_notifications"), defaultValue: true);
		}

		private string GetLocalizedDescription(string key)
		{
			return ModLocalizationManager.Instance?.GetLocalizedText(key) ?? key;
		}

		public ConfigEntry<bool> RegisterBool(string section, string key, string description, bool defaultValue)
		{
			ConfigEntry<bool> val = _configFile.Bind<bool>(section, key, defaultValue, description);
			_boolConfigs[key] = val;
			return val;
		}

		public ConfigEntry<string> RegisterString(string section, string key, string description, string defaultValue)
		{
			ConfigEntry<string> val = _configFile.Bind<string>(section, key, defaultValue, description);
			_stringConfigs[key] = val;
			return val;
		}

		public ConfigEntry<KeyCode> RegisterKeyCode(string section, string key, string description, KeyCode defaultValue)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			ConfigEntry<KeyCode> val = _configFile.Bind<KeyCode>(section, key, defaultValue, description);
			_keyCodeConfigs[key] = val;
			return val;
		}

		public ConfigEntry<int> RegisterInt(string section, string key, string description, int defaultValue)
		{
			ConfigEntry<int> val = _configFile.Bind<int>(section, key, defaultValue, description);
			_intConfigs[key] = val;
			return val;
		}

		public ConfigEntry<int> RegisterIntRange(string section, string key, string description, int defaultValue, int minValue, int maxValue)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			ConfigEntry<int> val = _configFile.Bind<int>(section, key, defaultValue, new ConfigDescription(description, (AcceptableValueBase)(object)new AcceptableValueRange<int>(minValue, maxValue), Array.Empty<object>()));
			_intConfigs[key] = val;
			return val;
		}

		public ConfigEntry<float> RegisterFloat(string section, string key, string description, float defaultValue)
		{
			ConfigEntry<float> val = _configFile.Bind<float>(section, key, defaultValue, description);
			_floatConfigs[key] = val;
			return val;
		}

		public ConfigEntry<float> RegisterFloatRange(string section, string key, string description, float defaultValue, float minValue, float maxValue)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			ConfigEntry<float> val = _configFile.Bind<float>(section, key, defaultValue, new ConfigDescription(description, (AcceptableValueBase)(object)new AcceptableValueRange<float>(minValue, maxValue), Array.Empty<object>()));
			_floatConfigs[key] = val;
			return val;
		}
	}
}