using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class EquipmentManager : MonoBehaviour
{
	public enum ViewMode
	{
		Normal = 0,
		Popup = 1
	}

	public ViewMode viewMode;

	public PlayerHeader playerHeader;

	public Camera mCamera;

	public Image mainContentMaskImage;

	public int currentSlotIndex = -1;

	public Text infoSlotName;

	public Transform[] slotButtons;

	public Button[] resetButtons;

	public Image[] damageSignSlot;

	public Transform slotItemsContent;

	public Transform normalItemsContent;

	public Transform popupItemsContent;

	public GameObject slotItemPrefab;

	public GameObject slotItemInfoBarPrefab;

	public Transform infoSlotContainer;

	public GameObject infoItemSlotInfoPrefab;

	private GameObject infoBarSlotAnim;

	public Image brandLogoImage;

	public bool debugMode;

	[HideInInspector]
	public GameManager.ItemType itemtypeToDelete;

	[HideInInspector]
	public int uniqueIdItemToDelete = -1;

	private int lastCurrentSlotRodUniqueId = -1;

	private int lastCurrentSlotRodWear = -1;

	private int lastCurrentSlotReelUniqueId = -1;

	private int lastCurrentSlotReelWear = -1;

	private int lastCurrentSlotLineUniqueId = -1;

	private int lastCurrentSlotLeaderUniqueId = -1;

	private int lastCurrentSlotHookUniqueId = -1;

	private int lastCurrentSlotFloatUniqueId = -1;

	private int lastCurrentSlotFeederUniqueId = -1;

	private int lastCurrentSlotBaitUniqueId = -1;

	private int lastCurrentSlotWeightUniqueId = -1;

	[Tooltip("Change Set Name PopUp")]
	public GameObject setNmaePopUp;

	[Tooltip("Change Set Display Transform")]
	public Transform setNmaeTransform;

	public Text[] CustomNamesText;

	public GameManager.ItemType itemsDisplayType;

	public InputField searchInputField;

	public Transform popupItems;

	public Dropdown sortDropdown;

	private int dropdownIndex = -1;

	private string sortType;

	public List<Dropdown.OptionData> dropDownOptions = new List<Dropdown.OptionData>();

	[HideInInspector]
	public List<SlotItem> search_items = new List<SlotItem>();

	private IEnumerator Start()
	{
		Debug.Log("[EquipmentManager.cs] Start method is called.");
		yield return null;
		Debug.Log("[EquipmentManager.cs] After yield return null.");
		SaveDataManager.SavePlayerDataClass currentPlayerData = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData();
		if (currentPlayerData.PlayerRods == null)
		{
			Debug.Log("[EquipmentManager.cs] PlayerRods is null.");
		}
		if (currentPlayerData.PlayerReels == null)
		{
			Debug.Log("[EquipmentManager.cs] PlayerReels is null.");
		}
		if (currentPlayerData.PlayerLines == null)
		{
			Debug.Log("[EquipmentManager.cs] PlayerLines is null.");
		}
		if (currentPlayerData.PlayerLeaders == null)
		{
			Debug.Log("[EquipmentManager.cs] PlayerLeaders is null.");
		}
		if (currentPlayerData.PlayerHooks == null)
		{
			Debug.Log("[EquipmentManager.cs] PlayerHooks is null.");
		}
		if (currentPlayerData.PlayerFloats == null)
		{
			Debug.Log("[EquipmentManager.cs] PlayerFloats is null.");
		}
		if (currentPlayerData.PlayerFeeders == null)
		{
			Debug.Log("[EquipmentManager.cs] PlayerFeeders is null.");
		}
		if (currentPlayerData.PlayerBaits == null)
		{
			Debug.Log("[EquipmentManager.cs] PlayerBaits is null.");
		}
		if (currentPlayerData.PlayerWeights == null)
		{
			Debug.Log("[EquipmentManager.cs] PlayerWeights is null.");
		}
		if (currentPlayerData.PlayerSlotsEquip == null)
		{
			Debug.Log("[EquipmentManager.cs] PlayerSlotsEquip is null.");
		}
		if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip == null)
		{
			Debug.Log("[EquipmentManager.cs] PlayerSlotsEquip is null. Initializing with PlayerSlotsEquipTemplate.");
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip = new List<GameManager.PlayerData.CSlots>(GameManager.Instance._playerData.PlayerSlotsEquipTemplate);
		}
		if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip.Count == 0)
		{
			Debug.Log("[EquipmentManager.cs] PlayerSlotsEquip is empty. Initializing with PlayerSlotsEquipTemplate.");
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip = new List<GameManager.PlayerData.CSlots>(GameManager.Instance._playerData.PlayerSlotsEquipTemplate);
		}
		if (FScriptsHandler.Instance != null)
		{
			Debug.Log("[EquipmentManager.cs] FScriptsHandler.Instance is not null.");
			playerHeader.gameObject.SetActive(value: true);
			mainContentMaskImage.enabled = true;
			if (FScriptsHandler.Instance.m_PlayerMain.currentRod != null)
			{
				Debug.Log("[EquipmentManager.cs] Current rod is null.");
				int indexOfslot = FScriptsHandler.Instance.m_PlayerMain.currentRod.indexOfslot;
				lastCurrentSlotRodUniqueId = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].rod.uniqueId;
				lastCurrentSlotRodWear = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].rod.wear;
				lastCurrentSlotReelUniqueId = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].reel.uniqueId;
				lastCurrentSlotReelWear = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].reel.wear;
				lastCurrentSlotLineUniqueId = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].line.uniqueId;
				lastCurrentSlotLeaderUniqueId = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].leader.uniqueId;
				lastCurrentSlotHookUniqueId = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].hook.uniqueId;
				lastCurrentSlotFloatUniqueId = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].ffloat.uniqueId;
				lastCurrentSlotFeederUniqueId = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].feeder.uniqueId;
				lastCurrentSlotBaitUniqueId = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].bait.uniqueId;
				lastCurrentSlotWeightUniqueId = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].weight.uniqueId;
				slotButtons[indexOfslot].GetComponentInChildren<Text>().GetComponent<BlinkText>().enabled = true;
				Debug.Log("[EquipmentManager.cs] Last equipment data retrieved from SaveDataManager.");
			}
			else
			{
				Debug.Log("[EquipmentManager.cs] Current rod is null.");
			}
			FScriptsHandler.Instance.m_Canvas.gameObject.SetActive(value: false);
		}
		else if (Object.FindObjectOfType<Residence>() != null)
		{
			Debug.Log("[EquipmentManager.cs] FScriptsHandler.Instance is null. Found Residence GameObject.");
			playerHeader.gameObject.SetActive(value: true);
			mainContentMaskImage.enabled = true;
			mCamera.transform.position = Camera.main.transform.position;
			mCamera.transform.rotation = Camera.main.transform.rotation;
		}
		else
		{
			Debug.Log("[EquipmentManager.cs] FScriptsHandler.Instance is null. No Residence found.");
			playerHeader.gameObject.SetActive(value: false);
			mainContentMaskImage.enabled = false;
		}
		if (FScriptsHandler.Instance == null)
		{
			Debug.Log("[EquipmentManager.cs] FScriptsHandler.Instance is null. Showing default player slot.");
			ShowPlayerSlot(0);
		}
		else if ((bool)FScriptsHandler.Instance.m_PlayerMain.currentRod)
		{
			Debug.Log("[EquipmentManager.cs] Current rod is not null. Showing player slot based on current rod.");
			ShowPlayerSlot(FScriptsHandler.Instance.m_PlayerMain.currentRod.indexOfslot);
		}
		else
		{
			Debug.Log("[EquipmentManager.cs] Current rod is null. Showing default player slot.");
			ShowPlayerSlot(0);
		}
		if (Object.FindObjectsOfType<AudioListener>().Length > 1)
		{
			mCamera.GetComponent<AudioListener>().enabled = false;
		}
		infoSlotName.text = slotButtons[currentSlotIndex].GetComponentInChildren<Text>().text;
		sortDropdown.options[0].text = LanguageManager.Instance.GetText("SORT_BY_DATE");
		sortDropdown.options[1].text = LanguageManager.Instance.GetText("SORT_BY_LEVEL");
		sortDropdown.options[2].text = LanguageManager.Instance.GetText("SORT_BY_NAME");
	}

	public void ShowAccesoriesInPopup()
	{
		ShowHidePopupContent(visable: true, GameManager.ItemType.Accesories);
		itemsDisplayType = GameManager.ItemType.Accesories;
	}

	public void GoToShop()
	{
		GameManager.Instance.LoadAddectiveScene("shop");
	}

	public void ShowHidePopupContent(bool visable = true, GameManager.ItemType itemtype = GameManager.ItemType.Rod, int uniqueId = -1)
	{
		if (visable)
		{
			popupItemsContent.GetComponent<EquipPopup>().uniqueId = uniqueId;
			popupItemsContent.GetComponent<EquipPopup>().itemType = itemtype;
			popupItemsContent.GetComponent<EquipPopup>().currentSlotindex = currentSlotIndex;
			normalItemsContent.gameObject.SetActive(value: false);
			popupItemsContent.gameObject.SetActive(value: true);
			viewMode = ViewMode.Popup;
		}
		else
		{
			normalItemsContent.gameObject.SetActive(value: true);
			popupItemsContent.gameObject.SetActive(value: false);
			viewMode = ViewMode.Normal;
		}
	}

	public void HidePopupByBtn()
	{
		if (viewMode == ViewMode.Normal)
		{
			MainGameScene mainGameScene = Object.FindObjectOfType<MainGameScene>();
			if ((bool)mainGameScene)
			{
				mainGameScene.BackToLastContent();
			}
			else if (FScriptsHandler.Instance != null)
			{
				GameManager.Instance.LoadAddectiveScene("EscapeMenu");
			}
			else
			{
				GameManager.Instance.UnloadAddectiveScene();
			}
		}
		normalItemsContent.gameObject.SetActive(value: true);
		popupItemsContent.gameObject.SetActive(value: false);
		ShowPlayerSlot(currentSlotIndex);
		viewMode = ViewMode.Normal;
	}

	public void checkAndShowDamageSignSlot()
	{
		Debug.Log("[EquipmentManager.cs] checkAndShowDamageSignSlot");
		for (int i = 0; i < damageSignSlot.Length; i++)
		{
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[i].CheckSlotAndRod() == 0 || Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[i].CheckSlotAndRod() == 1)
			{
				damageSignSlot[i].gameObject.SetActive(value: true);
			}
			else
			{
				damageSignSlot[i].gameObject.SetActive(value: false);
			}
		}
	}

	private void SetResetButtons()
	{
		Debug.Log("[EquipmentManager.cs] SetResetButtons");
		for (int i = 0; i < resetButtons.Length; i++)
		{
			resetButtons[i].gameObject.SetActive(value: false);
		}
		if (currentSlotIndex > -1)
		{
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].CheckSlotAndRod() == 3)
			{
				resetButtons[currentSlotIndex].gameObject.SetActive(value: false);
			}
			else
			{
				resetButtons[currentSlotIndex].gameObject.SetActive(value: true);
			}
		}
		for (int j = 0; j < slotButtons.Length; j++)
		{
			if (j == currentSlotIndex)
			{
				slotButtons[j].GetComponent<Hover>().isSelected = true;
			}
			else
			{
				slotButtons[j].GetComponent<Hover>().isSelected = false;
			}
		}
	}

	public void ShowRefreshItems()
	{
		Debug.Log("[EquipmentManager.cs] ShowRefreshItems");
		Debug.Log("[EquipmentManager.cs] ShowRefreshItems currentSlotIndex: " + currentSlotIndex);
		Debug.Log("[EquipmentManager.cs] ShowRefreshItems SaveDataManager.Instance.GetCurrentPlayerData().PlayerSlotsEquip.Count: " + Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip.Count);
		checkAndShowDamageSignSlot();
		switch (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].CheckSlotAndRod())
		{
		case -1:
			if (infoBarSlotAnim != null)
			{
				int num = slotButtons[currentSlotIndex].transform.GetSiblingIndex() + 1;
				if (infoBarSlotAnim.transform.GetSiblingIndex() == num)
				{
					Object.Destroy(infoBarSlotAnim);
				}
				infoBarSlotAnim.GetComponent<Animator>().SetTrigger("Hide");
				infoBarSlotAnim = null;
			}
			break;
		case 0:
			ShowInfoSlotBar(currentSlotIndex, LanguageManager.Instance.GetText("ROD_DAMAGE"));
			break;
		case 1:
			ShowInfoSlotBar(currentSlotIndex, LanguageManager.Instance.GetText("REEL_DAMAGE"));
			break;
		case 2:
			ShowInfoSlotBar(currentSlotIndex, LanguageManager.Instance.GetText("INCOMPLETE_SET"));
			break;
		case 3:
			ShowInfoSlotBar(currentSlotIndex, LanguageManager.Instance.GetText("INUSE_SET"));
			break;
		}
		GameManager.TruncateContainer(slotItemsContent);
		GameManager.TruncateContainer(infoSlotContainer);
		GameManager.PlayerData.CRods rod = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].rod;
		GameManager.PlayerData.CReels reel = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].reel;
		GameManager.PlayerData.CLines line = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].line;
		GameManager.PlayerData.CHooks hook = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].hook;
		GameManager.PlayerData.CFloats ffloat = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].ffloat;
		GameManager.PlayerData.CBaits bait = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].bait;
		GameManager.PlayerData.CFeeders feeder = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].feeder;
		GameManager.PlayerData.CLeaders leader = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].leader;
		GameManager.PlayerData.CWeights weight = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].weight;
		if (rod.isNull)
		{
			CreateItemSlotSetRod(rod);
			return;
		}
		CreateItemSlotSetRod(rod);
		if (reel.isNull)
		{
			CreateItemSlotSetReel(reel);
			return;
		}
		CreateItemSlotSetReel(reel);
		if (line.isNull)
		{
			CreateItemSlotSetLine(line);
			return;
		}
		CreateItemSlotSetLine(line);
		if (leader.isNull)
		{
			CreateItemSlotSetLeader(leader);
		}
		else
		{
			CreateItemSlotSetLeader(leader);
		}
		int gameItemIndexByItemId = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Rod, rod.ID);
		switch (GameManager.Instance.gameRods[gameItemIndexByItemId].type)
		{
		case GameManager.GameRods.Type.Universal:
			if (ffloat.isNull && feeder.isNull && bait.isNull)
			{
				CreateItemSlotSetFloat(ffloat);
				CreateItemSlotSetFeeder(feeder);
				CreateItemSlotSetBait(bait, isBaitNatural: true);
			}
			else if (!ffloat.isNull)
			{
				CreateItemSlotSetFloat(ffloat);
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].method = GameManager.PlayerData.CSlots.Method.Float;
			}
			else if (!feeder.isNull)
			{
				CreateItemSlotSetFeeder(feeder);
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].method = GameManager.PlayerData.CSlots.Method.Feeder;
			}
			else if (!bait.isNull)
			{
				CreateItemSlotSetBait(bait);
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].method = GameManager.PlayerData.CSlots.Method.Spinning;
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].status = GameManager.PlayerData.CSlots.Status.Completed;
			}
			break;
		case GameManager.GameRods.Type.Spinning:
		case GameManager.GameRods.Type.Casting:
			if (bait.isNull)
			{
				CreateItemSlotSetBait(bait);
				return;
			}
			CreateItemSlotSetBait(bait);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].method = GameManager.PlayerData.CSlots.Method.Spinning;
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].status = GameManager.PlayerData.CSlots.Status.Completed;
			break;
		case GameManager.GameRods.Type.Feeder:
			if (feeder.isNull)
			{
				CreateItemSlotSetFeeder(feeder);
				return;
			}
			CreateItemSlotSetFeeder(feeder);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].method = GameManager.PlayerData.CSlots.Method.Feeder;
			break;
		case GameManager.GameRods.Type.Float:
			if (ffloat.isNull)
			{
				CreateItemSlotSetFloat(ffloat);
				return;
			}
			CreateItemSlotSetFloat(ffloat);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].method = GameManager.PlayerData.CSlots.Method.Float;
			break;
		}
		switch (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].method)
		{
		case GameManager.PlayerData.CSlots.Method.Float:
			if (weight.isNull)
			{
				CreateItemSlotSetWeight(weight);
				break;
			}
			CreateItemSlotSetWeight(weight);
			if (hook.isNull)
			{
				CreateItemSlotSetHook(hook);
				break;
			}
			CreateItemSlotSetHook(hook);
			if (bait.isNull)
			{
				CreateItemSlotSetBait(bait, isBaitNatural: true);
				break;
			}
			CreateItemSlotSetBait(bait, isBaitNatural: true);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].status = GameManager.PlayerData.CSlots.Status.Completed;
			break;
		case GameManager.PlayerData.CSlots.Method.Feeder:
			if (hook.isNull)
			{
				CreateItemSlotSetHook(hook);
				break;
			}
			CreateItemSlotSetHook(hook);
			if (bait.isNull)
			{
				CreateItemSlotSetBait(bait, isBaitNatural: true);
				break;
			}
			CreateItemSlotSetBait(bait, isBaitNatural: true);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].status = GameManager.PlayerData.CSlots.Status.Completed;
			break;
		}
	}

	private void CreateItemSlotSetBait(GameManager.PlayerData.CBaits bait, bool isBaitNatural = false)
	{
		Debug.Log("[EquipmentManager.cs] CreateItemSlotSetBait isBaitNatural: " + isBaitNatural);
		SlotItem component = Object.Instantiate(slotItemPrefab, slotItemsContent).GetComponent<SlotItem>();
		component.currentSlotIndex = currentSlotIndex;
		component.bait = bait;
		component.isBaitNatural = isBaitNatural;
		component.itemType = GameManager.ItemType.Bait;
		component.deleteItemButton.gameObject.SetActive(value: false);
		component.SetupItem();
	}

	private void CreateItemSlotSetRod(GameManager.PlayerData.CRods rod)
	{
		Debug.Log("[EquipmentManager.cs] CreateItemSlotSetRod");
		SlotItem component = Object.Instantiate(slotItemPrefab, slotItemsContent).GetComponent<SlotItem>();
		component.currentSlotIndex = currentSlotIndex;
		component.rod = rod;
		component.itemType = GameManager.ItemType.Rod;
		component.deleteItemButton.gameObject.SetActive(value: false);
		component.SetupItem();
	}

	private void CreateItemSlotSetReel(GameManager.PlayerData.CReels reel)
	{
		Debug.Log("[EquipmentManager.cs] CreateItemSlotSetReel");
		SlotItem component = Object.Instantiate(slotItemPrefab, slotItemsContent).GetComponent<SlotItem>();
		component.currentSlotIndex = currentSlotIndex;
		component.reel = reel;
		component.itemType = GameManager.ItemType.Reel;
		component.deleteItemButton.gameObject.SetActive(value: false);
		component.SetupItem();
	}

	private void CreateItemSlotSetLine(GameManager.PlayerData.CLines line)
	{
		Debug.Log("[EquipmentManager.cs] CreateItemSlotSetLine");
		SlotItem component = Object.Instantiate(slotItemPrefab, slotItemsContent).GetComponent<SlotItem>();
		component.currentSlotIndex = currentSlotIndex;
		component.line = line;
		component.itemType = GameManager.ItemType.Line;
		component.deleteItemButton.gameObject.SetActive(value: false);
		component.SetupItem();
	}

	private void CreateItemSlotSetLeader(GameManager.PlayerData.CLeaders leader)
	{
		Debug.Log("[EquipmentManager.cs] CreateItemSlotSetLeader");
		SlotItem component = Object.Instantiate(slotItemPrefab, slotItemsContent).GetComponent<SlotItem>();
		component.currentSlotIndex = currentSlotIndex;
		component.leader = leader;
		component.itemType = GameManager.ItemType.Leader;
		component.deleteItemButton.gameObject.SetActive(value: false);
		component.SetupItem();
	}

	private void CreateItemSlotSetFloat(GameManager.PlayerData.CFloats ffloat)
	{
		Debug.Log("[EquipmentManager.cs] CreateItemSlotSetFloat");
		SlotItem component = Object.Instantiate(slotItemPrefab, slotItemsContent).GetComponent<SlotItem>();
		component.currentSlotIndex = currentSlotIndex;
		component.ffloat = ffloat;
		component.itemType = GameManager.ItemType.Float;
		component.deleteItemButton.gameObject.SetActive(value: false);
		component.SetupItem();
	}

	private void CreateItemSlotSetHook(GameManager.PlayerData.CHooks hook)
	{
		Debug.Log("[EquipmentManager.cs] CreateItemSlotSetHook");
		SlotItem component = Object.Instantiate(slotItemPrefab, slotItemsContent).GetComponent<SlotItem>();
		component.currentSlotIndex = currentSlotIndex;
		component.hook = hook;
		component.itemType = GameManager.ItemType.Hook;
		component.deleteItemButton.gameObject.SetActive(value: false);
		component.SetupItem();
	}

	private void CreateItemSlotSetFeeder(GameManager.PlayerData.CFeeders feeder)
	{
		Debug.Log("[EquipmentManager.cs] CreateItemSlotSetFeeder");
		SlotItem component = Object.Instantiate(slotItemPrefab, slotItemsContent).GetComponent<SlotItem>();
		component.currentSlotIndex = currentSlotIndex;
		component.feeder = feeder;
		component.itemType = GameManager.ItemType.Feeder;
		component.deleteItemButton.gameObject.SetActive(value: false);
		component.SetupItem();
	}

	private void CreateItemSlotSetWeight(GameManager.PlayerData.CWeights weight)
	{
		Debug.Log("[EquipmentManager.cs] CreateItemSlotSetWeight");
		SlotItem component = Object.Instantiate(slotItemPrefab, slotItemsContent).GetComponent<SlotItem>();
		component.currentSlotIndex = currentSlotIndex;
		component.weight = weight;
		component.itemType = GameManager.ItemType.Weight;
		component.deleteItemButton.gameObject.SetActive(value: false);
		component.SetupItem();
	}

	public void CreateItemsStatsEquiped(GameManager.ItemType itemType, int index)
	{
		Debug.Log("[EquipmentManager.cs] CreateItemsStatsEquiped index: " + index);
		if (index != -1)
		{
			StatItemEquiped component = Object.Instantiate(infoItemSlotInfoPrefab, infoSlotContainer).GetComponent<StatItemEquiped>();
			component.equipmentManager = this;
			component.Setup(itemType, index);
		}
	}

	public void ShowPlayerSlot(int index)
	{
		Debug.Log("[EquipmentManager.cs] ShowPlayerSlot[" + index + "]");
		Debug.Log("[EquipmentManager.cs] SaveDataManager.Instance.GetCurrentPlayerData().PlayerSlotsEquip.Count: " + Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip.Count);
		if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip.Count > index)
		{
			currentSlotIndex = index;
			infoSlotName.text = slotButtons[currentSlotIndex].GetComponentInChildren<Text>().text;
			SetResetButtons();
			ShowRefreshItems();
		}
	}

	public void ResetAllSlotByButton()
	{
		Debug.Log("[EquipmentManager.cs] ResetAllSlotByButton");
		GameManager.Instance.CreateMessageBox("RESET_SLOT_QUESTION", GetComponent<Canvas>().transform, 1);
	}

	public void ResetAllSlot()
	{
		Debug.Log("[EquipmentManager.cs] ResetAllSlot");
		UnEquipAll();
		ShowRefreshItems();
		if (infoBarSlotAnim != null)
		{
			Object.Destroy(infoBarSlotAnim.gameObject);
		}
	}

	public void UnEquipAll()
	{
		Debug.Log("[EquipmentManager.cs] UnEquipAll currentSlotIndex: " + currentSlotIndex);
		GameManager.PlayerData.CRods rod = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].rod;
		GameManager.PlayerData.CReels reel = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].reel;
		GameManager.PlayerData.CLines line = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].line;
		GameManager.PlayerData.CHooks hook = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].hook;
		GameManager.PlayerData.CFloats ffloat = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].ffloat;
		GameManager.PlayerData.CBaits bait = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].bait;
		GameManager.PlayerData.CFeeders feeder = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].feeder;
		GameManager.PlayerData.CLeaders leader = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].leader;
		GameManager.PlayerData.CWeights weight = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].weight;
		bool flag = false;
		if (!rod.isNull)
		{
			flag = false;
			for (int i = 0; i < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods.Count; i++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[i].ID == rod.ID && Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[i].wear == rod.wear)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[i].amount++;
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[i].status = GameManager.PlayerData.CRods.Status.InEquip;
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].rod.SetToNull();
					flag = true;
				}
			}
			if (!flag)
			{
				GameManager.PlayerData.CRods cRods = new GameManager.PlayerData.CRods();
				cRods.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].rod);
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].rod.SetToNull();
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods.Add(cRods);
			}
		}
		if (!reel.isNull)
		{
			flag = false;
			for (int j = 0; j < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels.Count; j++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[j].ID == reel.ID && Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[j].wear == reel.wear)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[j].amount++;
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].reel.SetToNull();
					flag = true;
				}
			}
			if (!flag)
			{
				GameManager.PlayerData.CReels cReels = new GameManager.PlayerData.CReels();
				cReels.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].reel);
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].reel.SetToNull();
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels.Add(cReels);
			}
		}
		if (!line.isNull)
		{
			flag = false;
			for (int k = 0; k < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines.Count; k++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[k].ID == line.ID && Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[k].lenght == line.lenght)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[k].amount++;
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].line.SetToNull();
					flag = true;
				}
			}
			if (!flag)
			{
				GameManager.PlayerData.CLines cLines = new GameManager.PlayerData.CLines();
				cLines.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].line);
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].line.SetToNull();
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines.Add(cLines);
			}
		}
		if (!ffloat.isNull)
		{
			flag = false;
			for (int l = 0; l < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats.Count; l++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[l].ID == ffloat.ID)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[l].amount++;
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].ffloat.SetToNull();
					flag = true;
				}
			}
			if (!flag)
			{
				GameManager.PlayerData.CFloats cFloats = new GameManager.PlayerData.CFloats();
				cFloats.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].ffloat);
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].ffloat.SetToNull();
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats.Add(cFloats);
			}
		}
		if (!hook.isNull)
		{
			flag = false;
			for (int m = 0; m < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks.Count; m++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[m].ID == hook.ID)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[m].amount++;
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].hook.SetToNull();
					flag = true;
				}
			}
			if (!flag)
			{
				GameManager.PlayerData.CHooks cHooks = new GameManager.PlayerData.CHooks();
				cHooks.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].hook);
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].hook.SetToNull();
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks.Add(cHooks);
			}
		}
		if (!bait.isNull)
		{
			flag = false;
			for (int n = 0; n < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits.Count; n++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[n].ID == bait.ID)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[n].amount++;
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].bait.SetToNull();
					flag = true;
				}
			}
			if (!flag)
			{
				GameManager.PlayerData.CBaits cBaits = new GameManager.PlayerData.CBaits();
				cBaits.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].bait);
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].bait.SetToNull();
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits.Add(cBaits);
			}
		}
		if (!feeder.isNull)
		{
			flag = false;
			for (int num = 0; num < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders.Count; num++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[num].ID == feeder.ID)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[num].amount++;
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].feeder.SetToNull();
					flag = true;
				}
			}
			if (!flag)
			{
				GameManager.PlayerData.CFeeders cFeeders = new GameManager.PlayerData.CFeeders();
				cFeeders.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].feeder);
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].feeder.SetToNull();
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders.Add(cFeeders);
			}
		}
		if (!leader.isNull)
		{
			flag = false;
			for (int num2 = 0; num2 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders.Count; num2++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[num2].ID == leader.ID)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[num2].amount++;
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].leader.SetToNull();
					flag = true;
				}
			}
			if (!flag)
			{
				GameManager.PlayerData.CLeaders cLeaders = new GameManager.PlayerData.CLeaders();
				cLeaders.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].leader);
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].leader.SetToNull();
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders.Add(cLeaders);
			}
		}
		if (!weight.isNull)
		{
			flag = false;
			for (int num3 = 0; num3 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights.Count; num3++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[num3].ID == weight.ID)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[num3].amount++;
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].weight.SetToNull();
					flag = true;
				}
			}
			if (!flag)
			{
				GameManager.PlayerData.CWeights cWeights = new GameManager.PlayerData.CWeights();
				cWeights.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].weight);
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].weight.SetToNull();
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights.Add(cWeights);
			}
		}
		Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].status = GameManager.PlayerData.CSlots.Status.Empty;
		Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].method = GameManager.PlayerData.CSlots.Method.None;
	}

	private bool CheckChangecInCurrentRodSlot()
	{
		if (FScriptsHandler.Instance == null)
		{
			return false;
		}
		if (!FScriptsHandler.Instance.m_PlayerMain.currentRod)
		{
			return false;
		}
		int indexOfslot = FScriptsHandler.Instance.m_PlayerMain.currentRod.indexOfslot;
		if (indexOfslot != -1)
		{
			if (lastCurrentSlotRodUniqueId != Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].rod.uniqueId)
			{
				return true;
			}
			if (lastCurrentSlotRodWear != Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].rod.wear)
			{
				return true;
			}
			if (lastCurrentSlotReelUniqueId != Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].reel.uniqueId)
			{
				return true;
			}
			if (lastCurrentSlotReelWear != Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].reel.wear)
			{
				return true;
			}
			if (lastCurrentSlotLineUniqueId != Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].line.uniqueId)
			{
				return true;
			}
			if (lastCurrentSlotLeaderUniqueId != Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].leader.uniqueId)
			{
				return true;
			}
			if (lastCurrentSlotHookUniqueId != Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].hook.uniqueId)
			{
				return true;
			}
			if (lastCurrentSlotFloatUniqueId != Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].ffloat.uniqueId)
			{
				return true;
			}
			if (lastCurrentSlotFeederUniqueId != Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].feeder.uniqueId)
			{
				return true;
			}
			if (lastCurrentSlotBaitUniqueId != Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].bait.uniqueId)
			{
				return true;
			}
			if (lastCurrentSlotWeightUniqueId != Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[indexOfslot].weight.uniqueId)
			{
				return true;
			}
		}
		return false;
	}

	private void ShowInfoSlotBar(int indexOfSlot, string textOfInfo)
	{
		int num = slotButtons[indexOfSlot].transform.GetSiblingIndex() + 1;
		if (infoBarSlotAnim != null)
		{
			if (infoBarSlotAnim.transform.GetSiblingIndex() == num)
			{
				return;
			}
			infoBarSlotAnim.GetComponent<Animator>().SetTrigger("Hide");
			infoBarSlotAnim = null;
		}
		infoBarSlotAnim = Object.Instantiate(slotItemInfoBarPrefab, slotButtons[indexOfSlot].transform.parent);
		infoBarSlotAnim.transform.SetSiblingIndex(num);
		infoBarSlotAnim.GetComponent<SlotInfoBarScript>().infoBarText.text = textOfInfo;
	}

	public void DeleteItemConfirmYes()
	{
		if (uniqueIdItemToDelete == -1)
		{
			return;
		}
		int playerItemIndexByUniqueId = GameManager.Instance._playerData.GetPlayerItemIndexByUniqueId(itemtypeToDelete, uniqueIdItemToDelete);
		int num = 1;
		int id = 0;
		bool flag = false;
		switch (itemtypeToDelete)
		{
		case GameManager.ItemType.Rod:
			num = GameManager.Instance.GetGameItemAmount(itemtypeToDelete, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[playerItemIndexByUniqueId].ID);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[playerItemIndexByUniqueId].amount -= num;
			id = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[playerItemIndexByUniqueId].ID;
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[playerItemIndexByUniqueId].amount <= 0)
			{
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods.RemoveAt(playerItemIndexByUniqueId);
				flag = true;
			}
			break;
		case GameManager.ItemType.Reel:
			num = GameManager.Instance.GetGameItemAmount(itemtypeToDelete, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[playerItemIndexByUniqueId].ID);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[playerItemIndexByUniqueId].amount -= num;
			id = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[playerItemIndexByUniqueId].ID;
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[playerItemIndexByUniqueId].amount <= 0)
			{
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels.RemoveAt(playerItemIndexByUniqueId);
				flag = true;
			}
			break;
		case GameManager.ItemType.Line:
			num = GameManager.Instance.GetGameItemAmount(itemtypeToDelete, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[playerItemIndexByUniqueId].ID);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[playerItemIndexByUniqueId].amount -= num;
			id = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[playerItemIndexByUniqueId].ID;
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[playerItemIndexByUniqueId].amount <= 0)
			{
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines.RemoveAt(playerItemIndexByUniqueId);
				flag = true;
			}
			break;
		case GameManager.ItemType.Leader:
			num = GameManager.Instance.GetGameItemAmount(itemtypeToDelete, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[playerItemIndexByUniqueId].ID);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[playerItemIndexByUniqueId].amount -= num;
			id = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[playerItemIndexByUniqueId].ID;
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[playerItemIndexByUniqueId].amount <= 0)
			{
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders.RemoveAt(playerItemIndexByUniqueId);
				flag = true;
			}
			break;
		case GameManager.ItemType.Float:
			num = GameManager.Instance.GetGameItemAmount(itemtypeToDelete, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[playerItemIndexByUniqueId].ID);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[playerItemIndexByUniqueId].amount -= num;
			id = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[playerItemIndexByUniqueId].ID;
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[playerItemIndexByUniqueId].amount <= 0)
			{
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats.RemoveAt(playerItemIndexByUniqueId);
				flag = true;
			}
			break;
		case GameManager.ItemType.Feeder:
			num = GameManager.Instance.GetGameItemAmount(itemtypeToDelete, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[playerItemIndexByUniqueId].ID);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[playerItemIndexByUniqueId].amount -= num;
			id = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[playerItemIndexByUniqueId].ID;
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[playerItemIndexByUniqueId].amount <= 0)
			{
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders.RemoveAt(playerItemIndexByUniqueId);
				flag = true;
			}
			break;
		case GameManager.ItemType.Groundbaits:
			num = GameManager.Instance.GetGameItemAmount(itemtypeToDelete, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerGroundbaits[playerItemIndexByUniqueId].ID);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerGroundbaits[playerItemIndexByUniqueId].amount -= num;
			id = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerGroundbaits[playerItemIndexByUniqueId].ID;
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerGroundbaits[playerItemIndexByUniqueId].amount <= 0)
			{
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerGroundbaits.RemoveAt(playerItemIndexByUniqueId);
				flag = true;
			}
			break;
		case GameManager.ItemType.Hook:
			num = GameManager.Instance.GetGameItemAmount(itemtypeToDelete, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[playerItemIndexByUniqueId].ID);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[playerItemIndexByUniqueId].amount -= num;
			id = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[playerItemIndexByUniqueId].ID;
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[playerItemIndexByUniqueId].amount <= 0)
			{
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks.RemoveAt(playerItemIndexByUniqueId);
				flag = true;
			}
			break;
		case GameManager.ItemType.Weight:
			num = GameManager.Instance.GetGameItemAmount(itemtypeToDelete, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[playerItemIndexByUniqueId].ID);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[playerItemIndexByUniqueId].amount -= num;
			id = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[playerItemIndexByUniqueId].ID;
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[playerItemIndexByUniqueId].amount <= 0)
			{
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights.RemoveAt(playerItemIndexByUniqueId);
				flag = true;
			}
			break;
		case GameManager.ItemType.Accesories:
			num = GameManager.Instance.GetGameItemAmount(itemtypeToDelete, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[playerItemIndexByUniqueId].ID);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[playerItemIndexByUniqueId].amount -= num;
			id = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[playerItemIndexByUniqueId].ID;
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[playerItemIndexByUniqueId].amount <= 0)
			{
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories.RemoveAt(playerItemIndexByUniqueId);
				flag = true;
			}
			break;
		case GameManager.ItemType.Bait:
			num = GameManager.Instance.GetGameItemAmount(itemtypeToDelete, Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[playerItemIndexByUniqueId].ID);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[playerItemIndexByUniqueId].amount -= num;
			id = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[playerItemIndexByUniqueId].ID;
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[playerItemIndexByUniqueId].amount <= 0)
			{
				Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits.RemoveAt(playerItemIndexByUniqueId);
				flag = true;
			}
			break;
		}
		SlotItem[] componentsInChildren = popupItemsContent.GetComponentsInChildren<SlotItem>();
		for (int i = 0; i < componentsInChildren.Length; i++)
		{
			if (componentsInChildren[i].itemType == itemtypeToDelete && componentsInChildren[i].itemUniqueId == uniqueIdItemToDelete)
			{
				if (flag)
				{
					Object.Destroy(componentsInChildren[i].gameObject);
					Object.FindObjectOfType<EquipPopup>().RefreshSort();
				}
				else
				{
					componentsInChildren[i].Setup(itemtypeToDelete, id, uniqueIdItemToDelete);
				}
			}
		}
		uniqueIdItemToDelete = -1;
	}

	private void OnDestroy()
	{
		if (FScriptsHandler.Instance != null)
		{
			Debug.Log("Close equipment: " + CheckChangecInCurrentRodSlot());
			if (CheckChangecInCurrentRodSlot())
			{
				FScriptsHandler.Instance.m_InventoryManager.reAssignRod = true;
			}
			FScriptsHandler.Instance.m_Canvas.gameObject.SetActive(value: true);
		}
	}

	public void ChangeSetName(int id)
	{
		SetNamePopUpItem component = Object.Instantiate(setNmaePopUp, setNmaeTransform).GetComponent<SetNamePopUpItem>();
		component.SetID = id;
		component.customNameText = CustomNamesText[id - 1];
	}

	public void searchRealtime()
	{
		GameManager.TruncateContainer(popupItems);
		switch (itemsDisplayType)
		{
		case GameManager.ItemType.Bait:
		{
			if (searchInputField.text.Length < 2)
			{
				List<GameManager.PlayerData.CBaits> list13 = new List<GameManager.PlayerData.CBaits>();
				for (int num19 = 0; num19 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits.Count; num19++)
				{
					if (!list13.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[num19]))
					{
						Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[num19].amount = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[num19].amount;
						list13.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[num19]);
					}
				}
				for (int num20 = 0; num20 < list13.Count; num20++)
				{
					SlotItem component13 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
					component13.currentSlotIndex = currentSlotIndex;
					component13.bait = list13[num20];
					component13.bait.amount = list13[num20].amount;
					component13.isBaitNatural = false;
					component13.itemType = GameManager.ItemType.Bait;
					component13.deleteItemButton.gameObject.SetActive(value: true);
					if (component13.bait.amount > 1)
					{
						Text itemStatText5 = component13.itemStatText;
						itemStatText5.text = itemStatText5.text + "\nx " + list13[num20].amount;
					}
					component13.SetupItem();
				}
				break;
			}
			List<GameManager.PlayerData.CBaits> list14 = new List<GameManager.PlayerData.CBaits>();
			for (int num21 = 0; num21 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits.Count; num21++)
			{
				if (!list14.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[num21]))
				{
					list14.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[num21]);
				}
			}
			for (int num22 = 0; num22 < list14.Count; num22++)
			{
				if (GameManager.Instance.GetGameItemName(GameManager.ItemType.Bait, list14[num22].ID).ToUpper().Contains(searchInputField.text.ToUpper()))
				{
					SlotItem component14 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
					component14.currentSlotIndex = currentSlotIndex;
					component14.bait = list14[num22];
					component14.bait.amount = list14[num22].amount;
					component14.isBaitNatural = false;
					component14.itemType = GameManager.ItemType.Bait;
					component14.deleteItemButton.gameObject.SetActive(value: true);
					if (component14.bait.amount > 1)
					{
						Text itemStatText6 = component14.itemStatText;
						itemStatText6.text = itemStatText6.text + "\nx " + list14[num22].amount;
					}
					component14.SetupItem();
				}
			}
			break;
		}
		case GameManager.ItemType.Reel:
		{
			if (searchInputField.text.Length < 2)
			{
				List<GameManager.PlayerData.CReels> list11 = new List<GameManager.PlayerData.CReels>();
				for (int num15 = 0; num15 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels.Count; num15++)
				{
					if (!list11.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num15]))
					{
						Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num15].amount = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num15].amount;
						list11.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num15]);
					}
				}
				for (int num16 = 0; num16 < list11.Count; num16++)
				{
					SlotItem component11 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
					component11.currentSlotIndex = currentSlotIndex;
					component11.reel = list11[num16];
					component11.reel.amount = list11[num16].amount;
					component11.isBaitNatural = false;
					component11.itemType = GameManager.ItemType.Reel;
					component11.deleteItemButton.gameObject.SetActive(value: true);
					if (component11.reel.amount > 1)
					{
						Text itemStatText3 = component11.itemStatText;
						itemStatText3.text = itemStatText3.text + "\nx " + list11[num16].amount;
					}
					component11.SetupItem();
				}
				break;
			}
			List<GameManager.PlayerData.CReels> list12 = new List<GameManager.PlayerData.CReels>();
			for (int num17 = 0; num17 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels.Count; num17++)
			{
				if (!list12.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num17]))
				{
					list12.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num17]);
				}
			}
			for (int num18 = 0; num18 < list12.Count; num18++)
			{
				if (GameManager.Instance.GetGameItemName(GameManager.ItemType.Reel, list12[num18].ID).ToUpper().Contains(searchInputField.text.ToUpper()))
				{
					SlotItem component12 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
					component12.currentSlotIndex = currentSlotIndex;
					component12.reel = list12[num18];
					component12.reel.amount = list12[num18].amount;
					component12.isBaitNatural = false;
					component12.itemType = GameManager.ItemType.Reel;
					component12.deleteItemButton.gameObject.SetActive(value: true);
					if (component12.reel.amount > 1)
					{
						Text itemStatText4 = component12.itemStatText;
						itemStatText4.text = itemStatText4.text + "\nx " + list12[num18].amount;
					}
					component12.SetupItem();
				}
			}
			break;
		}
		case GameManager.ItemType.Weight:
		{
			if (searchInputField.text.Length < 2)
			{
				List<GameManager.PlayerData.CWeights> list17 = new List<GameManager.PlayerData.CWeights>();
				for (int num27 = 0; num27 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights.Count; num27++)
				{
					if (!list17.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[num27]))
					{
						Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[num27].amount = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[num27].amount;
						list17.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[num27]);
					}
				}
				for (int num28 = 0; num28 < list17.Count; num28++)
				{
					SlotItem component17 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
					component17.currentSlotIndex = currentSlotIndex;
					component17.weight = list17[num28];
					component17.weight.amount = list17[num28].amount;
					component17.isBaitNatural = false;
					component17.itemType = GameManager.ItemType.Weight;
					component17.deleteItemButton.gameObject.SetActive(value: true);
					component17.SetupItem();
					int gameItemIndexByItemId9 = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Weight, list17[num28].ID);
					if (component17.weight.amount > 1)
					{
						component17.itemStatText.text = GameManager.Instance.gameWeights[gameItemIndexByItemId9].weight.ToString("F0") + "g\nx " + list17[num28].amount;
					}
				}
				break;
			}
			List<GameManager.PlayerData.CWeights> list18 = new List<GameManager.PlayerData.CWeights>();
			for (int num29 = 0; num29 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights.Count; num29++)
			{
				if (!list18.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[num29]))
				{
					list18.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[num29]);
				}
			}
			for (int num30 = 0; num30 < list18.Count; num30++)
			{
				if (GameManager.Instance.GetGameItemName(GameManager.ItemType.Weight, list18[num30].ID).ToUpper().Contains(searchInputField.text.ToUpper()))
				{
					SlotItem component18 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
					component18.currentSlotIndex = currentSlotIndex;
					component18.weight = list18[num30];
					component18.weight.amount = list18[num30].amount;
					component18.isBaitNatural = false;
					component18.itemType = GameManager.ItemType.Weight;
					component18.deleteItemButton.gameObject.SetActive(value: true);
					component18.SetupItem();
					int gameItemIndexByItemId10 = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Weight, list18[num30].ID);
					if (component18.weight.amount > 1)
					{
						component18.itemStatText.text = GameManager.Instance.gameWeights[gameItemIndexByItemId10].weight.ToString("F0") + "g\nx " + list18[num30].amount;
					}
				}
			}
			break;
		}
		case GameManager.ItemType.Leader:
		{
			if (searchInputField.text.Length < 2)
			{
				List<GameManager.PlayerData.CLeaders> list9 = new List<GameManager.PlayerData.CLeaders>();
				for (int num11 = 0; num11 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders.Count; num11++)
				{
					if (!list9.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[num11]))
					{
						Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[num11].amount = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[num11].amount;
						list9.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[num11]);
					}
				}
				for (int num12 = 0; num12 < list9.Count; num12++)
				{
					SlotItem component9 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
					component9.currentSlotIndex = currentSlotIndex;
					component9.leader = list9[num12];
					component9.leader.amount = list9[num12].amount;
					component9.isBaitNatural = false;
					component9.itemType = GameManager.ItemType.Leader;
					component9.deleteItemButton.gameObject.SetActive(value: true);
					if (component9.reel.amount > 1)
					{
						Text itemStatText = component9.itemStatText;
						itemStatText.text = itemStatText.text + "\nx " + list9[num12].amount;
					}
					component9.SetupItem();
				}
				break;
			}
			List<GameManager.PlayerData.CLeaders> list10 = new List<GameManager.PlayerData.CLeaders>();
			for (int num13 = 0; num13 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders.Count; num13++)
			{
				if (!list10.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[num13]))
				{
					list10.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[num13]);
				}
			}
			for (int num14 = 0; num14 < list10.Count; num14++)
			{
				if (GameManager.Instance.GetGameItemName(GameManager.ItemType.Leader, list10[num14].ID).ToUpper().Contains(searchInputField.text.ToUpper()))
				{
					SlotItem component10 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
					component10.currentSlotIndex = currentSlotIndex;
					component10.leader = list10[num14];
					component10.leader.amount = list10[num14].amount;
					component10.isBaitNatural = false;
					component10.itemType = GameManager.ItemType.Leader;
					component10.deleteItemButton.gameObject.SetActive(value: true);
					if (component10.reel.amount > 1)
					{
						Text itemStatText2 = component10.itemStatText;
						itemStatText2.text = itemStatText2.text + "\nx " + list10[num14].amount;
					}
					component10.SetupItem();
				}
			}
			break;
		}
		case GameManager.ItemType.Line:
		{
			if (searchInputField.text.Length < 2)
			{
				List<GameManager.PlayerData.CLines> list19 = new List<GameManager.PlayerData.CLines>();
				for (int num31 = 0; num31 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines.Count; num31++)
				{
					if (!list19.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[num31]))
					{
						GameManager.PlayerData.CLines cLines = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[num31];
						cLines.amount = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[num31].amount;
						cLines.lenght = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[num31].lenght;
						list19.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[num31]);
					}
				}
				for (int num32 = 0; num32 < list19.Count; num32++)
				{
					SlotItem component19 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
					component19.currentSlotIndex = currentSlotIndex;
					component19.line = list19[num32];
					component19.line.amount = list19[num32].amount;
					component19.line.lenght = list19[num32].lenght;
					component19.isBaitNatural = false;
					component19.itemType = GameManager.ItemType.Line;
					component19.deleteItemButton.gameObject.SetActive(value: true);
					component19.SetupItem();
					int gameItemIndexByItemId11 = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Line, list19[num32].ID);
					component19.itemStatText.text = GameManager.Instance.ConvertWeight(GameManager.Instance.gameLines[gameItemIndexByItemId11].strength);
					Text itemStatText7 = component19.itemStatText;
					itemStatText7.text = itemStatText7.text + "\n" + GameManager.Instance.ConvertLenghtWithUnit(list19[num32].lenght, "F0");
				}
				break;
			}
			List<GameManager.PlayerData.CLines> list20 = new List<GameManager.PlayerData.CLines>();
			for (int num33 = 0; num33 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines.Count; num33++)
			{
				if (!list20.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[num33]))
				{
					list20.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[num33]);
				}
			}
			for (int num34 = 0; num34 < list20.Count; num34++)
			{
				if (GameManager.Instance.GetGameItemName(GameManager.ItemType.Line, list20[num34].ID).ToUpper().Contains(searchInputField.text.ToUpper()))
				{
					SlotItem component20 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
					component20.currentSlotIndex = currentSlotIndex;
					component20.line = list20[num34];
					component20.line.amount = list20[num34].amount;
					component20.line.lenght = list20[num34].lenght;
					component20.isBaitNatural = false;
					component20.itemType = GameManager.ItemType.Line;
					component20.deleteItemButton.gameObject.SetActive(value: true);
					component20.SetupItem();
					int gameItemIndexByItemId12 = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Line, list20[num34].ID);
					component20.itemStatText.text = GameManager.Instance.ConvertWeight(GameManager.Instance.gameLines[gameItemIndexByItemId12].strength);
					Text itemStatText8 = component20.itemStatText;
					itemStatText8.text = itemStatText8.text + "\n" + GameManager.Instance.ConvertLenghtWithUnit(list20[num34].lenght, "F0");
				}
			}
			break;
		}
		case GameManager.ItemType.Hook:
		{
			if (searchInputField.text.Length < 2)
			{
				List<GameManager.PlayerData.CHooks> list5 = new List<GameManager.PlayerData.CHooks>();
				for (int num3 = 0; num3 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks.Count; num3++)
				{
					if (!list5.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num3]))
					{
						Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num3].amount = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num3].amount;
						list5.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num3]);
					}
				}
				for (int num4 = 0; num4 < list5.Count; num4++)
				{
					SlotItem component5 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
					component5.currentSlotIndex = currentSlotIndex;
					component5.hook = list5[num4];
					component5.hook.amount = list5[num4].amount;
					component5.isBaitNatural = false;
					component5.itemType = GameManager.ItemType.Hook;
					component5.deleteItemButton.gameObject.SetActive(value: true);
					component5.SetupItem();
					int gameItemIndexByItemId3 = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Hook, list5[num4].ID);
					component5.itemStatText.text = GameManager.Instance.gameHooks[gameItemIndexByItemId3].GetSizetext();
				}
			}
			else
			{
				List<GameManager.PlayerData.CHooks> list6 = new List<GameManager.PlayerData.CHooks>();
				for (int num5 = 0; num5 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks.Count; num5++)
				{
					if (!list6.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num5]))
					{
						list6.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num5]);
					}
				}
				for (int num6 = 0; num6 < list6.Count; num6++)
				{
					if (GameManager.Instance.GetGameItemName(GameManager.ItemType.Hook, list6[num6].ID).ToUpper().Contains(searchInputField.text.ToUpper()))
					{
						SlotItem component6 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
						component6.currentSlotIndex = currentSlotIndex;
						component6.hook = list6[num6];
						component6.hook.amount = list6[num6].amount;
						component6.isBaitNatural = false;
						component6.itemType = GameManager.ItemType.Hook;
						component6.deleteItemButton.gameObject.SetActive(value: true);
						component6.SetupItem();
						int gameItemIndexByItemId4 = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Hook, list6[num6].ID);
						component6.itemStatText.text = GameManager.Instance.gameHooks[gameItemIndexByItemId4].GetSizetext();
					}
				}
			}
			if (!searchInputField.text.StartsWith("#") || searchInputField.text.Length < 2)
			{
				break;
			}
			if (searchInputField.text.Length < 2)
			{
				List<GameManager.PlayerData.CHooks> list7 = new List<GameManager.PlayerData.CHooks>();
				for (int num7 = 0; num7 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks.Count; num7++)
				{
					if (!list7.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num7]))
					{
						Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num7].amount = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num7].amount;
						list7.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num7]);
					}
				}
				for (int num8 = 0; num8 < list7.Count; num8++)
				{
					SlotItem component7 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
					component7.currentSlotIndex = currentSlotIndex;
					component7.hook = list7[num8];
					component7.hook.amount = list7[num8].amount;
					component7.isBaitNatural = false;
					component7.itemType = GameManager.ItemType.Hook;
					component7.deleteItemButton.gameObject.SetActive(value: true);
					component7.SetupItem();
					int gameItemIndexByItemId5 = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Hook, list7[num8].ID);
					component7.itemStatText.text = GameManager.Instance.gameHooks[gameItemIndexByItemId5].GetSizetext();
				}
				break;
			}
			List<GameManager.PlayerData.CHooks> list8 = new List<GameManager.PlayerData.CHooks>();
			for (int num9 = 0; num9 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks.Count; num9++)
			{
				if (!list8.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num9]))
				{
					list8.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[num9]);
				}
			}
			for (int num10 = 0; num10 < list8.Count; num10++)
			{
				if (GameManager.Instance.GetGameItemName(GameManager.ItemType.Hook, list8[num10].ID).ToUpper().Contains(searchInputField.text.ToUpper()))
				{
					SlotItem component8 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
					component8.currentSlotIndex = currentSlotIndex;
					component8.hook = list8[num10];
					component8.hook.amount = list8[num10].amount;
					component8.isBaitNatural = false;
					component8.itemType = GameManager.ItemType.Hook;
					component8.deleteItemButton.gameObject.SetActive(value: true);
					component8.SetupItem();
					int gameItemIndexByItemId6 = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Hook, list8[num10].ID);
					component8.itemStatText.text = GameManager.Instance.gameHooks[gameItemIndexByItemId6].GetSizetext();
				}
			}
			break;
		}
		case GameManager.ItemType.Float:
		{
			if (searchInputField.text.Length < 2)
			{
				List<GameManager.PlayerData.CFloats> list15 = new List<GameManager.PlayerData.CFloats>();
				for (int num23 = 0; num23 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats.Count; num23++)
				{
					if (!list15.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[num23]))
					{
						Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[num23].amount = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[num23].amount;
						list15.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[num23]);
					}
				}
				for (int num24 = 0; num24 < list15.Count; num24++)
				{
					SlotItem component15 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
					component15.currentSlotIndex = currentSlotIndex;
					component15.ffloat = list15[num24];
					component15.ffloat.amount = list15[num24].amount;
					component15.isBaitNatural = false;
					component15.itemType = GameManager.ItemType.Float;
					component15.deleteItemButton.gameObject.SetActive(value: true);
					component15.SetupItem();
					int gameItemIndexByItemId7 = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Float, list15[num24].ID);
					component15.itemStatText.text = GameManager.Instance.gameFloats[gameItemIndexByItemId7].displacement.ToString("F0") + "g";
				}
				break;
			}
			List<GameManager.PlayerData.CFloats> list16 = new List<GameManager.PlayerData.CFloats>();
			for (int num25 = 0; num25 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats.Count; num25++)
			{
				if (!list16.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[num25]))
				{
					list16.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[num25]);
				}
			}
			for (int num26 = 0; num26 < list16.Count; num26++)
			{
				if (GameManager.Instance.GetGameItemName(GameManager.ItemType.Float, list16[num26].ID).ToUpper().Contains(searchInputField.text.ToUpper()))
				{
					SlotItem component16 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
					component16.currentSlotIndex = currentSlotIndex;
					component16.ffloat = list16[num26];
					component16.ffloat.amount = list16[num26].amount;
					component16.isBaitNatural = false;
					component16.itemType = GameManager.ItemType.Float;
					component16.deleteItemButton.gameObject.SetActive(value: true);
					component16.SetupItem();
					int gameItemIndexByItemId8 = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Float, list16[num26].ID);
					component16.itemStatText.text = GameManager.Instance.gameFloats[gameItemIndexByItemId8].displacement.ToString("F0") + "g";
				}
			}
			break;
		}
		case GameManager.ItemType.Feeder:
		{
			if (searchInputField.text.Length < 2)
			{
				List<GameManager.PlayerData.CFeeders> list3 = new List<GameManager.PlayerData.CFeeders>();
				for (int m = 0; m < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders.Count; m++)
				{
					if (!list3.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[m]))
					{
						Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[m].amount = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[m].amount;
						list3.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[m]);
					}
				}
				for (int n = 0; n < list3.Count; n++)
				{
					SlotItem component3 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
					component3.currentSlotIndex = currentSlotIndex;
					component3.feeder = list3[n];
					component3.feeder.amount = list3[n].amount;
					component3.isBaitNatural = false;
					component3.itemType = GameManager.ItemType.Feeder;
					component3.deleteItemButton.gameObject.SetActive(value: true);
					component3.SetupItem();
					int gameItemIndexByItemId = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Feeder, list3[n].ID);
					component3.itemStatText.text = GameManager.Instance.gameFeeders[gameItemIndexByItemId].weight.ToString("F0") + "g";
				}
				break;
			}
			List<GameManager.PlayerData.CFeeders> list4 = new List<GameManager.PlayerData.CFeeders>();
			for (int num = 0; num < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders.Count; num++)
			{
				if (!list4.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[num]))
				{
					list4.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[num]);
				}
			}
			for (int num2 = 0; num2 < list4.Count; num2++)
			{
				if (GameManager.Instance.GetGameItemName(GameManager.ItemType.Feeder, list4[num2].ID).ToUpper().Contains(searchInputField.text.ToUpper()))
				{
					SlotItem component4 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
					component4.currentSlotIndex = currentSlotIndex;
					component4.feeder = list4[num2];
					component4.feeder.amount = list4[num2].amount;
					component4.isBaitNatural = false;
					component4.itemType = GameManager.ItemType.Feeder;
					component4.deleteItemButton.gameObject.SetActive(value: true);
					component4.SetupItem();
					int gameItemIndexByItemId2 = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Feeder, list4[num2].ID);
					component4.itemStatText.text = GameManager.Instance.gameFeeders[gameItemIndexByItemId2].weight.ToString("F0") + "g";
				}
			}
			break;
		}
		case GameManager.ItemType.Rod:
		{
			if (searchInputField.text.Length < 2)
			{
				List<GameManager.PlayerData.CRods> list21 = new List<GameManager.PlayerData.CRods>();
				for (int num35 = 0; num35 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods.Count; num35++)
				{
					if (!list21.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num35]))
					{
						GameManager.PlayerData.CRods cRods = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num35];
						cRods.amount = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num35].amount;
						cRods.status = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num35].status;
						list21.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num35]);
					}
				}
				for (int num36 = 0; num36 < list21.Count; num36++)
				{
					SlotItem component21 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
					component21.currentSlotIndex = currentSlotIndex;
					component21.rod = list21[num36];
					component21.rod.amount = list21[num36].amount;
					component21.isBaitNatural = false;
					component21.itemType = GameManager.ItemType.Rod;
					component21.deleteItemButton.gameObject.SetActive(value: true);
					component21.SetupItem();
					int gameItemIndexByItemId13 = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Line, list21[num36].ID);
					if (float.TryParse(GameManager.Instance.gameRods[gameItemIndexByItemId13].length.Replace(',', '.'), out var result))
					{
						component21.itemStatText.text = GameManager.Instance.ConvertLenghtWithUnit(result);
					}
					Text itemStatText9 = component21.itemStatText;
					itemStatText9.text = itemStatText9.text + "\n" + GameManager.Instance.ConvertWeight(GameManager.Instance.gameRods[gameItemIndexByItemId13].strength);
				}
				break;
			}
			List<GameManager.PlayerData.CRods> list22 = new List<GameManager.PlayerData.CRods>();
			for (int num37 = 0; num37 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods.Count; num37++)
			{
				if (!list22.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num37]))
				{
					list22.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num37]);
				}
			}
			for (int num38 = 0; num38 < list22.Count; num38++)
			{
				if (GameManager.Instance.GetGameItemName(GameManager.ItemType.Rod, list22[num38].ID).ToUpper().Contains(searchInputField.text.ToUpper()))
				{
					SlotItem component22 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
					component22.currentSlotIndex = currentSlotIndex;
					component22.rod = list22[num38];
					component22.rod.amount = list22[num38].amount;
					component22.isBaitNatural = false;
					component22.itemType = GameManager.ItemType.Rod;
					component22.deleteItemButton.gameObject.SetActive(value: true);
					component22.SetupItem();
					int gameItemIndexByItemId14 = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Line, list22[num38].ID);
					if (float.TryParse(GameManager.Instance.gameRods[gameItemIndexByItemId14].length.Replace(',', '.'), out var result2))
					{
						component22.itemStatText.text = GameManager.Instance.ConvertLenghtWithUnit(result2);
					}
					Text itemStatText10 = component22.itemStatText;
					itemStatText10.text = itemStatText10.text + "\n" + GameManager.Instance.ConvertWeight(GameManager.Instance.gameRods[gameItemIndexByItemId14].strength);
				}
			}
			break;
		}
		case GameManager.ItemType.Accesories:
		{
			if (searchInputField.text.Length < 2)
			{
				List<GameManager.PlayerData.CAccesories> list = new List<GameManager.PlayerData.CAccesories>();
				for (int i = 0; i < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories.Count; i++)
				{
					if (!list.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[i]))
					{
						Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[i].amount = Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[i].amount;
						list.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[i]);
					}
				}
				for (int j = 0; j < list.Count; j++)
				{
					SlotItem component = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
					component.isBaitNatural = false;
					component.currentSlotIndex = 0;
					component.gameItemIndex = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Accesories, list[j].ID);
					component.itemUniqueId = list[j].uniqueId;
					component.itemType = GameManager.ItemType.Accesories;
					component.deleteItemButton.gameObject.SetActive(value: true);
					component.SetupItem();
					component.itemIconImage.sprite = GameManager.Instance.gameAccesories[component.gameItemIndex].GetIconImage();
					component.itemNameText.text = GameManager.Instance.gameAccesories[component.gameItemIndex].GetName();
					component.itemStatText.text = "";
				}
				break;
			}
			List<GameManager.PlayerData.CAccesories> list2 = new List<GameManager.PlayerData.CAccesories>();
			for (int k = 0; k < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories.Count; k++)
			{
				if (!list2.Contains(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[k]))
				{
					list2.Add(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerAccessories[k]);
				}
			}
			for (int l = 0; l < list2.Count; l++)
			{
				if (GameManager.Instance.GetGameItemName(GameManager.ItemType.Accesories, list2[l].ID).ToUpper().Contains(searchInputField.text.ToUpper()))
				{
					SlotItem component2 = Object.Instantiate(slotItemPrefab, popupItems).GetComponent<SlotItem>();
					component2.isBaitNatural = false;
					component2.currentSlotIndex = 0;
					component2.gameItemIndex = GameManager.Instance._playerData.GetGameItemIndexByItemId(GameManager.ItemType.Accesories, list2[l].ID);
					component2.itemUniqueId = list2[l].uniqueId;
					component2.itemType = GameManager.ItemType.Accesories;
					component2.deleteItemButton.gameObject.SetActive(value: true);
					component2.SetupItem();
					component2.itemIconImage.sprite = GameManager.Instance.gameAccesories[component2.gameItemIndex].GetIconImage();
					component2.itemNameText.text = GameManager.Instance.gameAccesories[component2.gameItemIndex].GetName();
					component2.itemStatText.text = "";
				}
			}
			break;
		}
		}
	}

	public void OnChangeSort()
	{
		dropdownIndex = sortDropdown.value;
		SortFilter(dropdownIndex);
	}

	private void SortFilter(int indexSort)
	{
		List<SlotItem> list = new List<SlotItem>();
		list.AddRange(popupItems.GetComponentsInChildren<SlotItem>());
		if (itemsDisplayType == GameManager.ItemType.Rod || itemsDisplayType == GameManager.ItemType.Reel || itemsDisplayType == GameManager.ItemType.Line || itemsDisplayType == GameManager.ItemType.Leader)
		{
			switch (indexSort)
			{
			case 0:
				popupItemsContent.GetComponent<EquipPopup>().RefreshSort();
				return;
			case 1:
				list.Sort(CompareListByLevel);
				break;
			case 2:
				list.Sort(CompareListByName);
				break;
			case 3:
				list.Sort(CompareListByStrength);
				break;
			}
		}
		else
		{
			switch (indexSort)
			{
			case 0:
				popupItemsContent.GetComponent<EquipPopup>().RefreshSort();
				return;
			case 1:
				list.Sort(CompareListByLevel);
				break;
			case 2:
				list.Sort(CompareListByName);
				break;
			}
		}
		for (int i = 0; i < list.Count; i++)
		{
			list[i].transform.SetSiblingIndex(i);
		}
	}

	private int CompareListByName(SlotItem i1, SlotItem i2)
	{
		return i1.itemNameText.text.CompareTo(i2.itemNameText.text);
	}

	private int CompareListByStrength(SlotItem i1, SlotItem i2)
	{
		return itemsDisplayType switch
		{
			GameManager.ItemType.Rod => GameManager.Instance.gameRods[i1.gameItemIndex].strength.CompareTo(GameManager.Instance.gameRods[i2.gameItemIndex].strength), 
			GameManager.ItemType.Reel => GameManager.Instance.gameReels[i1.gameItemIndex].strength.CompareTo(GameManager.Instance.gameReels[i2.gameItemIndex].strength), 
			GameManager.ItemType.Line => GameManager.Instance.gameLines[i1.gameItemIndex].strength.CompareTo(GameManager.Instance.gameLines[i2.gameItemIndex].strength), 
			GameManager.ItemType.Leader => GameManager.Instance.gameLeaders[i1.gameItemIndex].strength.CompareTo(GameManager.Instance.gameLeaders[i2.gameItemIndex].strength), 
			_ => 0, 
		};
	}

	private int CompareListByLevel(SlotItem i1, SlotItem i2)
	{
		return itemsDisplayType switch
		{
			GameManager.ItemType.Bait => GameManager.Instance.gameBaits[i1.gameItemIndex].Level.CompareTo(GameManager.Instance.gameBaits[i2.gameItemIndex].Level), 
			GameManager.ItemType.Reel => GameManager.Instance.gameReels[i1.gameItemIndex].Level.CompareTo(GameManager.Instance.gameReels[i2.gameItemIndex].Level), 
			GameManager.ItemType.Rod => GameManager.Instance.gameRods[i1.gameItemIndex].Level.CompareTo(GameManager.Instance.gameRods[i2.gameItemIndex].Level), 
			GameManager.ItemType.Line => GameManager.Instance.gameLines[i1.gameItemIndex].Level.CompareTo(GameManager.Instance.gameLines[i2.gameItemIndex].Level), 
			GameManager.ItemType.Weight => GameManager.Instance.gameWeights[i1.gameItemIndex].Level.CompareTo(GameManager.Instance.gameWeights[i2.gameItemIndex].Level), 
			GameManager.ItemType.Leader => GameManager.Instance.gameLeaders[i1.gameItemIndex].Level.CompareTo(GameManager.Instance.gameLeaders[i2.gameItemIndex].Level), 
			GameManager.ItemType.Hook => GameManager.Instance.gameHooks[i1.gameItemIndex].Level.CompareTo(GameManager.Instance.gameHooks[i2.gameItemIndex].Level), 
			GameManager.ItemType.Feeder => GameManager.Instance.gameFeeders[i1.gameItemIndex].Level.CompareTo(GameManager.Instance.gameFeeders[i2.gameItemIndex].Level), 
			GameManager.ItemType.Float => GameManager.Instance.gameFloats[i1.gameItemIndex].Level.CompareTo(GameManager.Instance.gameFloats[i2.gameItemIndex].Level), 
			GameManager.ItemType.Accesories => GameManager.Instance.gameAccesories[i1.gameItemIndex].Level.CompareTo(GameManager.Instance.gameAccesories[i2.gameItemIndex].Level), 
			_ => -1, 
		};
	}

	public void BuildDropDown()
	{
		dropDownOptions.Clear();
		sortDropdown.ClearOptions();
		Dropdown.OptionData optionData = new Dropdown.OptionData();
		optionData.text = LanguageManager.Instance.GetText("SORT_BY_DATE");
		Dropdown.OptionData optionData2 = new Dropdown.OptionData();
		optionData2.text = LanguageManager.Instance.GetText("SORT_BY_LEVEL");
		Dropdown.OptionData optionData3 = new Dropdown.OptionData();
		optionData3.text = LanguageManager.Instance.GetText("SORT_BY_NAME");
		dropDownOptions.Add(optionData);
		dropDownOptions.Add(optionData2);
		dropDownOptions.Add(optionData3);
		sortDropdown.AddOptions(dropDownOptions);
	}
}