using System;
using System.Collections;
using FishNet.Connection;
using FishNet.Managing;
using FishNet.Object;
using FishNet.Object.Synchronizing;
using FishNet.Serializing;
using FishNet.Transporting;
using Obvious.Soap;
using UnityEngine;

public class MultiplayerBoatController : NetworkBehaviour
{
	[SerializeField]
	private Transform model;

	[SerializeField]
	private CapsuleCollider collisionCollider;

	[SerializeField]
	private BoxCollider overlapCollider;

	[SerializeField]
	private ScriptableEventGameObject OnTakeBoatEvent;

	[SerializeField]
	private LayerMask collisionDetectLayer;

	[SerializeField]
	private Transform boatLights;

	[SerializeField]
	private Transform propeller;

	[SerializeField]
	private AudioSource audioSource;

	private BoatController boatController;

	private Vector3 lastPosition;

	private Vector3 velocity;

	private Transform boatLightsLocal;

	public readonly SyncVar<bool> isLightsOn = new SyncVar<bool>();

	private bool NetworkInitialize___EarlyMultiplayerBoatControllerAssembly_002DCSharp_002Edll_Excuted;

	private bool NetworkInitialize___LateMultiplayerBoatControllerAssembly_002DCSharp_002Edll_Excuted;

	public static event Action<MultiplayerBoatController> OnStartLocal;

	public static event Action<MultiplayerBoatController> OnStartRemote;

	public static event Action<MultiplayerBoatController> OnStopLocal;

	public static event Action<MultiplayerBoatController> OnStopRemote;

	public override void OnStartClient()
	{
		base.OnStartClient();
		if (base.IsOwner)
		{
			MultiplayerBoatController.OnStartLocal?.Invoke(this);
			return;
		}
		OnTakeBoatEvent.OnRaised += OnTakeBoatEventNoParam_OnRaised;
		StartCoroutine(DisableCollisionCoroutine());
		MultiplayerBoatController.OnStartRemote?.Invoke(this);
	}

	public override void OnStopClient()
	{
		base.OnStopClient();
		if (base.IsOwner)
		{
			MultiplayerBoatController.OnStopLocal?.Invoke(this);
			return;
		}
		OnTakeBoatEvent.OnRaised -= OnTakeBoatEventNoParam_OnRaised;
		MultiplayerBoatController.OnStopRemote?.Invoke(this);
	}

	private void OnTakeBoatEventNoParam_OnRaised(GameObject boat)
	{
		if (!base.IsOwner)
		{
			StopAllCoroutines();
			StartCoroutine(DisableCollisionCoroutine());
		}
	}

	public void Init(BoatController boatController)
	{
		if (base.IsOwner)
		{
			this.boatController = boatController;
			model.gameObject.SetActive(value: false);
			collisionCollider.gameObject.SetActive(value: false);
			overlapCollider.gameObject.SetActive(value: false);
			boatLightsLocal = boatController.transform.Find("boat lights root");
		}
	}

	public void Deinit()
	{
		if (base.IsOwner)
		{
			DespawnRPC();
		}
	}

	private void FixedUpdate()
	{
		DetectLargePerStepMovement();
	}

	private void Update()
	{
		if (base.IsOwner)
		{
			UpdateLocal();
		}
		else
		{
			UpdateRemote();
		}
	}

	private void UpdateLocal()
	{
		if (!(boatController == null))
		{
			base.transform.SetPositionAndRotation(boatController.transform.position, boatController.transform.rotation);
			bool flag = (isLightsOn.Value = boatLightsLocal != null && boatLightsLocal.gameObject.activeSelf);
			UpdateSyncVars(flag);
		}
	}

	private void UpdateRemote()
	{
		model.gameObject.SetActive(value: true);
		boatLights.gameObject.SetActive(isLightsOn.Value);
		float num = 800f;
		propeller.Rotate(Vector3.forward, num * Time.deltaTime, Space.Self);
		UpdateRemoteSounds();
	}

	private void UpdateRemoteSounds()
	{
		audioSource.gameObject.SetActive(value: true);
		float magnitude = velocity.magnitude;
		float num = 10f;
		float a = 0.5f;
		float b = 1f;
		float t = Mathf.Clamp01(magnitude / num);
		audioSource.pitch = Mathf.Lerp(a, b, t);
		audioSource.volume = Mathf.Lerp(0.5f, 1f, t);
	}

	private bool IsColliderOverlapping()
	{
		Vector3 center = overlapCollider.transform.position + overlapCollider.center;
		Vector3 halfExtents = overlapCollider.size * 0.5f;
		Quaternion rotation = overlapCollider.transform.rotation;
		return Physics.OverlapBox(center, halfExtents, rotation, collisionDetectLayer, QueryTriggerInteraction.Ignore).Length != 0;
	}

	private void DrawBoxDebugLines(Vector3 center, Vector3 halfExtents, Quaternion rotation, Color color)
	{
		Vector3[] array = new Vector3[8];
		Vector3 vector = rotation * Vector3.right * halfExtents.x;
		Vector3 vector2 = rotation * Vector3.up * halfExtents.y;
		Vector3 vector3 = rotation * Vector3.forward * halfExtents.z;
		array[0] = center + vector + vector2 + vector3;
		array[1] = center + vector + vector2 - vector3;
		array[2] = center + vector - vector2 + vector3;
		array[3] = center + vector - vector2 - vector3;
		array[4] = center - vector + vector2 + vector3;
		array[5] = center - vector + vector2 - vector3;
		array[6] = center - vector - vector2 + vector3;
		array[7] = center - vector - vector2 - vector3;
		Debug.DrawLine(array[0], array[1], color, 10f);
		Debug.DrawLine(array[1], array[3], color, 10f);
		Debug.DrawLine(array[3], array[2], color, 10f);
		Debug.DrawLine(array[2], array[0], color, 10f);
		Debug.DrawLine(array[4], array[5], color, 10f);
		Debug.DrawLine(array[5], array[7], color, 10f);
		Debug.DrawLine(array[7], array[6], color, 10f);
		Debug.DrawLine(array[6], array[4], color, 10f);
		Debug.DrawLine(array[0], array[4], color, 10f);
		Debug.DrawLine(array[1], array[5], color, 10f);
		Debug.DrawLine(array[2], array[6], color, 10f);
		Debug.DrawLine(array[3], array[7], color, 10f);
	}

	private void DetectLargePerStepMovement()
	{
		if (!base.IsOwner)
		{
			Vector3 position = base.transform.position;
			Vector3 vector = position - lastPosition;
			float magnitude = vector.magnitude;
			lastPosition = position;
			if (magnitude > 2f)
			{
				StopAllCoroutines();
				StartCoroutine(DisableCollisionCoroutine());
			}
			float fixedDeltaTime = Time.fixedDeltaTime;
			if (fixedDeltaTime > 0f)
			{
				velocity = vector / fixedDeltaTime;
			}
		}
	}

	private IEnumerator DisableCollisionCoroutine()
	{
		collisionCollider.gameObject.SetActive(value: false);
		overlapCollider.gameObject.SetActive(value: true);
		yield return new WaitForSeconds(5f);
		while (IsColliderOverlapping())
		{
			yield return new WaitForSeconds(2f);
		}
		collisionCollider.gameObject.SetActive(value: true);
	}

	[ServerRpc]
	public void DespawnRPC()
	{
		RpcWriter___Server_DespawnRPC_2166136261();
	}

	[ServerRpc]
	private void UpdateSyncVars(bool isLightsOn)
	{
		RpcWriter___Server_UpdateSyncVars_1140765316(isLightsOn);
	}

	public override void NetworkInitialize___Early()
	{
		if (!NetworkInitialize___EarlyMultiplayerBoatControllerAssembly_002DCSharp_002Edll_Excuted)
		{
			NetworkInitialize___EarlyMultiplayerBoatControllerAssembly_002DCSharp_002Edll_Excuted = true;
			base.NetworkInitialize___Early();
			isLightsOn.InitializeEarly(this, 0u, isSyncObject: false);
			RegisterServerRpc(0u, RpcReader___Server_DespawnRPC_2166136261);
			RegisterServerRpc(1u, RpcReader___Server_UpdateSyncVars_1140765316);
		}
	}

	public override void NetworkInitialize___Late()
	{
		if (!NetworkInitialize___LateMultiplayerBoatControllerAssembly_002DCSharp_002Edll_Excuted)
		{
			NetworkInitialize___LateMultiplayerBoatControllerAssembly_002DCSharp_002Edll_Excuted = true;
			base.NetworkInitialize___Late();
			isLightsOn.InitializeLate();
		}
	}

	public override void NetworkInitializeIfDisabled()
	{
		NetworkInitialize___Early();
		NetworkInitialize___Late();
	}

	private void RpcWriter___Server_DespawnRPC_2166136261()
	{
		if (!base.IsClientInitialized)
		{
			NetworkManager networkManager = base.NetworkManager;
			networkManager.LogWarning("Cannot complete action because client is not active. This may also occur if the object is not yet initialized, has deinitialized, or if it does not contain a NetworkObject component.");
			return;
		}
		if (!base.IsOwner)
		{
			NetworkManager networkManager2 = base.NetworkManager;
			networkManager2.LogWarning("Cannot complete action because you are not the owner of this object. .");
			return;
		}
		Channel channel = Channel.Reliable;
		PooledWriter pooledWriter = WriterPool.Retrieve();
		SendServerRpc(0u, pooledWriter, channel, DataOrderType.Default);
		pooledWriter.Store();
	}

	public void RpcLogic___DespawnRPC_2166136261()
	{
		Despawn();
	}

	private void RpcReader___Server_DespawnRPC_2166136261(PooledReader PooledReader0, Channel channel, NetworkConnection conn)
	{
		if (base.IsServerInitialized && OwnerMatches(conn))
		{
			RpcLogic___DespawnRPC_2166136261();
		}
	}

	private void RpcWriter___Server_UpdateSyncVars_1140765316(bool isLightsOn)
	{
		if (!base.IsClientInitialized)
		{
			NetworkManager networkManager = base.NetworkManager;
			networkManager.LogWarning("Cannot complete action because client is not active. This may also occur if the object is not yet initialized, has deinitialized, or if it does not contain a NetworkObject component.");
			return;
		}
		if (!base.IsOwner)
		{
			NetworkManager networkManager2 = base.NetworkManager;
			networkManager2.LogWarning("Cannot complete action because you are not the owner of this object. .");
			return;
		}
		Channel channel = Channel.Reliable;
		PooledWriter pooledWriter = WriterPool.Retrieve();
		pooledWriter.WriteBoolean(isLightsOn);
		SendServerRpc(1u, pooledWriter, channel, DataOrderType.Default);
		pooledWriter.Store();
	}

	private void RpcLogic___UpdateSyncVars_1140765316(bool P_0)
	{
		isLightsOn.Value = P_0;
	}

	private void RpcReader___Server_UpdateSyncVars_1140765316(PooledReader PooledReader0, Channel channel, NetworkConnection conn)
	{
		bool flag = PooledReader0.ReadBoolean();
		if (base.IsServerInitialized && OwnerMatches(conn))
		{
			RpcLogic___UpdateSyncVars_1140765316(flag);
		}
	}

	public virtual void Awake()
	{
		NetworkInitialize___Early();
		NetworkInitialize___Late();
	}
}