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

namespace XUtliPoolLib
{
	public class XInterpolate
	{
		public enum EaseType
		{
			Linear,
			EaseInQuad,
			EaseOutQuad,
			EaseInOutQuad,
			EaseInCubic,
			EaseOutCubic,
			EaseInOutCubic,
			EaseInQuart,
			EaseOutQuart,
			EaseInOutQuart,
			EaseInQuint,
			EaseOutQuint,
			EaseInOutQuint,
			EaseInSine,
			EaseOutSine,
			EaseInOutSine,
			EaseInExpo,
			EaseOutExpo,
			EaseInOutExpo,
			EaseInCirc,
			EaseOutCirc,
			EaseInOutCirc
		}

		public delegate Vector3 ToVector3<T>(T v);

		public delegate float Function(float a, float b, float c, float d);

		private static Vector3 Identity(Vector3 v)
		{
			return v;
		}

		private static Vector3 TransformDotPosition(Transform t)
		{
			return t.position;
		}

		private static IEnumerable<float> NewTimer(float duration)
		{
			float elapsedTime = 0f;
			while (elapsedTime < duration)
			{
				yield return elapsedTime;
				elapsedTime += Time.deltaTime;
				bool flag = elapsedTime >= duration;
				if (flag)
				{
					yield return elapsedTime;
				}
			}
			yield break;
		}

		private static IEnumerable<float> NewCounter(int start, int end, int step)
		{
			for (int i = start; i <= end; i += step)
			{
				yield return (float)i;
			}
			yield break;
		}

		public static IEnumerator NewEase(XInterpolate.Function ease, Vector3 start, Vector3 end, float duration)
		{
			IEnumerable<float> driver = XInterpolate.NewTimer(duration);
			return XInterpolate.NewEase(ease, start, end, duration, driver);
		}

		public static IEnumerator NewEase(XInterpolate.Function ease, Vector3 start, Vector3 end, int slices)
		{
			IEnumerable<float> driver = XInterpolate.NewCounter(0, slices + 1, 1);
			return XInterpolate.NewEase(ease, start, end, (float)(slices + 1), driver);
		}

		private static IEnumerator NewEase(XInterpolate.Function ease, Vector3 start, Vector3 end, float total, IEnumerable<float> driver)
		{
			Vector3 distance = end - start;
			foreach (float i in driver)
			{
				yield return XInterpolate.Ease(ease, start, distance, i, total);
			}
			IEnumerator<float> enumerator = null;
			yield break;
			yield break;
		}

		private static Vector3 Ease(XInterpolate.Function ease, Vector3 start, Vector3 distance, float elapsedTime, float duration)
		{
			start.x = ease(start.x, distance.x, elapsedTime, duration);
			start.y = ease(start.y, distance.y, elapsedTime, duration);
			start.z = ease(start.z, distance.z, elapsedTime, duration);
			return start;
		}

		public static XInterpolate.Function Ease(XInterpolate.EaseType type)
		{
			XInterpolate.Function result = null;
			switch (type)
			{
			case XInterpolate.EaseType.Linear:
				result = new XInterpolate.Function(XInterpolate.Linear);
				break;
			case XInterpolate.EaseType.EaseInQuad:
				result = new XInterpolate.Function(XInterpolate.EaseInQuad);
				break;
			case XInterpolate.EaseType.EaseOutQuad:
				result = new XInterpolate.Function(XInterpolate.EaseOutQuad);
				break;
			case XInterpolate.EaseType.EaseInOutQuad:
				result = new XInterpolate.Function(XInterpolate.EaseInOutQuad);
				break;
			case XInterpolate.EaseType.EaseInCubic:
				result = new XInterpolate.Function(XInterpolate.EaseInCubic);
				break;
			case XInterpolate.EaseType.EaseOutCubic:
				result = new XInterpolate.Function(XInterpolate.EaseOutCubic);
				break;
			case XInterpolate.EaseType.EaseInOutCubic:
				result = new XInterpolate.Function(XInterpolate.EaseInOutCubic);
				break;
			case XInterpolate.EaseType.EaseInQuart:
				result = new XInterpolate.Function(XInterpolate.EaseInQuart);
				break;
			case XInterpolate.EaseType.EaseOutQuart:
				result = new XInterpolate.Function(XInterpolate.EaseOutQuart);
				break;
			case XInterpolate.EaseType.EaseInOutQuart:
				result = new XInterpolate.Function(XInterpolate.EaseInOutQuart);
				break;
			case XInterpolate.EaseType.EaseInQuint:
				result = new XInterpolate.Function(XInterpolate.EaseInQuint);
				break;
			case XInterpolate.EaseType.EaseOutQuint:
				result = new XInterpolate.Function(XInterpolate.EaseOutQuint);
				break;
			case XInterpolate.EaseType.EaseInOutQuint:
				result = new XInterpolate.Function(XInterpolate.EaseInOutQuint);
				break;
			case XInterpolate.EaseType.EaseInSine:
				result = new XInterpolate.Function(XInterpolate.EaseInSine);
				break;
			case XInterpolate.EaseType.EaseOutSine:
				result = new XInterpolate.Function(XInterpolate.EaseOutSine);
				break;
			case XInterpolate.EaseType.EaseInOutSine:
				result = new XInterpolate.Function(XInterpolate.EaseInOutSine);
				break;
			case XInterpolate.EaseType.EaseInExpo:
				result = new XInterpolate.Function(XInterpolate.EaseInExpo);
				break;
			case XInterpolate.EaseType.EaseOutExpo:
				result = new XInterpolate.Function(XInterpolate.EaseOutExpo);
				break;
			case XInterpolate.EaseType.EaseInOutExpo:
				result = new XInterpolate.Function(XInterpolate.EaseInOutExpo);
				break;
			case XInterpolate.EaseType.EaseInCirc:
				result = new XInterpolate.Function(XInterpolate.EaseInCirc);
				break;
			case XInterpolate.EaseType.EaseOutCirc:
				result = new XInterpolate.Function(XInterpolate.EaseOutCirc);
				break;
			case XInterpolate.EaseType.EaseInOutCirc:
				result = new XInterpolate.Function(XInterpolate.EaseInOutCirc);
				break;
			}
			return result;
		}

		public static IEnumerable<Vector3> NewBezier(XInterpolate.Function ease, Transform[] nodes, float duration)
		{
			IEnumerable<float> steps = XInterpolate.NewTimer(duration);
			return XInterpolate.NewBezier<Transform>(ease, nodes, new XInterpolate.ToVector3<Transform>(XInterpolate.TransformDotPosition), duration, steps);
		}

		public static IEnumerable<Vector3> NewBezier(XInterpolate.Function ease, Transform[] nodes, int slices)
		{
			IEnumerable<float> steps = XInterpolate.NewCounter(0, slices + 1, 1);
			return XInterpolate.NewBezier<Transform>(ease, nodes, new XInterpolate.ToVector3<Transform>(XInterpolate.TransformDotPosition), (float)(slices + 1), steps);
		}

		public static IEnumerable<Vector3> NewBezier(XInterpolate.Function ease, Vector3[] points, float duration)
		{
			IEnumerable<float> steps = XInterpolate.NewTimer(duration);
			return XInterpolate.NewBezier<Vector3>(ease, points, new XInterpolate.ToVector3<Vector3>(XInterpolate.Identity), duration, steps);
		}

		public static IEnumerable<Vector3> NewBezier(XInterpolate.Function ease, Vector3[] points, int slices)
		{
			IEnumerable<float> steps = XInterpolate.NewCounter(0, slices + 1, 1);
			return XInterpolate.NewBezier<Vector3>(ease, points, new XInterpolate.ToVector3<Vector3>(XInterpolate.Identity), (float)(slices + 1), steps);
		}

		private static IEnumerable<Vector3> NewBezier<T>(XInterpolate.Function ease, IList nodes, XInterpolate.ToVector3<T> toVector3, float maxStep, IEnumerable<float> steps)
		{
			bool flag = nodes.Count >= 2;
			if (flag)
			{
				Vector3[] points = new Vector3[nodes.Count];
				foreach (float step in steps)
				{
					int num;
					for (int i = 0; i < nodes.Count; i = num + 1)
					{
						points[i] = toVector3((T)((object)nodes[i]));
						num = i;
					}
					yield return XInterpolate.Bezier(ease, points, step, maxStep);
				}
				IEnumerator<float> enumerator = null;
				points = null;
			}
			yield break;
			yield break;
		}

		private static Vector3 Bezier(XInterpolate.Function ease, Vector3[] points, float elapsedTime, float duration)
		{
			for (int i = points.Length - 1; i > 0; i--)
			{
				for (int j = 0; j < i; j++)
				{
					points[j].x = ease(points[j].x, points[j + 1].x - points[j].x, elapsedTime, duration);
					points[j].y = ease(points[j].y, points[j + 1].y - points[j].y, elapsedTime, duration);
					points[j].z = ease(points[j].z, points[j + 1].z - points[j].z, elapsedTime, duration);
				}
			}
			return points[0];
		}

		public static IEnumerable<Vector3> NewCatmullRom(Transform[] nodes, int slices, bool loop)
		{
			return XInterpolate.NewCatmullRom<Transform>(nodes, new XInterpolate.ToVector3<Transform>(XInterpolate.TransformDotPosition), slices, loop);
		}

		public static IEnumerable<Vector3> NewCatmullRom(Vector3[] points, int slices, bool loop)
		{
			return XInterpolate.NewCatmullRom<Vector3>(points, new XInterpolate.ToVector3<Vector3>(XInterpolate.Identity), slices, loop);
		}

		private static IEnumerable<Vector3> NewCatmullRom<T>(IList nodes, XInterpolate.ToVector3<T> toVector3, int slices, bool loop)
		{
			bool flag = nodes.Count >= 2;
			if (flag)
			{
				yield return toVector3((T)((object)nodes[0]));
				int last = nodes.Count - 1;
				int current = 0;
				while (loop || current < last)
				{
					bool flag2 = loop && current > last;
					if (flag2)
					{
						current = 0;
					}
					int previous = (current == 0) ? (loop ? last : current) : (current - 1);
					int start = current;
					int end = (current == last) ? (loop ? 0 : current) : (current + 1);
					int next = (end == last) ? (loop ? 0 : end) : (end + 1);
					int stepCount = slices + 1;
					int num;
					for (int step = 1; step <= stepCount; step = num + 1)
					{
						yield return XInterpolate.CatmullRom(toVector3((T)((object)nodes[previous])), toVector3((T)((object)nodes[start])), toVector3((T)((object)nodes[end])), toVector3((T)((object)nodes[next])), (float)step, (float)stepCount);
						num = step;
					}
					num = current;
					current = num + 1;
				}
			}
			yield break;
		}

		private static Vector3 CatmullRom(Vector3 previous, Vector3 start, Vector3 end, Vector3 next, float elapsedTime, float duration)
		{
			float num = elapsedTime / duration;
			float num2 = num * num;
			float num3 = num2 * num;
			return previous * (-0.5f * num3 + num2 - 0.5f * num) + start * (1.5f * num3 + -2.5f * num2 + 1f) + end * (-1.5f * num3 + 2f * num2 + 0.5f * num) + next * (0.5f * num3 - 0.5f * num2);
		}

		private static float Linear(float start, float distance, float elapsedTime, float duration)
		{
			bool flag = elapsedTime > duration;
			if (flag)
			{
				elapsedTime = duration;
			}
			return distance * (elapsedTime / duration) + start;
		}

		private static float EaseInQuad(float start, float distance, float elapsedTime, float duration)
		{
			elapsedTime = ((elapsedTime > duration) ? 1f : (elapsedTime / duration));
			return distance * elapsedTime * elapsedTime + start;
		}

		private static float EaseOutQuad(float start, float distance, float elapsedTime, float duration)
		{
			elapsedTime = ((elapsedTime > duration) ? 1f : (elapsedTime / duration));
			return -distance * elapsedTime * (elapsedTime - 2f) + start;
		}

		private static float EaseInOutQuad(float start, float distance, float elapsedTime, float duration)
		{
			elapsedTime = ((elapsedTime > duration) ? 2f : (elapsedTime / (duration / 2f)));
			bool flag = elapsedTime < 1f;
			float result;
			if (flag)
			{
				result = distance / 2f * elapsedTime * elapsedTime + start;
			}
			else
			{
				elapsedTime -= 1f;
				result = -distance / 2f * (elapsedTime * (elapsedTime - 2f) - 1f) + start;
			}
			return result;
		}

		private static float EaseInCubic(float start, float distance, float elapsedTime, float duration)
		{
			elapsedTime = ((elapsedTime > duration) ? 1f : (elapsedTime / duration));
			return distance * elapsedTime * elapsedTime * elapsedTime + start;
		}

		private static float EaseOutCubic(float start, float distance, float elapsedTime, float duration)
		{
			elapsedTime = ((elapsedTime > duration) ? 1f : (elapsedTime / duration));
			elapsedTime -= 1f;
			return distance * (elapsedTime * elapsedTime * elapsedTime + 1f) + start;
		}

		private static float EaseInOutCubic(float start, float distance, float elapsedTime, float duration)
		{
			elapsedTime = ((elapsedTime > duration) ? 2f : (elapsedTime / (duration / 2f)));
			bool flag = elapsedTime < 1f;
			float result;
			if (flag)
			{
				result = distance / 2f * elapsedTime * elapsedTime * elapsedTime + start;
			}
			else
			{
				elapsedTime -= 2f;
				result = distance / 2f * (elapsedTime * elapsedTime * elapsedTime + 2f) + start;
			}
			return result;
		}

		private static float EaseInQuart(float start, float distance, float elapsedTime, float duration)
		{
			elapsedTime = ((elapsedTime > duration) ? 1f : (elapsedTime / duration));
			return distance * elapsedTime * elapsedTime * elapsedTime * elapsedTime + start;
		}

		private static float EaseOutQuart(float start, float distance, float elapsedTime, float duration)
		{
			elapsedTime = ((elapsedTime > duration) ? 1f : (elapsedTime / duration));
			elapsedTime -= 1f;
			return -distance * (elapsedTime * elapsedTime * elapsedTime * elapsedTime - 1f) + start;
		}

		private static float EaseInOutQuart(float start, float distance, float elapsedTime, float duration)
		{
			elapsedTime = ((elapsedTime > duration) ? 2f : (elapsedTime / (duration / 2f)));
			bool flag = elapsedTime < 1f;
			float result;
			if (flag)
			{
				result = distance / 2f * elapsedTime * elapsedTime * elapsedTime * elapsedTime + start;
			}
			else
			{
				elapsedTime -= 2f;
				result = -distance / 2f * (elapsedTime * elapsedTime * elapsedTime * elapsedTime - 2f) + start;
			}
			return result;
		}

		private static float EaseInQuint(float start, float distance, float elapsedTime, float duration)
		{
			elapsedTime = ((elapsedTime > duration) ? 1f : (elapsedTime / duration));
			return distance * elapsedTime * elapsedTime * elapsedTime * elapsedTime * elapsedTime + start;
		}

		private static float EaseOutQuint(float start, float distance, float elapsedTime, float duration)
		{
			elapsedTime = ((elapsedTime > duration) ? 1f : (elapsedTime / duration));
			elapsedTime -= 1f;
			return distance * (elapsedTime * elapsedTime * elapsedTime * elapsedTime * elapsedTime + 1f) + start;
		}

		private static float EaseInOutQuint(float start, float distance, float elapsedTime, float duration)
		{
			elapsedTime = ((elapsedTime > duration) ? 2f : (elapsedTime / (duration / 2f)));
			bool flag = elapsedTime < 1f;
			float result;
			if (flag)
			{
				result = distance / 2f * elapsedTime * elapsedTime * elapsedTime * elapsedTime * elapsedTime + start;
			}
			else
			{
				elapsedTime -= 2f;
				result = distance / 2f * (elapsedTime * elapsedTime * elapsedTime * elapsedTime * elapsedTime + 2f) + start;
			}
			return result;
		}

		private static float EaseInSine(float start, float distance, float elapsedTime, float duration)
		{
			bool flag = elapsedTime > duration;
			if (flag)
			{
				elapsedTime = duration;
			}
			return -distance * Mathf.Cos(elapsedTime / duration * 1.57079637f) + distance + start;
		}

		private static float EaseOutSine(float start, float distance, float elapsedTime, float duration)
		{
			bool flag = elapsedTime > duration;
			if (flag)
			{
				elapsedTime = duration;
			}
			return distance * Mathf.Sin(elapsedTime / duration * 1.57079637f) + start;
		}

		private static float EaseInOutSine(float start, float distance, float elapsedTime, float duration)
		{
			bool flag = elapsedTime > duration;
			if (flag)
			{
				elapsedTime = duration;
			}
			return -distance / 2f * (Mathf.Cos(3.14159274f * elapsedTime / duration) - 1f) + start;
		}

		private static float EaseInExpo(float start, float distance, float elapsedTime, float duration)
		{
			bool flag = elapsedTime > duration;
			if (flag)
			{
				elapsedTime = duration;
			}
			return distance * Mathf.Pow(2f, 10f * (elapsedTime / duration - 1f)) + start;
		}

		private static float EaseOutExpo(float start, float distance, float elapsedTime, float duration)
		{
			bool flag = elapsedTime > duration;
			if (flag)
			{
				elapsedTime = duration;
			}
			return distance * (-Mathf.Pow(2f, -10f * elapsedTime / duration) + 1f) + start;
		}

		private static float EaseInOutExpo(float start, float distance, float elapsedTime, float duration)
		{
			elapsedTime = ((elapsedTime > duration) ? 2f : (elapsedTime / (duration / 2f)));
			bool flag = elapsedTime < 1f;
			float result;
			if (flag)
			{
				result = distance / 2f * Mathf.Pow(2f, 10f * (elapsedTime - 1f)) + start;
			}
			else
			{
				elapsedTime -= 1f;
				result = distance / 2f * (-Mathf.Pow(2f, -10f * elapsedTime) + 2f) + start;
			}
			return result;
		}

		private static float EaseInCirc(float start, float distance, float elapsedTime, float duration)
		{
			elapsedTime = ((elapsedTime > duration) ? 1f : (elapsedTime / duration));
			return -distance * (Mathf.Sqrt(1f - elapsedTime * elapsedTime) - 1f) + start;
		}

		private static float EaseOutCirc(float start, float distance, float elapsedTime, float duration)
		{
			elapsedTime = ((elapsedTime > duration) ? 1f : (elapsedTime / duration));
			elapsedTime -= 1f;
			return distance * Mathf.Sqrt(1f - elapsedTime * elapsedTime) + start;
		}

		private static float EaseInOutCirc(float start, float distance, float elapsedTime, float duration)
		{
			elapsedTime = ((elapsedTime > duration) ? 2f : (elapsedTime / (duration / 2f)));
			bool flag = elapsedTime < 1f;
			float result;
			if (flag)
			{
				result = -distance / 2f * (Mathf.Sqrt(1f - elapsedTime * elapsedTime) - 1f) + start;
			}
			else
			{
				elapsedTime -= 2f;
				result = distance / 2f * (Mathf.Sqrt(1f - elapsedTime * elapsedTime) + 1f) + start;
			}
			return result;
		}
	}
}