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

public class SlotItem : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler, IPointerClickHandler
{
	public Image itemIconImage;

	public Text itemNameText;

	public Text itemStatText;

	public Text itemStatusText;

	public Image addIconImage;

	public Image damageSignImage;

	public Image bgHoverImage;

	public Image hoverProgress;

	public Image damageImage;

	public GameObject UnequipImage;

	public GameObject UnequipImageGamePad;

	public Button deleteItemButton;

	[SerializeField]
	private bool isHovered;

	public GameManager.ItemType itemType;

	public GameManager.GameBaits.Type baitType = GameManager.GameBaits.Type.Spinning;

	public bool isBaitNatural;

	public bool isEmpty = true;

	public int itemUniqueId = -1;

	public int currentSlotIndex;

	public int gameItemIndex = -1;

	public Color equipedColor = Color.white;

	public Color selectedColor = Color.white;

	public AudioSource hoverAudioSource;

	public GameManager.PlayerData.CRods rod;

	public GameManager.PlayerData.CReels reel;

	public GameManager.PlayerData.CBaits bait;

	public GameManager.PlayerData.CLines line;

	public GameManager.PlayerData.CLeaders leader;

	public GameManager.PlayerData.CHooks hook;

	public GameManager.PlayerData.CFeeders feeder;

	public GameManager.PlayerData.CFloats ffloat;

	public GameManager.PlayerData.CWeights weight;

	public Sprite[] itemTypeSprite;

	private float timePressed;

	private bool isPressed;

	private void Start()
	{
		bgHoverImage.enabled = false;
		switch (itemType)
		{
		case GameManager.ItemType.Rod:
			GetComponent<Image>().sprite = itemTypeSprite[0];
			break;
		case GameManager.ItemType.Reel:
			GetComponent<Image>().sprite = itemTypeSprite[1];
			break;
		case GameManager.ItemType.Line:
			GetComponent<Image>().sprite = itemTypeSprite[2];
			break;
		case GameManager.ItemType.Float:
			GetComponent<Image>().sprite = itemTypeSprite[3];
			break;
		case GameManager.ItemType.Hook:
			GetComponent<Image>().sprite = itemTypeSprite[4];
			break;
		case GameManager.ItemType.Bait:
			if (isBaitNatural)
			{
				GetComponent<Image>().sprite = itemTypeSprite[5];
			}
			else
			{
				GetComponent<Image>().sprite = itemTypeSprite[6];
			}
			break;
		case GameManager.ItemType.Feeder:
			GetComponent<Image>().sprite = itemTypeSprite[11];
			break;
		case GameManager.ItemType.Weight:
			GetComponent<Image>().sprite = itemTypeSprite[8];
			break;
		case GameManager.ItemType.Leader:
			GetComponent<Image>().sprite = itemTypeSprite[9];
			break;
		case GameManager.ItemType.Accesories:
			GetComponent<Image>().sprite = itemTypeSprite[9];
			break;
		}
	}

	private void Update()
	{
		if (Input.GetMouseButtonDown(1))
		{
			isPressed = true;
		}
		if (Input.GetMouseButtonUp(1))
		{
			isPressed = false;
		}
		timePressed = (isPressed ? (timePressed + Time.unscaledDeltaTime) : 0f);
		if (isHovered)
		{
			if (GameManager.Instance.player.GetButtonTimePressed("cameraThirdPersonChangeSide") > 0.0)
			{
				timePressed = (float)GameManager.Instance.player.GetButtonTimePressed("cameraThirdPersonChangeSide");
			}
			if (itemUniqueId != -1)
			{
				hoverProgress.fillAmount = timePressed;
			}
		}
		if (hoverProgress.fillAmount == 1f)
		{
			UnEquipButton();
			Debug.Log("Unequip");
		}
	}

	public void SetupItem()
	{
		damageSignImage.gameObject.SetActive(value: false);
		damageImage.gameObject.SetActive(value: false);
		itemStatusText.gameObject.SetActive(value: false);
		int num = 0;
		switch (itemType)
		{
		case GameManager.ItemType.Rod:
		{
			if (rod.isNull)
			{
				isEmpty = true;
				addIconImage.enabled = true;
				itemIconImage.enabled = false;
				itemNameText.text = "";
				itemStatText.text = LanguageManager.Instance.GetText("CHOOSE").ToUpper();
				itemUniqueId = -1;
				break;
			}
			num = GameManager.Instance._playerData.GetGameItemIndexByItemId(itemType, rod.ID);
			itemIconImage.sprite = GameManager.Instance.gameRods[num].GetIconImage();
			itemNameText.text = GameManager.Instance.gameRods[num].name;
			if (float.TryParse(GameManager.Instance.gameRods[num].length.Replace(',', '.'), out var result))
			{
				itemStatText.text = GameManager.Instance.ConvertLenghtWithUnit(result);
			}
			Text text = itemStatText;
			text.text = text.text + "\n" + GameManager.Instance.ConvertWeight(GameManager.Instance.gameRods[num].strength);
			if (rod.wear == 0)
			{
				damageSignImage.gameObject.SetActive(value: true);
				damageImage.gameObject.SetActive(value: true);
			}
			else
			{
				damageSignImage.gameObject.SetActive(value: false);
				damageImage.gameObject.SetActive(value: false);
			}
			itemUniqueId = rod.uniqueId;
			gameItemIndex = num;
			Debug.Log("Rod:" + rod.ID + " wear: " + rod.wear);
			break;
		}
		case GameManager.ItemType.Reel:
			if (reel.isNull)
			{
				isEmpty = true;
				addIconImage.enabled = true;
				itemIconImage.enabled = false;
				itemNameText.text = "";
				itemStatText.text = LanguageManager.Instance.GetText("CHOOSE").ToUpper();
				itemUniqueId = -1;
				break;
			}
			num = GameManager.Instance._playerData.GetGameItemIndexByItemId(itemType, reel.ID);
			itemIconImage.sprite = GameManager.Instance.gameReels[num].GetIconImage();
			itemNameText.text = GameManager.Instance.gameReels[num].name;
			itemStatText.text = GameManager.Instance.ConvertWeight(GameManager.Instance.gameReels[num].strength);
			if (reel.wear == 0)
			{
				damageSignImage.gameObject.SetActive(value: true);
				damageImage.gameObject.SetActive(value: true);
			}
			else
			{
				damageSignImage.gameObject.SetActive(value: false);
				damageImage.gameObject.SetActive(value: false);
			}
			itemUniqueId = reel.uniqueId;
			gameItemIndex = num;
			break;
		case GameManager.ItemType.Line:
			if (line.isNull)
			{
				isEmpty = true;
				addIconImage.enabled = true;
				itemIconImage.enabled = false;
				itemNameText.text = "";
				itemStatText.text = LanguageManager.Instance.GetText("CHOOSE").ToUpper();
				itemUniqueId = -1;
			}
			else
			{
				num = GameManager.Instance._playerData.GetGameItemIndexByItemId(itemType, line.ID);
				itemIconImage.sprite = GameManager.Instance.gameLines[num].GetIconImage();
				itemNameText.text = GameManager.Instance.gameLines[num].name;
				itemStatText.text = GameManager.Instance.ConvertWeight(GameManager.Instance.gameLines[num].strength);
				Text text2 = itemStatText;
				text2.text = text2.text + "\n" + GameManager.Instance.ConvertLenghtWithUnit(line.lenght, "F0");
				itemUniqueId = line.uniqueId;
				gameItemIndex = num;
			}
			break;
		case GameManager.ItemType.Float:
			if (ffloat.isNull)
			{
				isEmpty = true;
				addIconImage.enabled = true;
				itemIconImage.enabled = false;
				itemNameText.text = "";
				itemStatText.text = LanguageManager.Instance.GetText("CHOOSE").ToUpper();
				itemUniqueId = -1;
			}
			else
			{
				num = GameManager.Instance._playerData.GetGameItemIndexByItemId(itemType, ffloat.ID);
				itemIconImage.sprite = GameManager.Instance.gameFloats[num].GetIconImage();
				itemNameText.text = GameManager.Instance.gameFloats[num].name;
				itemStatText.text = GameManager.Instance.ConvertWeightGramWithOz(GameManager.Instance.gameFloats[num].displacement);
				itemUniqueId = ffloat.uniqueId;
				gameItemIndex = num;
			}
			break;
		case GameManager.ItemType.Hook:
			if (hook.isNull)
			{
				isEmpty = true;
				addIconImage.enabled = true;
				itemIconImage.enabled = false;
				itemNameText.text = "";
				itemStatText.text = LanguageManager.Instance.GetText("CHOOSE").ToUpper();
				itemUniqueId = -1;
			}
			else
			{
				num = GameManager.Instance._playerData.GetGameItemIndexByItemId(itemType, hook.ID);
				itemIconImage.sprite = GameManager.Instance.gameHooks[num].GetIconImage();
				itemNameText.text = GameManager.Instance.gameHooks[num].GetName();
				itemStatText.text = GameManager.Instance.gameHooks[num].GetSizetext();
				itemUniqueId = hook.uniqueId;
				gameItemIndex = num;
			}
			break;
		case GameManager.ItemType.Bait:
			if (bait.isNull)
			{
				isEmpty = true;
				addIconImage.enabled = true;
				itemIconImage.enabled = false;
				itemNameText.text = "";
				itemStatText.text = LanguageManager.Instance.GetText("CHOOSE").ToUpper();
				itemUniqueId = -1;
				break;
			}
			baitType = GameManager.Instance.gameBaits[GameManager.Instance.GetIndexByItemId(GameManager.ItemType.Bait, bait.ID)].type;
			num = GameManager.Instance._playerData.GetGameItemIndexByItemId(itemType, bait.ID);
			itemIconImage.sprite = GameManager.Instance.gameBaits[num].GetIconImage();
			itemNameText.text = GameManager.Instance.gameBaits[num].GetName();
			if (GameManager.Instance.gameBaits[num].type == GameManager.GameBaits.Type.Spinning)
			{
				itemStatText.text = GameManager.Instance.gameBaits[num].weight + " g";
			}
			itemUniqueId = bait.uniqueId;
			gameItemIndex = num;
			break;
		case GameManager.ItemType.Feeder:
			if (feeder.isNull)
			{
				isEmpty = true;
				addIconImage.enabled = true;
				itemIconImage.enabled = false;
				itemNameText.text = "";
				itemStatText.text = LanguageManager.Instance.GetText("CHOOSE").ToUpper();
				itemUniqueId = -1;
			}
			else
			{
				num = GameManager.Instance._playerData.GetGameItemIndexByItemId(itemType, feeder.ID);
				itemIconImage.sprite = GameManager.Instance.gameFeeders[num].GetIconImage();
				itemNameText.text = GameManager.Instance.gameFeeders[num].name;
				itemStatText.text = GameManager.Instance.ConvertWeightGramWithOz(GameManager.Instance.gameFeeders[num].weight);
				itemUniqueId = feeder.uniqueId;
				gameItemIndex = num;
			}
			break;
		case GameManager.ItemType.Leader:
			if (leader.isNull)
			{
				isEmpty = true;
				addIconImage.enabled = true;
				itemIconImage.enabled = false;
				itemNameText.text = "";
				itemStatText.text = LanguageManager.Instance.GetText("CHOOSE").ToUpper();
				itemUniqueId = -1;
			}
			else
			{
				num = GameManager.Instance._playerData.GetGameItemIndexByItemId(itemType, leader.ID);
				itemIconImage.sprite = GameManager.Instance.gameLeaders[num].GetIconImage();
				itemNameText.text = GameManager.Instance.gameLeaders[num].GetName();
				itemStatText.text = GameManager.Instance.ConvertWeight(GameManager.Instance.gameLeaders[num].strength);
				itemUniqueId = leader.uniqueId;
				gameItemIndex = num;
			}
			break;
		case GameManager.ItemType.Weight:
			if (weight.isNull)
			{
				isEmpty = true;
				addIconImage.enabled = true;
				itemIconImage.enabled = false;
				itemNameText.text = "";
				itemStatText.text = LanguageManager.Instance.GetText("CHOOSE").ToUpper();
				itemUniqueId = -1;
			}
			else
			{
				num = GameManager.Instance._playerData.GetGameItemIndexByItemId(itemType, weight.ID);
				itemIconImage.sprite = GameManager.Instance.gameWeights[num].GetIconImage();
				itemNameText.text = GameManager.Instance.gameWeights[num].GetName();
				itemStatText.text = GameManager.Instance.ConvertWeightGramWithOz(GameManager.Instance.gameWeights[num].weight);
				itemUniqueId = weight.uniqueId;
				gameItemIndex = num;
			}
			break;
		case GameManager.ItemType.Accesories:
			itemIconImage.sprite = GameManager.Instance.gameAccesories[num].GetIconImage();
			itemNameText.text = GameManager.Instance.gameAccesories[num].GetName();
			itemStatText.text = "";
			break;
		}
	}

	public void Setup(GameManager.ItemType itemType, int id, int uniqueId, bool isEmpty = false, bool isEquiped = false)
	{
		damageSignImage.gameObject.SetActive(value: false);
		damageImage.gameObject.SetActive(value: false);
		itemStatusText.gameObject.SetActive(value: false);
		if (isEmpty)
		{
			isEmpty = true;
			addIconImage.enabled = true;
			itemIconImage.enabled = false;
			itemNameText.text = "";
			itemStatText.text = LanguageManager.Instance.GetText("CHOOSE").ToUpper();
			return;
		}
		int gameItemIndexByItemId = GameManager.Instance._playerData.GetGameItemIndexByItemId(itemType, id);
		int index = 0;
		if (!isEquiped)
		{
			index = GameManager.Instance._playerData.GetPlayerItemIndexByUniqueId(itemType, uniqueId);
		}
		Debug.Log(itemType.ToString() + " id: " + id + " playerItemIndex: " + index + " currentSlotIndex:" + currentSlotIndex);
		itemUniqueId = uniqueId;
		gameItemIndex = gameItemIndexByItemId;
		switch (itemType)
		{
		case GameManager.ItemType.Rod:
		{
			itemIconImage.sprite = GameManager.Instance.gameRods[gameItemIndexByItemId].GetIconImage();
			itemNameText.text = GameManager.Instance.gameRods[gameItemIndexByItemId].name;
			if (float.TryParse(GameManager.Instance.gameRods[gameItemIndexByItemId].length.Replace(',', '.'), out var result))
			{
				itemStatText.text = GameManager.Instance.ConvertLenghtWithUnit(result);
			}
			Text text6 = itemStatText;
			text6.text = text6.text + "\n" + GameManager.Instance.ConvertWeight(GameManager.Instance.gameRods[gameItemIndexByItemId].strength);
			if (!isEquiped)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[index].amount > 1)
				{
					Text text7 = itemStatText;
					text7.text = text7.text + "\nx " + Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[index].amount;
				}
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[index].wear == 0)
				{
					damageSignImage.gameObject.SetActive(value: true);
					damageImage.gameObject.SetActive(value: true);
				}
				else
				{
					damageSignImage.gameObject.SetActive(value: false);
					damageImage.gameObject.SetActive(value: false);
				}
			}
			else if (rod.wear == 0)
			{
				damageSignImage.gameObject.SetActive(value: true);
				damageImage.gameObject.SetActive(value: true);
			}
			else
			{
				damageSignImage.gameObject.SetActive(value: false);
				damageImage.gameObject.SetActive(value: false);
			}
			break;
		}
		case GameManager.ItemType.Reel:
			itemIconImage.sprite = GameManager.Instance.gameReels[gameItemIndexByItemId].GetIconImage();
			itemNameText.text = GameManager.Instance.gameReels[gameItemIndexByItemId].name;
			itemStatText.text = GameManager.Instance.ConvertWeight(GameManager.Instance.gameReels[gameItemIndexByItemId].strength);
			if (!isEquiped)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[index].amount > 1)
				{
					Text text10 = itemStatText;
					text10.text = text10.text + "\nx " + Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[index].amount;
				}
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[index].wear == 0)
				{
					damageSignImage.gameObject.SetActive(value: true);
					damageImage.gameObject.SetActive(value: true);
				}
				else
				{
					damageSignImage.gameObject.SetActive(value: false);
					damageImage.gameObject.SetActive(value: false);
				}
			}
			else if (reel.wear == 0)
			{
				damageSignImage.gameObject.SetActive(value: true);
				damageImage.gameObject.SetActive(value: true);
			}
			else
			{
				damageSignImage.gameObject.SetActive(value: false);
				damageImage.gameObject.SetActive(value: false);
			}
			break;
		case GameManager.ItemType.Line:
			itemIconImage.sprite = GameManager.Instance.gameLines[gameItemIndexByItemId].GetIconImage();
			itemNameText.text = GameManager.Instance.gameLines[gameItemIndexByItemId].name;
			itemStatText.text = GameManager.Instance.ConvertWeight(GameManager.Instance.gameLines[gameItemIndexByItemId].strength);
			if (!isEquiped)
			{
				Text text3 = itemStatText;
				text3.text = text3.text + "\n" + GameManager.Instance.ConvertLenghtWithUnit(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[index].lenght, "F0");
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[index].amount > 1)
				{
					Text text4 = itemStatText;
					text4.text = text4.text + " / x " + Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[index].amount;
				}
			}
			break;
		case GameManager.ItemType.Float:
			itemIconImage.sprite = GameManager.Instance.gameFloats[gameItemIndexByItemId].GetIconImage();
			itemNameText.text = GameManager.Instance.gameFloats[gameItemIndexByItemId].name;
			itemStatText.text = GameManager.Instance.ConvertWeightGramWithOz(GameManager.Instance.gameFloats[gameItemIndexByItemId].displacement);
			if (!isEquiped && Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[index].amount > 1)
			{
				Text text8 = itemStatText;
				text8.text = text8.text + "\nx " + Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[index].amount;
			}
			break;
		case GameManager.ItemType.Hook:
			itemIconImage.sprite = GameManager.Instance.gameHooks[gameItemIndexByItemId].GetIconImage();
			itemNameText.text = GameManager.Instance.gameHooks[gameItemIndexByItemId].GetName();
			itemStatText.text = GameManager.Instance.gameHooks[gameItemIndexByItemId].GetSizetext();
			if (!isEquiped && Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[index].amount > 1)
			{
				Text text11 = itemStatText;
				text11.text = text11.text + "\nx " + Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[index].amount;
			}
			break;
		case GameManager.ItemType.Bait:
			itemIconImage.sprite = GameManager.Instance.gameBaits[gameItemIndexByItemId].GetIconImage();
			itemNameText.text = GameManager.Instance.gameBaits[gameItemIndexByItemId].GetName();
			if (GameManager.Instance.gameBaits[gameItemIndexByItemId].type == GameManager.GameBaits.Type.Spinning)
			{
				itemStatText.text = GameManager.Instance.gameBaits[gameItemIndexByItemId].weight + " g";
			}
			if (!isEquiped && Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[index].amount > 1)
			{
				Text text2 = itemStatText;
				text2.text = text2.text + "\nx " + Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[index].amount;
			}
			break;
		case GameManager.ItemType.Feeder:
			itemIconImage.sprite = GameManager.Instance.gameFeeders[gameItemIndexByItemId].GetIconImage();
			itemNameText.text = GameManager.Instance.gameFeeders[gameItemIndexByItemId].name;
			itemStatText.text = GameManager.Instance.gameFeeders[gameItemIndexByItemId].weight + " g";
			if (!isEquiped && Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[index].amount > 1)
			{
				Text text9 = itemStatText;
				text9.text = text9.text + "\nx " + Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[index].amount;
			}
			break;
		case GameManager.ItemType.Leader:
			itemIconImage.sprite = GameManager.Instance.gameLeaders[gameItemIndexByItemId].GetIconImage();
			itemNameText.text = GameManager.Instance.gameLeaders[gameItemIndexByItemId].GetName();
			itemStatText.text = GameManager.Instance.ConvertWeight(GameManager.Instance.gameLeaders[gameItemIndexByItemId].strength);
			if (!isEquiped && Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[index].amount > 1)
			{
				Text text5 = itemStatText;
				text5.text = text5.text + "\nx " + Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[index].amount;
			}
			break;
		case GameManager.ItemType.Weight:
			itemIconImage.sprite = GameManager.Instance.gameWeights[gameItemIndexByItemId].GetIconImage();
			itemNameText.text = GameManager.Instance.gameWeights[gameItemIndexByItemId].GetName();
			itemStatText.text = GameManager.Instance.gameWeights[gameItemIndexByItemId].weight + " g";
			if (!isEquiped && Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[index].amount > 1)
			{
				Text text = itemStatText;
				text.text = text.text + "\nx " + Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[index].amount;
			}
			break;
		case GameManager.ItemType.Accesories:
			itemIconImage.sprite = GameManager.Instance.gameAccesories[gameItemIndexByItemId].GetIconImage();
			itemNameText.text = GameManager.Instance.gameAccesories[gameItemIndexByItemId].GetName();
			itemStatText.text = "";
			break;
		}
	}

	public void ShowInPopup()
	{
		if (itemType != GameManager.ItemType.Accesories)
		{
			if (!Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].rod.isNull && (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].rod.status == GameManager.PlayerData.CRods.Status.InOut || Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[currentSlotIndex].rod.status == GameManager.PlayerData.CRods.Status.InUse))
			{
				return;
			}
			if (Object.FindObjectOfType<EquipmentManager>().viewMode == EquipmentManager.ViewMode.Normal)
			{
				Object.FindObjectOfType<EquipmentManager>().ShowHidePopupContent(visable: true, itemType, itemUniqueId);
				Object.FindObjectOfType<EquipmentManager>().itemsDisplayType = itemType;
				if (itemType == GameManager.ItemType.Rod || itemType == GameManager.ItemType.Reel || itemType == GameManager.ItemType.Line || itemType == GameManager.ItemType.Leader)
				{
					Object.FindObjectOfType<EquipmentManager>().BuildDropDown();
					Dropdown.OptionData optionData = new Dropdown.OptionData();
					optionData.text = LanguageManager.Instance.GetText("SORT_BY_STRENGTH");
					List<Dropdown.OptionData> list = new List<Dropdown.OptionData>();
					list.Add(optionData);
					Object.FindObjectOfType<EquipmentManager>().sortDropdown.AddOptions(list);
				}
				else
				{
					Object.FindObjectOfType<EquipmentManager>().BuildDropDown();
				}
			}
			if (Object.FindObjectOfType<EquipmentManager>().viewMode == EquipmentManager.ViewMode.Popup)
			{
				Object.FindObjectOfType<EquipPopup>().SelectItem(itemUniqueId, this);
			}
		}
		else
		{
			Object.FindObjectOfType<EquipPopup>().SelectItemAccesory(itemUniqueId, this);
		}
	}

	public void SetColorItem(Color newColor)
	{
		GetComponent<Image>().color = newColor;
	}

	public void OnPointerEnter(PointerEventData pointerEventData)
	{
		if (!Object.FindObjectOfType<EquipPopup>())
		{
			if ((bool)FScriptsHandler.Instance)
			{
				FRod currentRod = FScriptsHandler.Instance.m_PlayerMain.currentRod;
				if ((bool)currentRod && currentRod.isRodCast)
				{
					Object.FindObjectOfType<EquipmentManager>().CreateItemsStatsEquiped(itemType, gameItemIndex);
					bgHoverImage.enabled = true;
					return;
				}
			}
			if (GameManager.Instance.controllerType == GameManager.ControllerType.GamePad)
			{
				UnequipImage.gameObject.SetActive(value: false);
				UnequipImageGamePad.gameObject.SetActive(value: true);
			}
			else
			{
				UnequipImage.gameObject.SetActive(value: true);
				UnequipImageGamePad.gameObject.SetActive(value: false);
			}
			isHovered = true;
			hoverProgress.fillAmount = 0f;
		}
		Object.FindObjectOfType<EquipmentManager>().CreateItemsStatsEquiped(itemType, gameItemIndex);
		bgHoverImage.enabled = true;
	}

	public void DeleteItem()
	{
		EquipmentManager equipmentManager = Object.FindObjectOfType<EquipmentManager>();
		equipmentManager.itemtypeToDelete = itemType;
		equipmentManager.uniqueIdItemToDelete = itemUniqueId;
		Debug.Log("Delete item uid:" + itemUniqueId);
		GameManager.Instance.CreateMessageBox("DELETE_PLAYER_ITEM_QUESTION", equipmentManager.GetComponent<Canvas>().transform, 9);
	}

	public void OnPointerExit(PointerEventData pointerEventData)
	{
		if (!Object.FindObjectOfType<EquipPopup>())
		{
			UnequipImage.gameObject.SetActive(value: false);
			UnequipImageGamePad.gameObject.SetActive(value: false);
			isHovered = false;
			hoverProgress.fillAmount = 0f;
		}
		GameManager.TruncateContainer(Object.FindObjectOfType<EquipmentManager>().infoSlotContainer);
		Object.FindObjectOfType<EquipmentManager>().brandLogoImage.enabled = false;
		bgHoverImage.enabled = false;
	}

	public void OnPointerClick(PointerEventData pointerEventData)
	{
		EquipPopup equipPopup = Object.FindObjectOfType<EquipPopup>();
		if ((bool)equipPopup && pointerEventData.clickCount == 2)
		{
			if (equipPopup.equipButton.activeSelf)
			{
				equipPopup.Equip();
			}
			else
			{
				GameManager.Instance.ShowMessagePopup(LanguageManager.Instance.GetText("CANT_EQUIP_ITEM"), Object.FindObjectOfType<EquipmentManager>().GetComponent<Canvas>().transform);
			}
		}
	}

	public void UnEquipButton()
	{
		EquipmentManager equipmentManager = Object.FindObjectOfType<EquipmentManager>();
		UnEquip(itemType);
		if (itemType == GameManager.ItemType.Rod)
		{
			UnEquip(GameManager.ItemType.Reel);
			UnEquip(GameManager.ItemType.Float);
			UnEquip(GameManager.ItemType.Feeder);
			UnEquip(GameManager.ItemType.Weight);
			UnEquip(GameManager.ItemType.Hook);
			UnEquip(GameManager.ItemType.Line);
			UnEquip(GameManager.ItemType.Bait);
			UnEquip(GameManager.ItemType.Leader);
		}
		else if (itemType == GameManager.ItemType.Reel)
		{
			UnEquip(GameManager.ItemType.Float);
			UnEquip(GameManager.ItemType.Feeder);
			UnEquip(GameManager.ItemType.Weight);
			UnEquip(GameManager.ItemType.Hook);
			UnEquip(GameManager.ItemType.Line);
			UnEquip(GameManager.ItemType.Bait);
			UnEquip(GameManager.ItemType.Leader);
		}
		else if (itemType == GameManager.ItemType.Line)
		{
			UnEquip(GameManager.ItemType.Leader);
			UnEquip(GameManager.ItemType.Bait);
			UnEquip(GameManager.ItemType.Feeder);
			UnEquip(GameManager.ItemType.Hook);
			UnEquip(GameManager.ItemType.Weight);
			UnEquip(GameManager.ItemType.Float);
		}
		equipmentManager.ShowRefreshItems();
	}

	private void UnEquip(GameManager.ItemType itemTypeS)
	{
		EquipmentManager equipmentManager = Object.FindObjectOfType<EquipmentManager>();
		switch (itemTypeS)
		{
		case GameManager.ItemType.Rod:
		{
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].rod.isNull)
			{
				break;
			}
			for (int num = 0; num < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods.Count; num++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num].ID == Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].rod.ID && Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num].wear == Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].rod.wear)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].rod.SetToNull();
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods[num].amount++;
					return;
				}
			}
			GameManager.PlayerData.CRods cRods = new GameManager.PlayerData.CRods();
			cRods.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].rod);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerRods.Add(cRods);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].rod.SetToNull();
			break;
		}
		case GameManager.ItemType.Reel:
		{
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].reel.isNull)
			{
				break;
			}
			for (int num2 = 0; num2 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels.Count; num2++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num2].ID == Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].reel.ID && Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num2].wear == Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].reel.wear)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].reel.SetToNull();
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels[num2].amount++;
					return;
				}
			}
			GameManager.PlayerData.CReels cReels = new GameManager.PlayerData.CReels();
			cReels.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].reel);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerReels.Add(cReels);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].reel.SetToNull();
			break;
		}
		case GameManager.ItemType.Line:
		{
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].line.isNull)
			{
				break;
			}
			for (int l = 0; l < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines.Count; l++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[l].ID == Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].line.ID && Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[l].lenght == Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].line.lenght)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].line.SetToNull();
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines[l].amount++;
					return;
				}
			}
			GameManager.PlayerData.CLines cLines = new GameManager.PlayerData.CLines();
			cLines.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].line);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLines.Add(cLines);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].line.SetToNull();
			break;
		}
		case GameManager.ItemType.Float:
		{
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].ffloat.isNull)
			{
				break;
			}
			for (int j = 0; j < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats.Count; j++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[j].ID == Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].ffloat.ID)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].ffloat.SetToNull();
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats[j].amount++;
					return;
				}
			}
			GameManager.PlayerData.CFloats cFloats = new GameManager.PlayerData.CFloats();
			cFloats.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].ffloat);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFloats.Add(cFloats);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].ffloat.SetToNull();
			break;
		}
		case GameManager.ItemType.Hook:
		{
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].hook.isNull)
			{
				break;
			}
			for (int k = 0; k < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks.Count; k++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[k].ID == Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].hook.ID)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].hook.SetToNull();
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks[k].amount++;
					return;
				}
			}
			GameManager.PlayerData.CHooks cHooks = new GameManager.PlayerData.CHooks();
			cHooks.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].hook);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerHooks.Add(cHooks);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].hook.SetToNull();
			break;
		}
		case GameManager.ItemType.Bait:
		{
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].bait.isNull)
			{
				break;
			}
			for (int n = 0; n < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits.Count; n++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[n].ID == Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].bait.ID)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].bait.SetToNull();
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits[n].amount++;
					return;
				}
			}
			GameManager.PlayerData.CBaits cBaits = new GameManager.PlayerData.CBaits();
			cBaits.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].bait);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerBaits.Add(cBaits);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].bait.SetToNull();
			Debug.Log("UnEquip bait " + Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].bait.isNull);
			break;
		}
		case GameManager.ItemType.Feeder:
		{
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].feeder.isNull)
			{
				break;
			}
			for (int num3 = 0; num3 < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders.Count; num3++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[num3].ID == Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].feeder.ID)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].feeder.SetToNull();
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders[num3].amount++;
					return;
				}
			}
			GameManager.PlayerData.CFeeders cFeeders = new GameManager.PlayerData.CFeeders();
			cFeeders.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].feeder);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerFeeders.Add(cFeeders);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].feeder.SetToNull();
			break;
		}
		case GameManager.ItemType.Leader:
		{
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].leader.isNull)
			{
				break;
			}
			for (int m = 0; m < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders.Count; m++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[m].ID == Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].leader.ID)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].leader.SetToNull();
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders[m].amount++;
					return;
				}
			}
			GameManager.PlayerData.CLeaders cLeaders = new GameManager.PlayerData.CLeaders();
			cLeaders.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].leader);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerLeaders.Add(cLeaders);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].leader.SetToNull();
			break;
		}
		case GameManager.ItemType.Weight:
		{
			if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].weight.isNull)
			{
				break;
			}
			for (int i = 0; i < Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights.Count; i++)
			{
				if (Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[i].ID == Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].weight.ID)
				{
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].weight.SetToNull();
					Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights[i].amount++;
					return;
				}
			}
			GameManager.PlayerData.CWeights cWeights = new GameManager.PlayerData.CWeights();
			cWeights.CopyValues(Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].weight);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerWeights.Add(cWeights);
			Singleton<SaveDataManager>.Instance.GetCurrentPlayerData().PlayerSlotsEquip[equipmentManager.currentSlotIndex].weight.SetToNull();
			break;
		}
		}
	}
}