using System.Collections.Generic;
using System.Linq;
using BitStrap;
using UIWidgets;
using UnityEngine;
using UnityEngine.UI;

public class EquipmentGUI : MonoBehaviour
{
	[Header("Current Equipment")]
	public List<EquipmentCurrentObject> equipmentCurrentObjects = new List<EquipmentCurrentObject>(13);

	public List<EquipmentCurrentObject> equipmentCurrentBaits = new List<EquipmentCurrentObject>(3);

	public List<GameObject> tabsOnlyNormal = new List<GameObject>();

	public List<GameObject> tabsOnlyIce = new List<GameObject>();

	public List<EquipmentCategoryButton> tabsCategories = new List<EquipmentCategoryButton>();

	public List<GameObject> tabsSubCategories = new List<GameObject>();

	public GameObject hookAndBaitsWindow;

	public GameObject floatWeightWidget;

	public GameObject floatDepthWidget;

	public EquipmentSizeSlider equipmentSizeSlider;

	public Text totalDurabilityText;

	[ReadOnly]
	public bool showOnlyBought;

	[ReadOnly]
	[Space]
	public bool isIceEquipment;

	public GameObject equipmentNormalParent;

	public GameObject equipmentIceParent;

	public Button toggleEquipmentButton;

	public bool canEquipmentBeChanged = true;

	public bool canSetBeChanged = true;

	public bool isCurrentSet = true;

	[Header("Tabs")]
	public Tabs tabs;

	public LayoutDynamicFix layoutDynamicFix;

	public List<EquipmentTileView> equipmentTileView = new List<EquipmentTileView>();

	public List<EquipmentTypeButton> equipmentTypeButtons = new List<EquipmentTypeButton>();

	[Header("Info Window")]
	public ModelViewerManager modelViewerManager;

	public GameObject infoParent;

	public Image infoIcon;

	public Image infoProducerIcon;

	public Text infoName;

	public Text infoDescription;

	public Text infoAmount;

	public List<EquipmentParameter> infoParameters = new List<EquipmentParameter>();

	public Text infoBestFor;

	public Text infoBestForLures;

	private ScrollRect infoBestForScrollRect;

	private ScrollRect infoBestForLuresScrollRect;

	public GameObject infoPriceParent;

	public GameObject infoLevelParent;

	public Text infoPriceValue;

	public Text infoLevelValue;

	public Color requirementsColor = Color.red;

	public Button infoBtnBuy;

	public Button infoBtnEquip;

	public Button infoBtnSell;

	[ReadOnly]
	public Text infoBtnSellText;

	public List<Button> infoBtnEquipBaits = new List<Button>();

	public Button infoBtnShow;

	public Button changeEquipmentBtn;

	[ReadOnly]
	public EquipmentObject currentSelectedEquipment;

	[Header("Message")]
	public GameObject msgParent;

	public Text msgText;

	[HideInInspector]
	public EquipmentManager equipmentManager;

	[HideInInspector]
	public PlayerSettingsMy playerSettings;

	public void Awake()
	{
		infoParent.SetActive(false);
		infoBtnBuy.interactable = false;
		equipmentSizeSlider.gameObject.SetActive(false);
		for (int i = 0; i < equipmentCurrentObjects.Count; i++)
		{
			if ((bool)equipmentCurrentObjects[i])
			{
				equipmentCurrentObjects[i].equipmentGUI = this;
			}
		}
		for (int j = 0; j < equipmentCurrentBaits.Count; j++)
		{
			equipmentCurrentBaits[j].equipmentGUI = this;
		}
		equipmentTypeButtons = GetComponentsInChildren<EquipmentTypeButton>().ToList();
		infoBtnSellText = infoBtnSell.GetComponentInChildren<Text>();
		infoBestForScrollRect = infoBestFor.rectTransform.parent.parent.GetComponent<ScrollRect>();
		infoBestForLuresScrollRect = infoBestForLures.rectTransform.parent.parent.GetComponent<ScrollRect>();
	}

	private void Start()
	{
		equipmentManager = GlobalSettings.Instance.equipmentManager;
		playerSettings = GlobalSettings.Instance.playerSettings;
		floatDepthWidget.GetComponent<FloatParamWidget>().equipmentGUI = this;
		floatWeightWidget.GetComponent<FloatParamWidget>().equipmentGUI = this;
		isIceEquipment = true;
		ToggleEquipment();
		RefreshList(false);
		tabs.Initialize();
		for (int i = 0; i < equipmentTileView.Count; i++)
		{
			MenuManager.Instance.rightStickScrollbars.Add(equipmentTileView[i].ScrollRect.verticalScrollbar);
		}
		OnEnable();
	}

	private void OnEnable()
	{
		if ((bool)equipmentManager)
		{
			equipmentManager.CheckStartEquipment();
			UpdateCanEquipmentBeChanged();
			RefreshAll();
			DeselectedEquipment();
			if (!GameController.Instance)
			{
				equipmentManager.ResetChanged();
				ResetChanged();
			}
			else if (!equipmentManager.HasAnythingChanged())
			{
				ResetChanged();
			}
			if ((bool)GameController.Instance)
			{
				SetEquipmentType(GameController.Instance.iceLevel);
			}
			CheckFloatArtificialBait();
			for (int i = 0; i < 3; i++)
			{
				infoBtnEquipBaits[i].GetComponentInChildren<Text>().text = Utilities.GetTranslation("GUI/BTN_EQUIP") + "\n" + Utilities.GetTranslation("EQUIPMENT/BAIT") + " " + (i + 1);
			}
		}
		msgText.text = string.Empty;
	}

	private void OnDisable()
	{
		CheckFloatArtificialBait();
		if ((bool)GameController.Instance && equipmentManager.HasAnythingChanged())
		{
			ChangeEquipment();
		}
		else if ((bool)HUDManager.Instance)
		{
			HUDManager.Instance.hudBaits.Refresh(HUDManager.Instance.fishingPlayer.currentHands);
		}
		if ((bool)equipmentManager && (bool)GlobalSettings.Instance && GlobalSettings.Instance.saveManager.isProfileLoaded)
		{
			equipmentManager.Save();
			playerSettings.Save();
		}
	}

	public void RefreshList(bool onlyBought)
	{
		if (equipmentManager == null)
		{
			return;
		}
		for (int i = 0; i < equipmentTileView.Count; i++)
		{
			equipmentTileView[i].Clear();
			List<EquipmentObject> list = null;
			list = equipmentManager.GetEquipmentSpecificList(equipmentTileView[i].equipmentTileViewParameters);
			if (list[0].equipmentType == EquipmentObject.EquipmentType.BAIT)
			{
				list.Sort((EquipmentObject f1, EquipmentObject f2) => f1.prefab.GetComponent<BaitPart>().priceFactor.CompareTo(f2.prefab.GetComponent<BaitPart>().priceFactor));
			}
			else
			{
				list.Sort((EquipmentObject f1, EquipmentObject f2) => f1.price.CompareTo(f2.price));
			}
			foreach (EquipmentObject item in list)
			{
				if ((!onlyBought || item.amount != 0 || item.isEquipped) && (!item.onlyCheat || GlobalSettings.Instance.turnOnCheats) && (!item.onlyBeta || GlobalSettings.Instance.isBeta) && (item.isAvailable || GlobalSettings.Instance.turnOnMyCheats) && (!GlobalSettings.Instance.isDemo || item.isInDemo))
				{
					EquipmentTileViewItem equipmentTileViewItem = new EquipmentTileViewItem();
					equipmentTileViewItem.icon = item.icon;
					equipmentTileViewItem.equipmentName = item.GetFullName();
					equipmentTileViewItem.equipmentId = item.id;
					equipmentTileViewItem.equipmentObject = item;
					equipmentTileView[i].Add(equipmentTileViewItem);
				}
			}
		}
	}

	public void OnSelectObject(int index, ListViewItem item)
	{
		RefreshInfo();
		RefreshMessage();
	}

	public void RefreshInfo(EquipmentObject selectedEquipment = null)
	{
		currentSelectedEquipment = selectedEquipment;
		bool flag = selectedEquipment != null;
		if (selectedEquipment == null)
		{
			selectedEquipment = GetSelectedEquipment();
		}
		if (selectedEquipment != null && !selectedEquipment.isAvailableFromDLCs && selectedEquipment.fromDLC.Count > 0)
		{
			DLCManager.Instance.BuyDLC(selectedEquipment.fromDLC[0]);
			selectedEquipment = null;
		}
		infoParent.SetActive(selectedEquipment != null);
		infoBtnShow.gameObject.SetActive(selectedEquipment != null);
		bool flag2 = true;
		bool flag3 = true;
		bool flag4 = true;
		RefreshEquipmentParameters(selectedEquipment);
		if (selectedEquipment == null)
		{
			infoIcon.sprite = null;
			infoProducerIcon.sprite = null;
			infoName.text = string.Empty;
			infoDescription.text = string.Empty;
			infoBestFor.text = string.Empty;
			infoBestForLures.text = string.Empty;
			infoPriceParent.SetActive(false);
			infoLevelParent.SetActive(false);
			equipmentSizeSlider.gameObject.SetActive(false);
			flag3 = false;
			flag4 = false;
			flag2 = false;
			infoBtnSellText.text = Utilities.GetTranslation("GUI/BTN_SELL");
		}
		else
		{
			infoIcon.sprite = selectedEquipment.icon;
			infoProducerIcon.sprite = selectedEquipment.producerIcon;
			infoName.text = selectedEquipment.GetFullName();
			infoDescription.text = Utilities.GetTranslation(selectedEquipment.description);
			infoDescription.text = string.Empty;
			infoPriceValue.text = string.Empty + selectedEquipment.GetCurrentSellPrice() + " $";
			infoLevelValue.text = string.Empty + selectedEquipment.level;
			infoPriceValue.color = ((!CheckPrice(selectedEquipment)) ? requirementsColor : Color.white);
			infoLevelValue.color = ((!CheckLevel(selectedEquipment)) ? requirementsColor : Color.white);
			if (selectedEquipment.equipmentType == EquipmentObject.EquipmentType.HOOK && IsEquippedInCurrentSet(selectedEquipment))
			{
				SetEquipmentSliderActive(true, selectedEquipment);
			}
			else
			{
				SetEquipmentSliderActive(false);
			}
			infoBtnSellText.text = Utilities.GetTranslation("GUI/BTN_SELL") + " +" + Mathf.RoundToInt((float)selectedEquipment.price * equipmentManager.sellObjectFactor) + " $";
			if (selectedEquipment.hasAmount)
			{
				infoPriceParent.SetActive(true);
				infoLevelParent.SetActive(true);
				flag3 = selectedEquipment.amount < selectedEquipment.maxAmount && CheckPrice(selectedEquipment) && CheckLevel(selectedEquipment);
				flag4 = ((!equipmentManager.IsThisStartEquipment(selectedEquipment)) ? (selectedEquipment.amount > 0) : (selectedEquipment.amount > 1 || (selectedEquipment.isEquipped && selectedEquipment.amount > 0)));
				flag2 = (IsEquipmentWithAmount(selectedEquipment.equipmentType) ? (selectedEquipment.amount > 0 && !IsEquippedInCurrentSet(selectedEquipment)) : ((selectedEquipment.equipmentType != EquipmentObject.EquipmentType.OTHER || selectedEquipment.equipmentSubType != EquipmentObject.EquipmentSubType.FLOAT_WEIGHT) && ((selectedEquipment.equipmentType != EquipmentObject.EquipmentType.BAIT) ? (selectedEquipment.amount > 0 && selectedEquipment.equipmentType != EquipmentObject.EquipmentType.OTHER) : (selectedEquipment.amount > 0))));
				if (selectedEquipment.equipmentType == EquipmentObject.EquipmentType.BITE_INDICATOR && (bool)GameController.Instance && GameController.Instance.iceLevel)
				{
					flag2 = false;
				}
			}
			else
			{
				infoPriceParent.SetActive(!selectedEquipment.isBought);
				infoLevelParent.SetActive(true);
				flag3 = !selectedEquipment.isBought && CheckPrice(selectedEquipment) && CheckLevel(selectedEquipment);
				flag4 = selectedEquipment.isBought && !selectedEquipment.isEquipped && selectedEquipment.canBeSold;
				flag2 = selectedEquipment.equipmentSubType != EquipmentObject.EquipmentSubType.DRILLER && selectedEquipment.equipmentSubType != EquipmentObject.EquipmentSubType.FISHING_NET && selectedEquipment.equipmentSubType != EquipmentObject.EquipmentSubType.GAS_STOVE && selectedEquipment.isBought && !selectedEquipment.isEquipped;
			}
			infoAmount.text = selectedEquipment.amount.ToString();
			infoAmount.gameObject.SetActive(selectedEquipment.hasAmount);
			if (!canEquipmentBeChanged)
			{
				flag2 = false;
			}
			if (!flag4)
			{
				infoBtnSellText.text = Utilities.GetTranslation("GUI/BTN_SELL");
			}
		}
		infoProducerIcon.gameObject.SetActive(infoProducerIcon.sprite != null);
		if (flag)
		{
			flag2 = false;
		}
		if (playerSettings.IsSandbox())
		{
			flag3 = false;
			flag4 = false;
		}
		UpdateEquipVisibility(flag2);
		infoBtnBuy.interactable = flag3;
		infoBtnSell.interactable = flag4;
		infoBtnSell.GetComponent<ButtonDeselectFix>().DeselectFix();
		infoBtnBuy.GetComponent<ButtonDeselectFix>().DeselectFix();
		infoBtnEquip.GetComponent<ButtonDeselectFix>().DeselectFix();
		for (int i = 0; i < infoBtnEquipBaits.Count; i++)
		{
			infoBtnEquipBaits[i].GetComponent<ButtonDeselectFix>().DeselectFix();
		}
		if (selectedEquipment != null && selectedEquipment.equipmentType == EquipmentObject.EquipmentType.BAIT)
		{
			infoBtnEquip.gameObject.SetActive(false);
			infoBtnEquipBaits[0].transform.parent.gameObject.SetActive(true);
			infoBtnEquipBaits[3].transform.parent.gameObject.SetActive(true);
		}
		else
		{
			infoBtnEquip.gameObject.SetActive(true);
			infoBtnEquipBaits[0].transform.parent.gameObject.SetActive(false);
			infoBtnEquipBaits[3].transform.parent.gameObject.SetActive(false);
		}
		if (selectedEquipment != null)
		{
			modelViewerManager.InstantiateObject(selectedEquipment);
		}
		else
		{
			modelViewerManager.InstantiateObject(null);
		}
	}

	public void RemoveCurrent()
	{
		for (int i = 0; i < equipmentCurrentObjects.Count; i++)
		{
			equipmentCurrentObjects[i].RemoveObject();
		}
		for (int j = 0; j < equipmentCurrentBaits.Count; j++)
		{
			equipmentCurrentBaits[j].RemoveObject();
		}
	}

	public void RefreshCurrent()
	{
		for (int i = 0; i < equipmentCurrentObjects.Count; i++)
		{
			equipmentCurrentObjects[i].Refresh();
		}
		for (int j = 0; j < equipmentCurrentBaits.Count; j++)
		{
			equipmentCurrentBaits[j].Refresh();
		}
		floatDepthWidget.GetComponent<FloatParamWidget>().Refresh();
		floatWeightWidget.GetComponent<FloatParamWidget>().Refresh();
	}

	public void RefreshBaits()
	{
		int num = 0;
		if (equipmentCurrentObjects[5].equipmentObject != null)
		{
			num = equipmentCurrentObjects[5].equipmentObject.prefab.GetComponent<Bait>().baitPartsMax;
		}
		for (int i = 0; i < equipmentCurrentBaits.Count; i++)
		{
			equipmentCurrentBaits[i].SetActive(i < num);
		}
	}

	public void RefreshMessage()
	{
		string text = string.Empty;
		EquipmentObject selectedEquipment = GetSelectedEquipment();
		bool flag = equipmentCurrentObjects[4].equipmentObject != null && (bool)equipmentCurrentObjects[4].equipmentObject.prefab;
		bool flag2 = selectedEquipment != null && selectedEquipment.equipmentType == EquipmentObject.EquipmentType.FLOAT;
		bool flag3 = equipmentCurrentObjects[10].equipmentObject != null && (bool)equipmentCurrentObjects[10].equipmentObject.prefab;
		bool flag4 = selectedEquipment != null && selectedEquipment.equipmentType == EquipmentObject.EquipmentType.FEEDER;
		bool flag5 = equipmentCurrentObjects[5].equipmentObject != null && (bool)equipmentCurrentObjects[5].equipmentObject.prefab && equipmentCurrentObjects[5].equipmentObject.prefab.GetComponent<Bait>().baitType != Bait.BaitType.HOOK;
		bool flag6 = selectedEquipment != null && selectedEquipment.equipmentType == EquipmentObject.EquipmentType.HOOK && selectedEquipment.prefab.GetComponent<Bait>().baitType != Bait.BaitType.HOOK;
		bool flag7 = equipmentCurrentObjects[5].equipmentObject != null && (bool)equipmentCurrentObjects[5].equipmentObject.prefab && equipmentCurrentObjects[5].equipmentObject.prefab.GetComponent<Bait>().baitType == Bait.BaitType.HOOK;
		bool flag8 = selectedEquipment != null && selectedEquipment.equipmentType == EquipmentObject.EquipmentType.HOOK && selectedEquipment.prefab.GetComponent<Bait>().baitType == Bait.BaitType.HOOK;
		bool flag9 = selectedEquipment != null && selectedEquipment.equipmentType == EquipmentObject.EquipmentType.BAIT;
		FishingRod fishingRod = null;
		FishingRod fishingRod2 = null;
		FishingReel fishingReel = null;
		FishingReel fishingReel2 = null;
		FishingLine fishingLine = null;
		FishingLine fishingLine2 = null;
		Bait bait = null;
		Bait bait2 = null;
		if (equipmentCurrentObjects[0].equipmentObject != null && (bool)equipmentCurrentObjects[0].equipmentObject.prefab)
		{
			fishingRod = equipmentCurrentObjects[0].equipmentObject.prefab.GetComponent<FishingRod>();
		}
		if (equipmentCurrentObjects[2].equipmentObject != null && (bool)equipmentCurrentObjects[2].equipmentObject.prefab)
		{
			fishingReel = equipmentCurrentObjects[2].equipmentObject.prefab.GetComponent<FishingReel>();
		}
		if (equipmentCurrentObjects[3].equipmentObject != null && (bool)equipmentCurrentObjects[3].equipmentObject.prefab)
		{
			fishingLine = equipmentCurrentObjects[3].equipmentObject.prefab.GetComponent<FishingLine>();
		}
		if (equipmentCurrentObjects[5].equipmentObject != null && (bool)equipmentCurrentObjects[5].equipmentObject.prefab)
		{
			bait = equipmentCurrentObjects[5].equipmentObject.prefab.GetComponent<Bait>();
		}
		if (selectedEquipment != null && selectedEquipment.equipmentType == EquipmentObject.EquipmentType.ROD)
		{
			fishingRod2 = selectedEquipment.prefab.GetComponent<FishingRod>();
		}
		if (selectedEquipment != null && selectedEquipment.equipmentType == EquipmentObject.EquipmentType.REEL)
		{
			fishingReel2 = selectedEquipment.prefab.GetComponent<FishingReel>();
		}
		if (selectedEquipment != null && selectedEquipment.equipmentType == EquipmentObject.EquipmentType.LINE)
		{
			fishingLine2 = selectedEquipment.prefab.GetComponent<FishingLine>();
		}
		if (selectedEquipment != null && selectedEquipment.equipmentType == EquipmentObject.EquipmentType.HOOK)
		{
			bait2 = selectedEquipment.prefab.GetComponent<Bait>();
		}
		bool flag10 = true;
		if (selectedEquipment != null)
		{
			if (!isIceEquipment && ((flag && flag6) || (flag5 && flag2) || (flag3 && flag6) || (flag5 && flag4)))
			{
				text = Utilities.GetTranslation("EQUIPMENT/MSG_ARTIFICIAL_WITH_FLOAT");
				flag10 = false;
			}
			else if (!isIceEquipment && ((flag && flag4) || (flag3 && flag2)))
			{
				text = Utilities.GetTranslation("EQUIPMENT/MSG_FLOATS_WITH_FEEDERS");
				flag10 = false;
			}
			else if (!isIceEquipment && !flag && !flag3 && flag8)
			{
				text = Utilities.GetTranslation("EQUIPMENT/MSG_HOOK_WITHOUT_FLOAT");
				flag10 = false;
			}
			else if (flag5 && flag9)
			{
				text = Utilities.GetTranslation("EQUIPMENT/MSG_ARTIFICIAL_WITH_NATURAL");
				flag10 = false;
			}
			else if (((bool)fishingRod && fishingRod.rodType == FishingRod.RodType.FLY_FISHING && (bool)fishingReel2 && fishingReel2.reelType != FishingReel.ReelType.FLY) || ((bool)fishingRod && fishingRod.rodType != FishingRod.RodType.FLY_FISHING && (bool)fishingReel2 && fishingReel2.reelType == FishingReel.ReelType.FLY) || ((bool)fishingReel && fishingReel.reelType == FishingReel.ReelType.FLY && (bool)fishingRod2 && fishingRod2.rodType != FishingRod.RodType.FLY_FISHING) || ((bool)fishingReel && fishingReel.reelType != FishingReel.ReelType.FLY && (bool)fishingRod2 && fishingRod2.rodType == FishingRod.RodType.FLY_FISHING))
			{
				text = Utilities.GetTranslation("EQUIPMENT/MSG_FLY_EQUIPMENT_ROD_REEL");
				flag10 = false;
			}
			else if (!isIceEquipment && (((bool)fishingLine && fishingLine.lineType == FishingLine.LineType.FLY && (bool)fishingReel2 && fishingReel2.reelType != FishingReel.ReelType.FLY) || ((bool)fishingLine && fishingLine.lineType != FishingLine.LineType.FLY && (bool)fishingReel2 && fishingReel2.reelType == FishingReel.ReelType.FLY) || ((bool)fishingReel && fishingReel.reelType == FishingReel.ReelType.FLY && (bool)fishingLine2 && fishingLine2.lineType != FishingLine.LineType.FLY) || ((bool)fishingReel && fishingReel.reelType != FishingReel.ReelType.FLY && (bool)fishingLine2 && fishingLine2.lineType == FishingLine.LineType.FLY)))
			{
				text = Utilities.GetTranslation("EQUIPMENT/MSG_FLY_EQUIPMENT_LINE_REEL");
				flag10 = false;
			}
			else if (!isIceEquipment && (((bool)fishingLine && fishingLine.lineType == FishingLine.LineType.FLY && (bool)bait2 && bait2.baitType != Bait.BaitType.FLY) || ((bool)fishingLine && fishingLine.lineType != FishingLine.LineType.FLY && (bool)bait2 && bait2.baitType == Bait.BaitType.FLY) || ((bool)bait && bait.baitType == Bait.BaitType.FLY && (bool)fishingLine2 && fishingLine2.lineType != FishingLine.LineType.FLY) || ((bool)bait && bait.baitType != Bait.BaitType.FLY && (bool)fishingLine2 && fishingLine2.lineType == FishingLine.LineType.FLY)))
			{
				text = Utilities.GetTranslation("EQUIPMENT/MSG_FLY_EQUIPMENT_LINE_BAIT");
				flag10 = false;
			}
		}
		if (!canEquipmentBeChanged)
		{
			text = Utilities.GetTranslation("EQUIPMENT/MSG_CANT_CHANGE_FISHING");
		}
		if (!flag10)
		{
			UpdateEquipVisibility(false);
		}
		msgText.text = text;
	}

	public void CheckFloatArtificialBait()
	{
		bool flag = equipmentCurrentObjects[4].equipmentObject != null && (bool)equipmentCurrentObjects[4].equipmentObject.prefab;
		bool flag2 = equipmentCurrentObjects[10].equipmentObject != null && (bool)equipmentCurrentObjects[10].equipmentObject.prefab;
		bool flag3 = equipmentCurrentObjects[5].equipmentObject != null && (bool)equipmentCurrentObjects[5].equipmentObject.prefab && equipmentCurrentObjects[5].equipmentObject.prefab.GetComponent<Bait>().baitType != Bait.BaitType.HOOK;
		bool flag4 = equipmentCurrentObjects[5].equipmentObject != null && (bool)equipmentCurrentObjects[5].equipmentObject.prefab && equipmentCurrentObjects[5].equipmentObject.prefab.GetComponent<Bait>().baitType == Bait.BaitType.HOOK;
		if (isIceEquipment)
		{
			if ((flag || flag2) && flag3)
			{
				if (flag)
				{
					equipmentCurrentObjects[4].RemoveObject();
					Debug.LogError("EQUIPMENT/MSG_ARTIFICIAL_WITH_FLOAT remove float");
				}
				if (flag2)
				{
					equipmentCurrentObjects[10].RemoveObject();
					Debug.LogError("EQUIPMENT/MSG_ARTIFICIAL_WITH_FLOAT remove feeder");
				}
				msgText.text = Utilities.GetTranslation("EQUIPMENT/MSG_ARTIFICIAL_WITH_FLOAT");
			}
		}
		else if ((flag || flag2) && flag3)
		{
			equipmentCurrentObjects[5].RemoveObject();
			msgText.text = Utilities.GetTranslation("EQUIPMENT/MSG_ARTIFICIAL_WITH_FLOAT");
			Debug.LogError("EQUIPMENT/MSG_ARTIFICIAL_WITH_FLOAT remove hook 1");
		}
		else if (!flag && !flag2 && flag4)
		{
			equipmentCurrentObjects[5].RemoveObject();
			msgText.text = Utilities.GetTranslation("EQUIPMENT/MSG_ARTIFICIAL_WITH_FLOAT");
			Debug.LogError("EQUIPMENT/MSG_ARTIFICIAL_WITH_FLOAT remove hook 2");
		}
	}

	public void RefreshAll()
	{
		if (equipmentManager == null)
		{
			equipmentManager = GlobalSettings.Instance.equipmentManager;
		}
		if ((bool)equipmentManager)
		{
			RefreshInfo();
			RefreshCurrent();
			RefreshBaits();
			RefreshMessage();
		}
	}

	private void SetEquipmentSliderActive(bool active, EquipmentObject selectedEquipment = null)
	{
		if (active)
		{
			equipmentSizeSlider.equipmentObject = selectedEquipment;
			equipmentSizeSlider.hookToWeightParameter = infoParameters[2];
			equipmentSizeSlider.gameObject.SetActive(true);
			equipmentSizeSlider.Refresh();
		}
		else
		{
			equipmentSizeSlider.gameObject.SetActive(false);
		}
	}

	private EquipmentParameter GetEquipmentParameter(string name)
	{
		EquipmentParameter result = null;
		int num = 0;
		foreach (EquipmentParameter infoParameter in infoParameters)
		{
			if (infoParameter.nameText.text == name)
			{
				result = infoParameter;
			}
			Debug.Log("EquipmentParameter--------------------------------------------EquipmentParameter " + num + " --------- " + infoParameter.nameText.text);
			num++;
		}
		return result;
	}

	private void SetHookToWeightParameter(EquipmentObject equipmentObject, EquipmentParameter hookToWeightParameter)
	{
		Bait component = equipmentObject.prefab.GetComponent<Bait>();
		Debug.Log(string.Concat("------------bait -------------", component, " -------- hook to weight ", hookToWeightParameter));
		if (component == null)
		{
			hookToWeightParameter.gameObject.SetActive(false);
			return;
		}
		int index = (int)equipmentObject.sizes[(int)equipmentSizeSlider.slider.value];
		FishManager fishManager = GlobalSettings.Instance.fishManager;
		Vector2 one = Vector2.one;
		one = ((component.baitType == Bait.BaitType.HOOK) ? fishManager.hookToFishWeight[index] : ((component.baitType != Bait.BaitType.FLY) ? fishManager.lureToFishWeight[index] : fishManager.flyToFishWeight[index]));
		string paramValue = UtilitiesUnits.GetWeightString(one.x) + " - " + UtilitiesUnits.GetWeightString(one.y);
		hookToWeightParameter.SetParameter(Utilities.GetTranslation("EQUIPMENT_PARAMETERS/HOOK_TO_WEIGHT"), paramValue);
	}

	public bool CheckPrice(EquipmentObject equipmentObject)
	{
		return equipmentObject.GetCurrentSellPrice() <= (int)playerSettings.playersMoney;
	}

	public bool CheckLevel(EquipmentObject equipmentObject)
	{
		return equipmentObject.level <= (int)playerSettings.playersLevel;
	}

	public void OnDeselectObject(int index, ListViewItem item)
	{
	}

	public void BuyItem()
	{
		EquipmentObject selectedEquipment = GetSelectedEquipment();
		if (selectedEquipment.equipmentType == EquipmentObject.EquipmentType.BAIT)
		{
			equipmentCurrentBaits[0].BuyObject(selectedEquipment);
		}
		else if (selectedEquipment.equipmentType == EquipmentObject.EquipmentType.OTHER)
		{
			equipmentManager.BuyObject(selectedEquipment);
		}
		else
		{
			equipmentCurrentObjects[(int)selectedEquipment.equipmentType].BuyObject(selectedEquipment);
		}
		RefreshInfo(currentSelectedEquipment);
		RefreshMessage();
		RefreshTileViews();
	}

	public void SellItem()
	{
		EquipmentObject selectedEquipment = GetSelectedEquipment();
		if (selectedEquipment.equipmentType == EquipmentObject.EquipmentType.BAIT)
		{
			equipmentCurrentBaits[0].SellObject(selectedEquipment);
		}
		else if (selectedEquipment.equipmentType == EquipmentObject.EquipmentType.OTHER)
		{
			equipmentManager.SellObject(selectedEquipment);
		}
		else
		{
			equipmentCurrentObjects[(int)selectedEquipment.equipmentType].SellObject(selectedEquipment);
		}
		RefreshInfo(currentSelectedEquipment);
		RefreshMessage();
		RefreshTileViews();
		if (selectedEquipment.amount == 0 && !selectedEquipment.isEquipped && showOnlyBought)
		{
			ShowOnlyBought(showOnlyBought);
		}
	}

	public void EquipItem()
	{
		EquipmentObject selectedEquipment = GetSelectedEquipment();
		if (selectedEquipment == null)
		{
			UpdateEquipVisibility(false);
			Debug.LogError("EquipItem equipmentObject == null");
			return;
		}
		if (selectedEquipment.equipmentType != EquipmentObject.EquipmentType.BAIT)
		{
			if (selectedEquipment.equipmentType == EquipmentObject.EquipmentType.HOOK)
			{
				if ((int)equipmentSizeSlider.slider.value < selectedEquipment.sizes.Count)
				{
					equipmentManager.currentSetSpecificParameters.currentHookSize = (int)selectedEquipment.sizes[(int)equipmentSizeSlider.slider.value];
				}
				else if (selectedEquipment.sizes.Count > 0)
				{
					equipmentManager.currentSetSpecificParameters.currentHookSize = (int)selectedEquipment.sizes[selectedEquipment.sizes.Count - 1];
				}
				else
				{
					equipmentManager.currentSetSpecificParameters.currentHookSize = 0f;
				}
			}
			EquipmentCurrentObject equipmentCurrentObject = equipmentCurrentObjects[(int)selectedEquipment.equipmentType];
			if (IsEquipmentWithAmount(selectedEquipment.equipmentType) && equipmentCurrentObject.equipmentObject != null)
			{
				equipmentCurrentObject.RemoveObject();
			}
			equipmentCurrentObject.ShowEquipmentChanged(true);
			equipmentCurrentObject.EquipObject(selectedEquipment);
		}
		RefreshBaits();
		RefreshInfo();
		RefreshTotalDurability();
		RefreshMessage();
		RefreshTileViews();
		CheckFloatArtificialBait();
		if (isCurrentSet && canEquipmentBeChanged)
		{
			equipmentManager.EquipmentChanged(selectedEquipment.equipmentType);
		}
		if (selectedEquipment.equipmentType == EquipmentObject.EquipmentType.FLOAT)
		{
			TutorialManager.Instance.ShowTutorial(TutorialManager.TutorialsId.FLOAT_PARAMS_01, 0.5f);
		}
	}

	public void EquipBait(int baitSlotId)
	{
		EquipmentObject selectedEquipment = GetSelectedEquipment();
		if (selectedEquipment == null)
		{
			UpdateEquipVisibility(false);
			Debug.LogError("EquipItem equipmentObject == null");
			return;
		}
		EquipmentCurrentObject equipmentCurrentObject = equipmentCurrentBaits[baitSlotId - 1];
		if (equipmentCurrentObject.equipmentObject != null)
		{
			equipmentCurrentObject.RemoveObject();
		}
		equipmentCurrentObject.ShowEquipmentChanged(true);
		equipmentCurrentObject.EquipObject(selectedEquipment);
		EquipItem();
	}

	public void UnequipItem()
	{
		RefreshTotalDurability();
		RefreshMessage();
		RefreshTileViews();
	}

	public EquipmentObject GetSelectedEquipment()
	{
		if (currentSelectedEquipment != null)
		{
			return currentSelectedEquipment;
		}
		EquipmentTileView equipmentTileView = this.equipmentTileView[tabs.selectedIndex];
		if (equipmentTileView.SelectedIndex < 0)
		{
			return null;
		}
		EquipmentTileViewItem equipmentTileViewItem = equipmentTileView.DataSource[equipmentTileView.SelectedIndex];
		return equipmentTileViewItem.equipmentObject;
	}

	public void DeselectedEquipment()
	{
		foreach (EquipmentTileView item in equipmentTileView)
		{
			item.SelectedIndex = -1;
		}
		infoBtnShow.gameObject.SetActive(false);
		RefreshInfo();
	}

	public void ShowHookAndBaits(bool show)
	{
		hookAndBaitsWindow.SetActive(show);
	}

	public void SetEquipmentType(bool ice)
	{
		if (isIceEquipment == ice)
		{
			return;
		}
		isIceEquipment = ice;
		equipmentNormalParent.SetActive(!isIceEquipment);
		equipmentIceParent.SetActive(isIceEquipment);
		for (int i = 0; i < tabsOnlyNormal.Count; i++)
		{
			tabsOnlyNormal[i].SetActive(!isIceEquipment);
		}
		for (int j = 0; j < tabsOnlyIce.Count; j++)
		{
			tabsOnlyIce[j].SetActive(isIceEquipment);
		}
		for (int k = 0; k < tabsSubCategories.Count; k++)
		{
			tabsSubCategories[k].SetActive(false);
		}
		for (int l = 0; l < tabsCategories.Count; l++)
		{
			tabsCategories[l].Expand(false);
		}
		if (isIceEquipment)
		{
			equipmentTypeButtons[5].ChangeType();
			tabsOnlyNormal[0].transform.parent.GetComponent<VerticalLayoutGroup>().spacing = -100f;
		}
		else
		{
			equipmentTypeButtons[0].ChangeType();
			tabsOnlyNormal[0].transform.parent.GetComponent<VerticalLayoutGroup>().spacing = 0f;
		}
		DeselectedEquipment();
		if (isIceEquipment)
		{
			ShowFloatParams(false);
		}
		else
		{
			CheckFloatArtificialBait();
			if (equipmentManager.GetCurrentEquipment(EquipmentObject.EquipmentType.FLOAT) != null && (bool)equipmentManager.GetCurrentEquipment(EquipmentObject.EquipmentType.FLOAT).prefab)
			{
				ShowFloatParams(true);
			}
		}
		toggleEquipmentButton.GetComponentInChildren<Text>().text = ((!isIceEquipment) ? Utilities.GetTranslation("EQUIPMENT/BTN_SHOW_ICE") : Utilities.GetTranslation("EQUIPMENT/BTN_SHOW_NORMAL"));
		layoutDynamicFix.Refresh();
	}

	public void ToggleEquipment()
	{
		SetEquipmentType(!isIceEquipment);
	}

	public void ShowFloatParams(bool show)
	{
		floatDepthWidget.SetActive(show);
		floatWeightWidget.SetActive(show);
	}

	public void ChangeTab(EquipmentObject equipmentObject)
	{
		EquipmentObject.EquipmentType equipmentType = equipmentObject.equipmentType;
		int subType = 0;
		switch (equipmentType)
		{
		case EquipmentObject.EquipmentType.ROD:
			subType = (int)equipmentObject.prefab.GetComponent<FishingRod>().rodType;
			break;
		case EquipmentObject.EquipmentType.REEL:
			subType = (int)equipmentObject.prefab.GetComponent<FishingReel>().reelType;
			break;
		case EquipmentObject.EquipmentType.LINE:
			subType = (int)equipmentObject.prefab.GetComponent<FishingLine>().lineType;
			break;
		case EquipmentObject.EquipmentType.HOOK:
			subType = (int)equipmentObject.prefab.GetComponent<Bait>().baitType;
			break;
		}
		ChangeTab(equipmentType, subType, false);
	}

	public void ChangeTab(EquipmentObject.EquipmentType equipmentType, int subType, bool allTypes)
	{
		switch (equipmentType)
		{
		case EquipmentObject.EquipmentType.ROD:
			if (allTypes)
			{
				tabs.SelectTab("GUI/BTN_RODS", true);
				break;
			}
			switch (subType)
			{
			case 0:
				tabs.SelectTab("GUI/BTN_RODS_SPINNING", true);
				break;
			case 1:
				tabs.SelectTab("GUI/BTN_RODS_CASTING", true);
				break;
			case 4:
				tabs.SelectTab("GUI/BTN_RODS_GROUND", true);
				break;
			case 2:
				tabs.SelectTab("GUI/BTN_RODS_FLY", true);
				break;
			default:
				tabs.SelectTab("GUI/BTN_RODS", true);
				break;
			}
			break;
		case EquipmentObject.EquipmentType.ICE_ROD:
			tabs.SelectTab("GUI/BTN_ICE_RODS", true);
			break;
		case EquipmentObject.EquipmentType.REEL:
			if (allTypes)
			{
				tabs.SelectTab("GUI/BTN_REELS", true);
				break;
			}
			switch (subType)
			{
			case 0:
				tabs.SelectTab("GUI/BTN_REELS_STANDARD", true);
				break;
			case 1:
				tabs.SelectTab("GUI/BTN_REELS_LINE_COUNTER", true);
				break;
			case 2:
				tabs.SelectTab("GUI/BTN_REELS_GROUND", true);
				break;
			case 3:
				tabs.SelectTab("GUI/BTN_REELS_FLY", true);
				break;
			default:
				tabs.SelectTab("GUI/BTN_REELS", true);
				break;
			}
			break;
		case EquipmentObject.EquipmentType.LINE:
			tabs.SelectTab("GUI/BTN_LINES", true);
			break;
		case EquipmentObject.EquipmentType.FLOAT:
			tabs.SelectTab("GUI/BTN_FLOATS", true);
			break;
		case EquipmentObject.EquipmentType.HOOK:
			switch (subType)
			{
			case 3:
				tabs.SelectTab("GUI/BTN_WOBBLER", true);
				break;
			case 0:
				tabs.SelectTab("GUI/BTN_HOOKS", true);
				break;
			}
			if (subType == 4)
			{
				tabs.SelectTab("GUI/BTN_SOFT_BAITS", true);
			}
			if (subType == 1)
			{
				tabs.SelectTab("GUI/BTN_SPINNERS", true);
			}
			if (subType == 2)
			{
				tabs.SelectTab("GUI/BTN_SPOONS", true);
			}
			if (subType == 5)
			{
				tabs.SelectTab("GUI/BTN_FLIES", true);
			}
			if (subType == 6)
			{
				tabs.SelectTab("GUI/BTN_SAKURA_DLC_01", true);
			}
			break;
		case EquipmentObject.EquipmentType.BAIT:
			tabs.SelectTab("GUI/BTN_BAITS", true);
			break;
		case EquipmentObject.EquipmentType.OTHER:
			tabs.SelectTab("GUI/BTN_OTHER", true);
			break;
		case EquipmentObject.EquipmentType.BOILIE:
			tabs.SelectTab("GUI/BTN_BOILIES", true);
			break;
		case EquipmentObject.EquipmentType.ROD_STAND:
			tabs.SelectTab("GUI/BTN_ROD_STANDS", true);
			break;
		case EquipmentObject.EquipmentType.FEEDER:
			tabs.SelectTab("GUI/BTN_FEEDERS", true);
			break;
		case EquipmentObject.EquipmentType.FEEDER_BAIT:
			tabs.SelectTab("GUI/BTN_FEEDER_BAITS", true);
			break;
		case EquipmentObject.EquipmentType.BITE_INDICATOR:
			tabs.SelectTab("GUI/BTN_BITE_INDICATORS", true);
			break;
		}
		DeselectedEquipment();
	}

	public void RefreshTileViews()
	{
		for (int i = 0; i < equipmentTileView.Count; i++)
		{
			equipmentTileView[i].RefreshTileViewComponents();
		}
	}

	public void ShowOnlyBought(bool onlyBought)
	{
		RefreshList(onlyBought);
		showOnlyBought = onlyBought;
		for (int i = 0; i < equipmentTileView.Count; i++)
		{
			equipmentTileView[i].ShowOnlyBought(onlyBought);
			equipmentTileView[i].enabled = false;
			equipmentTileView[i].enabled = true;
		}
	}

	public void UpdateEquipmentTypeButton(EquipmentTypeButton currentTypeButton)
	{
		foreach (EquipmentTypeButton equipmentTypeButton in equipmentTypeButtons)
		{
			equipmentTypeButton.activeIndicator.SetActive(false);
		}
		currentTypeButton.activeIndicator.SetActive(true);
	}

	public void RefreshEquipmentParameters(EquipmentObject equipmentObject)
	{
		if (equipmentObject == null)
		{
			for (int i = 0; i < infoParameters.Count; i++)
			{
				infoParameters[i].gameObject.SetActive(false);
			}
			infoBestFor.text = string.Empty;
			infoBestForLures.text = string.Empty;
			return;
		}
		equipmentObject.Initialize(true);
		for (int j = 0; j < infoParameters.Count; j++)
		{
			if (j >= equipmentObject.parameters.Count)
			{
				continue;
			}
			infoParameters[j].gameObject.SetActive(equipmentObject.parameters[j].isVisible);
			if (equipmentObject.parameters[j].isVisible)
			{
				infoParameters[j].nameText.text = equipmentObject.parameters[j].parameterName;
				if (equipmentObject.parameters[j].type == EquipmentObject.Parameter.ParameterType.STRING)
				{
					infoParameters[j].valueText.text = Utilities.GetTranslation(equipmentObject.parameters[j].parameterString);
				}
				else if (equipmentObject.parameters[j].type == EquipmentObject.Parameter.ParameterType.INT)
				{
					infoParameters[j].valueText.text = equipmentObject.parameters[j].parameterInt.ToString();
				}
				else if (equipmentObject.parameters[j].type == EquipmentObject.Parameter.ParameterType.FLOAT)
				{
					infoParameters[j].valueText.text = equipmentObject.parameters[j].parameterFloat.ToString("F2");
				}
				else if (equipmentObject.parameters[j].type == EquipmentObject.Parameter.ParameterType.BOOL)
				{
					infoParameters[j].valueText.text = equipmentObject.parameters[j].parameterBool.ToString();
				}
			}
		}
		if (equipmentObject.equipmentType == EquipmentObject.EquipmentType.BAIT || equipmentObject.equipmentType == EquipmentObject.EquipmentType.BOILIE || equipmentObject.equipmentType == EquipmentObject.EquipmentType.FEEDER_BAIT || (equipmentObject.equipmentType == EquipmentObject.EquipmentType.HOOK && equipmentObject.prefab.GetComponent<Bait>().baitType != Bait.BaitType.HOOK))
		{
			infoBestFor.text = "<b>" + Utilities.GetTranslation("GUI/BEST_FOR") + "</b>: ";
			FishLikesParams component = equipmentObject.prefab.GetComponent<FishLikesParams>();
			foreach (FishLikesParams.FishInterest fishInterest in component.fishInterests)
			{
				FishManager.FishDefinition fishDefinition = GlobalSettings.Instance.fishManager.GetFishDefinition(fishInterest.species);
				if (fishInterest.interest >= 0.5f && fishDefinition != null && fishDefinition.isAvailable && fishDefinition.isAvailableFromDLCs)
				{
					infoBestFor.text += GlobalSettings.Instance.fishManager.GetFishName(fishInterest.species);
					infoBestFor.text += ", ";
				}
			}
			infoBestFor.text = infoBestFor.text.Remove(infoBestFor.text.Length - 2, 2);
			infoBestForLures.text = infoBestFor.text;
			infoBestFor.enabled = equipmentObject.equipmentType != EquipmentObject.EquipmentType.HOOK;
			infoBestForLures.enabled = equipmentObject.equipmentType == EquipmentObject.EquipmentType.HOOK;
		}
		else
		{
			infoBestFor.text = string.Empty;
			infoBestForLures.text = string.Empty;
		}
		if (equipmentObject.equipmentType == EquipmentObject.EquipmentType.HOOK)
		{
			infoBestFor.text = string.Empty;
		}
		else
		{
			infoBestForLures.text = string.Empty;
		}
		infoBestForScrollRect.content.sizeDelta = new Vector2(infoBestFor.preferredWidth, infoBestFor.preferredHeight);
		infoBestForScrollRect.verticalScrollbar.value = 1f;
		infoBestForScrollRect.verticalNormalizedPosition = 1f;
		infoBestForLuresScrollRect.content.sizeDelta = new Vector2(infoBestForLures.preferredWidth, infoBestForLures.preferredHeight);
		infoBestForLuresScrollRect.verticalScrollbar.value = 1f;
		infoBestForLuresScrollRect.verticalNormalizedPosition = 1f;
		infoBestForScrollRect.gameObject.SetActive(infoBestFor.text != string.Empty);
		infoBestForLuresScrollRect.gameObject.SetActive(infoBestForLures.text != string.Empty);
	}

	public void RefreshTotalDurability()
	{
	}

	public void ChangeEquipment()
	{
		if ((bool)GameController.Instance)
		{
			GameController.Instance.fishingPlayer.currentHands.ChangeEquipmentButton();
			ResetChanged();
		}
	}

	public void ResetChanged()
	{
		for (int i = 0; i < equipmentCurrentObjects.Count; i++)
		{
			equipmentCurrentObjects[i].ShowEquipmentChanged(false);
		}
		for (int j = 0; j < equipmentCurrentBaits.Count; j++)
		{
			equipmentCurrentBaits[j].ShowEquipmentChanged(false);
		}
	}

	public bool IsEquipmentWithAmount(EquipmentObject.EquipmentType equipmentType)
	{
		return equipmentType == EquipmentObject.EquipmentType.HOOK || equipmentType == EquipmentObject.EquipmentType.BOILIE || equipmentType == EquipmentObject.EquipmentType.ROD || equipmentType == EquipmentObject.EquipmentType.ICE_ROD || equipmentType == EquipmentObject.EquipmentType.REEL || equipmentType == EquipmentObject.EquipmentType.LINE || equipmentType == EquipmentObject.EquipmentType.FEEDER || equipmentType == EquipmentObject.EquipmentType.FEEDER_BAIT || equipmentType == EquipmentObject.EquipmentType.FLOAT || equipmentType == EquipmentObject.EquipmentType.BITE_INDICATOR;
	}

	public bool IsEquippedInCurrentSet(EquipmentObject equipmentObject)
	{
		if (equipmentObject.IsBuyAndEquip())
		{
			return equipmentObject.isEquipped;
		}
		return equipmentCurrentObjects[(int)equipmentObject.equipmentType].equipmentObject == equipmentObject;
	}

	public void UpdateCanEquipmentBeChanged()
	{
		canEquipmentBeChanged = true;
		if ((bool)GameController.Instance)
		{
			FishingHands fishingHands = GameController.Instance.fishingPlayer.allFishingHands[equipmentManager.currentEquipmentSetId];
			if (GameController.Instance.iceLevel)
			{
				isCurrentSet = equipmentManager.currentEquipmentSetId == GameController.Instance.fishingPlayer.currentHands.equipmentSetId;
			}
			else
			{
				isCurrentSet = GameController.Instance.fishingPlayer.currentHands == fishingHands;
			}
			canSetBeChanged = GameController.Instance.fishingPlayer.CanChangeEquipment() || ((bool)GameController.Instance.fishingPlayer.currentHands.fishingRod && GameController.Instance.fishingPlayer.currentHands.fishingRod.isOnRodStand);
			Utilities.LogError(GameController.Instance.iceLevel, "equipmentManager.currentEquipmentSetId: " + equipmentManager.currentEquipmentSetId + " isCurrentSet: " + isCurrentSet + " canSetBeChanged: " + canSetBeChanged, "lightblue", true);
			if (!isCurrentSet)
			{
				canEquipmentBeChanged = !fishingHands.fishingRod || !fishingHands.fishingRod.isOnRodStand;
			}
			else
			{
				canEquipmentBeChanged = GameController.Instance.fishingPlayer.CanChangeEquipment();
			}
		}
	}

	public void UpdateEquipVisibility(bool showEquipBtn)
	{
		infoBtnEquip.interactable = showEquipBtn;
		for (int i = 0; i < infoBtnEquipBaits.Count; i++)
		{
			infoBtnEquipBaits[i].interactable = showEquipBtn;
		}
	}
}