using System.Collections;
using GameNetcodeStuff;
using Unity.Netcode;
using UnityEngine;

public class ManualCameraRenderer : NetworkBehaviour
{
	public Camera cam;

	public CameraView[] cameraViews;

	public int cameraViewIndex;

	public bool currentCameraDisabled;

	[Space(5f)]
	public MeshRenderer mesh;

	public Material offScreenMat;

	public Material onScreenMat;

	public int materialIndex;

	private bool isScreenOn;

	public bool overrideCameraForOtherUse;

	public bool renderAtLowerFramerate;

	public float fps = 60f;

	private float elapsed;

	public PlayerControllerB targetPlayer;

	public int targetPlayerIndex;

	public Camera mapCamera;

	public Animator mapCameraAnimator;

	private bool mapCameraMaxFramerate;

	private Coroutine updateMapCameraCoroutine;

	private bool syncingTargetPlayer;

	private bool syncingSwitchScreen;

	private bool screenEnabledOnLocalClient;

	private Vector3 targetDeathPosition;

	public Transform mapCameraStationaryUI;

	public Transform shipArrowPointer;

	public GameObject shipArrowUI;

	private void Start()
	{
		if (cam == null)
		{
			cam = GetComponent<Camera>();
		}
		if (!isScreenOn)
		{
			cam.enabled = false;
		}
		targetPlayer = StartOfRound.Instance.allPlayerScripts[0];
		targetDeathPosition = new Vector3(0f, -100f, 0f);
	}

	public void SwitchScreenButton()
	{
		bool on = !isScreenOn;
		SwitchScreenOn(on);
		syncingSwitchScreen = true;
		SwitchScreenOnServerRpc(on);
	}

	public void SwitchScreenOn(bool on = true)
	{
		isScreenOn = on;
		currentCameraDisabled = !on;
		Material[] sharedMaterials = mesh.sharedMaterials;
		if (on)
		{
			sharedMaterials[materialIndex] = onScreenMat;
			mapCameraAnimator.SetTrigger("Transition");
		}
		else
		{
			sharedMaterials[materialIndex] = offScreenMat;
		}
		mesh.sharedMaterials = sharedMaterials;
	}

	[ServerRpc(RequireOwnership = false)]
	public void SwitchScreenOnServerRpc(bool on)
	{
		NetworkManager networkManager = base.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			if (__rpc_exec_stage != __RpcExecStage.Server && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams serverRpcParams = default(ServerRpcParams);
				FastBufferWriter bufferWriter = __beginSendServerRpc(1937545459u, serverRpcParams, RpcDelivery.Reliable);
				bufferWriter.WriteValueSafe(in on, default(FastBufferWriter.ForPrimitives));
				__endSendServerRpc(ref bufferWriter, 1937545459u, serverRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
			{
				SwitchScreenOnClientRpc(on);
			}
		}
	}

	[ClientRpc]
	public void SwitchScreenOnClientRpc(bool on)
	{
		NetworkManager networkManager = base.NetworkManager;
		if ((object)networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if (__rpc_exec_stage != __RpcExecStage.Client && (networkManager.IsServer || networkManager.IsHost))
		{
			ClientRpcParams clientRpcParams = default(ClientRpcParams);
			FastBufferWriter bufferWriter = __beginSendClientRpc(2637643520u, clientRpcParams, RpcDelivery.Reliable);
			bufferWriter.WriteValueSafe(in on, default(FastBufferWriter.ForPrimitives));
			__endSendClientRpc(ref bufferWriter, 2637643520u, clientRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
		{
			if (syncingSwitchScreen)
			{
				syncingSwitchScreen = false;
			}
			else
			{
				SwitchScreenOn(on);
			}
		}
	}

	public void SwitchCameraView(bool switchForward = true, int switchToView = -1)
	{
		cam.enabled = false;
		cameraViewIndex = (cameraViewIndex + 1) % cameraViews.Length;
		cam = cameraViews[cameraViewIndex].camera;
		onScreenMat = cameraViews[cameraViewIndex].cameraMaterial;
	}

	public void SwitchMapCameraTargetPlayer(int syncTargetIndex = -1)
	{
		if (!isScreenOn)
		{
			if (syncTargetIndex == -1)
			{
				return;
			}
			SwitchScreenOn();
		}
		if (updateMapCameraCoroutine != null)
		{
			StopCoroutine(updateMapCameraCoroutine);
		}
		updateMapCameraCoroutine = StartCoroutine(updateMapTarget(syncTargetIndex));
	}

	private IEnumerator updateMapTarget(int syncTargetIndex = -1)
	{
		if (screenEnabledOnLocalClient)
		{
			mapCameraMaxFramerate = true;
			mapCameraAnimator.SetTrigger("Transition");
		}
		yield return new WaitForSeconds(0.035f);
		if (syncTargetIndex != -1)
		{
			targetPlayerIndex = syncTargetIndex;
			targetPlayer = StartOfRound.Instance.allPlayerScripts[syncTargetIndex];
			StartOfRound.Instance.mapScreenPlayerName.text = "MONITORING: " + targetPlayer.playerUsername;
		}
		else
		{
			int num = StartOfRound.Instance.allPlayerScripts.Length;
			string text = "";
			for (int i = 0; i < num; i++)
			{
				targetPlayerIndex = (targetPlayerIndex + 1) % num;
				targetPlayer = StartOfRound.Instance.allPlayerScripts[targetPlayerIndex];
				text = "MONITORING: " + targetPlayer.playerUsername;
				if (targetPlayer.isPlayerControlled || targetPlayer.isPlayerDead)
				{
					break;
				}
				Debug.Log($"Skipped player on map screen: {targetPlayer.isPlayerControlled}; {targetPlayer.isPlayerDead}");
			}
			StartOfRound.Instance.mapScreenPlayerName.text = text;
			syncingTargetPlayer = true;
			SwitchMapCameraTargetServerRpc(targetPlayerIndex);
		}
		mapCameraMaxFramerate = false;
	}

	[ServerRpc(RequireOwnership = false)]
	public void SwitchMapCameraTargetServerRpc(int targetIndex)
	{
		NetworkManager networkManager = base.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			if (__rpc_exec_stage != __RpcExecStage.Server && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams serverRpcParams = default(ServerRpcParams);
				FastBufferWriter bufferWriter = __beginSendServerRpc(1252373737u, serverRpcParams, RpcDelivery.Reliable);
				BytePacker.WriteValueBitPacked(bufferWriter, targetIndex);
				__endSendServerRpc(ref bufferWriter, 1252373737u, serverRpcParams, RpcDelivery.Reliable);
			}
			if (__rpc_exec_stage == __RpcExecStage.Server && (networkManager.IsServer || networkManager.IsHost))
			{
				SwitchMapCameraTargetClientRpc(targetIndex);
			}
		}
	}

	[ClientRpc]
	public void SwitchMapCameraTargetClientRpc(int targetIndex)
	{
		NetworkManager networkManager = base.NetworkManager;
		if ((object)networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if (__rpc_exec_stage != __RpcExecStage.Client && (networkManager.IsServer || networkManager.IsHost))
		{
			ClientRpcParams clientRpcParams = default(ClientRpcParams);
			FastBufferWriter bufferWriter = __beginSendClientRpc(3804991398u, clientRpcParams, RpcDelivery.Reliable);
			BytePacker.WriteValueBitPacked(bufferWriter, targetIndex);
			__endSendClientRpc(ref bufferWriter, 3804991398u, clientRpcParams, RpcDelivery.Reliable);
		}
		if (__rpc_exec_stage == __RpcExecStage.Client && (networkManager.IsClient || networkManager.IsHost))
		{
			if (syncingTargetPlayer)
			{
				syncingTargetPlayer = false;
			}
			else
			{
				SwitchMapCameraTargetPlayer(targetIndex);
			}
		}
	}

	private void MapCameraFocusOnPosition(Vector3 pos)
	{
		if (targetPlayer.isInHangarShipRoom)
		{
			mapCamera.nearClipPlane = -0.96f;
		}
		else
		{
			mapCamera.nearClipPlane = -2.47f;
		}
		mapCamera.transform.position = new Vector3(pos.x, pos.y + 3.636f, pos.z);
	}

	private void Update()
	{
		if (GameNetworkManager.Instance.localPlayerController == null || NetworkManager.Singleton == null)
		{
			return;
		}
		if (overrideCameraForOtherUse)
		{
			if (shipArrowUI != null)
			{
				shipArrowUI.SetActive(value: false);
			}
			return;
		}
		if (cam == mapCamera)
		{
			if (targetPlayer.isPlayerDead)
			{
				if (targetPlayer.deadBody != null)
				{
					MapCameraFocusOnPosition(targetPlayer.deadBody.transform.position);
					targetDeathPosition = targetPlayer.deadBody.spawnPosition;
				}
				else
				{
					MapCameraFocusOnPosition(targetPlayer.placeOfDeath);
				}
			}
			else
			{
				MapCameraFocusOnPosition(targetPlayer.transform.position);
			}
			if (mapCameraMaxFramerate)
			{
				mapCamera.enabled = true;
				return;
			}
		}
		PlayerControllerB player = ((!GameNetworkManager.Instance.localPlayerController.isPlayerDead || !(GameNetworkManager.Instance.localPlayerController.spectatedPlayerScript != null)) ? GameNetworkManager.Instance.localPlayerController : GameNetworkManager.Instance.localPlayerController.spectatedPlayerScript);
		if (!MeetsCameraEnabledConditions(player))
		{
			screenEnabledOnLocalClient = false;
			cam.enabled = false;
			return;
		}
		if (cam == mapCamera)
		{
			if (targetPlayer != null && Vector3.Distance(targetPlayer.transform.position, StartOfRound.Instance.elevatorTransform.transform.position) > 16f && !targetPlayer.isInsideFactory)
			{
				shipArrowPointer.LookAt(StartOfRound.Instance.elevatorTransform);
				shipArrowPointer.eulerAngles = new Vector3(0f, shipArrowPointer.eulerAngles.y, 0f);
				shipArrowUI.SetActive(value: true);
			}
			else
			{
				shipArrowUI.SetActive(value: false);
			}
		}
		screenEnabledOnLocalClient = true;
		if (renderAtLowerFramerate)
		{
			cam.enabled = false;
			elapsed += Time.deltaTime;
			if (elapsed > 1f / fps)
			{
				elapsed = 0f;
				cam.Render();
			}
		}
		else
		{
			cam.enabled = true;
		}
	}

	private bool MeetsCameraEnabledConditions(PlayerControllerB player)
	{
		if (currentCameraDisabled)
		{
			return false;
		}
		if (mesh != null && !mesh.isVisible)
		{
			return false;
		}
		if (!StartOfRound.Instance.inShipPhase && (!player.isInHangarShipRoom || (!StartOfRound.Instance.shipDoorsEnabled && (StartOfRound.Instance.currentPlanetPrefab == null || !StartOfRound.Instance.currentPlanetPrefab.activeSelf))))
		{
			return false;
		}
		return true;
	}

	protected override void __initializeVariables()
	{
		base.__initializeVariables();
	}

	[RuntimeInitializeOnLoadMethod]
	internal static void InitializeRPCS_ManualCameraRenderer()
	{
		NetworkManager.__rpc_func_table.Add(1937545459u, __rpc_handler_1937545459);
		NetworkManager.__rpc_func_table.Add(2637643520u, __rpc_handler_2637643520);
		NetworkManager.__rpc_func_table.Add(1252373737u, __rpc_handler_1252373737);
		NetworkManager.__rpc_func_table.Add(3804991398u, __rpc_handler_3804991398);
	}

	private static void __rpc_handler_1937545459(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		NetworkManager networkManager = target.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			reader.ReadValueSafe(out bool value, default(FastBufferWriter.ForPrimitives));
			target.__rpc_exec_stage = __RpcExecStage.Server;
			((ManualCameraRenderer)target).SwitchScreenOnServerRpc(value);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_2637643520(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		NetworkManager networkManager = target.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			reader.ReadValueSafe(out bool value, default(FastBufferWriter.ForPrimitives));
			target.__rpc_exec_stage = __RpcExecStage.Client;
			((ManualCameraRenderer)target).SwitchScreenOnClientRpc(value);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_1252373737(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		NetworkManager networkManager = target.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			ByteUnpacker.ReadValueBitPacked(reader, out int value);
			target.__rpc_exec_stage = __RpcExecStage.Server;
			((ManualCameraRenderer)target).SwitchMapCameraTargetServerRpc(value);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	private static void __rpc_handler_3804991398(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
	{
		NetworkManager networkManager = target.NetworkManager;
		if ((object)networkManager != null && networkManager.IsListening)
		{
			ByteUnpacker.ReadValueBitPacked(reader, out int value);
			target.__rpc_exec_stage = __RpcExecStage.Client;
			((ManualCameraRenderer)target).SwitchMapCameraTargetClientRpc(value);
			target.__rpc_exec_stage = __RpcExecStage.None;
		}
	}

	protected internal override string __getTypeName()
	{
		return "ManualCameraRenderer";
	}
}