using UnityEngine;
using UnityEngine.Events;

public class AimbotProjectile : MonoBehaviour
{
	private Weapon weapon;

	public bool shakeCameraOnDestroy;

	private Transform targetTransform;

	private Hp targetHp;

	private TaggedObject targetTaggedObject;

	private Vector3 rememberTarget;

	private Vector3 myLinearPosition;

	private Vector3 spawnPosition;

	private Vector3 previousPosition;

	private float finalDamageMultiplyer = 1f;

	private float remainingRange;

	private TaggedObject firedBy;

	private bool firedByPlayer;

	private bool targetIsFlying;

	[HideInInspector]
	public UnityEvent onHit = new UnityEvent();

	public Weapon Weapon
	{
		get
		{
			return weapon;
		}
		set
		{
			weapon = value;
		}
	}

	public void Fire(Weapon _weapon, Hp _target, float _chaseRange, Vector3 _backupTarget, TaggedObject _firedBy, float _finalDamageMultiplyer = 1f)
	{
		firedBy = _firedBy;
		if ((bool)firedBy)
		{
			firedByPlayer = _firedBy.Tags.Contains(TagManager.ETag.Player);
		}
		weapon = _weapon;
		if ((bool)_target)
		{
			targetTransform = _target.transform;
			targetHp = _target;
			targetTaggedObject = _target.GetComponent<TaggedObject>();
			if (targetTaggedObject.Tags.Contains(TagManager.ETag.Flying))
			{
				targetIsFlying = true;
			}
		}
		else
		{
			rememberTarget = _backupTarget;
		}
		myLinearPosition = base.transform.position;
		spawnPosition = base.transform.position;
		previousPosition = base.transform.position;
		remainingRange = _chaseRange;
		finalDamageMultiplyer = _finalDamageMultiplyer;
		Update();
	}

	private void Update()
	{
		if ((bool)targetTransform)
		{
			if (targetTaggedObject.colliderForBigOjectsToMeasureDistance != null)
			{
				rememberTarget = targetTaggedObject.colliderForBigOjectsToMeasureDistance.ClosestPoint(spawnPosition);
			}
			else
			{
				rememberTarget = targetTransform.position + targetHp.hitFeedbackHeight * Vector3.up;
			}
		}
		Vector3 vector = rememberTarget - myLinearPosition;
		float num = weapon.projectileSpeed * Time.deltaTime;
		if (num >= vector.magnitude)
		{
			Vector3 position = base.transform.position;
			base.transform.position = rememberTarget;
			if (targetTaggedObject != null && targetHp != null && targetTransform != null)
			{
				weapon.DealDamage(targetHp, finalDamageMultiplyer, firedBy);
			}
			else if (weapon.performRaycastWhenHittingEmptyPosition)
			{
				float raycastLength = weapon.raycastLength;
				Vector3 normalized = (base.transform.position - position).normalized;
				Physics.Raycast(base.transform.position - normalized * raycastLength, normalized, out var hitInfo, raycastLength, weapon.emptyPositionRaycastLayerMask);
				if ((bool)hitInfo.collider)
				{
					Hp componentInParent = hitInfo.collider.GetComponentInParent<Hp>();
					if ((bool)componentInParent)
					{
						weapon.DealDamage(componentInParent, finalDamageMultiplyer, firedBy);
					}
				}
			}
			if (!targetIsFlying && (bool)weapon.spawnOnGroundWhenTargetingGround)
			{
				if (targetTransform != null)
				{
					Object.Instantiate(weapon.spawnOnGroundWhenTargetingGround, targetTransform.position, Quaternion.identity);
				}
				else
				{
					Object.Instantiate(weapon.spawnOnGroundWhenTargetingGround, base.transform.position, Quaternion.identity);
				}
			}
			onHit.Invoke();
			Object.Destroy(base.gameObject);
		}
		else
		{
			myLinearPosition += vector.normalized * num;
		}
		float magnitude = (rememberTarget - spawnPosition).magnitude;
		float num4;
		if (magnitude > 0.001f)
		{
			float num2 = (myLinearPosition - spawnPosition).magnitude / magnitude;
			float num3 = Mathf.Max(0f, (magnitude + weapon.projectileParabulaOffset) * weapon.projectileParabulaFactor);
			num4 = (0f - Mathf.Pow(2f * num2 - 1f, 2f) + 1f) * num3;
		}
		else
		{
			num4 = 0f;
		}
		base.transform.position = myLinearPosition + Vector3.up * num4;
		if (weapon.projectileFacingDirection == Weapon.EFacingDirection.FaceVictim && base.transform.position != previousPosition)
		{
			base.transform.rotation = Quaternion.LookRotation(base.transform.position - previousPosition, Vector3.up);
		}
		previousPosition = base.transform.position;
		remainingRange -= num;
		if (remainingRange <= 0f)
		{
			targetTransform = null;
		}
	}

	private void OnDestroy()
	{
		if (shakeCameraOnDestroy && (bool)CameraController.instance)
		{
			CameraController.instance.ShakePunch();
		}
	}
}