using UnityEngine;

public class Boat : Singleton<Boat>
{
	public enum SteringType
	{
		None = 0,
		Rows = 1,
		Engine = 2
	}

	[HideInInspector]
	public Rigidbody rigidbody;

	public Transform engineContainer;

	public Vector2 controllInput;

	[HideInInspector]
	public Animator animator;

	public BoatSit[] boatSits;

	[HideInInspector]
	public int currentSitPointIndex;

	public SteringType steringType;

	[SerializeField]
	private Transform steringWheel;

	[SerializeField]
	private Transform analogSpeedArrow;

	[SerializeField]
	private Transform analogTorqueArrow;

	[SerializeField]
	private Transform analogTurningArrow;

	public BoatRow[] boatRows;

	public BoatEngine boatEngine;

	public FPlayer currentPlayerCharacter;

	public AudioClip[] audioClip;

	private AudioSource audioSource;

	private bool isHitTerrain;

	internal bool isPlayerMoveRange;

	[SerializeField]
	private Transform steringPositionTransform;

	[SerializeField]
	private Transform steringPlayerPositionTransform;

	[SerializeField]
	private Transform lastPlayerParent;

	[SerializeField]
	private BoatRodSupport[] rodSupports;

	[SerializeField]
	private Vector2 clampCameraSteringX;

	private Vector2 lastClampCameraSteringX;

	public BoatParking currentParking;

	[SerializeField]
	private bool useEnterByKey = true;

	private FPlayer player;

	[SerializeField]
	private BoatPlayerDetectSit boatPlayerDetect;

	[SerializeField]
	private Renderer waterSubstractRenderer;

	private bool isPlayerRangeOnBoat;

	private bool wasExitClicked;

	private BoatPanel boatPanel;

	private float hitSoundDelay = 0.5f;

	private void Start()
	{
		rigidbody = GetComponent<Rigidbody>();
		animator = GetComponent<Animator>();
		audioSource = GetComponent<AudioSource>();
		lastPlayerParent = GameObject.Find("_GAMEPLAY_V2").transform;
		Invoke("PositionInParkingOnStart", 0.5f);
	}

	private void Update()
	{
		if (GameManager.Instance.ChechIfPlayerShouldBeStoppedFromDoingAnything())
		{
			FScriptsHandler.Instance.m_HudManager.ShowTeleportToParkingBoatPanel(hide: true);
			FScriptsHandler.Instance.m_HudManager.ShowEnterToBoatPanel(hide: true);
			FScriptsHandler.Instance.m_HudManager.ShowGetDropPanel(hide: true);
			FScriptsHandler.Instance.m_HudManager.ShowGetDropSupportPanel(hide: true);
			FScriptsHandler.Instance.m_HudManager.ShowLeaveBoatPanel(hide: true);
			FScriptsHandler.Instance.m_HudManager.ShowSteerBoatPanel(hide: true);
			return;
		}
		GetInput();
		if (!CheckEnterToBoatByKey() && (bool)currentParking)
		{
			LeavePlayerFromBoatByParking();
		}
		TeleportToParking();
		if (GameManager.Instance.player.GetButtonUp("isEnterLeaveBoat"))
		{
			wasExitClicked = false;
		}
		if (FScriptsHandler.Instance.m_HudManager.currentLeaveBoatPanel != null && !FScriptsHandler.Instance.m_HudManager.isInLeaveBoatCollider)
		{
			FScriptsHandler.Instance.m_HudManager.ShowLeaveBoatPanel(hide: true);
		}
	}

	private void FixedUpdate()
	{
		if (GameManager.Instance.ChechIfPlayerShouldBeStoppedFromDoingAnything())
		{
			return;
		}
		Move();
		AudioController();
		CheckSteringPointAndControllStart();
		if ((bool)currentPlayerCharacter)
		{
			if ((bool)currentPlayerCharacter.currentRod && (bool)currentPlayerCharacter.currentRod.currentFish && currentPlayerCharacter.currentRod.currentFish.isGetFish && currentPlayerCharacter.currentRod.currentFish.transform.parent != base.transform)
			{
				currentPlayerCharacter.currentRod.currentFish.transform.SetParent(base.transform);
			}
			if ((bool)currentParking && currentSitPointIndex == 0 && FScriptsHandler.Instance.m_HudManager.currentSteerBoatPanel == null && !FScriptsHandler.Instance.m_HudManager.currentGetDropPanel && (bool)currentPlayerCharacter)
			{
				if (currentParking.isParkingRange && FScriptsHandler.Instance.m_HudManager.isInLeaveBoatCollider)
				{
					FScriptsHandler.Instance.m_HudManager.ShowLeaveBoatPanel(hide: false);
				}
			}
			else
			{
				FScriptsHandler.Instance.m_HudManager.ShowLeaveBoatPanel(hide: true);
			}
		}
		else
		{
			FScriptsHandler.Instance.m_HudManager.ShowLeaveBoatPanel(hide: true);
		}
	}

	private void TeleportToParking()
	{
		if (!currentPlayerCharacter)
		{
			FScriptsHandler.Instance.m_HudManager.ShowTeleportToParkingBoatPanel(hide: true);
			return;
		}
		bool flag = true;
		for (int i = 0; i < rodSupports.Length; i++)
		{
			if (rodSupports[i].currentRod_1 != null)
			{
				flag = false;
			}
		}
		if ((bool)currentPlayerCharacter.currentRod)
		{
			flag = false;
		}
		if (currentParking.isParkingRange)
		{
			flag = false;
		}
		if (flag)
		{
			if (FScriptsHandler.Instance.m_HudManager.currentLeaveBoatPanel == null && FScriptsHandler.Instance.m_HudManager.currentSteerBoatPanel == null)
			{
				FScriptsHandler.Instance.m_HudManager.ShowTeleportToParkingBoatPanel(hide: false);
				if ((bool)FScriptsHandler.Instance.m_HudManager.currentTeleportBoatPanel)
				{
					FScriptsHandler.Instance.m_HudManager.currentTeleportBoatPanel.circleImage.fillAmount = (float)GameManager.Instance.player.GetButtonTimePressed("isRestartPositionBoat");
				}
				if (GameManager.Instance.player.GetButtonTimePressed("isRestartPositionBoat") >= 1.0)
				{
					PositionInParkingOnStart();
				}
			}
			else
			{
				FScriptsHandler.Instance.m_HudManager.ShowTeleportToParkingBoatPanel(hide: true);
			}
		}
		else
		{
			FScriptsHandler.Instance.m_HudManager.ShowTeleportToParkingBoatPanel(hide: true);
		}
	}

	private bool CheckEnterToBoatByKey()
	{
		if (GameManager.Instance.ChechIfPlayerShouldBeStoppedFromDoingAnything())
		{
			return false;
		}
		if (!useEnterByKey)
		{
			return false;
		}
		if ((bool)currentPlayerCharacter)
		{
			FScriptsHandler.Instance.m_HudManager.ShowEnterToBoatPanel(hide: true);
			return false;
		}
		if (!player)
		{
			player = FScriptsHandler.Instance.m_PlayerMain;
			return false;
		}
		if (!player.gameObject.activeSelf)
		{
			player = null;
			return false;
		}
		if (isPlayerRangeOnBoat)
		{
			FScriptsHandler.Instance.m_HudManager.ShowEnterToBoatPanel(hide: false);
			if (GameManager.Instance.player.GetButtonTimePressed("isEnterLeaveBoat") >= 1.0 && !wasExitClicked)
			{
				if (FScriptsHandler.Instance.m_HudManager.currentEnterBoatPanel == null)
				{
					return false;
				}
				TeleportPlayerToBoat(player);
				wasExitClicked = true;
				FScriptsHandler.Instance.m_HudManager.ShowLeaveBoatPanel(hide: true);
				return true;
			}
		}
		else
		{
			FScriptsHandler.Instance.m_HudManager.ShowEnterToBoatPanel(hide: true);
		}
		if ((bool)FScriptsHandler.Instance.m_HudManager.currentEnterBoatPanel && !wasExitClicked)
		{
			FScriptsHandler.Instance.m_HudManager.currentEnterBoatPanel.circleImage.fillAmount = (float)GameManager.Instance.player.GetButtonTimePressed("isEnterLeaveBoat");
		}
		return false;
	}

	private void PositionInParkingOnStart()
	{
		if ((bool)currentParking)
		{
			if (currentParking.boatPlaceTransform.position != base.transform.position)
			{
				base.transform.position = currentParking.boatPlaceTransform.position;
				base.transform.rotation = currentParking.boatPlaceTransform.rotation;
				rigidbody.velocity = Vector3.zero;
				boatEngine.StopEngine();
			}
			if ((bool)currentPlayerCharacter)
			{
				currentPlayerCharacter.transform.position = currentParking.boatPlaceTransform.position;
			}
		}
	}

	private void GetInput()
	{
		if ((bool)currentPlayerCharacter)
		{
			if (currentSitPointIndex == 0)
			{
				controllInput = Vector2.zero;
				return;
			}
			float axis = GameManager.Instance.player.GetAxis("moveHorizontal");
			float axis2 = GameManager.Instance.player.GetAxis("moveVertical");
			controllInput = new Vector2(axis, axis2);
		}
	}

	private void Move()
	{
		if (!currentPlayerCharacter)
		{
			return;
		}
		switch (steringType)
		{
		case SteringType.None:
			if ((bool)boatEngine && boatEngine.currentTorquePercent != 0f)
			{
				steringType = SteringType.Engine;
			}
			break;
		case SteringType.Engine:
			if (!boatEngine)
			{
				steringType = SteringType.Rows;
				break;
			}
			if (!boatEngine.currentBoat)
			{
				boatEngine.currentBoat = this;
			}
			boatEngine.AddMove(controllInput);
			if ((bool)steringWheel && boatEngine.currentTurningTorquePercent > -1f && boatEngine.currentTurningTorquePercent < 1f)
			{
				steringWheel.Rotate(Vector3.up * controllInput.x * Time.deltaTime * 1000f);
			}
			if ((bool)analogSpeedArrow)
			{
				float num = Mathf.Abs(Vector3.Dot(rigidbody.velocity, rigidbody.transform.forward));
				analogSpeedArrow.localRotation = Quaternion.AngleAxis(num * 45f, Vector3.right);
			}
			if ((bool)analogTorqueArrow)
			{
				analogTorqueArrow.localRotation = Quaternion.AngleAxis(Mathf.Abs(boatEngine.currentTorquePercent) * 300f, Vector3.right);
			}
			if ((bool)analogTurningArrow)
			{
				analogTurningArrow.localRotation = Quaternion.AngleAxis(180f + boatEngine.currentTurningTorquePercent * 180f, Vector3.right);
			}
			break;
		case SteringType.Rows:
			if (boatRows.Length < 2)
			{
				break;
			}
			if ((bool)boatEngine && boatEngine.currentTorquePercent != 0f)
			{
				steringType = SteringType.Engine;
				break;
			}
			if (!boatRows[0].currentBoat)
			{
				boatRows[0].currentBoat = this;
			}
			if (!boatRows[1].currentBoat)
			{
				boatRows[1].currentBoat = this;
			}
			boatRows[0].AddMove(controllInput);
			boatRows[1].AddMove(controllInput);
			break;
		}
	}

	private void CheckSteringPointAndControllStart()
	{
		if (!currentPlayerCharacter)
		{
			return;
		}
		if (currentSitPointIndex == 1 && !currentPlayerCharacter.firstPersonController.frezzePosition)
		{
			lastClampCameraSteringX = new Vector2(currentPlayerCharacter.firstPersonController.m_MouseLook.MinimumX, currentPlayerCharacter.firstPersonController.m_MouseLook.MaximumX);
			currentPlayerCharacter.transform.position = steringPlayerPositionTransform.position;
			currentPlayerCharacter.transform.rotation = steringPlayerPositionTransform.rotation;
			currentPlayerCharacter.firstPersonController.frezzePosition = true;
			currentPlayerCharacter.firstPersonController.m_MouseLook.MinimumX = clampCameraSteringX.x;
			currentPlayerCharacter.firstPersonController.m_MouseLook.MaximumX = clampCameraSteringX.y;
			currentPlayerCharacter.firstPersonController.m_CharacterController.enabled = false;
		}
		else if (currentSitPointIndex == 0 && currentPlayerCharacter.firstPersonController.frezzePosition)
		{
			currentPlayerCharacter.firstPersonController.m_CharacterController.enabled = true;
			currentPlayerCharacter.firstPersonController.UnFrezzeLook();
			currentPlayerCharacter.firstPersonController.m_MouseLook.MinimumX = lastClampCameraSteringX.x;
			currentPlayerCharacter.firstPersonController.m_MouseLook.MaximumX = lastClampCameraSteringX.y;
		}
		if (currentSitPointIndex == 1)
		{
			currentPlayerCharacter.transform.position = steringPlayerPositionTransform.position;
			return;
		}
		Vector3 vector = currentPlayerCharacter.firstPersonController.m_MoveDir * Time.fixedDeltaTime;
		Vector3 vector2 = rigidbody.velocity * Time.fixedDeltaTime;
		if (boatPlayerDetect.CheckPosition(currentPlayerCharacter.transform.position, 0f))
		{
			currentPlayerCharacter.firstPersonController.m_CharacterController.Move(vector + vector2);
			return;
		}
		Vector3 normalized = (boatPlayerDetect.GetCorrection(currentPlayerCharacter.transform.position, 0.2f) - currentPlayerCharacter.transform.position).normalized;
		normalized *= Time.fixedDeltaTime * 0.25f;
		currentPlayerCharacter.firstPersonController.m_CharacterController.Move(normalized + vector2);
	}

	public void Leave()
	{
		Debug.Log("Leave Boat");
		for (int i = 0; i < boatSits.Length; i++)
		{
			boatSits[i].Leave();
		}
		currentPlayerCharacter = null;
	}

	public void ShowHideUIPanel(bool isHide = false)
	{
		if (FScriptsHandler.Instance.boatUIPanelPrefab == null)
		{
			return;
		}
		if ((bool)boatPanel)
		{
			if (isHide)
			{
				Object.Destroy(boatPanel.gameObject);
			}
		}
		else if (!isHide)
		{
			boatPanel = Object.Instantiate(FScriptsHandler.Instance.boatUIPanelPrefab, FScriptsHandler.Instance.m_Canvas.transform).GetComponent<BoatPanel>();
			boatPanel.currntBoat = this;
		}
	}

	private void AudioController()
	{
		if (rigidbody.velocity.sqrMagnitude > 1f || rigidbody.angularVelocity.sqrMagnitude > 0f)
		{
			audioSource.volume = Mathf.Clamp01(rigidbody.velocity.sqrMagnitude * 0.01f) * 0.5f + Mathf.Clamp01(rigidbody.angularVelocity.sqrMagnitude * 0.2f) * 0.5f;
			audioSource.pitch = 0.7f + Mathf.Clamp01(rigidbody.velocity.sqrMagnitude * 0.1f) * 0.5f + Mathf.Clamp01(rigidbody.angularVelocity.sqrMagnitude * 0.1f) * 0.5f;
			if (!audioSource.isPlaying)
			{
				audioSource.Play();
			}
		}
		else if (audioSource.isPlaying)
		{
			audioSource.Stop();
		}
		if (isHitTerrain && hitSoundDelay == 0f)
		{
			audioSource.volume = Mathf.Clamp01(rigidbody.velocity.sqrMagnitude * 0.2f) + Mathf.Clamp01(rigidbody.angularVelocity.sqrMagnitude * 0.2f);
			audioSource.PlayOneShot(audioClip[1]);
			hitSoundDelay = Random.Range(0.2f, 0.6f);
		}
		else
		{
			hitSoundDelay = Mathf.MoveTowards(hitSoundDelay, 0f, Time.deltaTime);
		}
	}

	public void SitPlayerInBoat(FPlayer player)
	{
		Debug.Log("Gracz wszedl do lodki");
		currentPlayerCharacter = player;
		currentPlayerCharacter.firstPersonController.notMove = true;
	}

	public void TeleportPlayerToBoat(FPlayer player)
	{
		if ((bool)player.currentRod)
		{
			GameManager.Instance.ShowMessagePopup(LanguageManager.Instance.GetText("ENTER_TO_BOAT_WITH_ROD"), FScriptsHandler.Instance.m_Canvas.transform);
			return;
		}
		Debug.Log("Gracz wszedl do lodki");
		currentPlayerCharacter = player;
		currentPlayerCharacter.firstPersonController.notMove = true;
		currentPlayerCharacter.transform.position = base.transform.position;
	}

	public void LeavePlayerFromBoat(FPlayer player)
	{
		if ((bool)currentPlayerCharacter)
		{
			Debug.Log("Gracz wyszedl z lodki");
			currentPlayerCharacter.transform.SetParent(lastPlayerParent);
			currentPlayerCharacter.firstPersonController.notMove = false;
			currentPlayerCharacter = null;
		}
	}

	public void LeavePlayerFromBoatByParking()
	{
		if (GameManager.Instance.ChechIfPlayerShouldBeStoppedFromDoingAnything() || !currentPlayerCharacter || !currentParking || currentSitPointIndex != 0 || FScriptsHandler.Instance.m_HudManager.currentSteerBoatPanel != null || (bool)FScriptsHandler.Instance.m_HudManager.currentGetDropPanel)
		{
			return;
		}
		if ((bool)FScriptsHandler.Instance.m_HudManager.currentLeaveBoatPanel)
		{
			FScriptsHandler.Instance.m_HudManager.currentLeaveBoatPanel.circleImage.fillAmount = (float)GameManager.Instance.player.GetButtonTimePressed("isEnterLeaveBoat");
		}
		if (!(GameManager.Instance.player.GetButtonTimePressed("isEnterLeaveBoat") >= 1.0) || wasExitClicked || FScriptsHandler.Instance.m_HudManager.currentLeaveBoatPanel == null)
		{
			return;
		}
		for (int i = 0; i < rodSupports.Length; i++)
		{
			if (rodSupports[i].currentRod_1 != null)
			{
				GameManager.Instance.ShowMessagePopup(LanguageManager.Instance.GetText("BOAT_LEFT_ROD"), FScriptsHandler.Instance.m_Canvas.transform);
				return;
			}
		}
		wasExitClicked = true;
		if ((bool)currentPlayerCharacter.currentRod)
		{
			GameManager.Instance.ShowMessagePopup(LanguageManager.Instance.GetText("LEAVE_FROM_BOAT_WITH_ROD"), FScriptsHandler.Instance.m_Canvas.transform);
			return;
		}
		Debug.Log("Gracz wyszedl z lodki");
		currentPlayerCharacter.transform.SetParent(lastPlayerParent);
		currentPlayerCharacter.firstPersonController.notMove = false;
		currentPlayerCharacter.transform.position = currentParking.transform.position;
		currentPlayerCharacter = null;
		base.transform.position = currentParking.boatPlaceTransform.position;
		base.transform.rotation = currentParking.boatPlaceTransform.rotation;
		rigidbody.velocity = Vector3.zero;
	}

	private void OnCollisionEnter(Collision collision)
	{
		if (collision.gameObject.layer == LayerMask.NameToLayer("Terrain"))
		{
			isHitTerrain = true;
		}
	}

	private void OnCollisionExit(Collision collision)
	{
		if (collision.gameObject.layer == LayerMask.NameToLayer("Terrain"))
		{
			isHitTerrain = false;
		}
	}

	private void OnTriggerStay(Collider other)
	{
		if (LayerMask.NameToLayer("Player") == other.gameObject.layer)
		{
			isPlayerRangeOnBoat = true;
		}
	}

	private void OnTriggerExit(Collider other)
	{
		if (LayerMask.NameToLayer("Player") == other.gameObject.layer)
		{
			isPlayerRangeOnBoat = false;
		}
	}

	private void OnEnable()
	{
		FPlayer.OnChangeCameraToUnderwater += FPlayer_OnChangeCameraToUnderwater;
		FPlayer.OnChangeCameraOutUnderwater += FPlayer_OnChangeCameraOutUnderwater;
	}

	private void OnDisable()
	{
		FPlayer.OnChangeCameraToUnderwater -= FPlayer_OnChangeCameraToUnderwater;
		FPlayer.OnChangeCameraOutUnderwater -= FPlayer_OnChangeCameraOutUnderwater;
	}

	private void FPlayer_OnChangeCameraOutUnderwater()
	{
		if ((bool)waterSubstractRenderer)
		{
			waterSubstractRenderer.enabled = true;
		}
	}

	private void FPlayer_OnChangeCameraToUnderwater()
	{
		if ((bool)waterSubstractRenderer)
		{
			waterSubstractRenderer.enabled = false;
		}
	}
}