using System;
using System.Collections.Generic;
using BitStrap;
using UnityEngine;

public class EquipmentManager : MonoBehaviour
{
	[Serializable]
	public class SetSpecificParameters
	{
		public float currentFloatDepth = 50f;

		public float currentFloatWeight;

		public float currentHookSize;
	}

	[ReadOnly]
	public int equipmentCount;

	public List<EquipmentObject> equipmentAll = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentRods = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentIceRods = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentReels = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentLines = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentFloats = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentBaits = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentHooks = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentNets = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentOther = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentBoilies = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentRodStands = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentFeeders = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentFeederBaits = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentBiteIndicator = new List<EquipmentObject>();

	[Header("Rods")]
	public List<EquipmentObject> equipmentRodsSpinning = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentRodsCasting = new List<EquipmentObject>();

	[Header("Reels")]
	public List<EquipmentObject> equipmentReelsStandard = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentReelsLineCounter = new List<EquipmentObject>();

	[Header("Ground")]
	public List<EquipmentObject> equipmentRodsGround = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentReelsGround = new List<EquipmentObject>();

	[Header("Fly")]
	public List<EquipmentObject> equipmentRodsFly = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentReelsFly = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentLinesFly = new List<EquipmentObject>();

	[Header("Hooks/Lures")]
	public List<EquipmentObject> equipmentNormalHooks = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentSpinners = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentSpoons = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentWobblers = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentSoftBaits = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentFlies = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentDLC_01 = new List<EquipmentObject>();

	[Header("Current")]
	public List<EquipmentObject> currentEquipment = new List<EquipmentObject>(13);

	public List<EquipmentObject> currentBaits = new List<EquipmentObject>();

	public const int equipmentSetsAmount = 5;

	public int currentEquipmentSetId;

	public List<EquipmentObject>[] equipmentSets = new List<EquipmentObject>[5];

	public List<EquipmentObject>[] baitsSets = new List<EquipmentObject>[5];

	public List<EquipmentObject> equipmentSet_01 = new List<EquipmentObject>(13);

	public List<EquipmentObject> baitsSet_01 = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentSet_02 = new List<EquipmentObject>(13);

	public List<EquipmentObject> baitsSet_02 = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentSet_03 = new List<EquipmentObject>(13);

	public List<EquipmentObject> baitsSet_03 = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentSet_04 = new List<EquipmentObject>(13);

	public List<EquipmentObject> baitsSet_04 = new List<EquipmentObject>();

	public List<EquipmentObject> equipmentSet_05 = new List<EquipmentObject>(13);

	public List<EquipmentObject> baitsSet_05 = new List<EquipmentObject>();

	[Space(10f)]
	public List<string> startEquipment = new List<string>();

	[Header("Random params set")]
	public List<FishingRod> equipmentFishingRods = new List<FishingRod>();

	public List<FishingReel> equipmentFishingReels = new List<FishingReel>();

	public float minFloatDepth = 30f;

	public float maxFloatDepth = 250f;

	[Space(10f)]
	public SetSpecificParameters currentSetSpecificParameters;

	public List<SetSpecificParameters> setSpecificParameters = new List<SetSpecificParameters>();

	public float currentFloatDepth;

	public float currentFloatWeight;

	public float currentHookSize;

	[Space(10f)]
	public List<float> hookSizesCm = new List<float>();

	public float sellObjectFactor = 0.66f;

	[Header("Equipment Change")]
	public List<bool> equipmentChanged = new List<bool>(13);

	[Header("Producer Names")]
	public List<string> producerNames = new List<string>();

	[Header("Prices")]
	public float globalPriceMultiplier = 1f;

	public Vector2 priceRod = Vector2.one;

	public Vector2 priceIceRod = Vector2.one;

	public Vector2 priceReel = Vector2.one;

	public Vector2 priceLine = Vector2.one;

	public Vector2 priceFloat = Vector2.one;

	public Vector2 priceBait = Vector2.one;

	public Vector2 priceHook = Vector2.one;

	[HideInInspector]
	public PlayerSettingsMy playerSettings;

	private void Awake()
	{
		equipmentSets[0] = equipmentSet_01;
		equipmentSets[1] = equipmentSet_02;
		equipmentSets[2] = equipmentSet_03;
		equipmentSets[3] = equipmentSet_04;
		equipmentSets[4] = equipmentSet_05;
		baitsSets[0] = baitsSet_01;
		baitsSets[1] = baitsSet_02;
		baitsSets[2] = baitsSet_03;
		baitsSets[3] = baitsSet_04;
		baitsSets[4] = baitsSet_05;
		ChangeCurrentEquipmentSet(0);
		foreach (EquipmentObject item in equipmentRodsSpinning)
		{
			equipmentRods.Add(item);
		}
		foreach (EquipmentObject item2 in equipmentRodsCasting)
		{
			equipmentRods.Add(item2);
		}
		foreach (EquipmentObject item3 in equipmentReelsStandard)
		{
			equipmentReels.Add(item3);
		}
		foreach (EquipmentObject item4 in equipmentReelsLineCounter)
		{
			equipmentReels.Add(item4);
		}
		foreach (EquipmentObject item5 in equipmentRodsGround)
		{
			equipmentRods.Add(item5);
		}
		foreach (EquipmentObject item6 in equipmentReelsGround)
		{
			equipmentReels.Add(item6);
		}
		foreach (EquipmentObject item7 in equipmentRodsFly)
		{
			equipmentRods.Add(item7);
		}
		foreach (EquipmentObject item8 in equipmentReelsFly)
		{
			equipmentReels.Add(item8);
		}
		foreach (EquipmentObject item9 in equipmentLinesFly)
		{
			equipmentLines.Add(item9);
		}
		foreach (EquipmentObject item10 in equipmentDLC_01)
		{
			if (item10.equipmentType != EquipmentObject.EquipmentType.HOOK)
			{
				continue;
			}
			if ((bool)DLCManager.Instance && DLCManager.Instance.IsDLCInstalled(DLCManager.DLC_ID.EQUIPMENT_01))
			{
				switch (item10.prefab.GetComponent<Bait>().baitType)
				{
				case Bait.BaitType.WOBBLER:
					equipmentWobblers.Add(item10);
					break;
				case Bait.BaitType.SOFT_BAIT:
					equipmentSoftBaits.Add(item10);
					break;
				case Bait.BaitType.SPINNER:
					equipmentSpinners.Add(item10);
					break;
				case Bait.BaitType.SPOON:
					equipmentSpoons.Add(item10);
					break;
				case Bait.BaitType.FLY:
					equipmentFlies.Add(item10);
					break;
				}
			}
			else
			{
				equipmentHooks.Add(item10);
			}
		}
		foreach (EquipmentObject equipmentNormalHook in equipmentNormalHooks)
		{
			equipmentHooks.Add(equipmentNormalHook);
		}
		foreach (EquipmentObject equipmentWobbler in equipmentWobblers)
		{
			equipmentHooks.Add(equipmentWobbler);
		}
		foreach (EquipmentObject equipmentSoftBait in equipmentSoftBaits)
		{
			equipmentHooks.Add(equipmentSoftBait);
		}
		foreach (EquipmentObject equipmentSpinner in equipmentSpinners)
		{
			equipmentHooks.Add(equipmentSpinner);
		}
		foreach (EquipmentObject equipmentSpoon in equipmentSpoons)
		{
			equipmentHooks.Add(equipmentSpoon);
		}
		foreach (EquipmentObject equipmentFly in equipmentFlies)
		{
			equipmentHooks.Add(equipmentFly);
		}
	}

	private void Start()
	{
		playerSettings = GlobalSettings.Instance.playerSettings;
		foreach (EquipmentObject equipmentRod in equipmentRods)
		{
			equipmentRod.equipmentType = EquipmentObject.EquipmentType.ROD;
			equipmentRod.hasAmount = true;
			equipmentRod.maxAmount = 5;
			equipmentRod.Initialize();
		}
		foreach (EquipmentObject equipmentIceRod in equipmentIceRods)
		{
			equipmentIceRod.equipmentType = EquipmentObject.EquipmentType.ICE_ROD;
			equipmentIceRod.hasAmount = true;
			equipmentIceRod.maxAmount = 5;
			equipmentIceRod.Initialize();
		}
		foreach (EquipmentObject equipmentReel in equipmentReels)
		{
			equipmentReel.equipmentType = EquipmentObject.EquipmentType.REEL;
			equipmentReel.hasAmount = true;
			equipmentReel.maxAmount = 5;
			equipmentReel.Initialize();
		}
		foreach (EquipmentObject equipmentLine in equipmentLines)
		{
			equipmentLine.equipmentType = EquipmentObject.EquipmentType.LINE;
			equipmentLine.hasAmount = true;
			equipmentLine.maxAmount = 5;
			equipmentLine.Initialize();
		}
		foreach (EquipmentObject equipmentFloat in equipmentFloats)
		{
			equipmentFloat.equipmentType = EquipmentObject.EquipmentType.FLOAT;
			equipmentFloat.hasAmount = true;
			equipmentFloat.maxAmount = 5;
			equipmentFloat.Initialize();
		}
		foreach (EquipmentObject equipmentBait in equipmentBaits)
		{
			equipmentBait.equipmentType = EquipmentObject.EquipmentType.BAIT;
			equipmentBait.Initialize();
		}
		foreach (EquipmentObject equipmentHook in equipmentHooks)
		{
			equipmentHook.equipmentType = EquipmentObject.EquipmentType.HOOK;
			equipmentHook.Initialize();
		}
		foreach (EquipmentObject item in equipmentOther)
		{
			item.equipmentType = EquipmentObject.EquipmentType.OTHER;
			item.Initialize();
		}
		foreach (EquipmentObject equipmentBoily in equipmentBoilies)
		{
			equipmentBoily.equipmentType = EquipmentObject.EquipmentType.BOILIE;
			equipmentBoily.Initialize();
		}
		foreach (EquipmentObject equipmentRodStand in equipmentRodStands)
		{
			equipmentRodStand.equipmentType = EquipmentObject.EquipmentType.ROD_STAND;
			equipmentRodStand.Initialize();
		}
		foreach (EquipmentObject equipmentFeeder in equipmentFeeders)
		{
			equipmentFeeder.equipmentType = EquipmentObject.EquipmentType.FEEDER;
			equipmentFeeder.Initialize();
		}
		foreach (EquipmentObject equipmentFeederBait in equipmentFeederBaits)
		{
			equipmentFeederBait.price = Mathf.RoundToInt((float)equipmentFeederBait.price * 0.66f);
			equipmentFeederBait.equipmentType = EquipmentObject.EquipmentType.FEEDER_BAIT;
			equipmentFeederBait.Initialize();
		}
		foreach (EquipmentObject item2 in equipmentBiteIndicator)
		{
			item2.equipmentType = EquipmentObject.EquipmentType.BITE_INDICATOR;
			item2.Initialize();
		}
		UpdateAllPriceAndLevel();
	}

	public List<EquipmentObject> GetEquipmentList(EquipmentObject.EquipmentType type)
	{
		switch (type)
		{
		case EquipmentObject.EquipmentType.ROD:
			return equipmentRods;
		case EquipmentObject.EquipmentType.ICE_ROD:
			return equipmentIceRods;
		case EquipmentObject.EquipmentType.REEL:
			return equipmentReels;
		case EquipmentObject.EquipmentType.LINE:
			return equipmentLines;
		case EquipmentObject.EquipmentType.FLOAT:
			return equipmentFloats;
		case EquipmentObject.EquipmentType.BAIT:
			return equipmentBaits;
		case EquipmentObject.EquipmentType.HOOK:
			return equipmentHooks;
		case EquipmentObject.EquipmentType.OTHER:
			return equipmentOther;
		case EquipmentObject.EquipmentType.BOILIE:
			return equipmentBoilies;
		case EquipmentObject.EquipmentType.ROD_STAND:
			return equipmentRodStands;
		case EquipmentObject.EquipmentType.FEEDER:
			return equipmentFeeders;
		case EquipmentObject.EquipmentType.FEEDER_BAIT:
			return equipmentFeederBaits;
		case EquipmentObject.EquipmentType.BITE_INDICATOR:
			return equipmentBiteIndicator;
		default:
			return null;
		}
	}

	public List<EquipmentObject> GetEquipmentSpecificList(EquipmentTileViewParameters equipmentTileViewParameters)
	{
		return GetEquipmentSpecificList(equipmentTileViewParameters.equipmentType, equipmentTileViewParameters.rodType, equipmentTileViewParameters.reelType, equipmentTileViewParameters.lineType, equipmentTileViewParameters.baitType, equipmentTileViewParameters.allTypes);
	}

	public List<EquipmentObject> GetEquipmentSpecificList(EquipmentObject.EquipmentType type, FishingRod.RodType rodType, FishingReel.ReelType reelType, FishingLine.LineType lineType, Bait.BaitType baitType, bool allTypes)
	{
		switch (type)
		{
		case EquipmentObject.EquipmentType.ROD:
			if (allTypes)
			{
				return GetEquipmentList(type);
			}
			switch (rodType)
			{
			case FishingRod.RodType.SPINNING:
				return equipmentRodsSpinning;
			case FishingRod.RodType.CASTING:
				return equipmentRodsCasting;
			case FishingRod.RodType.GROUND:
				return equipmentRodsGround;
			case FishingRod.RodType.FLY_FISHING:
				return equipmentRodsFly;
			}
			break;
		case EquipmentObject.EquipmentType.REEL:
			if (allTypes)
			{
				return GetEquipmentList(type);
			}
			switch (reelType)
			{
			case FishingReel.ReelType.STANDARD:
				return equipmentReelsStandard;
			case FishingReel.ReelType.LINE_COUNTER:
				return equipmentReelsLineCounter;
			case FishingReel.ReelType.GROUND:
				return equipmentReelsGround;
			case FishingReel.ReelType.FLY:
				return equipmentReelsFly;
			}
			break;
		case EquipmentObject.EquipmentType.LINE:
			return GetEquipmentList(type);
		case EquipmentObject.EquipmentType.HOOK:
			switch (baitType)
			{
			case Bait.BaitType.HOOK:
				return equipmentNormalHooks;
			case Bait.BaitType.WOBBLER:
				return equipmentWobblers;
			case Bait.BaitType.SOFT_BAIT:
				return equipmentSoftBaits;
			case Bait.BaitType.SPINNER:
				return equipmentSpinners;
			case Bait.BaitType.SPOON:
				return equipmentSpoons;
			case Bait.BaitType.FLY:
				return equipmentFlies;
			case Bait.BaitType.SAKURA_DLC_01:
				return equipmentDLC_01;
			}
			break;
		default:
			return GetEquipmentList(type);
		}
		return null;
	}

	public List<EquipmentObject> GetHooksList(Bait.BaitType type)
	{
		switch (type)
		{
		case Bait.BaitType.HOOK:
			return equipmentNormalHooks;
		case Bait.BaitType.WOBBLER:
			return equipmentWobblers;
		case Bait.BaitType.SOFT_BAIT:
			return equipmentSoftBaits;
		case Bait.BaitType.SPINNER:
			return equipmentSpinners;
		case Bait.BaitType.SPOON:
			return equipmentSpoons;
		case Bait.BaitType.FLY:
			return equipmentFlies;
		default:
			return null;
		}
	}

	public EquipmentObject FindEquipment(EquipmentObject.EquipmentType type, string id)
	{
		if (string.IsNullOrEmpty(id))
		{
			return null;
		}
		List<EquipmentObject> equipmentList = GetEquipmentList(type);
		if (equipmentList != null)
		{
			foreach (EquipmentObject item in equipmentList)
			{
				if (item.id == id)
				{
					return item;
				}
			}
		}
		Debug.LogError("FindEquipment not found: " + id);
		return null;
	}

	public EquipmentObject FindEquipment(EquipmentObject.EquipmentSubType type, string id)
	{
		if (string.IsNullOrEmpty(id))
		{
			return null;
		}
		foreach (EquipmentObject item in equipmentOther)
		{
			if (item.id == id)
			{
				return item;
			}
		}
		Debug.LogError("FindEquipment SubType not found: " + id);
		return null;
	}

	public void EquipObject(EquipmentObject equipmentObject, int setId = -1, int baitId = -1)
	{
		if (equipmentObject.equipmentType == EquipmentObject.EquipmentType.BAIT)
		{
			List<EquipmentObject> list = ((setId != -1) ? baitsSets[setId] : currentBaits);
			int num = ((baitId != -1) ? baitId : GetAvailableBaitSlot());
			if (num < 0 || num >= list.Count)
			{
				Debug.LogWarning("No slot ID");
				return;
			}
			if (list[num] != null)
			{
			}
			list[num] = equipmentObject;
		}
		else if (equipmentObject.equipmentType == EquipmentObject.EquipmentType.ROD_STAND || equipmentObject.equipmentType == EquipmentObject.EquipmentType.BOILIE)
		{
			for (int i = 0; i < equipmentSets.Length; i++)
			{
				if (equipmentSets[i][(int)equipmentObject.equipmentType] != null)
				{
					equipmentSets[i][(int)equipmentObject.equipmentType].Equip(false);
				}
				equipmentSets[i][(int)equipmentObject.equipmentType] = equipmentObject;
			}
		}
		else
		{
			List<EquipmentObject> list2 = ((setId != -1) ? equipmentSets[setId] : currentEquipment);
			if (list2[(int)equipmentObject.equipmentType] != null)
			{
				list2[(int)equipmentObject.equipmentType].Equip(false);
			}
			list2[(int)equipmentObject.equipmentType] = equipmentObject;
		}
		equipmentObject.Equip(true);
	}

	public void UnequipObject(EquipmentObject.EquipmentType equipmentType, int setId = -1, int baitId = 0)
	{
		switch (equipmentType)
		{
		case EquipmentObject.EquipmentType.BAIT:
		{
			List<EquipmentObject> list2 = ((setId != -1) ? baitsSets[setId] : currentBaits);
			if (list2[baitId] != null && list2[baitId].prefab != null)
			{
				list2[baitId].Equip(false);
			}
			list2[baitId] = null;
			break;
		}
		case EquipmentObject.EquipmentType.BOILIE:
		case EquipmentObject.EquipmentType.ROD_STAND:
		{
			for (int i = 0; i < equipmentSets.Length; i++)
			{
				if (equipmentSets[i][(int)equipmentType] != null)
				{
					equipmentSets[i][(int)equipmentType].Equip(false);
				}
				equipmentSets[i][(int)equipmentType] = null;
			}
			break;
		}
		default:
		{
			List<EquipmentObject> list = ((setId != -1) ? equipmentSets[setId] : currentEquipment);
			if (list[(int)equipmentType] != null)
			{
				list[(int)equipmentType].Equip(false);
			}
			list[(int)equipmentType] = null;
			break;
		}
		}
	}

	public int GetAvailableBaitSlot()
	{
		for (int i = 0; i < currentBaits.Count; i++)
		{
			if (currentBaits[i] == null || currentBaits[i].prefab == null)
			{
				return i;
			}
		}
		return -1;
	}

	public bool HasAvailableBaitSlot()
	{
		return GetAvailableBaitSlot() >= 0;
	}

	public bool HasBoilieEquiped()
	{
		return GetCurrentEquipment(EquipmentObject.EquipmentType.BOILIE) != null && (bool)GetCurrentEquipment(EquipmentObject.EquipmentType.BOILIE).prefab;
	}

	public void BuyObject(EquipmentObject equipmentObject)
	{
		playerSettings.AddMoney(-equipmentObject.GetCurrentSellPrice());
		equipmentObject.Buy();
		Save();
		playerSettings.Save();
	}

	public void SellObject(EquipmentObject equipmentObject)
	{
		playerSettings.AddMoney(Mathf.RoundToInt((float)equipmentObject.price * sellObjectFactor));
		equipmentObject.Sell();
		Save();
		playerSettings.Save();
	}

	public EquipmentObject GetCurrentEquipment(EquipmentObject.EquipmentType equipmentType)
	{
		if (currentEquipment == null)
		{
			Debug.LogError("currentEquipment == null");
			return null;
		}
		return currentEquipment[(int)equipmentType];
	}

	public List<EquipmentObject> GetCurrentEquipmentBaits()
	{
		return currentBaits;
	}

	public void ChangeCurrentEquipmentSet(int setId)
	{
		currentEquipmentSetId = setId;
		currentEquipment = equipmentSets[setId];
		currentBaits = baitsSets[setId];
		currentSetSpecificParameters = setSpecificParameters[setId];
	}

	public int CountFillets(int fishMoney)
	{
		return Mathf.CeilToInt((float)fishMoney / ((float)FindEquipment(EquipmentObject.EquipmentType.OTHER, "FILLET_01").price * 1.3f));
	}

	public void AddFillets(int fishMoney)
	{
		EquipmentObject equipmentObject = FindEquipment(EquipmentObject.EquipmentType.OTHER, "FILLET_01");
		int num = Mathf.CeilToInt((float)fishMoney / ((float)equipmentObject.price * 1.3f));
		equipmentObject.amount += Mathf.CeilToInt(num);
		Debug.Log("Added fillets: " + num + " fishMoney: " + fishMoney);
	}

	public void AddYoungFishBait(int size, int amount)
	{
		EquipmentObject equipmentObject = null;
		switch (size)
		{
		case 1:
			equipmentObject = FindEquipment(EquipmentObject.EquipmentType.BAIT, "BAIT_YOUNG_FISH_S_01");
			break;
		case 2:
			equipmentObject = FindEquipment(EquipmentObject.EquipmentType.BAIT, "BAIT_YOUNG_FISH_M_01");
			break;
		case 3:
			equipmentObject = FindEquipment(EquipmentObject.EquipmentType.BAIT, "BAIT_YOUNG_FISH_L_01");
			break;
		}
		if (equipmentObject != null)
		{
			equipmentObject.amount += amount;
		}
		Debug.Log("AddYoungFishBait size:" + size);
	}

	public int GetRodId()
	{
		if ((bool)GetCurrentEquipment(EquipmentObject.EquipmentType.ROD).prefab)
		{
			for (int i = 0; i < equipmentRods.Count; i++)
			{
				if (equipmentRods[i].prefab == GetCurrentEquipment(EquipmentObject.EquipmentType.ROD).prefab)
				{
					return i;
				}
			}
		}
		return 0;
	}

	[Button]
	public void BuyAll()
	{
		for (int i = 0; i < 13; i++)
		{
			List<EquipmentObject> equipmentList = GetEquipmentList((EquipmentObject.EquipmentType)i);
			if (equipmentList != null)
			{
				for (int j = 0; j < equipmentList.Count; j++)
				{
					equipmentList[j].Buy();
				}
			}
		}
	}

	[Button]
	public void BuyAllMax()
	{
		for (int i = 0; i < 13; i++)
		{
			List<EquipmentObject> equipmentList = GetEquipmentList((EquipmentObject.EquipmentType)i);
			if (equipmentList != null)
			{
				for (int j = 0; j < equipmentList.Count; j++)
				{
					equipmentList[j].SetAmount(equipmentList[j].maxAmount);
				}
			}
		}
	}

	public bool HasAnythingChanged()
	{
		for (int i = 0; i < equipmentChanged.Count; i++)
		{
			if (equipmentChanged[i])
			{
				return true;
			}
		}
		return false;
	}

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

	public void EquipmentChanged(EquipmentObject.EquipmentType equipmentType)
	{
		if (equipmentType == EquipmentObject.EquipmentType.COUNT)
		{
			equipmentChanged[0] = GameController.Instance;
			equipmentChanged[10] = GameController.Instance;
			equipmentChanged[12] = GameController.Instance;
		}
		else
		{
			equipmentChanged[(int)equipmentType] = GameController.Instance;
		}
	}

	public string GetProducerName(int id)
	{
		if (id >= 0)
		{
			return producerNames[id];
		}
		return string.Empty;
	}

	public float CalculateEquipmentDurability()
	{
		return 0f;
	}

	[Button]
	public void UpdateAllPriceAndLevel()
	{
		foreach (EquipmentObject equipmentRod in equipmentRods)
		{
			equipmentRod.CalculateValue();
		}
		foreach (EquipmentObject equipmentIceRod in equipmentIceRods)
		{
			equipmentIceRod.CalculateValue();
		}
		foreach (EquipmentObject equipmentReel in equipmentReels)
		{
			equipmentReel.CalculateValue();
		}
		foreach (EquipmentObject equipmentLine in equipmentLines)
		{
			equipmentLine.CalculateValue();
		}
		foreach (EquipmentObject equipmentFloat in equipmentFloats)
		{
			equipmentFloat.CalculateValue();
		}
		foreach (EquipmentObject equipmentBait in equipmentBaits)
		{
			equipmentBait.CalculateValue();
		}
		foreach (EquipmentObject equipmentHook in equipmentHooks)
		{
			equipmentHook.CalculateValue();
		}
		foreach (EquipmentObject item in equipmentOther)
		{
			item.CalculateValue();
		}
		foreach (EquipmentObject equipmentBoily in equipmentBoilies)
		{
			equipmentBoily.CalculateValue();
		}
	}

	public Vector2 GetEquipmentPriceAndLevel(EquipmentObject.EquipmentType equipmentType, float value)
	{
		Vector2 one = Vector2.one;
		if (value < 0f)
		{
			return -one;
		}
		bool flag = value > 1f;
		if (flag)
		{
			value -= 1f;
		}
		value = Mathf.Pow(value, 1.5f);
		switch (equipmentType)
		{
		case EquipmentObject.EquipmentType.ROD:
			one.x = Mathf.Lerp(priceRod.x, priceRod.y, value);
			break;
		case EquipmentObject.EquipmentType.ICE_ROD:
			one.x = Mathf.Lerp(priceIceRod.x, priceIceRod.y, value);
			break;
		case EquipmentObject.EquipmentType.REEL:
			one.x = Mathf.Lerp(priceReel.x, priceReel.y, value);
			break;
		case EquipmentObject.EquipmentType.LINE:
			one.x = Mathf.Lerp(priceLine.x, priceLine.y, value);
			break;
		case EquipmentObject.EquipmentType.FLOAT:
			one.x = Mathf.Lerp(priceFloat.x, priceFloat.y, value);
			break;
		case EquipmentObject.EquipmentType.BAIT:
			one.x = Mathf.Lerp(priceBait.x, priceBait.y, value);
			break;
		case EquipmentObject.EquipmentType.HOOK:
			one.x = Mathf.Lerp(priceHook.x, priceHook.y, value);
			break;
		}
		one.x *= globalPriceMultiplier;
		if (equipmentType == EquipmentObject.EquipmentType.REEL)
		{
			value *= 1.2f;
		}
		one.y = Mathf.Lerp(0f, (int)playerSettings.maxPlayerLevelPrices, value);
		one.y = Mathf.Clamp(one.y, 1f, (int)playerSettings.maxPlayerLevel);
		if (flag)
		{
			switch (equipmentType)
			{
			case EquipmentObject.EquipmentType.ROD:
				one.x += priceRod.y;
				break;
			case EquipmentObject.EquipmentType.REEL:
				one.x += priceReel.y;
				break;
			case EquipmentObject.EquipmentType.LINE:
				one.x += priceLine.y;
				break;
			}
			one.y = (float)(int)playerSettings.maxPlayerLevelPrices + 1f;
		}
		return one;
	}

	[Button]
	public void CalculateEquipmentCount()
	{
		equipmentCount = 0;
		equipmentCount += equipmentRods.Count;
		equipmentCount += equipmentIceRods.Count;
		equipmentCount += equipmentReels.Count;
		equipmentCount += equipmentLines.Count;
		equipmentCount += equipmentFloats.Count;
		equipmentCount += equipmentBaits.Count;
		equipmentCount += equipmentOther.Count;
		equipmentCount += equipmentRods.Count;
		equipmentCount += equipmentNormalHooks.Count;
		equipmentCount += equipmentSpinners.Count;
		equipmentCount += equipmentSpoons.Count;
		equipmentCount += equipmentWobblers.Count;
		equipmentCount += equipmentSoftBaits.Count;
	}

	[Button]
	public void CopyRodsToTypes()
	{
		for (int i = 0; i < equipmentRods.Count; i++)
		{
			switch (equipmentRods[i].prefab.GetComponent<FishingRod>().rodType)
			{
			case FishingRod.RodType.SPINNING:
				equipmentRodsSpinning.Add(equipmentRods[i]);
				break;
			case FishingRod.RodType.CASTING:
				equipmentRodsCasting.Add(equipmentRods[i]);
				break;
			}
		}
	}

	[Button]
	public void CopyReelsToTypes()
	{
		for (int i = 0; i < equipmentReels.Count; i++)
		{
			switch (equipmentReels[i].prefab.GetComponent<FishingReel>().reelType)
			{
			case FishingReel.ReelType.STANDARD:
				equipmentReelsStandard.Add(equipmentReels[i]);
				break;
			case FishingReel.ReelType.LINE_COUNTER:
				equipmentReelsLineCounter.Add(equipmentReels[i]);
				break;
			}
		}
	}

	[Button]
	public void ShuffleRods()
	{
		Utilities.Shuffle(equipmentFishingRods);
	}

	[Button]
	public void CalculateRodParams()
	{
		float num = 19f;
		for (int i = 0; i < equipmentFishingRods.Count; i++)
		{
			float num2 = num;
			float num3 = UnityEngine.Random.Range(-1f, 1f);
			num3 = num3 * num * 0.25f;
			equipmentFishingRods[i].durability = Mathf.Clamp01((num2 + num3) / 100f);
			num += 3.4f;
		}
		Debug.Log("currentValue: " + num);
	}

	[Button]
	public void ShuffleReels()
	{
		Utilities.Shuffle(equipmentFishingReels);
	}

	[Button]
	public void CalculateReelParams()
	{
		float num = 22f;
		for (int i = 0; i < equipmentFishingReels.Count; i++)
		{
			float num2 = num;
			float num3 = num;
			float num4 = num;
			float num5 = UnityEngine.Random.Range(-1f, 1f);
			num5 = num5 * num * 0.25f;
			equipmentFishingReels[i].durability = Mathf.Clamp01((num2 + num5) / 200f);
			equipmentFishingReels[i].dragSteps = Mathf.RoundToInt(Mathf.Clamp01((num3 - num5) / 200f) * (float)FishingReel.maxDragSteps);
			equipmentFishingReels[i].maxLineLength = Mathf.RoundToInt(Mathf.Lerp(6f, 30f, Mathf.Clamp01(num / 200f))) * 10;
			num += 8.5f;
		}
		Debug.Log("currentReelValue: " + num);
	}

	public bool CheckMinimumRequiredEquipment()
	{
		if (GameController.Instance.iceLevel)
		{
			if (GetCurrentEquipment(EquipmentObject.EquipmentType.ICE_ROD) == null || GetCurrentEquipment(EquipmentObject.EquipmentType.ICE_ROD).prefab == null)
			{
				return false;
			}
			if (GetCurrentEquipment(EquipmentObject.EquipmentType.LINE) == null || GetCurrentEquipment(EquipmentObject.EquipmentType.LINE).prefab == null)
			{
				return false;
			}
		}
		else
		{
			if (GetCurrentEquipment(EquipmentObject.EquipmentType.ROD) == null || GetCurrentEquipment(EquipmentObject.EquipmentType.ROD).prefab == null)
			{
				return false;
			}
			if (GetCurrentEquipment(EquipmentObject.EquipmentType.REEL) == null || GetCurrentEquipment(EquipmentObject.EquipmentType.REEL).prefab == null)
			{
				return false;
			}
			if (GetCurrentEquipment(EquipmentObject.EquipmentType.LINE) == null || GetCurrentEquipment(EquipmentObject.EquipmentType.LINE).prefab == null)
			{
				return false;
			}
		}
		return true;
	}

	[Button]
	public void TestUnequip()
	{
		List<EquipmentObject> list = equipmentSets[0];
		for (int i = 0; i < list.Count; i++)
		{
			UnequipObject((EquipmentObject.EquipmentType)i);
		}
	}

	[Button]
	public void TestUnequipRod()
	{
		List<EquipmentObject> list = equipmentSets[0];
		UnequipObject(EquipmentObject.EquipmentType.ROD);
	}

	[Button]
	public void CheckStartEquipment()
	{
		if ((int)GlobalSettings.Instance.playerSettings.playersExperience > 0)
		{
			return;
		}
		bool flag = true;
		List<EquipmentObject> list = equipmentSets[0];
		for (int i = 0; i < list.Count; i++)
		{
			if (list[i] != null && list[i].prefab != null)
			{
				flag = false;
				break;
			}
		}
		if (flag)
		{
			Debug.LogError("CheckStartEquipment sthWrong");
			Reset();
		}
	}

	public bool CanBeSold(EquipmentObject equipmentObject)
	{
		return !IsThisStartEquipment(equipmentObject);
	}

	public bool IsThisStartEquipment(EquipmentObject equipmentObject)
	{
		if ((int)equipmentObject.equipmentType >= startEquipment.Count)
		{
			return false;
		}
		return startEquipment[(int)equipmentObject.equipmentType] == equipmentObject.id;
	}

	public void AddFakeBaits()
	{
		EquipmentObject equipmentObject = FindEquipment(EquipmentObject.EquipmentType.BAIT, startEquipment[6]);
		if (equipmentObject.amount == 0 && (int)playerSettings.playersMoney < equipmentObject.price)
		{
			equipmentObject.amount = 1;
			Debug.LogError("AddFakeBaits");
		}
	}

	public void Save()
	{
		string currentProfilePrefix = GlobalSettings.Instance.saveManager.GetCurrentProfilePrefix();
		using (ES2Writer eS2Writer = ES2Writer.Create(currentProfilePrefix))
		{
			for (int i = 0; i < 13; i++)
			{
				List<EquipmentObject> equipmentList = GetEquipmentList((EquipmentObject.EquipmentType)i);
				if (equipmentList != null)
				{
					for (int j = 0; j < equipmentList.Count; j++)
					{
						eS2Writer.Write(equipmentList[j].isBought, equipmentList[j].id + "_isBought");
						eS2Writer.Write(equipmentList[j].amount, equipmentList[j].id + "_amount");
					}
				}
			}
			for (int k = 0; k < equipmentSets.Length; k++)
			{
				string text = ((k != 0) ? (k + 1 + "_") : string.Empty);
				List<EquipmentObject> list = equipmentSets[k];
				for (int l = 0; l < list.Count; l++)
				{
					if (list[l] != null)
					{
						string id = list[l].id;
						EquipmentObject.EquipmentType equipmentType = (EquipmentObject.EquipmentType)l;
						eS2Writer.Write(id, "currentEquipment_" + text + equipmentType);
					}
					else
					{
						string empty = string.Empty;
						EquipmentObject.EquipmentType equipmentType2 = (EquipmentObject.EquipmentType)l;
						eS2Writer.Write(empty, "currentEquipment_" + text + equipmentType2);
					}
				}
				List<EquipmentObject> list2 = baitsSets[k];
				for (int m = 0; m < list2.Count; m++)
				{
					if (list2[m] != null)
					{
						eS2Writer.Write(list2[m].id, "currentBaits_" + text + m);
					}
					else
					{
						eS2Writer.Write(string.Empty, "currentBaits_" + text + m);
					}
				}
				eS2Writer.Write(setSpecificParameters[k].currentFloatDepth, "currentFloatDepth" + text);
				eS2Writer.Write(setSpecificParameters[k].currentFloatWeight, "currentFloatWeight" + text);
				eS2Writer.Write(setSpecificParameters[k].currentHookSize, "currentHookSize" + text);
			}
			try
			{
				eS2Writer.Save();
			}
			catch (Exception exception)
			{
				Debug.LogException(exception, this);
			}
			Debug.Log("Save Equipment");
		}
	}

	public void Load()
	{
		string currentProfilePrefix = GlobalSettings.Instance.saveManager.GetCurrentProfilePrefix();
		using (ES2Reader reader = ES2Reader.Create(currentProfilePrefix))
		{
			for (int i = 0; i < 13; i++)
			{
				List<EquipmentObject> equipmentList = GetEquipmentList((EquipmentObject.EquipmentType)i);
				if (equipmentList == null)
				{
					continue;
				}
				for (int j = 0; j < equipmentList.Count; j++)
				{
					equipmentList[j].isBought = SaveManager.Read(reader, equipmentList[j].id + "_isBought", false);
					equipmentList[j].amount = SaveManager.Read(reader, equipmentList[j].id + "_amount", (!equipmentList[j].hasAmount) ? (-1) : 0);
					if (equipmentList[j].hasAmount && equipmentList[j].amount < 0)
					{
						equipmentList[j].amount = 0;
					}
					if (equipmentList[j].hasAmount && equipmentList[j].amount < 0 && equipmentList[j].isBought && !equipmentList[j].isEquipped)
					{
						equipmentList[j].amount = 1;
					}
					if (equipmentList[j].isBought && equipmentList[j].IsBuyAndEquip())
					{
						equipmentList[j].isEquipped = true;
					}
				}
			}
			for (int k = 0; k < equipmentSets.Length; k++)
			{
				string text = ((k != 0) ? (k + 1 + "_") : string.Empty);
				List<EquipmentObject> list = equipmentSets[k];
				for (int l = 0; l < list.Count; l++)
				{
					EquipmentObject.EquipmentType equipmentType = (EquipmentObject.EquipmentType)l;
					string id = SaveManager.Read(reader, "currentEquipment_" + text + equipmentType, string.Empty);
					EquipmentObject equipmentObject = FindEquipment((EquipmentObject.EquipmentType)l, id);
					if (equipmentObject != null)
					{
						EquipObject(equipmentObject, k);
					}
					else
					{
						UnequipObject((EquipmentObject.EquipmentType)l, k);
					}
				}
				List<EquipmentObject> list2 = baitsSets[k];
				for (int m = 0; m < list2.Count; m++)
				{
					string text2 = SaveManager.Read(reader, "currentBaits_" + text + m, string.Empty);
					EquipmentObject equipmentObject2 = FindEquipment(EquipmentObject.EquipmentType.BAIT, text2);
					if (equipmentObject2 != null && text2 != string.Empty)
					{
						EquipObject(equipmentObject2, k, m);
					}
					else
					{
						UnequipObject(EquipmentObject.EquipmentType.BAIT, k, m);
					}
				}
				setSpecificParameters[k].currentFloatDepth = SaveManager.Read(reader, "currentFloatDepth" + text, 50f);
				setSpecificParameters[k].currentFloatWeight = SaveManager.Read(reader, "currentFloatWeight" + text, 2f);
				setSpecificParameters[k].currentHookSize = SaveManager.Read(reader, "currentHookSize" + text, 0f);
			}
		}
		AddFakeBaits();
		ChangeCurrentEquipmentSet(0);
		Debug.Log("Load Equipment");
	}

	public void Reset()
	{
		if (GlobalSettings.Instance.currentPlatform == GlobalSettings.Platform.ARCADE)
		{
			return;
		}
		for (int i = 0; i < 13; i++)
		{
			List<EquipmentObject> equipmentList = GetEquipmentList((EquipmentObject.EquipmentType)i);
			if (equipmentList == null)
			{
				continue;
			}
			for (int j = 0; j < equipmentList.Count; j++)
			{
				equipmentList[j].isBought = equipmentList[j].isBoughtAtStart;
				equipmentList[j].isEquipped = false;
				if (equipmentList[j].equipmentSubType == EquipmentObject.EquipmentSubType.FLOAT_WEIGHT)
				{
					equipmentList[j].amount = 2;
				}
				else
				{
					equipmentList[j].amount = ((!equipmentList[j].hasAmount) ? (-1) : 0);
				}
			}
		}
		EquipmentObject equipmentObject = FindEquipment(EquipmentObject.EquipmentType.HOOK, "HOOK_GNOME_MIKADO_01");
		equipmentObject.isBought = true;
		equipmentObject.amount = 1;
		RefreshStartEquipment();
		Debug.Log("Reset Equipment");
		Save();
	}

	public void RefreshStartEquipment()
	{
		for (int i = 0; i < equipmentSets.Length; i++)
		{
			string text = ((i != 0) ? (i + 1 + "_") : string.Empty);
			List<EquipmentObject> list = baitsSets[i];
			for (int j = 0; j < list.Count; j++)
			{
				UnequipObject(EquipmentObject.EquipmentType.BAIT, i, j);
			}
			List<EquipmentObject> list2 = equipmentSets[i];
			for (int k = 0; k < list2.Count; k++)
			{
				EquipmentObject equipmentObject = FindEquipment((EquipmentObject.EquipmentType)k, startEquipment[k]);
				if (equipmentObject != null)
				{
					switch (k)
					{
					case 5:
						equipmentObject.amount = 1;
						break;
					case 6:
						equipmentObject.amount = 30;
						break;
					default:
						equipmentObject.isBought = true;
						break;
					}
				}
				else if (!string.IsNullOrEmpty(startEquipment[k]))
				{
					Debug.LogError("StartEquipment not found: " + startEquipment[k]);
				}
				if (equipmentObject != null && i == 0)
				{
					EquipObject(equipmentObject, 0);
				}
				else
				{
					UnequipObject((EquipmentObject.EquipmentType)k, i);
				}
			}
			setSpecificParameters[i].currentFloatDepth = 50f;
			setSpecificParameters[i].currentFloatWeight = 2f;
			setSpecificParameters[i].currentHookSize = 3f;
		}
	}
}