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

public class SpinningMethodController : MonoBehaviour
{
	public enum SpinningMethod
	{
		NONE = 0,
		STRAIGHT_SLOW = 1,
		STRAIGHT = 2,
		STRAIGHT_FAST = 3,
		LIFT_DROP = 4,
		STOP_GO = 5,
		TWITCHING = 6
	}

	public enum SpinningState
	{
		MOVE_SLOW = 0,
		MOVE_MEDIUM = 1,
		MOVE_FAST = 2,
		JERK = 3,
		GROUND = 4,
		IDLE = 5
	}

	[HideInInspector]
	public Bait bait;

	[HideInInspector]
	public FishingFloat fishingFloat;

	[HideInInspector]
	public FishingHands fishingHands;

	[ReadOnly]
	public SpinningMethod currentSpinningMethod;

	[ReadOnly]
	public int currentSpinningLevel = 1;

	[ReadOnly]
	public SpinningState currentSpinningState = SpinningState.IDLE;

	[ReadOnly]
	public List<SpinningState> spinningStates = new List<SpinningState>();

	[ReadOnly]
	public List<int> spinningStatesLevel = new List<int>();

	[ReadOnly]
	public SpinningState currentSpinningEvent = SpinningState.IDLE;

	[ReadOnly]
	public float stateCheckTimer;

	[ReadOnly]
	public float noMethodTimer;

	private const float noMethodDelay = 18f;

	public int rememberedStates = 40;

	public Vector3 levelThresholds = new Vector3(5f, 10f, 15f);

	public Vector3 levelThresholdsTwitching = new Vector3(10f, 20f, 30f);

	public Vector3 levelThresholdsStopGo = new Vector3(20f, 40f, 60f);

	public float[] levelMultipliers = new float[3] { 1f, 1.15f, 1.3f };

	public float stateCheckDelay = 0.5f;

	[ReadOnly]
	public int fishCatchMethodLevel;

	private void Start()
	{
		stateCheckTimer = stateCheckDelay;
		for (int i = 0; i < rememberedStates; i++)
		{
			spinningStates.Add(SpinningState.IDLE);
		}
	}

	private void Update()
	{
		if (fishingHands == null || fishingHands != fishingHands.fishingPlayer.currentHands || fishingHands.isFloatRig || fishingHands.isGroundRig || !fishingHands.ThrowObjectOnWater() || fishingHands.fishingPlayer.IsSomethingOnBait())
		{
			return;
		}
		stateCheckTimer -= Time.deltaTime;
		if (stateCheckTimer <= 0f)
		{
			stateCheckTimer = stateCheckDelay;
			AddSpinningState(currentSpinningEvent, Random.Range(1, 4));
			currentSpinningEvent = SpinningState.IDLE;
		}
		if (currentSpinningMethod == SpinningMethod.NONE && !GameController.Instance.iceLevel)
		{
			noMethodTimer -= Time.deltaTime;
			if (noMethodTimer <= 0f)
			{
				HUDManager.Instance.ShowMessage(Utilities.GetTranslation("HUD_MESSAGE/NO_LURING_METHOD"));
				noMethodTimer = 18f;
			}
		}
		else
		{
			noMethodTimer = 18f;
		}
	}

	public void SpinningStateEvent(SpinningState state)
	{
		if (currentSpinningEvent != SpinningState.GROUND || state != SpinningState.GROUND)
		{
		}
		switch (state)
		{
		case SpinningState.MOVE_SLOW:
			currentSpinningEvent = SpinningState.MOVE_SLOW;
			break;
		case SpinningState.MOVE_MEDIUM:
			currentSpinningEvent = SpinningState.MOVE_MEDIUM;
			break;
		case SpinningState.MOVE_FAST:
			currentSpinningEvent = SpinningState.MOVE_FAST;
			break;
		case SpinningState.JERK:
		{
			for (int i = 0; i < 1; i++)
			{
				if (spinningStates[i] == SpinningState.JERK)
				{
					return;
				}
			}
			currentSpinningEvent = SpinningState.IDLE;
			stateCheckTimer = stateCheckDelay;
			AddSpinningState(SpinningState.JERK, 1);
			break;
		}
		case SpinningState.GROUND:
			currentSpinningEvent = SpinningState.GROUND;
			break;
		}
	}

	public void AddSpinningState(SpinningState state, int level)
	{
		for (int num = rememberedStates - 1; num >= 0; num--)
		{
			if (num >= 1)
			{
				spinningStates[num] = spinningStates[num - 1];
			}
			else
			{
				spinningStates[num] = state;
			}
		}
		CheckSpinningMethod();
	}

	public void CheckSpinningMethod()
	{
		currentSpinningMethod = SpinningMethod.NONE;
		currentSpinningLevel = 0;
		if (currentSpinningMethod == SpinningMethod.NONE && spinningStates[0] == SpinningState.MOVE_SLOW)
		{
			for (int i = 0; i < rememberedStates; i++)
			{
				if (spinningStates[i] != SpinningState.MOVE_SLOW)
				{
					if ((float)i < levelThresholds.x)
					{
						currentSpinningMethod = SpinningMethod.NONE;
					}
					break;
				}
				currentSpinningLevel = i;
				currentSpinningMethod = SpinningMethod.STRAIGHT_SLOW;
			}
		}
		if (currentSpinningMethod == SpinningMethod.NONE && spinningStates[0] == SpinningState.MOVE_MEDIUM)
		{
			for (int j = 0; j < rememberedStates; j++)
			{
				if (spinningStates[j] != SpinningState.MOVE_MEDIUM)
				{
					if ((float)j < levelThresholds.x)
					{
						currentSpinningMethod = SpinningMethod.NONE;
					}
					break;
				}
				currentSpinningLevel = j;
				currentSpinningMethod = SpinningMethod.STRAIGHT;
			}
		}
		if (currentSpinningMethod == SpinningMethod.NONE && spinningStates[0] == SpinningState.MOVE_FAST)
		{
			for (int k = 0; k < rememberedStates; k++)
			{
				if (spinningStates[k] != SpinningState.MOVE_FAST)
				{
					if ((float)k < levelThresholds.x)
					{
						currentSpinningMethod = SpinningMethod.NONE;
					}
					break;
				}
				currentSpinningLevel = k;
				currentSpinningMethod = SpinningMethod.STRAIGHT_FAST;
			}
		}
		if (currentSpinningMethod == SpinningMethod.NONE && (spinningStates[0] == SpinningState.JERK || IsMoving(spinningStates[0])))
		{
			int num = 0;
			bool flag = false;
			Vector2 vector = new Vector2(2f, 5f);
			bool flag2 = false;
			for (int l = 0; (float)l <= vector.y + 1f; l++)
			{
				if (spinningStates[l] == SpinningState.JERK)
				{
					flag2 = true;
				}
			}
			if (flag2)
			{
				bool flag3 = IsMoving(spinningStates[0]);
				if (flag3)
				{
					num = 1;
				}
				for (int m = 1; m < rememberedStates; m++)
				{
					if (!IsMoving(spinningStates[m]) && spinningStates[m] != SpinningState.JERK)
					{
						flag = true;
					}
					else if (IsMoving(spinningStates[m]))
					{
						num++;
						if ((float)num > vector.y)
						{
							flag = true;
						}
					}
					else if (spinningStates[m] == SpinningState.JERK)
					{
						if ((float)num < vector.x && !flag3)
						{
							flag = true;
						}
						num = 0;
						flag3 = false;
					}
					if (flag)
					{
						if ((float)m < levelThresholdsTwitching.x)
						{
							currentSpinningMethod = SpinningMethod.NONE;
						}
						break;
					}
					currentSpinningLevel = m;
					currentSpinningMethod = SpinningMethod.LIFT_DROP;
				}
			}
		}
		if (currentSpinningMethod == SpinningMethod.NONE && (spinningStates[0] == SpinningState.GROUND || IsMovingOrIdle(spinningStates[0])))
		{
			bool flag4 = false;
			int num2 = 0;
			Vector2 vector2 = new Vector2(1f, 10f);
			int num3 = 0;
			Vector2 vector3 = new Vector2(1f, 5f);
			bool flag5 = false;
			for (int n = 0; (float)n <= vector2.y + 1f; n++)
			{
				if (spinningStates[n] == SpinningState.GROUND)
				{
					flag5 = true;
				}
			}
			if (flag5)
			{
				if (IsMovingOrIdle(spinningStates[0]))
				{
					num2 = 1;
				}
				for (int num4 = 1; num4 < rememberedStates; num4++)
				{
					if (!IsMovingOrIdle(spinningStates[num4]) && spinningStates[num4] != SpinningState.GROUND)
					{
						flag4 = true;
					}
					else if (IsMovingOrIdle(spinningStates[num4]))
					{
						num3 = 0;
						num2++;
						if ((float)num2 > vector2.y)
						{
							flag4 = true;
						}
					}
					else if (spinningStates[num4] == SpinningState.GROUND)
					{
						num2 = 0;
						num3++;
						if ((float)num3 > vector3.y)
						{
							flag4 = true;
						}
						bool flag6 = false;
					}
					if (flag4)
					{
						if ((float)num4 < levelThresholdsStopGo.x)
						{
							currentSpinningMethod = SpinningMethod.NONE;
						}
						break;
					}
					currentSpinningLevel = num4;
					currentSpinningMethod = SpinningMethod.STOP_GO;
				}
			}
		}
		if (currentSpinningMethod == SpinningMethod.NONE && (spinningStates[0] == SpinningState.JERK || spinningStates[0] == SpinningState.IDLE))
		{
			int num5 = 0;
			bool flag7 = false;
			Vector2 vector4 = new Vector2(2f, 5f);
			bool flag8 = false;
			for (int num6 = 0; (float)num6 <= vector4.y + 1f; num6++)
			{
				if (spinningStates[num6] == SpinningState.JERK)
				{
					flag8 = true;
				}
			}
			if (flag8)
			{
				bool flag9 = spinningStates[0] == SpinningState.IDLE;
				if (flag9)
				{
					num5 = 1;
				}
				for (int num7 = 1; num7 < rememberedStates; num7++)
				{
					if (spinningStates[num7] != SpinningState.IDLE && spinningStates[num7] != SpinningState.JERK)
					{
						flag7 = true;
					}
					else if (spinningStates[num7] == SpinningState.IDLE)
					{
						num5++;
						if ((float)num5 > vector4.y)
						{
							flag7 = true;
						}
					}
					else if (spinningStates[num7] == SpinningState.JERK)
					{
						if ((float)num5 < vector4.x && !flag9)
						{
							flag7 = true;
						}
						num5 = 0;
						flag9 = false;
					}
					if (flag7)
					{
						if ((float)num7 < levelThresholdsTwitching.x)
						{
							currentSpinningMethod = SpinningMethod.NONE;
						}
						break;
					}
					currentSpinningLevel = num7;
					currentSpinningMethod = SpinningMethod.TWITCHING;
				}
			}
		}
		if (currentSpinningMethod == SpinningMethod.STRAIGHT || currentSpinningMethod == SpinningMethod.STRAIGHT_FAST || currentSpinningMethod == SpinningMethod.STRAIGHT_SLOW)
		{
			if ((float)currentSpinningLevel >= levelThresholds.z)
			{
				currentSpinningLevel = 3;
			}
			else if ((float)currentSpinningLevel >= levelThresholds.y)
			{
				currentSpinningLevel = 2;
			}
			else
			{
				currentSpinningLevel = 1;
			}
		}
		else if (currentSpinningMethod == SpinningMethod.LIFT_DROP || currentSpinningMethod == SpinningMethod.TWITCHING)
		{
			if ((float)currentSpinningLevel >= levelThresholdsTwitching.z)
			{
				currentSpinningLevel = 3;
			}
			else if ((float)currentSpinningLevel >= levelThresholdsTwitching.y)
			{
				currentSpinningLevel = 2;
			}
			else
			{
				currentSpinningLevel = 1;
			}
		}
		else if (currentSpinningMethod == SpinningMethod.STOP_GO)
		{
			if ((float)currentSpinningLevel >= levelThresholdsStopGo.z)
			{
				currentSpinningLevel = 3;
			}
			else if ((float)currentSpinningLevel >= levelThresholdsStopGo.y)
			{
				currentSpinningLevel = 2;
			}
			else
			{
				currentSpinningLevel = 1;
			}
		}
		if (!GameController.Instance.iceLevel)
		{
			fishingHands.fishingPlayer.gameController.hudManager.hudFishing.UpdateSpinningMethod(currentSpinningMethod, currentSpinningLevel);
		}
		if ((bool)jkmStatistic.Instance)
		{
			jkmStatistic.Instance.spinnigMethod.text = currentSpinningMethod.ToString() + " " + currentSpinningLevel;
		}
	}

	public float GetLevelMultiplier()
	{
		return levelMultipliers[currentSpinningLevel - 1];
	}

	public bool IsMoving(SpinningState state)
	{
		return state == SpinningState.MOVE_SLOW || state == SpinningState.MOVE_MEDIUM || state == SpinningState.MOVE_FAST;
	}

	public bool IsMovingOrIdle(SpinningState state)
	{
		return state == SpinningState.MOVE_SLOW || state == SpinningState.MOVE_MEDIUM || state == SpinningState.MOVE_FAST || state == SpinningState.IDLE;
	}

	public bool IsMovingOrJerking(SpinningState state)
	{
		return state == SpinningState.MOVE_SLOW || state == SpinningState.MOVE_MEDIUM || state == SpinningState.MOVE_FAST || state == SpinningState.JERK || state == SpinningState.IDLE;
	}

	public void FishCatchBait()
	{
		fishCatchMethodLevel = currentSpinningLevel;
	}

	public void Reset()
	{
		for (int i = 0; i < spinningStates.Count; i++)
		{
			spinningStates[i] = SpinningState.IDLE;
		}
		currentSpinningEvent = SpinningState.IDLE;
		currentSpinningMethod = SpinningMethod.NONE;
		currentSpinningLevel = 1;
		fishingHands.fishingPlayer.gameController.hudManager.hudFishing.UpdateSpinningMethod(currentSpinningMethod, currentSpinningLevel);
		noMethodTimer = 18f;
	}

	public static string GetSpinningMethodName(SpinningMethod spinningMethod)
	{
		switch (spinningMethod)
		{
		case SpinningMethod.LIFT_DROP:
			return Utilities.GetTranslation("HUD/SPINNING_LIFT_DROP");
		case SpinningMethod.STOP_GO:
			return Utilities.GetTranslation("HUD/SPINNING_STOP_GO");
		case SpinningMethod.STRAIGHT:
			return Utilities.GetTranslation("HUD/SPINNING_STRAIGHT");
		case SpinningMethod.STRAIGHT_SLOW:
			return Utilities.GetTranslation("HUD/SPINNING_STRAIGHT_SLOW");
		case SpinningMethod.STRAIGHT_FAST:
			return Utilities.GetTranslation("HUD/SPINNING_STRAIGHT_FAST");
		case SpinningMethod.TWITCHING:
			return Utilities.GetTranslation("HUD/SPINNING_TWITCHING");
		default:
			return "None";
		}
	}
}