using UnityEngine;

namespace Fie.Utility
{
	public class Wiggler
	{
		public enum WiggleTemplate
		{
			WIGGLE_TYPE_MINIMUM,
			WIGGLE_TYPE_SMALL,
			WIGGLE_TYPE_MIDDLE,
			WIGGLE_TYPE_BIG
		}

		private const float MIN_RANDOM_SHAKE_ANGLE_RANGE = 120f;

		private const float MAX_RANDOM_SHAKE_ANGLE_RANGE = 240f;

		private float nowAngle;

		private float nowTime;

		private float totalTime;

		private float wiggleSegmentTime;

		private int totalWiggleCount = 1;

		private int nowWiggleCount;

		private Vector3 wiggleScale = Vector3.zero;

		private Vector3 wiggleNormal = Vector3.zero;

		private Vector3 nowWigglePoint = Vector3.zero;

		private Vector3 nextWigglePoint = Vector3.zero;

		public bool isEnd => nowWiggleCount >= totalWiggleCount;

		public Wiggler(Vector3 normal, float initTotalTime, int initWiggleCount, Vector3 initWiggleScale)
		{
			totalTime = Mathf.Max(initTotalTime, 0f);
			totalWiggleCount = Mathf.Max(initWiggleCount, 1);
			wiggleScale = initWiggleScale;
			wiggleNormal = normal.normalized;
			InitializeGeneralParams();
		}

		public Wiggler(Vector3 normal, WiggleTemplate template)
		{
			float num = 0f;
			int num2 = 1;
			Vector3 zero = Vector3.zero;
			switch (template)
			{
			default:
				num = 0.15f;
				num2 = 4;
				zero = new Vector3(0.015f, 0.015f);
				break;
			case WiggleTemplate.WIGGLE_TYPE_SMALL:
				num = 0.2f;
				num2 = 5;
				zero = new Vector3(0.03f, 0.03f);
				break;
			case WiggleTemplate.WIGGLE_TYPE_MIDDLE:
				num = 0.3f;
				num2 = 7;
				zero = new Vector3(0.1f, 0.1f);
				break;
			case WiggleTemplate.WIGGLE_TYPE_BIG:
				num = 0.5f;
				num2 = 10;
				zero = new Vector3(0.1f, 0.1f);
				break;
			}
			totalTime = Mathf.Max(num, 0f);
			totalWiggleCount = Mathf.Max(num2, 1);
			wiggleScale = zero;
			wiggleNormal = normal.normalized;
			InitializeGeneralParams();
		}

		public Vector3 UpdateWiggler(float updateTime)
		{
			if (nowTime >= totalTime)
			{
				return Vector3.zero;
			}
			Vector3 result = (!(wiggleSegmentTime > 0f)) ? Vector3.zero : Vector3.Lerp(nowWigglePoint, nextWigglePoint, Mathf.Min(nowTime / wiggleSegmentTime, 1f));
			nowTime += updateTime;
			if (nowTime > wiggleSegmentTime && nowWiggleCount < totalWiggleCount)
			{
				nowWiggleCount++;
				SetNextWigglePoint(nowWiggleCount);
				nowTime = 0f;
			}
			return result;
		}

		private void InitializeGeneralParams()
		{
			nowTime = 0f;
			wiggleSegmentTime = totalTime / (float)totalWiggleCount;
			nowWiggleCount = 0;
			SetNextWigglePoint(nowWiggleCount);
		}

		private void SetNextWigglePoint(int count)
		{
			nowWigglePoint = new Vector3(nextWigglePoint.x, nextWigglePoint.y);
			float num = ((float)totalWiggleCount - (float)count) / (float)totalWiggleCount;
			float angle = nowAngle + Random.Range(120f, 240f);
			Quaternion rotation = Quaternion.AngleAxis(angle, wiggleNormal);
			Vector3 vector = rotation * Vector3.up;
			vector.Normalize();
			nextWigglePoint = new Vector3(wiggleScale.x * (vector.x * num), wiggleScale.y * (vector.y * num));
			nowAngle = angle;
		}
	}
}