using UnityEngine;

public class CameraMovement : MonoBehaviour
{
	public Camera camera;

	public Transform positionTarget;

	public Transform headPosition;

	public Transform rotationTarget;

	public Transform bobberTarget;

	private StandingDataHandler standingData;

	private float fallingValue;

	private float fallingEffectValue;

	private float minBobble = 0.02f;

	public bool ADS;

	public DamageEffects effects;

	private WeaponHandler weaponHandler;

	private Rigidbody hip;

	private HasControl hasControl;

	private HeadCollisionHandler headCollisionHandler;

	private MovementDataHandler movementData;

	private Rigidbody torso;

	private PlayerDeath death;

	private Strength str;

	private Vector3 cameraCurrentRelativeADSPosition = Vector3.zero;

	private Vector3 movementADSVelocity = Vector3.zero;

	private Vector3 ADSMovementPosition = Vector3.zero;

	private void Start()
	{
		torso = base.transform.root.GetComponentInChildren<Torso>().GetComponent<Rigidbody>();
		headCollisionHandler = base.transform.root.GetComponentInChildren<HeadCollisionHandler>();
		standingData = base.transform.GetComponentInParent<StandingDataHandler>();
		movementData = base.transform.GetComponentInParent<MovementDataHandler>();
		weaponHandler = base.transform.GetComponentInParent<WeaponHandler>();
		camera = GetComponentInChildren<Camera>();
		hip = base.transform.root.GetComponentInChildren<Hip>().GetComponent<Rigidbody>();
		hasControl = base.transform.root.GetComponent<HasControl>();
		death = base.transform.root.GetComponent<PlayerDeath>();
		str = base.transform.root.GetComponent<Strength>();
		effects = base.transform.root.GetComponent<DamageEffects>();
	}

	private void LateUpdate()
	{
		if (hasControl.hasControl)
		{
			headCollisionHandler.collisionValue = 0f;
			if (standingData.sinceLanded > 1f)
			{
				fallingValue = Mathf.Clamp(standingData.sinceGrounded - 0.5f, 0f, 10f) * 0.5f;
			}
			if (standingData.sinceGrounded > 0.5f || standingData.sinceLanded < 0.5f)
			{
				fallingEffectValue = Mathf.Lerp(fallingEffectValue, fallingValue, Time.smoothDeltaTime * 15f);
			}
			else
			{
				fallingEffectValue = Mathf.Lerp(fallingEffectValue, minBobble, Time.smoothDeltaTime * 3f);
			}
			float physicsValue = GetPhysicsValue();
			Vector3 vector = Vector3.Lerp(positionTarget.position, bobberTarget.position, Mathf.Clamp(physicsValue + headCollisionHandler.collisionValue, 0f, 1f));
			Vector3 position = vector;
			position.y = base.transform.position.y;
			base.transform.position = position;
			base.transform.position = vector;
			base.transform.rotation = Quaternion.Lerp(rotationTarget.rotation, bobberTarget.rotation, Mathf.Clamp(physicsValue + Mathf.Clamp(headCollisionHandler.collisionValue, 0f, 0.4f), 0f, 1f));
			SetCameraPosition();
		}
	}

	private void SetCameraPosition()
	{
		if (ADS && (bool)weaponHandler.gunADS)
		{
			cameraCurrentRelativeADSPosition = Vector3.Lerp(cameraCurrentRelativeADSPosition, Vector3.zero, Time.deltaTime * 20f);
			camera.transform.position = weaponHandler.gunADS.TransformPoint(cameraCurrentRelativeADSPosition) + ADSMovementPosition;
			camera.fieldOfView = Mathf.Lerp(camera.fieldOfView, weaponHandler.ADSFOV, Time.deltaTime * 20f);
			return;
		}
		if ((bool)weaponHandler && (bool)weaponHandler.gunADS)
		{
			cameraCurrentRelativeADSPosition = weaponHandler.gunADS.InverseTransformPoint(camera.transform.position);
		}
		camera.transform.localPosition = Vector3.Lerp(camera.transform.localPosition, Vector3.zero, Time.deltaTime * 20f);
		camera.fieldOfView = Mathf.Lerp(camera.fieldOfView, 90f, Time.deltaTime * 20f);
	}

	private void FixedUpdate()
	{
		if (hasControl.hasControl && (bool)weaponHandler && (bool)weaponHandler.rightGun)
		{
			movementADSVelocity += (weaponHandler.rightGun.rig.velocity - hip.velocity) * 0.01f;
			movementADSVelocity += -ADSMovementPosition * 3f;
			movementADSVelocity *= 0.8f;
		}
	}

	private void Update()
	{
		if (hasControl.hasControl)
		{
			ADSMovementPosition += movementADSVelocity * Time.deltaTime;
		}
	}

	private float GetPhysicsValue()
	{
		float result = fallingEffectValue * 0.3f + (1f - str.strength) + effects.damageValue;
		if (death.dead)
		{
			result = 1f;
		}
		return result;
	}
}