using System.Collections;
using UltimateWater;
using UnityEngine;

public class AquariumCameraControllerVR : MonoBehaviour, IAquariumCamera
{
	[SerializeField]
	private Transform _controllerParent;

	[SerializeField]
	private Transform _cameraParent;

	[SerializeField]
	[Header("Follow Fish")]
	private float _cameraPositionSmoothTime = 0.2f;

	[SerializeField]
	[Header("Height")]
	private float _minHeight = -2f;

	[SerializeField]
	private float _maxHeight = 2f;

	[SerializeField]
	private float _defaultHeight = -1f;

	[SerializeField]
	private float _cameraHeightSpeed = 1f;

	[SerializeField]
	private float _cameraHeightSmoothTime = 0.2f;

	[Header("Distance")]
	[SerializeField]
	private float _minDistance = 0.5f;

	[SerializeField]
	private float _maxDistance = 2f;

	[SerializeField]
	private float _defaultDistance = 0.75f;

	[SerializeField]
	private float _cameraZoomSpeed = 1f;

	[SerializeField]
	private float _cameraZoomSmoothTime = 0.2f;

	[SerializeField]
	[Header("Rotation")]
	private float _cameraRotationSpeed = 1f;

	[SerializeField]
	private float _cameraRotationSmoothTime = 0.2f;

	private Transform _cameraTransformVR;

	private SchoolChild _currentFish;

	private Vector3 _currentCameraPosition;

	private Vector3 _cameraPositionVelocity;

	private float _targetCameraDistance;

	private float _currentCameraDistance;

	private float _cameraDistanceVelocity;

	private float _targetCameraHeight;

	private float _currentCameraHeight;

	private float _cameraHeightVelocity;

	private Vector3 _targetCameraRotation;

	private Vector3 _currentCameraRotation;

	private Vector3 _cameraRotationVelocity;

	private Vector3 _targetCameraPosition
	{
		get
		{
			return _currentFish._cacheTransform.position;
		}
	}

	GameObject IAquariumCamera.gameObject
	{
		get
		{
			return base.gameObject;
		}
	}

	private void Update()
	{
		UpdateCameraRotation();
		CalculateCameraPosition();
		CalculateCameraDistance();
		CalculateCameraHeight();
		CalculateCameraRotateArund();
	}

	private void LateUpdate()
	{
		if (!(_currentFish == null))
		{
			SetCameraPosition();
			SetCameraDistance();
			SetCameraHeight();
			SetCameraRoteAround();
		}
	}

	public void AttachToFish(SchoolChild fish)
	{
		_currentFish = fish;
		_cameraTransformVR = TrophyRoomManager.Instance.trophyPlayerVR.vrCameraParent;
		_cameraTransformVR.SetParent(_cameraParent);
		_cameraTransformVR.localPosition = Vector3.down * VRManager.Instance.cameraHeight;
		_cameraTransformVR.localRotation = Quaternion.identity;
		TrophyRoomManager.Instance.trophyPlayerVR.ufpsCamera.GetComponent<WaterCamera>().enabled = true;
		TrophyRoomManager.Instance.trophyPlayerVR.ufpsCamera.GetComponent<UnderwaterIME>().enabled = true;
		_currentCameraPosition = _targetCameraPosition;
		_targetCameraDistance = (_currentCameraDistance = _defaultDistance);
		_targetCameraHeight = (_currentCameraHeight = _defaultHeight);
		_currentCameraRotation = (_targetCameraRotation = _controllerParent.eulerAngles);
		base.enabled = true;
	}

	public void DetachFromFish()
	{
		base.enabled = false;
		_currentFish = null;
		_cameraTransformVR.SetParent(TrophyRoomManager.Instance.trophyPlayerVR.transform);
		_cameraTransformVR.localPosition = Vector3.zero;
		_cameraTransformVR.localRotation = Quaternion.identity;
		TrophyRoomManager.Instance.trophyPlayerVR.ufpsCamera.GetComponent<WaterCamera>().enabled = false;
		TrophyRoomManager.Instance.trophyPlayerVR.ufpsCamera.GetComponent<UnderwaterIME>().enabled = false;
	}

	private void CalculateCameraPosition()
	{
		_currentCameraPosition = Vector3.SmoothDamp(_currentCameraPosition, _targetCameraPosition, ref _cameraPositionVelocity, _cameraPositionSmoothTime);
	}

	private void CalculateCameraDistance()
	{
		float axis = UtilitiesInput.GetAxis("MOVE_VERTICAL");
		_targetCameraDistance = Mathf.Clamp(_targetCameraDistance - axis * _cameraZoomSpeed * Time.deltaTime, _minDistance, _maxDistance);
		_currentCameraDistance = Mathf.SmoothDamp(_currentCameraDistance, _targetCameraDistance, ref _cameraDistanceVelocity, _cameraZoomSmoothTime);
	}

	private void CalculateCameraRotateArund()
	{
		float axis = UtilitiesInput.GetAxis("MOVE_HORIZONTAL");
		_targetCameraRotation.y -= axis * _cameraRotationSpeed * Time.deltaTime;
		_currentCameraRotation = Vector3.SmoothDamp(_currentCameraRotation, _targetCameraRotation, ref _cameraRotationVelocity, _cameraRotationSmoothTime);
	}

	private void CalculateCameraHeight()
	{
		float axis = UtilitiesInput.GetAxis("LOOK_VERTICAL");
		_targetCameraHeight = Mathf.Clamp(_targetCameraHeight + axis * _cameraHeightSpeed * Time.deltaTime, _minHeight, _maxHeight);
		_currentCameraHeight = Mathf.SmoothDamp(_currentCameraHeight, _targetCameraHeight, ref _cameraHeightVelocity, _cameraHeightSmoothTime);
	}

	private void SetCameraPosition()
	{
		_controllerParent.position = _currentCameraPosition;
	}

	private void SetCameraRoteAround()
	{
		_controllerParent.eulerAngles = _currentCameraRotation;
	}

	private void SetCameraDistance()
	{
		Vector3 localPosition = _cameraTransformVR.localPosition;
		localPosition.z = 0f - _currentCameraDistance;
		_cameraTransformVR.localPosition = localPosition;
	}

	private void SetCameraHeight()
	{
		Vector3 localPosition = _cameraTransformVR.localPosition;
		localPosition.y = _currentCameraHeight;
		_cameraTransformVR.localPosition = localPosition;
	}

	private void UpdateCameraRotation()
	{
		if (VRManager.Instance.playerRotateStyle == VRManager.PlayerRotateStyle.STEP)
		{
			if (UtilitiesInput.GetButtonDown("VR_TURN_LEFT") || OVRInput.GetDown(OVRInput.Button.SecondaryThumbstickLeft, OVRInput.Controller.Gamepad) || UtilitiesInput.isRThumbstickLeft)
			{
				Vector3 rotationAquariumCamera = new Vector3(_cameraTransformVR.eulerAngles.x, _cameraTransformVR.eulerAngles.y - VRManager.Instance.turnAngle, _cameraTransformVR.eulerAngles.z);
				SetRotationAquariumCamera(rotationAquariumCamera);
			}
			else if (UtilitiesInput.GetButtonDown("VR_TURN_RIGHT") || OVRInput.GetDown(OVRInput.Button.SecondaryThumbstickRight, OVRInput.Controller.Gamepad) || UtilitiesInput.isRThumbstickRight)
			{
				Vector3 rotationAquariumCamera2 = new Vector3(_cameraTransformVR.eulerAngles.x, _cameraTransformVR.eulerAngles.y + VRManager.Instance.turnAngle, _cameraTransformVR.eulerAngles.z);
				SetRotationAquariumCamera(rotationAquariumCamera2);
			}
		}
		else if (VRManager.Instance.playerRotateStyle == VRManager.PlayerRotateStyle.FADE_STEP)
		{
			if (UtilitiesInput.GetButtonDown("VR_TURN_LEFT") || OVRInput.GetDown(OVRInput.Button.SecondaryThumbstickLeft, OVRInput.Controller.Gamepad) || UtilitiesInput.isRThumbstickLeft)
			{
				Vector3 eulerAngles = new Vector3(_cameraTransformVR.eulerAngles.x, _cameraTransformVR.eulerAngles.y - VRManager.Instance.turnAngle, _cameraTransformVR.eulerAngles.z);
				StartCoroutine(SetRotationFadeAquariumCamera(eulerAngles, VRManager.Instance.fadeDuration));
			}
			else if (UtilitiesInput.GetButtonDown("VR_TURN_RIGHT") || OVRInput.GetDown(OVRInput.Button.SecondaryThumbstickRight, OVRInput.Controller.Gamepad) || UtilitiesInput.isRThumbstickRight)
			{
				Vector3 eulerAngles2 = new Vector3(_cameraTransformVR.eulerAngles.x, _cameraTransformVR.eulerAngles.y + VRManager.Instance.turnAngle, _cameraTransformVR.eulerAngles.z);
				StartCoroutine(SetRotationFadeAquariumCamera(eulerAngles2, VRManager.Instance.fadeDuration));
			}
		}
		else if (VRManager.Instance.playerRotateStyle == VRManager.PlayerRotateStyle.FREE && Mathf.Abs(UtilitiesInput.lookAxis.x) > 0.3f)
		{
			Vector3 rotationAquariumCamera3 = new Vector3(_cameraTransformVR.eulerAngles.x, _cameraTransformVR.eulerAngles.y + VRManager.Instance.freeTurnSpeed * Time.deltaTime * UtilitiesInput.lookAxis.x, base.transform.eulerAngles.z);
			SetRotationAquariumCamera(rotationAquariumCamera3);
		}
	}

	private void SetRotationAquariumCamera(Vector3 eulerAngles)
	{
		_cameraTransformVR.eulerAngles = eulerAngles;
	}

	private IEnumerator SetRotationFadeAquariumCamera(Vector3 eulerAngles, float fadeDuration)
	{
		if (!HUDManager.Instance)
		{
			SetRotationAquariumCamera(eulerAngles);
			yield break;
		}
		HUDManager.Instance.FadeDark(1f, fadeDuration);
		yield return new WaitForSeconds(fadeDuration);
		SetRotationAquariumCamera(eulerAngles);
		yield return new WaitForSeconds(0.05f);
		HUDManager.Instance.FadeDark(0f, fadeDuration);
	}
}