using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using UnityEngine;
using UnityEngine.EventSystems;

public class MultiTouchInputModule : StandaloneInputModule
{
	public static void Execute(IBeginPinchHandler handler, BaseEventData pinchEvent)
	{
		handler.OnBeginPinch((PinchEventData)pinchEvent);
	}

	public static void Execute(IPinchHandler handler, BaseEventData pinchEvent)
	{
		handler.OnPinch((PinchEventData)pinchEvent);
	}

	public static void Execute(IEndPinchHandler handler, BaseEventData pinchEvent)
	{
		handler.OnEndPinch((PinchEventData)pinchEvent);
	}

	public static float PreviousProcessedInputTime { get; private set; }

	protected override void Awake()
	{
		base.Awake();
		this._pinchEventData = new PinchEventData(base.eventSystem);
	}

	protected override void Start()
	{
		base.Start();
		this._hasTouch = true;
	}

	public override void Process()
	{
		base.Process();
		if (this._hasTouch)
		{
			bool flag = UnityEngine.Input.touchCount > 0;
			if (flag)
			{
				this.ProcessTouchInput();
				this.ProcessTouchPinch();
			}
		}
	}

	private Vector2 FindPinchCenter(ICollection<PointerEventData> pointerEvents)
	{
		Vector2 vector = Vector2.zero;
		int num = 0;
		foreach (PointerEventData pointerEventData in pointerEvents)
		{
			vector += pointerEventData.position;
			if (++num == 2)
			{
				break;
			}
		}
		if (num > 0)
		{
			vector /= (float)num;
		}
		return vector;
	}

	private float FindPinchDistance(ICollection<PointerEventData> pointerEvents)
	{
		if (pointerEvents.Count >= 2)
		{
			IEnumerator<PointerEventData> enumerator = pointerEvents.GetEnumerator();
			enumerator.MoveNext();
			Vector2 position = enumerator.Current.position;
			enumerator.MoveNext();
			return Vector2.Distance(position, enumerator.Current.position);
		}
		return 0f;
	}

	private void ResetVelocityMeasurements()
	{
		this._velocityMeasurementStart = 0;
		this._velocityMeasurementCount = 0;
	}

	private void AddVelocityMeasurement(Vector2 position, float time)
	{
		if (this._velocityMeasurementCount == 3)
		{
			this._velocityMeasurementStart = (this._velocityMeasurementStart + 1) % 3;
			this._velocityMeasurementCount--;
		}
		int num = (this._velocityMeasurementStart + this._velocityMeasurementCount) % 3;
		this._velocityMeasurements[num].position = position;
		this._velocityMeasurements[num].time = time;
		this._velocityMeasurementCount++;
	}

	private Vector2 GetVelocity()
	{
		if (this._velocityMeasurementCount <= 1)
		{
			return Vector2.zero;
		}
		int num = (this._velocityMeasurementStart + this._velocityMeasurementCount - 1) % 3;
		Vector2 a = this._velocityMeasurements[num].position - this._velocityMeasurements[this._velocityMeasurementStart].position;
		float num2 = this._velocityMeasurements[num].time - this._velocityMeasurements[this._velocityMeasurementStart].time;
		if (Mathf.Approximately(num2, 0f))
		{
			return Vector2.zero;
		}
		return a / num2;
	}

	private void ProcessTouchInput()
	{
		Touch[] touches = Input.touches;
		for (int i = 0; i < touches.Length; i++)
		{
			MultiTouchInputModule.PreviousProcessedInputTime = Time.unscaledTime;
			PointerEventData pointerEventData;
			base.GetPointerData(touches[i].fingerId, out pointerEventData, false);
			if (pointerEventData == null)
			{
				if (this._dragPointerData.ContainsKey(touches[i].fingerId))
				{
					this._dragPointerData.Remove(touches[i].fingerId);
					this._pinchEventData.Pointers = this._dragPointerData.Count;
					this._pinchEventData.Center = this.FindPinchCenter(this._dragPointerData.Values);
					this._pinchEventData.Delta = Vector2.zero;
					this._pinchEventData.Distance = this.FindPinchDistance(this._dragPointerData.Values);
					this._pinchEventData.ScaleDelta = 1f;
					if (this._pinchEventData.Pointers == 0)
					{
						this._pinchEventData.Reset();
						GameObject target = this._pinchEventData.Target;
						BaseEventData pinchEventData = this._pinchEventData;
						if (MultiTouchInputModule._003C_003Ef__mg_0024cache0 == null)
						{
							MultiTouchInputModule._003C_003Ef__mg_0024cache0 = new ExecuteEvents.EventFunction<IEndPinchHandler>(MultiTouchInputModule.Execute);
						}
						ExecuteEvents.Execute<IEndPinchHandler>(target, pinchEventData, MultiTouchInputModule._003C_003Ef__mg_0024cache0);
					}
					else
					{
						this.ResetVelocityMeasurements();
					}
				}
			}
			else
			{
				bool flag = touches[i].phase == TouchPhase.Began;
				if (flag && pointerEventData.pointerDrag == null)
				{
					pointerEventData.pointerDrag = ExecuteEvents.GetEventHandler<IPinchHandler>(pointerEventData.pointerCurrentRaycast.gameObject);
				}
				if (pointerEventData.dragging && !this._dragPointerData.ContainsKey(pointerEventData.pointerId))
				{
					this._dragPointerData.Add(pointerEventData.pointerId, pointerEventData);
					this._pinchEventData.Pointers = this._dragPointerData.Count;
					this._pinchEventData.Center = this.FindPinchCenter(this._dragPointerData.Values);
					this._pinchEventData.Delta = Vector2.zero;
					this._pinchEventData.Velocity = Vector2.zero;
					this._pinchEventData.Distance = this.FindPinchDistance(this._dragPointerData.Values);
					this._pinchEventData.ScaleDelta = 1f;
					this.ResetVelocityMeasurements();
					if (this._pinchEventData.Pointers == 1)
					{
						this._pinchEventData.Target = pointerEventData.pointerPressRaycast.gameObject;
						if (this._pinchEventData.Target != null)
						{
							this._pinchEventData.Target = ExecuteEvents.GetEventHandler<IPinchHandler>(this._pinchEventData.Target);
						}
						this._pinchEventData.Reset();
						GameObject target2 = this._pinchEventData.Target;
						BaseEventData pinchEventData2 = this._pinchEventData;
						if (MultiTouchInputModule._003C_003Ef__mg_0024cache1 == null)
						{
							MultiTouchInputModule._003C_003Ef__mg_0024cache1 = new ExecuteEvents.EventFunction<IBeginPinchHandler>(MultiTouchInputModule.Execute);
						}
						ExecuteEvents.Execute<IBeginPinchHandler>(target2, pinchEventData2, MultiTouchInputModule._003C_003Ef__mg_0024cache1);
					}
				}
				if (pointerEventData.dragging && pointerEventData.eligibleForClick)
				{
					pointerEventData.eligibleForClick = false;
				}
			}
		}
	}

	private void ProcessTouchPinch()
	{
		Vector2 center = this._pinchEventData.Center;
		float distance = this._pinchEventData.Distance;
		if (this._pinchEventData.Pointers > 0)
		{
			this._pinchEventData.Center = this.FindPinchCenter(this._dragPointerData.Values);
			this._pinchEventData.Distance = this.FindPinchDistance(this._dragPointerData.Values);
			this.AddVelocityMeasurement(this._pinchEventData.Center, Time.unscaledTime);
			if (this._pinchEventData.Center != center || !Mathf.Approximately(this._pinchEventData.Distance, distance))
			{
				this._pinchEventData.Delta = this._pinchEventData.Center - center;
				this._pinchEventData.Velocity = this.GetVelocity();
				if (Math.Abs(distance) > 1E-09f)
				{
					this._pinchEventData.ScaleDelta = this._pinchEventData.Distance / distance;
				}
				else
				{
					this._pinchEventData.ScaleDelta = 1f;
				}
				this._pinchEventData.Reset();
				GameObject target = this._pinchEventData.Target;
				BaseEventData pinchEventData = this._pinchEventData;
				if (MultiTouchInputModule._003C_003Ef__mg_0024cache2 == null)
				{
					MultiTouchInputModule._003C_003Ef__mg_0024cache2 = new ExecuteEvents.EventFunction<IPinchHandler>(MultiTouchInputModule.Execute);
				}
				ExecuteEvents.Execute<IPinchHandler>(target, pinchEventData, MultiTouchInputModule._003C_003Ef__mg_0024cache2);
			}
		}
	}

	private const int MaxVelocityMeasurementCount = 3;

	private const float ScrollScaleFactor = 0.1f;

	private PinchEventData _pinchEventData;

	private MultiTouchInputModule.VelocityMeasurement[] _velocityMeasurements = new MultiTouchInputModule.VelocityMeasurement[3];

	private int _velocityMeasurementStart;

	private int _velocityMeasurementCount;

	private Dictionary<int, PointerEventData> _dragPointerData = new Dictionary<int, PointerEventData>();

	private bool _hasTouch;

	[CompilerGenerated]
	private static ExecuteEvents.EventFunction<IEndPinchHandler> _003C_003Ef__mg_0024cache0;

	[CompilerGenerated]
	private static ExecuteEvents.EventFunction<IBeginPinchHandler> _003C_003Ef__mg_0024cache1;

	[CompilerGenerated]
	private static ExecuteEvents.EventFunction<IPinchHandler> _003C_003Ef__mg_0024cache2;

	private struct VelocityMeasurement
	{
		public Vector2 position;

		public float time;
	}
}